universal-mcp-agents 0.1.18__py3-none-any.whl → 0.1.19rc1__py3-none-any.whl

universal_mcp/applications/llm/app.py

@@ -2,10 +2,11 @@ import json
 from typing import Any, Literal, cast
 
 from langchain.chat_models import init_chat_model
-from langchain_openai import AzureChatOpenAI
 from pydantic import BaseModel, Field
 from universal_mcp.applications.application import BaseApplication
 
+from universal_mcp.agents.llm import load_chat_model
+
 MAX_RETRIES = 3
 
 
@@ -28,7 +29,7 @@ def _get_context_as_string(source: Any | list[Any] | dict[str, Any]) -> str:
     return "\n".join(f"<{k}>\n{str(v)}\n</{k}>" for k, v in source.items())
 
 
-class LLMApp(BaseApplication):
+class LlmApp(BaseApplication):
     """
     An application for leveraging Large Language Models (LLMs) for advanced text processing tasks.
     """
@@ -40,22 +41,34 @@ class LLMApp(BaseApplication):
     def generate_text(
         self,
         task: str,
-        context: Any | list[Any] | dict[str, Any],
+        context: str | list[str] | dict[str, str] = "",
         tone: str = "normal",
         output_format: Literal["markdown", "html", "plain"] = "markdown",
         length: Literal["very-short", "concise", "normal", "long"] = "concise",
     ) -> str:
         """
-        Generates well-written text for a high-level task using the provided context.
-
-        Use this function for creative writing, summarization, and other text generation tasks.
+        Given a high-level writing task and context, returns a well-written text
+        that achieves the task, given the context.
+
+        Example Call:
+            generate_text("Summarize this website with the goal of making it easy to understand.", web_content)
+            generate_text("Make a markdown table summarizing the key differences between doc_1 and doc_2.", {"doc_1": str(doc_1), "doc_2": str(doc_2)})
+            generate_text("Summarize all the provided documents.", [doc_1, doc_2, doc_3])
+
+        Important:
+        - Include specifics of the goal in the context verbatim.
+        - Be precise and direct in the task, and include as much context as possible.
+        - Include relevant high-level goals or intent in the task.
+        - You can provide multiple documents as input, and reference them in the task.
+        - You MUST provide the contents of any source documents to `generate_text`.
+        - NEVER use `generate_text` to produce JSON for a Pydantic model.
 
         Args:
             task: The main writing task or directive.
-            context: A single string, list of strings, or dictionary mapping labels to content.
-            tone: The desired tone of the output (e.g., "formal", "casual", "technical").
+            context: A single string, list of strings, or dict mapping labels to content.
+            tone: The desired tone of the output (e.g., "normal", "flirty", "formal", "casual", "crisp", "poetic", "technical", "internet-chat", "smartass", etc.).
             output_format: The desired output format ('markdown', 'html', 'plain').
-            length: The desired length of the output ('very-short', 'concise', 'normal', 'long').
+            length: Desired length of the output ('very-short', 'concise', 'normal', 'long').
 
         Returns:
             The generated text as a string.
@@ -78,31 +91,63 @@ class LLMApp(BaseApplication):
 
         full_prompt = f"{prompt}\n\nContext:\n{context_str}\n\n"
 
-        model = AzureChatOpenAI(model="gpt-4o", temperature=0.7)
+        model = load_chat_model("azure/gpt-5-mini")
         response = model.with_retry(stop_after_attempt=MAX_RETRIES).invoke(full_prompt)
         return str(response.content)
 
     def classify_data(
         self,
-        task: str,
+        classification_task_and_requirements: str,
         context: Any | list[Any] | dict[str, Any],
         class_descriptions: dict[str, str],
     ) -> dict[str, Any]:
         """
-        Classifies data into one of several categories based on a given task and context.
+        Classifies and compares data based on given requirements.
+
+        Use `classify_data` for tasks which need to classify data into one of many categories.
+        If making multiple binary classifications, call `classify_data` for each.
+
+        Guidance:
+        - Prefer to use classify_data operations to compare strings, rather than string ops.
+        - Prefer to include an "Unsure" category for classification tasks.
+        - The `class_descriptions` dict argument MUST be a map from possible class names to a precise description.
+        - Use precise and specific class names and concise descriptions.
+        - Pass ALL relevant context, preferably as a dict mapping labels to content.
+        - Returned dict maps each possible class name to a probability.
+
+        Example Usage:
+            classification_task_and_requirements = "Does the document contain an address?"
+            class_descriptions = {
+                "Is_Address": "Valid addresses usually have street names, city, and zip codes.",
+                "Not_Address": "Not valid addresses."
+            }
+            classification = classify_data(
+                classification_task_and_requirements,
+                {"address": extracted_address},
+                class_descriptions
+            )
+            if classification["probabilities"]["Is_Address"] > 0.5:
+                ...
 
         Args:
-            task: The classification question and any specific rules or requirements.
-            context: The data to be classified, provided as a string, list, or dictionary.
-            class_descriptions: A dictionary mapping class names to their descriptions.
+            classification_task_and_requirements: The classification question and rules.
+            context: The data to classify (string, list, or dict).
+            class_descriptions: Mapping from class names to descriptions.
+
+        Tags:
+            important
 
         Returns:
-            A dictionary containing the classification probabilities, the reasoning, and the top class.
+            dict: {
+                "probabilities": dict[str, float],
+                "reason": str,
+                "top_class": str,
+            }
         """
         context_str = _get_context_as_string(context)
 
         prompt = (
-            f"{task}\n\n"
+            f"{classification_task_and_requirements}\n\n"
             f"This is a classification task.\nPossible classes and descriptions:\n"
             f"{json.dumps(class_descriptions, indent=2)}\n\n"
             f"Context:\n{context_str}\n\n"
@@ -125,25 +170,61 @@ class LLMApp(BaseApplication):
 
     def extract_data(
         self,
-        task: str,
+        extraction_task: str,
         source: Any | list[Any] | dict[str, Any],
         output_schema: dict[str, Any],
     ) -> dict[str, Any]:
         """
-        Extracts structured data from unstructured text based on a provided JSON schema.
+        Extracts structured data from unstructured data (documents, webpages, images, large bodies of text),
+        returning a dictionary matching the given output_schema.
+
+        You MUST anticipate Exception raised for unextractable data; skip this item if applicable.
+
+        Strongly prefer to:
+        - Be comprehensive, specific, and precise on the data you want to extract.
+        - Use optional fields everywhere.
+        - Extract multiple items from each source unless otherwise specified.
+        - The more specific your extraction task and output_schema are, the better the results.
 
         Args:
-            task: A description of the data to be extracted.
-            source: The unstructured data to extract from (e.g., document, webpage content).
-            output_schema: A valid JSON schema with a 'title' and 'description'.
+            extraction_task: The directive describing what to extract.
+            source: The unstructured data to extract from.
+            output_schema: must be a valid JSON schema with top-level 'title' and 'description' keys.
 
         Returns:
             A dictionary containing the extracted data, matching the provided schema.
+
+        Example:
+            news_articles_schema = {
+                "title": "NewsArticleList",
+                "description": "A list of news articles with headlines and URLs",
+                "type": "object",
+                "properties": {
+                    "articles": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "headline": {
+                                    "type": "string"
+                                },
+                                "url": {
+                                    "type": "string"
+                                }
+                            },
+                            "required": ["headline", "url"]
+                        }
+                    }
+                },
+                "required": ["articles"]
+            }
+
+            news_articles = extract_data("Extract headlines and their corresponding URLs.", content, news_articles_schema)
         """
         context_str = _get_context_as_string(source)
 
         prompt = (
-            f"{task}\n\n"
+            f"{extraction_task}\n\n"
             f"Context:\n{context_str}\n\n"
             "Return ONLY a valid JSON object that conforms to the provided schema, with no extra text."
         )
@@ -156,3 +237,64 @@ class LLMApp(BaseApplication):
             .invoke(prompt)
         )
         return cast(dict[str, Any], response)
+
+    def call_llm(
+        self,
+        task_instructions: str,
+        context: Any | list[Any] | dict[str, Any],
+        output_schema: dict[str, Any],
+    ) -> dict[str, Any]:
+        """
+        Call a Large Language Model (LLM) with an instruction and contextual information,
+        returning a dictionary matching the given output_schema.
+        Can be used for tasks like creative writing, llm reasoning based content generation, etc.
+
+        You MUST anticipate Exceptions in reasoning based tasks which will lead to some empty fields
+        in the returned output; skip this item if applicable.
+
+        General Guidelines:
+        - Be comprehensive, specific, and precise on the task instructions.
+        - Include as much context as possible.
+        - You can provide multiple items in context, and reference them in the task.
+        - Include relevant high-level goals or intent in the task.
+        - In the output_schema, use required field wherever necessary.
+        - The more specific your task instructions and output_schema are, the better the results.
+
+        Guidelines for content generation tasks:
+        - Feel free to add instructions for tone, length, and format (markdown, html, plain-text, xml)
+        - Some examples of tone are: "normal", "flirty", "formal", "casual", "crisp", "poetic", "technical", "internet-chat", "smartass", etc.
+        - Prefer length to be concise by default. Other examples are: "very-short", "concise", "normal", "long", "2-3 lines", etc.
+        - In format prefer plain-text but you can also use markdown and html wherever useful.
+
+        Args:
+            task_instructions: The main directive for the LLM (e.g., "Summarize the article" or "Extract key entities").
+            context:
+                A dictionary containing named text elements that provide additional
+                information for the LLM. Keys are labels (e.g., 'article', 'transcript'),
+                values are strings of content.
+            output_schema: must be a valid JSON schema with top-level 'title' and 'description' keys.
+
+        Returns:
+            dict: Parsed JSON object matching the desired output_schema.
+
+        """
+        context_str = _get_context_as_string(context)
+
+        prompt = f"{task_instructions}\n\nContext:\n{context_str}\n\nReturn ONLY a valid JSON object, no extra text."
+
+        model = init_chat_model(model="claude-4-sonnet-20250514", temperature=0)
+
+        response = (
+            model.with_structured_output(schema=output_schema, method="json_mode")
+            .with_retry(stop_after_attempt=MAX_RETRIES)
+            .invoke(prompt)
+        )
+        return cast(dict[str, Any], response)
+
+    def list_tools(self):
+        return [
+            self.generate_text,
+            self.classify_data,
+            self.extract_data,
+            self.call_llm,
+        ]

{universal_mcp_agents-0.1.18.dist-info → universal_mcp_agents-0.1.19rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp-agents
-Version: 0.1.18
+Version: 0.1.19rc1
 Summary: Add your description here
 Project-URL: Homepage, https://github.com/universal-mcp/applications
 Project-URL: Repository, https://github.com/universal-mcp/applications

{universal_mcp_agents-0.1.18.dist-info → universal_mcp_agents-0.1.19rc1.dist-info}/RECORD

@@ -1,9 +1,10 @@
-universal_mcp/agents/__init__.py,sha256=5aE4zVgem6ehzfRrt5QqE6gLi7949vySZAn_uFuaU7Q,1252
+universal_mcp/agents/__init__.py,sha256=rXWhqmhXdhUdId7QzuQHUpWUwfioPmj7ksu6RHZvCFI,1368
 universal_mcp/agents/base.py,sha256=GmagwWFJdPpp_yLeAfsrr4fu-zzxh7CgIlBJbTgFgWM,7072
 universal_mcp/agents/cli.py,sha256=AG9e4iSX3GazT537573YrYT1wSaZYOr42rrYQ7xP3YA,1016
 universal_mcp/agents/hil.py,sha256=_5PCK6q0goGm8qylJq44aSp2MadP-yCPvhOJYKqWLMo,3808
 universal_mcp/agents/llm.py,sha256=hVRwjZs3MHl5_3BWedmurs2Jt1oZDfFX0Zj9F8KH7fk,1787
 universal_mcp/agents/react.py,sha256=8XQvJ0HLVgc-K0qn9Ml48WGcgUGuIKtL67HatlT6Da0,3334
+universal_mcp/agents/sandbox.py,sha256=Int2O8JNFPlB8c7gb86KRxlNbuV0zdz5_NCo_GMcCds,2876
 universal_mcp/agents/simple.py,sha256=NSATg5TWzsRNS7V3LFiDG28WSOCIwCdcC1g7NRwg2nM,2095
 universal_mcp/agents/utils.py,sha256=P6W9k6XAOBp6tdjC2VTP4tE0B2M4-b1EDmr-ylJ47Pw,7765
 universal_mcp/agents/bigtool/__init__.py,sha256=mZG8dsaCVyKlm82otxtiTA225GIFLUCUUYPEIPF24uw,2299
@@ -28,12 +29,12 @@ universal_mcp/agents/codeact/sandbox.py,sha256=NjN6ISj8psFtHf8V0w24ChJdUMUWkq7Or
 universal_mcp/agents/codeact/state.py,sha256=WTPfpxDlGRnlr5tZuXMg_KU7GS7TZbnrIKslOvZLbQI,565
 universal_mcp/agents/codeact/utils.py,sha256=JUbT_HYGS_D1BzmzoVpORIe7SGur1KgJguTZ_1tZ4JY,1918
 universal_mcp/agents/codeact0/__init__.py,sha256=ebKkpgg-0UnsvDtagEJ2tMer1VsfhmEE5KJcFzUk9fU,133
-universal_mcp/agents/codeact0/__main__.py,sha256=V2wLWW9ym3rtiSvPEs-N0Mki7G5dYHzV5dAsAoF-ygQ,1148
+universal_mcp/agents/codeact0/__main__.py,sha256=xeqNuawP9M8JVAnkhLesalnpI_TakC49ATJaSCzCsYs,880
 universal_mcp/agents/codeact0/agent.py,sha256=9BInAQr3csES-XHSscmeJlYJ3-wQUHPvLOf-6wFILUU,6695
 universal_mcp/agents/codeact0/config.py,sha256=H-1woj_nhSDwf15F63WYn723y4qlRefXzGxuH81uYF0,2215
 universal_mcp/agents/codeact0/langgraph_agent.py,sha256=ehjMV_Z1118pCFWB_Sa5H7XnUp0udsbUHjfjXjhIQM8,435
-universal_mcp/agents/codeact0/llm_tool.py,sha256=fydA4BbSnhG3OLMR_VEtJxTPTmRK_mMvXGsUCO-5Mig,13829
-universal_mcp/agents/codeact0/playbook_agent.py,sha256=JIyn4RZxFDJnXW7-jM16RLM1ylbVU02M8RBJuj1oBUs,17811
+universal_mcp/agents/codeact0/llm_tool.py,sha256=q-hiqkKtjVmpyNceFoRgo7hvKh4HtQf_I1VudRUEPR0,11075
+universal_mcp/agents/codeact0/playbook_agent.py,sha256=Eq_us8j7plxgep1LuJ4I3u8qxjS95_2vGEaPR3g8A-o,17796
 universal_mcp/agents/codeact0/prompts.py,sha256=CF2X6zSK1lYQ9ef78cn0iN0oQN_tDe3T02Ecfn1o45U,8627
 universal_mcp/agents/codeact0/sandbox.py,sha256=zMgHrWnQYkSkJb2MzfXvT3euCc4hvqzBE_EbX2_iLxA,3142
 universal_mcp/agents/codeact0/state.py,sha256=Y-Rzn_S7--aXH18KPvyhqDqOOB-miu1lsAmLgmMlaAg,1259
@@ -42,9 +43,22 @@ universal_mcp/agents/codeact0/utils.py,sha256=jAZItSd3KGDkY9PquSWRIFCj9N26K9Kt0H
 universal_mcp/agents/shared/__main__.py,sha256=XxH5qGDpgFWfq7fwQfgKULXGiUgeTp_YKfcxftuVZq8,1452
 universal_mcp/agents/shared/prompts.py,sha256=yjP3zbbuKi87qCj21qwTTicz8TqtkKgnyGSeEjMu3ho,3761
 universal_mcp/agents/shared/tool_node.py,sha256=DC9F-Ri28Pam0u3sXWNODVgmj9PtAEUb5qP1qOoGgfs,9169
-universal_mcp/applications/llm/__init__.py,sha256=xnpxq4Wl_pevvwtSUtEwcty8_d61ywO1V2YnEXyCREY,46
-universal_mcp/applications/llm/app.py,sha256=iNLU6z2LRZc01GfSKvV0vNzT1LhKAjq_UrSJEmjthjw,6032
+universal_mcp/agents/unified/README.md,sha256=lcZobDA7MVm7vOAefLr4EMlEmgmODhndOZhwrOQO8lg,3658
+universal_mcp/agents/unified/__init__.py,sha256=Oi5nfloc1saGh0HuYZvw2h7NRRWKKVptBXg6PFK6lnw,60
+universal_mcp/agents/unified/__main__.py,sha256=XzHdp_AEd7k2CaWmsUekk3r1eefjmZSKsPhyBBWQDHU,865
+universal_mcp/agents/unified/agent.py,sha256=jQrEk_AcaWpbty5hlncI9cTOOw1W_U4KYQB7xiraoYA,13551
+universal_mcp/agents/unified/langgraph_agent.py,sha256=7v76Uv_1UydCsQpDj99k1FtR1wm7e9yZihwCYdFebwY,403
+universal_mcp/agents/unified/llm_tool.py,sha256=-pAz04OrbZ_dJ2ueysT1qZd02DrbLY4EbU0tiuF_UNU,798
+universal_mcp/agents/unified/prompts.py,sha256=ojHoZUJ1tLc7CwOZPWRJvzdwC_H3hE6PgZ9GKfHqAhU,9521
+universal_mcp/agents/unified/sandbox.py,sha256=zMgHrWnQYkSkJb2MzfXvT3euCc4hvqzBE_EbX2_iLxA,3142
+universal_mcp/agents/unified/state.py,sha256=6gtl1TV4qnnvkhXgHntH13jlVL53S00dFtw_mPKTFw4,1380
+universal_mcp/agents/unified/tools.py,sha256=7hcFJxR26w_VCOWL8Oec8Ezfn3Auyv3YgeRv9f8j9xo,7642
+universal_mcp/agents/unified/utils.py,sha256=jAZItSd3KGDkY9PquSWRIFCj9N26K9Kt0HKQ_jwvvSQ,15944
+universal_mcp/applications/filesystem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/applications/filesystem/app.py,sha256=0TRjjm8YnslVRSmfkXI7qQOAlqWlD1eEn8Jm0xBeigs,5561
+universal_mcp/applications/llm/__init__.py,sha256=_XGRxN3O1--ZS5joAsPf8IlI9Qa6negsJrwJ5VJXno0,46
+universal_mcp/applications/llm/app.py,sha256=oqX3byvlFRmeRo4jJJxUBGy-iTDGm2fplMEKA2pcMtw,12743
 universal_mcp/applications/ui/app.py,sha256=c7OkZsO2fRtndgAzAQbKu-1xXRuRp9Kjgml57YD2NR4,9459
-universal_mcp_agents-0.1.18.dist-info/METADATA,sha256=_OEOGCno6HWgMENbxmi7zUeeMdyMcZyLVUELcBS72Rs,878
-universal_mcp_agents-0.1.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp_agents-0.1.18.dist-info/RECORD,,
+universal_mcp_agents-0.1.19rc1.dist-info/METADATA,sha256=6euKZt6O6J-GgvtqE57uQbZRrNtvL7Al2wGdOEBALvQ,881
+universal_mcp_agents-0.1.19rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp_agents-0.1.19rc1.dist-info/RECORD,,