universal-mcp-agents 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

universal_mcp/agents/cli.py

@@ -1,8 +1,11 @@
+from langgraph.checkpoint.memory import MemorySaver
 from typer import Typer
-
-from universal_mcp.agents import ReactAgent
+from universal_mcp.agentr.client import AgentrClient
+from universal_mcp.agentr.registry import AgentrRegistry
 from universal_mcp.logger import setup_logger
 
+from universal_mcp.agents import get_agent
+
 app = Typer()
 
 
@@ -13,13 +16,24 @@ app = Typer()
     mcp client run --config client_config.json
     """,
 )
-def run():
+def run(name: str = "react"):
     """Run the agent CLI"""
     import asyncio
 
-    setup_logger(log_file=None, level="WARNING")
 
-    agent = ReactAgent("React Agent", "You are a helpful assistant", "openrouter/auto")
+    setup_logger(log_file=None, level="ERROR")
+    client = AgentrClient()
+    params = {
+        "instructions": "You are a helpful assistant",
+        "model": "anthropic/claude-sonnet-4-20250514",
+        "registry": AgentrRegistry(client=client),
+        "memory": MemorySaver(),
+        "tools": {
+            "google_mail": ["send_email"],
+        }
+    }
+    agent_cls = get_agent(name)
+    agent = agent_cls(name, **params)
     asyncio.run(agent.run_interactive())
 
 

universal_mcp/agents/codeact/__init__.py

@@ -54,7 +54,11 @@ In addition to the Python Standard Library, you can use the following functions:
 
     for tool in tools:
         # Use coroutine if it exists, otherwise use func
-        tool_callable = tool.coroutine if hasattr(tool, "coroutine") and tool.coroutine is not None else tool.func
+        tool_callable = (
+            tool.coroutine
+            if hasattr(tool, "coroutine") and tool.coroutine is not None
+            else tool.func
+        )
         # Create a safe function name
         safe_name = make_safe_function_name(tool.name)
         # Determine if it's an async function
@@ -119,7 +123,11 @@ def create_codeact(
     for tool in tools:
         safe_name = make_safe_function_name(tool.name)
         # Use coroutine if it exists, otherwise use func (same as in create_default_prompt)
-        tool_callable = tool.coroutine if hasattr(tool, "coroutine") and tool.coroutine is not None else tool.func
+        tool_callable = (
+            tool.coroutine
+            if hasattr(tool, "coroutine") and tool.coroutine is not None
+            else tool.func
+        )
         # Only use the safe name for consistency with the prompt
         tools_context[safe_name] = tool_callable
 
@@ -145,7 +153,9 @@ def create_codeact(
                 )
 
                 # Add the current response
-                conversation_history += f'\n<message role="assistant">\n{response.content}\n</message>'
+                conversation_history += (
+                    f'\n<message role="assistant">\n{response.content}\n</message>'
+                )
 
                 # Create the reflection prompt with the tagged conversation history
                 formatted_prompt = f"""
@@ -204,7 +214,9 @@ DO NOT reference the feedback directly. Instead, provide a completely new respon
 
         # Return appropriate command with only the latest response
         if code:
-            return Command(goto="sandbox", update={"messages": [response], "script": code})
+            return Command(
+                goto="sandbox", update={"messages": [response], "script": code}
+            )
         else:
             # no code block, end the loop and respond to the user
             return Command(update={"messages": [response], "script": None})

universal_mcp/agents/codeact/test.py

@@ -1,8 +1,9 @@
 from universal_mcp.agentr import Agentr
+from universal_mcp.tools.adapters import ToolFormat
+
 from universal_mcp.agents.codeact import create_codeact
 from universal_mcp.agents.codeact.sandbox import eval_unsafe
 from universal_mcp.agents.llm import load_chat_model
-from universal_mcp.tools.adapters import ToolFormat
 
 model = load_chat_model("gpt-4.1")
 

universal_mcp/agents/hil.py

@@ -41,10 +41,15 @@ def ask_favourite_color_node(state: State) -> State:
     if state.get("favourite_color") is not None:
         return state
     favourite_color = interrupt(
-        {"question": "What is your favourite color?", "type": "choice", "choices": ["red", "green", "blue"]}
+        {
+            "question": "What is your favourite color?",
+            "type": "choice",
+            "choices": ["red", "green", "blue"],
+        }
     )
     state.update(
-        favourite_color=favourite_color, messages=[HumanMessage(content=f"My favourite color is {favourite_color}")]
+        favourite_color=favourite_color,
+        messages=[HumanMessage(content=f"My favourite color is {favourite_color}")],
     )
     return state
 
@@ -58,7 +63,12 @@ def handle_interrupt(interrupt: Interrupt) -> str | bool:
         value = input("Do you accept this? (y/n): " + interrupt.value["question"])
         return value.lower() in ["y", "yes"]
     elif interrupt_type == "choice":
-        value = input("Enter your choice: " + interrupt.value["question"] + " " + ", ".join(interrupt.value["choices"]))
+        value = input(
+            "Enter your choice: "
+            + interrupt.value["question"]
+            + " "
+            + ", ".join(interrupt.value["choices"])
+        )
         if value in interrupt.value["choices"]:
             return value
         else:
@@ -98,7 +108,9 @@ if __name__ == "__main__":
     import asyncio
 
     agent = HilAgent(
-        "Hil Agent", "You are a friendly agent that asks for the user's name and greets them.", "openrouter/auto"
+        "Hil Agent",
+        "You are a friendly agent that asks for the user's name and greets them.",
+        "openrouter/auto",
     )
 
     asyncio.run(agent.run_interactive())

universal_mcp/agents/llm.py

@@ -1,22 +1,26 @@
+from functools import lru_cache
+
 from langchain_anthropic import ChatAnthropic
 from langchain_core.language_models import BaseChatModel
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_openai import AzureChatOpenAI
 
 
+@lru_cache(maxsize=8)
 def load_chat_model(
-    fully_specified_name: str, temperature: float = 1.0, tags: list[str] | None = None
+    fully_specified_name: str, temperature: float = 1.0, tags: list[str] | None = None, thinking: bool = True
 ) -> BaseChatModel:
     """Load a chat model from a fully specified name.
     Args:
         fully_specified_name (str): String in the format 'provider/model'.
     """
-    provider, model = fully_specified_name.split("/", maxsplit=1)
+    fully_specified_name = fully_specified_name.replace("/", ":")
+    provider, model = fully_specified_name.split(":", maxsplit=1)
     if provider == "anthropic":
         return ChatAnthropic(
             model=model,
             temperature=temperature,
-            # thinking={"type": "enabled", "budget_tokens": 2048},
+            thinking={"type": "enabled", "budget_tokens": 2048} if thinking else None,
             max_tokens=4096,
             tags=tags,
             stream_usage=True,
@@ -39,7 +43,11 @@ def load_chat_model(
 if __name__ == "__main__":
     from loguru import logger
 
-    models_to_test = ["azure/gpt-5-chat", "anthropic/claude-4-sonnet-20250514", "gemini/gemini-2.5-pro"]
+    models_to_test = [
+        "azure/gpt-5-chat",
+        "anthropic/claude-4-sonnet-20250514",
+        "gemini/gemini-2.5-pro",
+    ]
     for model in models_to_test:
         llm = load_chat_model(model)
         logger.info(llm.invoke("Hi!"))

universal_mcp/agents/planner/__init__.py

@@ -1,11 +1,12 @@
 from langgraph.checkpoint.base import BaseCheckpointSaver
+from universal_mcp.tools.registry import ToolRegistry
 
 from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.llm import load_chat_model
 from universal_mcp.agents.react import ReactAgent
-from universal_mcp.tools.registry import ToolRegistry
 
 from .graph import build_graph
+from .prompts import DEVELOPER_PROMPT
 
 
 class PlannerAgent(BaseAgent):
@@ -24,11 +25,20 @@ class PlannerAgent(BaseAgent):
         self.llm = load_chat_model(model)
         self.executor_agent_cls = executor_agent_cls
 
-    async def _build_graph(self):
-        return build_graph(self.llm, self.app_registry, self.instructions, self.model, self.executor_agent_cls).compile(
-            checkpointer=self.memory
+    def _build_system_message(self):
+        return DEVELOPER_PROMPT.format(
+            name=self.name, instructions=self.instructions
         )
 
+    async def _build_graph(self):
+        return build_graph(
+            self.llm,
+            self.app_registry,
+            self._build_system_message(),
+            self.model,
+            self.executor_agent_cls,
+        ).compile(checkpointer=self.memory)
+
     @property
     def graph(self):
         return self._graph

universal_mcp/agents/planner/__main__.py

@@ -1,7 +1,9 @@
 import asyncio
 
 from universal_mcp.agentr.registry import AgentrRegistry
+
 from universal_mcp.agents.planner import PlannerAgent
+from universal_mcp.agents.utils import messages_to_list
 
 
 async def main():
@@ -9,15 +11,17 @@ async def main():
     agent = PlannerAgent(
         name="planner-agent",
         instructions="You are a helpful assistant.",
-        model="gemini/gemini-2.5-flash",
+        model="azure/gpt-4o",
         registry=registry,
     )
-    from rich.console import Console
+    from rich import print
 
-    console = Console()
-    console.print("Starting agent...", style="yellow")
-    async for event in agent.stream(user_input="Send an email to manoj@agentr.dev'", thread_id="xyz"):
-        console.print(event.content, style="red")
+    print("Starting agent...")
+    result = await agent.invoke(
+        user_input="Send an email to manoj@agentr.dev with the subject 'testing planner' and body 'This is a test of the planner agent.'",
+        thread_id="xyz",
+    )
+    print(messages_to_list(result["messages"]))
 
 
 if __name__ == "__main__":

universal_mcp/agents/planner/graph.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-from langchain_core.messages import AIMessage
+from langchain_core.messages import AIMessage, SystemMessage
 from langgraph.graph import END, START, StateGraph
 from loguru import logger
 
@@ -18,7 +18,9 @@ def build_graph(llm, registry, instructions, model, executor_agent_cls):
         task = state["messages"][-1].content
         logger.info(f"Running tool finder for task: {task}")
         tool_finder_graph = build_tool_node_graph(llm, registry)
-        tool_finder_state = await tool_finder_graph.ainvoke({"task": task, "messages": state["messages"]})
+        tool_finder_state = await tool_finder_graph.ainvoke(
+            {"task": task, "messages": state["messages"]}
+        )
 
         if not tool_finder_state.get("apps_required"):
             logger.info("Tool finder determined no apps are required.")
@@ -59,7 +61,11 @@ def build_graph(llm, registry, instructions, model, executor_agent_cls):
     async def _no_tools_node(state: State) -> dict[str, Any]:
         """Handles tasks that don't require tools by invoking the LLM directly."""
         logger.info("No tools required. Invoking LLM directly.")
-        response = await llm.ainvoke(state["messages"])
+        messages = [
+            SystemMessage(content=instructions),
+            *state["messages"],
+        ]
+        response = await llm.ainvoke(messages)
         return {"messages": [response]}
 
     graph_builder.add_node("tool_finder", _tool_finder_node)

universal_mcp/agents/planner/prompts.py

@@ -1 +1,14 @@
-# Prompts for the planner agent
+# prompts.py
+
+DEVELOPER_PROMPT = """
+You are a planner agent that orchestrates tasks by selecting the right tools.
+
+Your primary goal is to analyze a user's request and determine the most effective sequence of tools to accomplish it. You have access to a registry of applications and their corresponding tools.
+
+Here's your process:
+1.  **Assess the Task**: Understand the user's intent and what they want to achieve.
+2.  **Identify Necessary Tools**: Based on the task, identify which applications and tools are required.
+3.  **Orchestrate Execution**: Pass the selected tools and instructions to an executor agent to perform the task.
+
+{instructions}
+"""

universal_mcp/agents/planner/state.py

@@ -2,7 +2,6 @@ from typing import Annotated
 
 from langgraph.graph.message import add_messages
 from typing_extensions import TypedDict
-
 from universal_mcp.types import ToolConfig
 
 

universal_mcp/agents/react.py

@@ -1,13 +1,28 @@
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.prebuilt import create_react_agent
 from loguru import logger
-
 from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.llm import load_chat_model
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolConfig, ToolFormat
 
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.agents.utils import initialize_ui_tools, messages_to_list
+
+DEVELOPER_PROMPT = """You are {name}.
+
+You have access to various tools that can help you answer questions and complete tasks. When you need to use a tool:
+
+1. Think about what information you need
+2. Call the appropriate tool with the right parameters
+3. Use the tool results to provide a comprehensive answer
+
+Always explain your reasoning and be thorough in your responses. If you need to use multiple tools to answer a question completely, do so.
+
+Adhere to the following instructions strictly:
+{instructions}
+"""
+
 
 class ReactAgent(BaseAgent):
     def __init__(
@@ -24,6 +39,7 @@ class ReactAgent(BaseAgent):
         super().__init__(name, instructions, model, memory, **kwargs)
         self.llm = load_chat_model(model)
         self.tools = tools
+        self.ui_tools = initialize_ui_tools()
         self.max_iterations = max_iterations
         self.registry = registry
 
@@ -38,6 +54,8 @@ class ReactAgent(BaseAgent):
         else:
             tools = []
 
+        tools.extend(self.ui_tools)
+
         logger.debug(f"Initialized ReactAgent: name={self.name}, model={self.model}")
         return create_react_agent(
             self.llm,
@@ -47,30 +65,26 @@ class ReactAgent(BaseAgent):
         )
 
     def _build_system_message(self):
-        system_message = f"""You are {self.name}.
-
-You have access to various tools that can help you answer questions and complete tasks. When you need to use a tool:
-
-1. Think about what information you need
-2. Call the appropriate tool with the right parameters
-3. Use the tool results to provide a comprehensive answer
+        return DEVELOPER_PROMPT.format(name=self.name, instructions=self.instructions)
 
-Always explain your reasoning and be thorough in your responses. If you need to use multiple tools to answer a question completely, do so.
-
-{self.instructions}
-"""
-        return system_message
-
-
-if __name__ == "__main__":
-    import asyncio
 
+async def main():
     agent = ReactAgent(
         "Universal React Agent",
-        instructions="",
+        instructions="Be very concise in your answers.",
         model="azure/gpt-4o",
         tools={"google-mail": ["send_email"]},
         registry=AgentrRegistry(),
     )
-    result = asyncio.run(agent.invoke("Send an email with the subject 'testing react agent' to manoj@agentr.dev"))
-    logger.info(result["messages"][-1].content)
+    result = await agent.invoke(
+        "Send an email with the subject 'testing react agent' to manoj@agentr.dev"
+    )
+    from rich import print
+
+    print(messages_to_list(result["messages"]))
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(main())

universal_mcp/agents/shared/tool_node.py

@@ -9,7 +9,6 @@ from langgraph.graph import END, StateGraph
 from langgraph.graph.message import add_messages
 from loguru import logger
 from pydantic import BaseModel, Field
-
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolConfig
 
@@ -97,7 +96,9 @@ INSTRUCTIONS:
             reasoning: str
 
         response = await llm.with_structured_output(AppList).ainvoke(
-            input=prompt.format(task=task, all_apps=all_apps, connected_apps=connected_apps)
+            input=prompt.format(
+                task=task, all_apps=all_apps, connected_apps=connected_apps
+            )
         )
         app_list = response.app_list
         reasoning = f"Found relevant apps: {app_list}. Reasoning: {response.reasoning}"
@@ -105,7 +106,9 @@ INSTRUCTIONS:
 
         return {
             **state,
-            "messages": [AIMessage(content=f"Identified relevant apps: {', '.join(app_list)}")],
+            "messages": [
+                AIMessage(content=f"Identified relevant apps: {', '.join(app_list)}")
+            ],
             "relevant_apps": app_list,
             "reasoning": state.get("reasoning", "") + "\n" + reasoning,
         }
@@ -129,7 +132,9 @@ Your goal is to select the most appropriate tool for the given task.
 Only return tool ids.
 """
 
-        response = await llm.with_structured_output(schema=ToolSelectionOutput).ainvoke(input=SELECT_TOOL_PROMPT)
+        response = await llm.with_structured_output(schema=ToolSelectionOutput).ainvoke(
+            input=SELECT_TOOL_PROMPT
+        )
 
         selected_tool_ids = response.tool_ids
         return selected_tool_ids
@@ -159,7 +164,9 @@ Task: "{task}"
         class SearchQuery(BaseModel):
             query: str
 
-        response = await llm.with_structured_output(SearchQuery).ainvoke(input=prompt.format(task=task))
+        response = await llm.with_structured_output(SearchQuery).ainvoke(
+            input=prompt.format(task=task)
+        )
         query = response.query
         logger.info(f"Generated search query '{query}' for task '{task}'")
         return query
@@ -172,11 +179,17 @@ Task: "{task}"
         apps_with_tools_dict = {}
         reasoning_steps = []
         for app_name in state["relevant_apps"]:
-            logger.info(f"Searching for tools in {app_name} for task: {task} with query '{search_query}'")
-            found_tools = await registry.search_tools(query=search_query, app_id=app_name)
+            logger.info(
+                f"Searching for tools in {app_name} for task: {task} with query '{search_query}'"
+            )
+            found_tools = await registry.search_tools(
+                query=search_query, app_id=app_name
+            )
             selected_tools = await _select_tools(task, found_tools)
             apps_with_tools_dict[app_name] = selected_tools
-            reasoning_steps.append(f"For '{app_name}', selected tool(s): {', '.join(selected_tools)}.")
+            reasoning_steps.append(
+                f"For '{app_name}', selected tool(s): {', '.join(selected_tools)}."
+            )
 
         return {
             **state,
@@ -208,7 +221,9 @@ Task: "{task}"
     )
     workflow.add_conditional_edges(
         "find_relevant_apps",
-        lambda state: "search_tools" if state["relevant_apps"] else "handle_no_apps_found",
+        lambda state: "search_tools"
+        if state["relevant_apps"]
+        else "handle_no_apps_found",
     )
 
     workflow.add_edge("search_tools", END)
@@ -219,6 +234,7 @@ Task: "{task}"
 
 async def main():
     from universal_mcp.agentr.registry import AgentrRegistry
+
     from universal_mcp.agents.llm import load_chat_model
 
     registry = AgentrRegistry()
@@ -228,8 +244,7 @@ async def main():
         "task": "Send an email to manoj@agentr.dev",
         "messages": [HumanMessage(content="Send an email to manoj@agentr.dev")],
     }
-    result = await graph.ainvoke(initial_state)
-    print(result)
+    await graph.ainvoke(initial_state)
 
 
 if __name__ == "__main__":

universal_mcp/agents/simple.py

@@ -8,6 +8,14 @@ from typing_extensions import TypedDict
 
 from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.agents.utils import messages_to_list
+
+DEVELOPER_PROMPT = """
+You are {name}, an helpful assistant who can answer simple questions.
+
+Adhere to the following instructions strictly:
+{instructions}
+"""
 
 
 class State(TypedDict):
@@ -15,16 +23,26 @@ class State(TypedDict):
 
 
 class SimpleAgent(BaseAgent):
-    def __init__(self, name: str, instructions: str, model: str, memory: BaseCheckpointSaver = None, **kwargs):
+    def __init__(
+        self,
+        name: str,
+        instructions: str,
+        model: str,
+        memory: BaseCheckpointSaver = None,
+        **kwargs,
+    ):
         super().__init__(name, instructions, model, memory, **kwargs)
         self.llm = load_chat_model(model)
 
+    def _build_system_message(self):
+        return DEVELOPER_PROMPT.format(name=self.name, instructions=self.instructions)
+
     async def _build_graph(self):
         graph_builder = StateGraph(State)
 
         async def chatbot(state: State):
             messages = [
-                {"role": "system", "content": self.instructions},
+                {"role": "system", "content": self._build_system_message()},
                 *state["messages"],
             ]
             return {"messages": [await self.llm.ainvoke(messages)]}
@@ -34,7 +52,12 @@ class SimpleAgent(BaseAgent):
         graph_builder.add_edge("chatbot", END)
         return graph_builder.compile(checkpointer=self.memory)
 
+async def main():
+    agent = SimpleAgent("Simple Agent", "Act as a 14 year old kid, reply in Gen-Z lingo", "azure/gpt-5-mini")
+    output = await agent.invoke("What is the capital of France?")
+    from rich import print
+    print(messages_to_list(output["messages"]))
+
 
 if __name__ == "__main__":
-    agent = SimpleAgent("Simple Agent", "You are a helpful assistant", "azure/gpt-4o")
-    asyncio.run(agent.run_interactive())
+    asyncio.run(main())

universal_mcp/agents/tools.py

@@ -1,7 +1,6 @@
 import json
 
 from langchain_mcp_adapters.client import MultiServerMCPClient
-
 from universal_mcp.agentr.integration import AgentrIntegration
 from universal_mcp.applications.utils import app_from_slug
 from universal_mcp.tools.adapters import ToolFormat
@@ -15,7 +14,9 @@ async def load_agentr_tools(agentr_servers: dict):
         app = app_from_slug(app_name)
         integration = AgentrIntegration(name=app_name)
         app_instance = app(integration=integration)
-        tool_manager.register_tools_from_app(app_instance, tool_names=tool_names["tools"])
+        tool_manager.register_tools_from_app(
+            app_instance, tool_names=tool_names["tools"]
+        )
     tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
     return tools
 
@@ -30,6 +31,10 @@ async def load_tools(path: str) -> ToolConfig:
     with open(path) as f:
         data = json.load(f)
         config = ToolConfig.model_validate(data)
-        agentr_tools = await load_agentr_tools(config.model_dump(exclude_none=True)["agentrServers"])
-        mcp_tools = await load_mcp_tools(config.model_dump(exclude_none=True)["mcpServers"])
+        agentr_tools = await load_agentr_tools(
+            config.model_dump(exclude_none=True)["agentrServers"]
+        )
+        mcp_tools = await load_mcp_tools(
+            config.model_dump(exclude_none=True)["mcpServers"]
+        )
         return agentr_tools + mcp_tools