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

universal_mcp/agents/bigtoolcache/graph.py

@@ -11,11 +11,11 @@ from langgraph.runtime import Runtime
 from langgraph.types import Command
 
 from universal_mcp.agents.bigtoolcache.context import Context
+from universal_mcp.agents.bigtoolcache.prompts import TOOLS_LIST
 from universal_mcp.agents.bigtoolcache.state import State
 from universal_mcp.logger import logger
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolFormat
-from universal_mcp.agents.bigtoolcache.prompts import TOOLS_LIST
 
 
 class ToolSelectionOutput(TypedDict):
@@ -179,15 +179,14 @@ def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel):
                     content=json.dumps(tool_result),
                     name=tool_id,
                     tool_call_id=tool_call["id"],
-                )
-            )
-            recent_tool_ids.append(tool_id)
+                ))
+            recent_tool_ids.append(tool_call["name"])
         except Exception as e:
-            logger.error(f"Error executing tool '{tool_id}': {e}")
+            logger.error(f"Error executing tool '{tool_call['name']}': {e}")
             outputs.append(
                 ToolMessage(
                     content=json.dumps("Error: " + str(e)),
-                    name=tool_id,
+                    name=tool_call["name"],
                     tool_call_id=tool_call["id"],
                 )
             )

universal_mcp/agents/bigtoolcache/prompts.py

@@ -1,6 +1,5 @@
 """Default prompts used by the agent."""
 
-import os
 from pathlib import Path
 
 
@@ -14,7 +13,7 @@ def load_tools_from_file():
         tools_file = current_dir / "tools_all.txt"
 
     if tools_file.exists():
-        with open(tools_file, "r", encoding="utf-8") as f:
+        with open(tools_file, encoding="utf-8") as f:
             return f.read()
     else:
         return "No tools file found. Please run tool_retrieve.py to generate the tools list."

universal_mcp/agents/builder.py

@@ -8,12 +8,13 @@ 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
+from universal_mcp.agents.utils import messages_to_list
 
 
 class Agent(BaseModel):
@@ -35,17 +36,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.
 """
 
 
@@ -153,7 +183,10 @@ async def main():
     result = await agent.invoke(
         "Send a daily email to manoj@agentr.dev with daily agenda of the day",
     )
-    print(result)
+    from rich import print
+    print(messages_to_list(result["messages"]))
+    print(result["generated_agent"])
+    print(result["tool_config"])
 
 
 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 = False
 ) -> 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 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__(
@@ -23,7 +38,9 @@ class ReactAgent(BaseAgent):
     ):
         super().__init__(name, instructions, model, memory, **kwargs)
         self.llm = load_chat_model(model)
-        self.tools = tools
+        self.tools = tools or {}
+        if "ui" not in self.tools:
+            self.tools["ui"] = ["create_bar_chart", "create_line_chart", "create_pie_chart", "create_table", "http_get", "http_post", "http_put", "http_delete", "http_patch", "read_file"]
         self.max_iterations = max_iterations
         self.registry = registry
 
@@ -32,12 +49,12 @@ class ReactAgent(BaseAgent):
         if self.tools:
             if not self.registry:
                 raise ValueError("Tools are configured but no registry is provided")
-
             tools = await self.registry.export_tools(self.tools, ToolFormat.LANGCHAIN)
             logger.debug(tools)
         else:
             tools = []
 
+
         logger.debug(f"Initialized ReactAgent: name={self.name}, model={self.model}")
         return create_react_agent(
             self.llm,
@@ -47,34 +64,26 @@ class ReactAgent(BaseAgent):
         )
 
     def _build_system_message(self):
-        system_message = f"""You are {self.name}.
+        return DEVELOPER_PROMPT.format(name=self.name, instructions=self.instructions)
 
-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.
-
-{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/utils.py

@@ -1,12 +1,16 @@
 import json
 from contextlib import contextmanager
 
+from langchain_core.messages.base import BaseMessage
 from rich.console import Console
 from rich.live import Live
 from rich.markdown import Markdown
 from rich.panel import Panel
 from rich.prompt import Prompt
 from rich.table import Table
+from universal_mcp.tools.manager import ToolManager
+from universal_mcp.types import ToolFormat
+
 
 
 class RichCLI:
@@ -30,14 +34,8 @@ Available commands:
 
     def display_agent_response(self, response: str, agent_name: str):
         """Display agent response with formatting"""
-        self.console.print(
-            Panel(
-                Markdown(response),
-                title=f"🤖 {agent_name}",
-                border_style="green",
-                padding=(1, 2),
-            )
-        )
+        self.console.print(f"[green]🤖 {agent_name}:[/green]")
+        self.console.print(Markdown(response), style="green")
 
     @contextmanager
     def display_agent_response_streaming(self, agent_name: str):
@@ -46,28 +44,35 @@ Available commands:
         with Live(refresh_per_second=10, console=self.console) as live:
 
             class StreamUpdater:
+                type_ = ""
                 content = []
 
-                def update(self, chunk: str):
-                    self.content.append(chunk)
-                    panel = Panel(
-                        Markdown("".join(self.content)),
-                        title=f"🤖 {agent_name}",
-                        border_style="green",
-                        padding=(1, 2),
-                    )
-                    live.update(panel)
+                def update(self, chunk: str, type_: str):
+                    if not chunk:
+                        return
+
+                    # Check if type has changed and reset content if so
+                    if self.type_ != type_:
+                        if type_ == "thinking":
+                            self.content += (
+                                "\n[bold yellow]💭 Thinking:[/bold yellow] :"
+                            )
+                        elif type_ == "text":
+                            self.content += (
+                                f"\n[bold green]🤖 {agent_name}[/bold green] :"
+                            )
+                        self.type_ = type_
+                    self.content += chunk
+                    content_text = "".join(self.content)
+                    live.update(content_text)
 
             yield StreamUpdater()
 
     def display_thinking(self, thought: str):
         """Display agent's thinking process"""
         if thought:
-            self.console.print(
-                Panel(
-                    thought, title="💭 Thinking", border_style="yellow", padding=(1, 2)
-                )
-            )
+            self.console.print("[bold yellow]💭 Thinking:[/bold yellow]")
+            self.console.print(thought, style="yellow")
 
     def display_tools(self, tools: list):
         """Display available tools in a table"""
@@ -84,27 +89,18 @@ Available commands:
     def display_tool_call(self, tool_call: dict):
         """Display tool call"""
         tool_call_str = json.dumps(tool_call, indent=2)
-        self.console.print(
-            Panel(
-                tool_call_str, title="🛠️ Tool Call", border_style="green", padding=(1, 2)
-            )
-        )
+        self.console.print("[green]🛠️ Tool Call:[/green]")
+        self.console.print(tool_call_str, style="green")
 
     def display_tool_result(self, tool_result: dict):
         """Display tool result"""
         tool_result_str = json.dumps(tool_result, indent=2)
-        self.console.print(
-            Panel(
-                tool_result_str,
-                title="🛠️ Tool Result",
-                border_style="green",
-                padding=(1, 2),
-            )
-        )
+        self.console.print("[green]🛠️ Tool Result:[/green]")
+        self.console.print(tool_result_str, style="green")
 
     def display_error(self, error: str):
         """Display error message"""
-        self.console.print(Panel(error, title="❌ Error", border_style="red"))
+        self.console.print(f"[red]❌ Error: {error}[/red]")
 
     def get_user_input(self) -> str:
         """Get user input with rich prompt"""
@@ -137,3 +133,7 @@ Available commands:
             return value
         else:
             raise ValueError(f"Invalid interrupt type: {interrupt.value['type']}")
+
+
+def messages_to_list(messages: list[BaseMessage]):
+    return [{"type": message.type, "content": message.content} for message in messages]