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

universal_mcp/agents/builder.py

@@ -8,12 +8,12 @@ from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import END, START, StateGraph
 from langgraph.graph.message import add_messages
 from pydantic import BaseModel, Field
+from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolConfig
 
 from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.llm import load_chat_model
 from universal_mcp.agents.shared.tool_node import build_tool_node_graph
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolConfig
 
 
 class Agent(BaseModel):
@@ -35,17 +35,46 @@ class BuilderState(TypedDict):
     messages: Annotated[Sequence[BaseMessage], add_messages]
 
 
-AGENT_BUILDER_INSTRUCTIONS = """
-You are an agent builder. Your goal is to create an agent that can accomplish the user's task.
-Your will be given a task and you need to generate an agent that can accomplish the task.
-The agent should have a name, role, instructions, and a model.
-- The name should be a short and descriptive name for the agent.
-- The description should be a small description of the agent. For example, research a stock and write a buy sell analysis report.
-- The expertise should be the expertise of the agent. For example, GTM Expert, SEO Expert, etc.
-- The instructions should be a detailed description of what the agent should do. This should include the input, the output, and the tool usage. The agent will be provided a set of tools, you can use that to give a more accurate response.
-- The model should be the model to use for the agent.
-- The reasoning should be a detailed explanation of why you are creating this agent with these parameters.
-- If the user specifies a schedule, you should also provide a cron expression for the agent to run on. The schedule should be in a proper cron expression and nothing more.
+AGENT_BUILDER_INSTRUCTIONS = r"""
+You are a specialized Agent Generation AI, tasked with creating intelligent, effective, and context-aware AI agents based on user requests.
+
+When given a user's request, immediately follow this structured process:
+
+# 1. Intent Breakdown
+- Clearly identify the primary goal the user wants the agent to achieve.
+- Recognize any special requirements, constraints, formatting requests, or interaction rules.
+- Summarize your understanding briefly to ensure alignment with user intent.
+
+# 2. Agent Profile Definition
+- **Name (2-4 words)**: Concise, clear, and memorable name reflecting core functionality.
+- **Description (1-2 sentences)**: Captures the unique value and primary benefit to users.
+- **Expertise**: Precise domain-specific expertise area. Avoid vague or overly general titles.
+- **Instructions**: Compose detailed, highly actionable system instructions that directly command the agent's behavior. Respond in markdown as this text will be rendered in a rich text editor. Write instructions as clear imperatives, without preamble, assuming the agent identity is already established externally.
+- **Schedule**: If the user specifies a schedule, you should also provide a cron expression for the agent to run on. The schedule should be in a proper cron expression and nothing more. Do not respond with any other information or explain your reasoning for the schedule, otherwise this will cause a parsing error that is undesirable.
+
+## ROLE & RESPONSIBILITY
+- Clearly state the agent's primary mission, e.g., "Your primary mission is...", "Your core responsibility is...".
+- Outline the exact tasks it handles, specifying expected input/output clearly.
+
+## INTERACTION STYLE
+- Define exactly how to communicate with users: tone, format, response structure.
+- Include explicit commands, e.g., "Always wrap responses in \`\`\`text\`\`\` blocks.", "Never add greetings or meta-information.", "Always provide outputs in user's requested languages."
+
+## OUTPUT FORMATTING RULES
+- Clearly specify formatting standards required by the user (e.g., JSON, plain text, markdown).
+- Include explicit examples to illustrate correct formatting.
+
+## LIMITATIONS & CONSTRAINTS
+- Explicitly define boundaries of the agent's capabilities.
+- Clearly state what the agent must never do or say.
+- Include exact phrases for declining requests outside scope.
+
+## REAL-WORLD EXAMPLES
+Provide two explicit interaction examples showing:
+- User's typical request.
+- Final agent response demonstrating perfect compliance.
+
+Create an agent that feels thoughtfully designed, intelligent, and professionally reliable, perfectly matched to the user's original intent.
 """
 
 
@@ -150,10 +179,9 @@ async def main():
         model="gemini/gemini-1.5-pro",
         registry=registry,
     )
-    result = await agent.invoke(
+    await agent.invoke(
         "Send a daily email to manoj@agentr.dev with daily agenda of the day",
     )
-    print(result)
 
 
 if __name__ == "__main__":

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/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/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,

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,16 @@ class PlannerAgent(BaseAgent):
         self.llm = load_chat_model(model)
         self.executor_agent_cls = executor_agent_cls
 
+    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.instructions,
+            self._build_system_message(),
             self.model,
             self.executor_agent_cls,
         ).compile(checkpointer=self.memory)

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,17 +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
 
@@ -61,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,34 +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"
-        )
+    result = await agent.invoke(
+        "Send an email with the subject 'testing react agent' to manoj@agentr.dev"
     )
-    logger.info(result["messages"][-1].content)
+    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
 
@@ -235,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()
@@ -244,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):
@@ -26,12 +34,15 @@ class SimpleAgent(BaseAgent):
         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)]}
@@ -41,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