universal-mcp 0.1.24rc7__py3-none-any.whl → 0.1.24rc8__py3-none-any.whl

universal_mcp/agentr/__init__.py

@@ -1,6 +1,5 @@
-from .agentr import Agentr
 from .client import AgentrClient
 from .integration import AgentrIntegration
 from .registry import AgentrRegistry
 
-__all__ = ["Agentr", "AgentrClient", "AgentrRegistry", "AgentrIntegration"]
+__all__ = ["AgentrClient", "AgentrRegistry", "AgentrIntegration"]

universal_mcp/agentr/client.py

@@ -16,21 +16,45 @@ class AgentrClient:
     Args:
         api_key (str, optional): AgentR API key. If not provided, will look for AGENTR_API_KEY env var.
         base_url (str, optional): Base URL for AgentR API. Defaults to https://api.agentr.dev.
+        auth_token (str, optional): Auth token for AgentR API. If not provided, will look for AGENTR_AUTH_TOKEN env var.
     """
 
-    def __init__(self, api_key: str | None = None, base_url: str | None = None):
+    def __init__(
+        self, api_key: str | None = None, base_url: str | None = None, auth_token: str | None = None, **kwargs
+    ):
         base_url = base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")
         self.base_url = f"{base_url.rstrip('/')}/v1"
-        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
-        if not self.api_key:
-            raise ValueError("No API key provided and AGENTR_API_KEY not found in environment variables")
-        self.client = httpx.Client(
-            base_url=self.base_url,
-            headers={"X-API-KEY": self.api_key},
-            timeout=30,
-            follow_redirects=True,
-            verify=False,
-        )
+        api_key = api_key or os.getenv("AGENTR_API_KEY")
+        if api_key:
+            self.client = httpx.Client(
+                base_url=self.base_url,
+                headers={"X-API-KEY": api_key, "accept": "application/json"},
+                timeout=30,
+                follow_redirects=True,
+                verify=False,
+            )
+            me_data = self.me()
+            logger.debug(f"Client initialized with user: {me_data['email']}")
+        elif auth_token:
+            logger.debug("Initializing client with auth token")
+            self.client = httpx.Client(
+                base_url=self.base_url,
+                headers={"Authorization": f"Bearer {auth_token}", "accept": "application/json"},
+                timeout=30,
+                follow_redirects=True,
+                verify=False,
+            )
+            me_data = self.me()
+            logger.debug(f"Client initialized with user: {me_data['email']}")
+        else:
+            raise ValueError("No API key or auth token provided")
+
+    def me(self):
+        response = self.client.get("/users/me")
+        logger.debug(f"Me response: {response.status_code}")
+        response.raise_for_status()
+        data = response.json()
+        return data
 
     def get_credentials(self, app_id: str) -> dict[str, Any]:
         """Get credentials for an integration from the AgentR API.
@@ -46,9 +70,10 @@ class AgentrClient:
             HTTPError: For other API errors.
         """
         response = self.client.get(
-            "/credentials/",
+            "/credentials",
             params={"app_id": app_id},
         )
+        logger.debug(f"Credentials response: {response.status_code}")
         if response.status_code == 404:
             logger.warning(f"No credentials found for app '{app_id}'. Requesting authorization...")
             action_url = self.get_authorization_url(app_id)
@@ -73,7 +98,7 @@ class AgentrClient:
         url = response.json().get("authorize_url")
         return f"Please ask the user to visit the following url to authorize the application: {url}. Render the url in proper markdown format with a clickable link."
 
-    def list_all_apps(self) -> list[dict[str, Any]]:
+    def list_all_apps(self):
         """Fetch available apps from AgentR API.
 
         Returns:
@@ -86,27 +111,27 @@ class AgentrClient:
         response.raise_for_status()
         return response.json().get("items", [])
 
-    def list_my_apps(self) -> list[dict[str, Any]]:
+    def list_my_apps(self):
         """Fetch user apps from AgentR API.
 
         Returns:
             List[Dict[str, Any]]: A list of user app data dictionaries.
         """
-        response = self.client.get("/apps/me/")
+        response = self.client.get("/apps/me")
         response.raise_for_status()
         return response.json().get("items", [])
 
-    def list_my_connections(self) -> list[dict[str, Any]]:
+    def list_my_connections(self):
         """Fetch user connections from AgentR API.
 
         Returns:
             List[Dict[str, Any]]: A list of user connection data dictionaries.
         """
-        response = self.client.get("/connections/")
+        response = self.client.get("/connections")
         response.raise_for_status()
         return response.json().get("items", [])
 
-    def get_app_details(self, app_id: str) -> dict[str, Any]:
+    def get_app_details(self, app_id: str):
         """Fetch a specific app from AgentR API.
 
         Args:
@@ -122,7 +147,7 @@ class AgentrClient:
         response.raise_for_status()
         return response.json()
 
-    def list_all_tools(self) -> list[dict[str, Any]]:
+    def list_all_tools(self, app_id: str | None = None):
         """List all available tools from the AgentR API.
 
         Note: In the backend, tools are globally listed and not tied to a
@@ -131,11 +156,14 @@ class AgentrClient:
         Returns:
             List[Dict[str, Any]]: A list of tool configurations.
         """
-        response = self.client.get("/tools/")
+        params = {}
+        if app_id:
+            params["app_id"] = app_id
+        response = self.client.get("/tools", params=params)
         response.raise_for_status()
         return response.json().get("items", [])
 
-    def get_tool_details(self, tool_id: str) -> dict[str, Any]:
+    def get_tool_details(self, tool_id: str):
         """Fetch a specific tool configuration from the AgentR API.
 
         Args:
@@ -151,7 +179,7 @@ class AgentrClient:
         response.raise_for_status()
         return response.json()
 
-    def search_all_apps(self, query: str, limit: int = 2) -> list[dict[str, Any]]:
+    def search_all_apps(self, query: str, limit: int = 2):
         """Search for apps from the AgentR API.
 
         Args:
@@ -161,17 +189,21 @@ class AgentrClient:
         Returns:
             List[Dict[str, Any]]: A list of app data dictionaries.
         """
-        response = self.client.get("/apps/", params={"search": query, "limit": limit})
+        response = self.client.get("/apps", params={"search": query, "limit": limit})
         response.raise_for_status()
         return response.json().get("items", [])
 
-    def search_all_tools(self, query: str, limit: int = 2) -> list[dict[str, Any]]:
+    def search_all_tools(self, query: str, limit: int = 2, app_id: str | None = None):
         """Search for tools from the AgentR API.
 
         Args:
             query (str): The query to search for.
             limit (int, optional): The number of tools to return. Defaults to 2.
+            app_id (str, optional): The ID of the app to search tools for.
         """
-        response = self.client.get("/tools/", params={"search": query, "limit": limit})
+        params = {"search": query, "limit": limit}
+        if app_id:
+            params["app_id"] = app_id
+        response = self.client.get("/tools", params=params)
         response.raise_for_status()
         return response.json().get("items", [])

universal_mcp/agentr/registry.py

@@ -1,9 +1,12 @@
+from typing import Any
+
 from loguru import logger
 
 from universal_mcp.agentr.client import AgentrClient
 from universal_mcp.applications import app_from_slug
 from universal_mcp.tools.manager import ToolManager, _get_app_and_tool_name
 from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolConfig, ToolFormat
 
 from .integration import AgentrIntegration
 
@@ -15,9 +18,10 @@ class AgentrRegistry(ToolRegistry):
         """Initialize the AgentR platform manager."""
 
         self.client = client or AgentrClient(**kwargs)
+        self.tool_manager = ToolManager()
         logger.debug("AgentrRegistry initialized successfully")
 
-    def list_apps(self) -> list[dict[str, str]]:
+    async def list_all_apps(self) -> list[dict[str, Any]]:
         """Get list of available apps from AgentR.
 
         Returns:
@@ -32,7 +36,7 @@ class AgentrRegistry(ToolRegistry):
             logger.error(f"Error fetching apps from AgentR: {e}")
             return []
 
-    def get_app_details(self, app_id: str) -> dict[str, str]:
+    async def get_app_details(self, app_id: str) -> dict[str, Any]:
         """Get detailed information about a specific app from AgentR.
 
         Args:
@@ -48,40 +52,131 @@ class AgentrRegistry(ToolRegistry):
             logger.error(f"Error getting details for app {app_id}: {e}")
             return {}
 
-    def load_tools(self, tools: list[str] | None, tool_manager: ToolManager) -> None:
+    async def search_apps(
+        self,
+        query: str,
+        limit: int = 10,
+    ) -> list[dict[str, Any]]:
+        """Search for apps by a query.
+
+        Args:
+            query: The query to search for
+            limit: The number of apps to return
+
+        Returns:
+            List of app dictionaries matching the query
+        """
+        try:
+            apps = self.client.search_all_apps(query, limit)
+            return apps
+        except Exception as e:
+            logger.error(f"Error searching apps from AgentR: {e}")
+            return []
+
+    async def list_tools(
+        self,
+        app_id: str,
+    ) -> list[dict[str, Any]]:
+        """List all tools available on the platform, filter by app_id.
+
+        Args:
+            app_id: The ID of the app to list tools for
+
+        Returns:
+            List of tool dictionaries for the specified app
+        """
+        try:
+            all_tools = self.client.list_all_tools(app_id=app_id)
+            return all_tools
+        except Exception as e:
+            logger.error(f"Error listing tools for app {app_id}: {e}")
+            return []
+
+    async def search_tools(
+        self,
+        query: str,
+        limit: int = 2,
+        app_id: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """Search for tools by a query.
+
+        Args:
+            query: The query to search for
+            limit: The number of tools to return
+            app_id: The ID of the app to list tools for
+        Returns:
+            List of tool dictionaries matching the query
+        """
+        try:
+            tools = self.client.search_all_tools(query, limit, app_id)
+            return tools
+        except Exception as e:
+            logger.error(f"Error searching tools from AgentR: {e}")
+            return []
+
+    async def export_tools(
+        self,
+        tools: list[str] | ToolConfig,
+        format: ToolFormat,
+    ) -> str:
+        """Export given tools to required format.
+
+        Args:
+            tools: List of tool identifiers to export
+            format: The format to export tools to (native, mcp, langchain, openai)
+
+        Returns:
+            String representation of tools in the specified format
+        """
+        try:
+            # Clear tools from tool manager before loading new tools
+            self.tool_manager.clear_tools()
+            if isinstance(tools, ToolConfig):
+                print("Loading tools from tool config")
+                self._load_tools_from_tool_config(tools, self.tool_manager)
+            else:
+                print("Loading tools from list")
+                self._load_agentr_tools_from_list(tools, self.tool_manager)
+            loaded_tools = self.tool_manager.list_tools(format=format)
+            logger.info(f"Exporting {len(loaded_tools)} tools to {format} format")
+            return loaded_tools
+        except Exception as e:
+            logger.error(f"Error exporting tools: {e}")
+            return ""
+
+    def _load_tools(self, app_name: str, tool_names: list[str], tool_manager: ToolManager) -> None:
+        """Helper method to load and register tools for an app."""
+        app = app_from_slug(app_name)
+        integration = AgentrIntegration(name=app_name, client=self.client)
+        app_instance = app(integration=integration)
+        tool_manager.register_tools_from_app(app_instance, tool_names=tool_names)
+
+    def _load_agentr_tools_from_list(self, tools: list[str], tool_manager: ToolManager) -> None:
         """Load tools from AgentR and register them as tools.
 
         Args:
-            tools: The list of tools to load ( prefixed with app name )
+            tools: The list of tools to load (prefixed with app name)
             tool_manager: The tool manager to register tools with
         """
-        if not tools:
-            return
-        logger.info(f"Loading all actions for app: {tools}")
-        # Group all tools by app_name, tools
+        logger.info(f"Loading all tools: {tools}")
         tools_by_app = {}
         for tool_name in tools:
             app_name, _ = _get_app_and_tool_name(tool_name)
-            if app_name not in tools_by_app:
-                tools_by_app[app_name] = []
-            tools_by_app[app_name].append(tool_name)
+            tools_by_app.setdefault(app_name, []).append(tool_name)
 
         for app_name, tool_names in tools_by_app.items():
-            app = app_from_slug(app_name)
-            integration = AgentrIntegration(name=app_name)
-            # TODO: Import with name param, some apps are written incorrectly and hence passing name fails
-            app_instance = app(integration=integration)
-            tool_manager.register_tools_from_app(app_instance, tool_names=tool_names)
-        return
+            self._load_tools(app_name, tool_names, tool_manager)
 
-    def search_tools(self, query: str, limit: int = 20) -> list[str]:
-        """Search for tools in AgentR.
+    def _load_tools_from_tool_config(self, tool_config: ToolConfig, tool_manager: ToolManager) -> None:
+        """Load tools from ToolConfig and register them as tools.
 
         Args:
-            query: The query to search for
-
-        Returns:
-            List of tool names
+            tool_config: The tool configuration containing app names and tools
+            tool_manager: The tool manager to register tools with
         """
-        return self.client.search_all_tools(query, limit)
-    
+        for app_name, tool_data in tool_config.agentrServers.items():
+            self._load_tools(app_name, tool_data.tools, tool_manager)
+
+    async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> dict[str, Any]:
+        """Call a tool with the given name and arguments."""
+        return await self.tool_manager.call_tool(tool_name, tool_args)

universal_mcp/agents/__init__.py

@@ -1,4 +1,4 @@
-from universal_mcp.agents.auto import AutoAgent
+from universal_mcp.agents.autoagent import AutoAgent
 from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.react import ReactAgent
 from universal_mcp.agents.simple import SimpleAgent

universal_mcp/agents/auto.py

@@ -12,13 +12,12 @@ from pydantic import BaseModel
 from typing_extensions import TypedDict
 
 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 import ToolManager
 from universal_mcp.tools.adapters import ToolFormat
 from universal_mcp.tools.registry import ToolRegistry
 
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.llm import load_chat_model
-
 # Auto Agent
 # Working
 # 1. For every message, and given list of tools, figure out if external tools are needed

universal_mcp/agents/autoagent/__init__.py

@@ -1,10 +1,10 @@
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
 from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents.autoagent.graph import build_graph
 from universal_mcp.agents.base import BaseAgent
-from universal_mcp.tools.manager import ToolManager
 from universal_mcp.tools.registry import ToolRegistry
 
-from universal_mcp.agents.autoagent.graph import create_agent
-
 
 class AutoAgent(BaseAgent):
     def __init__(
@@ -12,20 +12,16 @@ class AutoAgent(BaseAgent):
         name: str,
         instructions: str,
         model: str,
-        tool_registry: ToolRegistry | None = None,
-        tool_manager: ToolManager | None = None,
+        memory: BaseCheckpointSaver | None = None,
+        registry: ToolRegistry | None = None,
+        **kwargs,
     ):
-        super().__init__(name, instructions, model, tool_registry)
-        self.tool_registry = tool_registry or AgentrRegistry()
-        self.tool_manager = tool_manager or ToolManager()
-        self.model = model
-        self.name = name
-        self.instructions = instructions
-        self._graph = self._build_graph()
+        super().__init__(name, instructions, model, memory, **kwargs)
+        self.tool_registry = registry or AgentrRegistry()
 
-    def _build_graph(self):
-        builder = create_agent(self.tool_registry, self.tool_manager, self.instructions)
-        return builder.compile()
+    async def _build_graph(self):
+        builder = await build_graph(self.tool_registry, self.instructions)
+        return builder.compile(checkpointer=self.memory)
 
     @property
     def graph(self):

universal_mcp/agents/autoagent/__main__.py

@@ -8,10 +8,10 @@ async def main():
     agent = AutoAgent(
         name="autoagent",
         instructions="You are a helpful assistant that can use tools to help the user.",
-        model="azure/gpt-4o",
+        model="anthropic/claude-4-sonnet-20250514",
         tool_registry=AgentrRegistry(),
     )
-    result = await agent.run(
+    result = await agent.invoke(
         user_input="Send an email to Manoj from my google mail account, manoj@agentr.dev, with the subject 'Hello from auto agent' and the body 'testing'"
     )
     print(result)

universal_mcp/agents/autoagent/graph.py

@@ -7,49 +7,65 @@ from langchain_core.tools import tool
 from langgraph.graph import END, START, StateGraph
 from langgraph.runtime import Runtime
 
-from universal_mcp.agents.llm import load_chat_model
-from universal_mcp.tools.manager import ToolManager
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolFormat
-
 from universal_mcp.agents.autoagent.context import Context
 from universal_mcp.agents.autoagent.prompts import SYSTEM_PROMPT
 from universal_mcp.agents.autoagent.state import State
+from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolFormat
 
 
-def create_agent(tool_registry: ToolRegistry, tool_manager: ToolManager, instructions: str = ""):
+async def build_graph(tool_registry: ToolRegistry, instructions: str = ""):
     @tool()
-    def retrieve_tools(query: str) -> list[str]:
-        """Retrieve tools using a search query. Use multiple times if you require tools for different tasks."""
-        tools = tool_registry.search_tools(query)
-        my_connections = tool_registry.client.list_my_connections()
-        connected_apps = set(connection["app_id"] for connection in my_connections)
-        filtered_tools = [tool for tool in tools if tool["app_id"] in connected_apps]
-        if len(filtered_tools) == 0:
-            return tools
-        return filtered_tools
-    
+    async def search_tools(query: str, app_ids: list[str] | None = None) -> list[str]:
+        """Retrieve tools using a search query and app id. Use multiple times if you require tools for different tasks."""
+        tools_list = []
+        if app_ids is not None:
+            for app_id in app_ids:
+                tools_list.extend(await tool_registry.search_tools(query, limit=10, app_id=app_id))
+        else:
+            tools_list = await tool_registry.search_tools(query, limit=10)
+        tools_list = [f"{tool['id']}: {tool['description']}" for tool in tools_list]
+        return tools_list
+
     @tool()
-    def ask_user(question: str) -> str:
+    async def ask_user(question: str) -> str:
         """Ask the user a question. Use this tool to ask the user for any missing information for performing a task, or when you have multiple apps to choose from for performing a task."""
         full_question = question
         return f"ASKING_USER: {full_question}"
+    
+    @tool()
+    async def load_tools(tools: list[str]) -> list[str]:
+        """Choose the tools you want to use by passing their tool ids.  Loads the tools for the chosen tools and returns the tool ids."""
+        return tools
+    
 
-    def call_model(
+    async def call_model(
         state: State,
         runtime: Runtime[Context],
     ):
         system_prompt = runtime.context.system_prompt if runtime.context.system_prompt else SYSTEM_PROMPT
-        system_prompt = system_prompt.format(system_time=datetime.now(tz=UTC).isoformat())
-
+        app_ids = await tool_registry.list_all_apps()
+        app_id_descriptions = "\n".join([f"{app['id']}: {app['description']}" for app in app_ids])
+        print(app_id_descriptions)
+        system_prompt = system_prompt.format(system_time=datetime.now(tz=UTC).isoformat(), app_ids=app_id_descriptions)
+        
         messages = [{"role": "system", "content": system_prompt + "\n" + instructions}, *state["messages"]]
         model = load_chat_model(runtime.context.model)
         # Load tools from tool registry
-        tool_registry.load_tools(tools=state["selected_tool_ids"], tool_manager=tool_manager)
-        loaded_tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
-        model_with_tools = model.bind_tools([retrieve_tools, ask_user, *loaded_tools], tool_choice="auto")
-        response = cast(AIMessage, model_with_tools.invoke(messages))
-        return {"messages": [response]}
+        loaded_tools = await tool_registry.export_tools(tools=state["selected_tool_ids"], format=ToolFormat.LANGCHAIN)
+        model_with_tools = model.bind_tools([search_tools, ask_user, load_tools, *loaded_tools], tool_choice="auto")
+        response_raw = model_with_tools.invoke(messages)
+        token_usage = state.get("token_usage", {})
+        for key in ["input_tokens", "output_tokens", "total_tokens"]:
+            if key in token_usage:
+                token_usage[key] += response_raw.usage_metadata[key]
+            else:
+                token_usage[key] = response_raw.usage_metadata[key]
+        print(response_raw.usage_metadata)
+        print(token_usage)
+        response = cast(AIMessage, response_raw) 
+        return {"messages": [response], "token_usage": token_usage}
 
     # Define the conditional edge that determines whether to continue or not
     def should_continue(state: State):
@@ -58,10 +74,9 @@ def create_agent(tool_registry: ToolRegistry, tool_manager: ToolManager, instruc
         # If there is no function call, then we finish
         if not last_message.tool_calls:
             return END
-        # Otherwise if there is, we continue
         else:
             return "tools"
-    
+
     def tool_router(state: State):
         last_message = state["messages"][-1]
         if isinstance(last_message, ToolMessage):
@@ -69,35 +84,45 @@ def create_agent(tool_registry: ToolRegistry, tool_manager: ToolManager, instruc
         else:
             return END
 
-
     async def tool_node(state: State):
         outputs = []
         tool_ids = state["selected_tool_ids"]
         for tool_call in state["messages"][-1].tool_calls:
-            if tool_call["name"] == retrieve_tools.name:
-                tool_result = retrieve_tools.invoke(tool_call["args"])
-                tool_ids = [tool["id"] for tool in tool_result]
+            if tool_call["name"] == ask_user.name:
                 outputs.append(
                     ToolMessage(
-                        content=json.dumps(tool_result),
+                        content=json.dumps(
+                            "The user has been asked the question, and the run will wait for the user's response."
+                        ),
                         name=tool_call["name"],
                         tool_call_id=tool_call["id"],
                     )
                 )
-            elif tool_call["name"] == ask_user.name:
+                ai_message = AIMessage(content=tool_call["args"]["question"])
+                outputs.append(ai_message)
+            elif tool_call["name"] == search_tools.name:
+                tools = await search_tools.ainvoke(tool_call["args"])
                 outputs.append(
                     ToolMessage(
-                        content=json.dumps("The user has been asked the question, and the run will wait for the user's response."),
+                        content=json.dumps(tools)+"\n\nUse the load_tools tool to load the tools you want to use.",
+                        name=tool_call["name"],
+                        tool_call_id=tool_call["id"],
+                    )
+                )
+                
+            elif tool_call["name"] == load_tools.name:
+                tool_ids = await load_tools.ainvoke(tool_call["args"])
+                print(tool_ids)
+                outputs.append(
+                    ToolMessage(
+                        content=json.dumps(tool_ids),
                         name=tool_call["name"],
                         tool_call_id=tool_call["id"],
                     )
                 )
-                ai_message = AIMessage(content=tool_call["args"]["question"])
-                outputs.append(ai_message)
             else:
-                tool_manager.clear_tools()
-                tool_registry.load_tools([tool_call["name"]], tool_manager=tool_manager)
-                tool_result = await tool_manager.call_tool(tool_call["name"], tool_call["args"])
+                await tool_registry.export_tools([tool_call["name"]], ToolFormat.LANGCHAIN)
+                tool_result = await tool_registry.call_tool(tool_call["name"], tool_call["args"])
                 outputs.append(
                     ToolMessage(
                         content=json.dumps(tool_result),
@@ -107,6 +132,10 @@ def create_agent(tool_registry: ToolRegistry, tool_manager: ToolManager, instruc
                 )
         return {"messages": outputs, "selected_tool_ids": tool_ids}
 
+                
+
+
+
     builder = StateGraph(State, context_schema=Context)
 
     builder.add_node("agent", call_model)

universal_mcp/agents/autoagent/prompts.py

@@ -1,5 +1,8 @@
 """Default prompts used by the agent."""
 
-SYSTEM_PROMPT = """You are a helpful AI assistant. When you lack tools for any task you should use the `retrieve_tools` function to unlock relevant tools. Whenever you need to ask the user for any information, or choose between multiple different applications, you can ask the user using the `ask_user` function.
+SYSTEM_PROMPT = """You are a helpful AI assistant. When you lack tools for any task you should use the `search_tools` function to unlock relevant tools. Whenever you need to ask the user for any information, or choose between multiple different applications, you can ask the user using the `ask_user` function.
 
-System time: {system_time}"""
+System time: {system_time}
+App IDs: {app_ids}
+Note that when multiple apps seem relevant for a task, you should ask the user to choose the app.
+"""

universal_mcp/agents/autoagent/state.py

@@ -25,3 +25,4 @@ def _enqueue(left: list, right: list) -> list:
 
 class State(AgentState):
     selected_tool_ids: Annotated[list[str], _enqueue]
+    token_usage: dict[str, int]

universal_mcp/agents/autoagent/studio.py

@@ -1,5 +1,7 @@
+import asyncio
+
 from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.agents.autoagent import create_agent
+from universal_mcp.agents.autoagent import build_graph
 from universal_mcp.tools import ToolManager
 
 tool_registry = AgentrRegistry()
@@ -7,16 +9,14 @@ tool_manager = ToolManager()
 
 
 
-apps = tool_registry.client.list_all_apps()
-names = [app["name"] for app in apps]
-
-instructions = """
-You are a helpful assistant that can use tools to help the user. If a task requires multiple steps, you should perform separate different searches for different actions.
-These are the list of applications you can use to help the user:
-{names}
-"""
-graph = create_agent(tool_registry, tool_manager, instructions=instructions)
+async def main():
+    instructions = """
+    You are a helpful assistant that can use tools to help the user. If a task requires multiple steps, you should perform separate different searches for different actions. Prefer completing one action before searching for another.
+    """
+    graph = await build_graph(tool_registry, instructions=instructions)
+    return graph
 
+graph = asyncio.run(main())
 
 
 

universal_mcp/agents/base.py

@@ -7,7 +7,6 @@ from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.checkpoint.memory import MemorySaver
 from langgraph.types import Command
 
-from .llm import load_chat_model
 from .utils import RichCLI
 
 
@@ -18,15 +17,19 @@ class BaseAgent:
         self.model = model
         self.memory = memory or MemorySaver()
         self._graph = None
-        self.llm = load_chat_model(model)
+        self._initialized = False
         self.cli = RichCLI()
 
+    async def ainit(self):
+        if not self._initialized:
+            self._graph = await self._build_graph()
+            self._initialized = True
+
     async def _build_graph(self):
         raise NotImplementedError("Subclasses must implement this method")
 
     async def stream(self, thread_id: str, user_input: str):
-        if self._graph is None:
-            self._graph = await self._build_graph()
+        await self.ainit()
         async for event, _ in self._graph.astream(
             {"messages": [{"role": "user", "content": user_input}]},
             config={"configurable": {"thread_id": thread_id}},
@@ -36,14 +39,14 @@ class BaseAgent:
             yield event
 
     async def stream_interactive(self, thread_id: str, user_input: str):
+        await self.ainit()
         with self.cli.display_agent_response_streaming(self.name) as stream_updater:
-            async for event in self.astream(thread_id, user_input):
+            async for event in self.stream(thread_id, user_input):
                 stream_updater.update(event.content)
 
-    async def run(self, user_input: str, thread_id: str = str(uuid4())):
+    async def invoke(self, user_input: str, thread_id: str = str(uuid4())):
         """Run the agent"""
-        if not self._graph:
-            self._graph = await self._build_graph()
+        await self.ainit()
         return await self._graph.ainvoke(
             {"messages": [{"role": "user", "content": user_input}]},
             config={"configurable": {"thread_id": thread_id}},
@@ -53,8 +56,7 @@ class BaseAgent:
     async def run_interactive(self, thread_id: str = str(uuid4())):
         """Main application loop"""
 
-        if not self._graph:
-            self._graph = await self._build_graph()
+        await self.ainit()
         # Display welcome
         self.cli.display_welcome(self.name)
 

universal_mcp/agents/react.py

@@ -2,9 +2,12 @@ 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.tools import load_agentr_tools, load_mcp_tools
-from universal_mcp.types import ToolConfig
+from universal_mcp.agents.llm import load_chat_model
+from universal_mcp.agents.tools import load_mcp_tools
+from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolConfig, ToolFormat
 
 
 class ReactAgent(BaseAgent):
@@ -15,18 +18,29 @@ class ReactAgent(BaseAgent):
         model: str,
         memory: BaseCheckpointSaver | None = None,
         tools: ToolConfig | None = None,
+        registry: ToolRegistry | None = None,
         max_iterations: int = 10,
         **kwargs,
     ):
         super().__init__(name, instructions, model, memory, **kwargs)
+        self.llm = load_chat_model(model)
         self.tools = tools
         self.max_iterations = max_iterations
+        self.registry = registry
 
     async def _build_graph(self):
         if self.tools:
             config = self.tools.model_dump(exclude_none=True)
-            agentr_tools = await load_agentr_tools(config["agentrServers"]) if config.get("agentrServers") else []
+            if config.get("agentrServers") and not self.registry:
+                raise ValueError("Agentr servers are configured but no registry is provided")
+            agentr_tools = (
+                await self.registry.export_tools(self.tools, ToolFormat.LANGCHAIN)
+                if config.get("agentrServers")
+                else []
+            )
+            print(agentr_tools)
             mcp_tools = await load_mcp_tools(config["mcpServers"]) if config.get("mcpServers") else []
+            print(mcp_tools)
             tools = agentr_tools + mcp_tools
         else:
             tools = []
@@ -39,7 +53,7 @@ class ReactAgent(BaseAgent):
         )
 
     def _build_system_message(self) -> str:
-        system_message = f"""You are {self.name}. {self.instructions}
+        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:
 
@@ -47,7 +61,10 @@ You have access to various tools that can help you answer questions and complete
 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."""
+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
 
 
@@ -57,10 +74,11 @@ if __name__ == "__main__":
     agent = ReactAgent(
         "Universal React Agent",
         instructions="",
-        model="gpt-4o",
+        model="azure/gpt-4o",
         tools=ToolConfig(agentrServers={"google-mail": {"tools": ["send_email"]}}),
+        registry=AgentrRegistry(),
     )
     result = asyncio.run(
-        agent.run(user_input="Send an email with the subject 'testing react agent' to manoj@agentr.dev")
+        agent.invoke(user_input="Send an email with the subject 'testing react agent' to manoj@agentr.dev")
     )
     print(result["messages"][-1].content)

universal_mcp/agents/simple.py

@@ -1,6 +1,7 @@
 import asyncio
 from typing import Annotated
 
+from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import END, START, StateGraph
 from langgraph.graph.message import add_messages
 from typing_extensions import TypedDict
@@ -14,27 +15,26 @@ class State(TypedDict):
 
 
 class SimpleAgent(BaseAgent):
-    def __init__(self, name: str, instructions: str, model: str):
-        super().__init__(name, instructions, model)
+    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)
-        self._graph = self._build_graph()
 
-    def _build_graph(self):
+    async def _build_graph(self):
         graph_builder = StateGraph(State)
 
-        def chatbot(state: State):
-            return {"messages": [self.llm.invoke(state["messages"])]}
+        async def chatbot(state: State):
+            messages = [
+                {"role": "system", "content": self.instructions},
+                *state["messages"],
+            ]
+            return {"messages": [await self.llm.ainvoke(messages)]}
 
         graph_builder.add_node("chatbot", chatbot)
         graph_builder.add_edge(START, "chatbot")
         graph_builder.add_edge("chatbot", END)
         return graph_builder.compile(checkpointer=self.memory)
 
-    @property
-    def graph(self):
-        return self._graph
-
 
 if __name__ == "__main__":
-    agent = SimpleAgent("Simple Agent", "You are a helpful assistant", "openrouter/auto")
+    agent = SimpleAgent("Simple Agent", "You are a helpful assistant", "azure/gpt-4o")
     asyncio.run(agent.run_interactive())

universal_mcp/tools/registry.py

@@ -1,19 +1,27 @@
 from abc import ABC, abstractmethod
 from typing import Any
 
-from universal_mcp.tools.manager import ToolManager
+from universal_mcp.types import ToolConfig, ToolFormat
 
 
 class ToolRegistry(ABC):
     """Abstract base class for platform-specific functionality.
 
     This class abstracts away platform-specific operations like fetching apps,
-    loading actions, and managing integrations. This allows the AutoAgent to
+    loading actions, and managing integrations. This allows the agents to
     work with different platforms without being tightly coupled to any specific one.
+
+    The following methods are abstract and must be implemented by the subclass:
+    - list_all_apps: Get list of available apps from the platform.
+    - get_app_details: Get details of a specific app.
+    - search_apps: Search for apps by a query.
+    - list_tools: List all tools available on the platform, filter by app_id.
+    - search_tools: Search for tools by a query.
+    - export_tools: Export tools to required format.
     """
 
     @abstractmethod
-    def list_apps(self) -> list[dict[str, Any]]:
+    async def list_all_apps(self) -> list[dict[str, Any]]:
         """Get list of available apps from the platform.
 
         Returns:
@@ -22,7 +30,7 @@ class ToolRegistry(ABC):
         pass
 
     @abstractmethod
-    def get_app_details(self, app_id: str) -> dict[str, Any]:
+    async def get_app_details(self, app_id: str) -> dict[str, Any]:
         """Get detailed information about a specific app.
 
         Args:
@@ -34,18 +42,42 @@ class ToolRegistry(ABC):
         pass
 
     @abstractmethod
-    def load_tools(self, tools: list[str], tool_manager: ToolManager) -> None:
-        """Load tools from the platform and register them as tools.
+    async def search_apps(
+        self,
+        query: str,
+        limit: int = 2,
+    ) -> list[dict[str, Any]]:
+        """Search for apps by a query."""
+        pass
 
-        Args:
-            tools: The list of tools to load
-        """
+    @abstractmethod
+    async def list_tools(
+        self,
+        app_id: str,
+    ) -> list[dict[str, Any]]:
+        """List all tools available on the platform, filter by app_id."""
         pass
 
     @abstractmethod
-    def search_tools(
+    async def search_tools(
         self,
         query: str,
-    ) -> list[str]:
-        """Retrieve a tool to use, given a search query."""
+        limit: int = 2,
+        app_id: str | None = None,
+    ) -> list[dict[str, Any]]:
+        """Search for tools by a query."""
+        pass
+
+    @abstractmethod
+    async def export_tools(
+        self,
+        tools: list[str] | ToolConfig,
+        format: ToolFormat,
+    ) -> str:
+        """Export giventools to required format."""
+        pass
+
+    @abstractmethod
+    async def call_tool(self, tool_name: str, tool_args: dict[str, Any]) -> dict[str, Any]:
+        """Call a tool with the given name and arguments."""
         pass

{universal_mcp-0.1.24rc7.dist-info → universal_mcp-0.1.24rc8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc7
+Version: 0.1.24rc8
 Summary: Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more.
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 License: MIT

{universal_mcp-0.1.24rc7.dist-info → universal_mcp-0.1.24rc8.dist-info}/RECORD

@@ -7,29 +7,28 @@ universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
 universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 universal_mcp/types.py,sha256=jeUEkUnwdGWo3T_qSRSF83u0fYpuydaWzdKlCYBlCQA,770
 universal_mcp/agentr/README.md,sha256=t15pVgkCwZM5wzgLgrf0Zv6hVL7dPmKXvAeTf8CiXPQ,6641
-universal_mcp/agentr/__init__.py,sha256=ogOhH_OJwkoUZu_2nQJc7-vEGmYQxEjOE511-6ubrX0,217
-universal_mcp/agentr/agentr.py,sha256=kTUiBpDl4ODuXit9VE_ZXW28IKpCqEnJDNtMXi2B3Pc,1245
-universal_mcp/agentr/client.py,sha256=B4pjIpfD5nDCZ9qldKIqlBV8DISrkTRrajCIQK4r4Hs,6232
+universal_mcp/agentr/__init__.py,sha256=fv1ZnOCduIUiJ9oN4e6Ya_hA2oWQvcEuDU3Ek1vEufI,180
+universal_mcp/agentr/client.py,sha256=-oyNlR5hWSV9CFaTp3JmzP99P44_A0QJ-tMuY6LIGWk,7419
 universal_mcp/agentr/integration.py,sha256=V5GjqocqS02tRoI8MeV9PL6m-BzejwBzgJhOHo4MxAE,4212
-universal_mcp/agentr/registry.py,sha256=BOxy9iuJagKLmH9komaabwXvUglrsWbpRX8WY9xJ7lI,3115
+universal_mcp/agentr/registry.py,sha256=O60qOsuby1GTkgc9GXVf9BjHmjMTyDbxqbDfIJ13CJ4,6583
 universal_mcp/agentr/server.py,sha256=bIPmHMiKKwnUYnxmfZVRh1thcn7Rytm_-bNiXTfANzc,2098
-universal_mcp/agents/__init__.py,sha256=ZkdQ71fn838LvYdyln6fL1mUMUUCZRZMyqos4aW2_I4,265
-universal_mcp/agents/auto.py,sha256=UUx3p9riLww2OwRg0pg10mWzWdDNydBrKJ-UdwzAQSk,25411
-universal_mcp/agents/base.py,sha256=uRb-flv_pdKfDJnHID1c-loYt-EvlAgFmB1_wJQNhUs,4152
+universal_mcp/agents/__init__.py,sha256=AMBDQs3p5PePjzdoHYNoPYEsUK_PLHGNVPGxK7yrKVo,270
+universal_mcp/agents/auto.py,sha256=BknCoeexTbFvwmVzYdGiiH72S_r6_5s9tmjH9M0I4d4,25410
+universal_mcp/agents/base.py,sha256=o41gxvwOqWY0IZnupAHfKeH7OG0dgHUQDDpqntsFg6M,4128
 universal_mcp/agents/cli.py,sha256=7GdRBpu9rhZPiC2vaNQXWI7K-0yCnvdlmE0IFpvy2Gk,539
 universal_mcp/agents/hil.py,sha256=6xi0hhK5g-rhCrAMcGbjcKMReLWPC8rnFZMBOF3N_cY,3687
 universal_mcp/agents/llm.py,sha256=0HUI2Srh3RWtGyrjJCKqsroEgc1Rtkta3T8I1axl1mg,1232
-universal_mcp/agents/react.py,sha256=kAyTS68xzBLWRNgjJrLSP85o1ligz_ziatdlMZAavnA,2385
-universal_mcp/agents/simple.py,sha256=CXmwJq7jvxAoDJifNK7jKJTMKG4Pvre75x-k2CE-ZEM,1202
+universal_mcp/agents/react.py,sha256=g2PwqxYe7v7wCMDCCQhTtGU1eFmSsF4g7T_t9d-v0ho,3012
+universal_mcp/agents/simple.py,sha256=JL8TFyXlA1F4zcArgKhlqVIbLWXetwM05z4MPDJgFeI,1367
 universal_mcp/agents/tools.py,sha256=7Vdw0VZYxXVAzAYSpRKWHzVl9Ll6NOnVRlc4cTXguUQ,1335
 universal_mcp/agents/utils.py,sha256=7kwFpD0Rv6JqHG-LlNCVwSu_xRX-N119mUmiBroHJL4,4109
-universal_mcp/agents/autoagent/__init__.py,sha256=Vfm8brM9TNXCjKbVXV-CAPg_BVnYHOn6RVmkS0EaNV0,1072
-universal_mcp/agents/autoagent/__main__.py,sha256=FUSETuCDMpp7VSis0UFDnpI32HmQuJYaAXaOX5fQl-4,622
+universal_mcp/agents/autoagent/__init__.py,sha256=E_vMnFz8Z120qdqaKXPNP_--4Tes4jImen7m_iZvtVo,913
+universal_mcp/agents/autoagent/__main__.py,sha256=ps0cT7b9DN-jQK8pOKFVRZf3Oz_dVSBSYWOa8sc7VNc,647
 universal_mcp/agents/autoagent/context.py,sha256=1ic3sIL14XZeiMjpkwysLImRTQFKXRFSx7rvgVh4plY,802
-universal_mcp/agents/autoagent/graph.py,sha256=f_TPcMk0t4JgM1gYs4sLFIeCrTGAzecc2rN0MPsmxvs,5116
-universal_mcp/agents/autoagent/prompts.py,sha256=DwLHwvsISuNrxeua0tKxTQbkU8u9gljCpk3P18VGk4w,386
-universal_mcp/agents/autoagent/state.py,sha256=TQeGZD99okclkoCh5oz-VYIlEsC9yLQyDpnBnm7QCN8,759
-universal_mcp/agents/autoagent/studio.py,sha256=FWmZTAH54euF0ePG6xCBNwklBjdmjZ3jAOBoTrwNcqs,656
+universal_mcp/agents/autoagent/graph.py,sha256=f6RF9Cm1aiYTHoEhNHG_FNQrU-MgEb8QIHdg9pQSyuA,6390
+universal_mcp/agents/autoagent/prompts.py,sha256=5EiQVE75LrERYAh29CltjMxI7znt_eW_LP4zX_7LxHY,502
+universal_mcp/agents/autoagent/state.py,sha256=pTKbgTK8TTx7qIioVt98u9KZpeWacWaRmKJWRv3Jj40,791
+universal_mcp/agents/autoagent/studio.py,sha256=nfVRzPXwBjDORHA0wln2k3Nz-zQXNKgZMvgeqBvkdtM,644
 universal_mcp/agents/autoagent/utils.py,sha256=AFq-8scw_WlSZxDnTzxSNrOSiGYsIlqkqtQLDWf_rMU,431
 universal_mcp/agents/codeact/__init__.py,sha256=5D_I3lI_3tWjZERRoFav_bPe9UDaJ53pDzZYtyixg3E,10097
 universal_mcp/agents/codeact/sandbox.py,sha256=lGRzhuXTHCB1qauuOI3bH1-fPTsyL6Lf9EmMIz4C2xQ,1039
@@ -52,7 +51,7 @@ universal_mcp/tools/adapters.py,sha256=YJ2oqgc8JgmtsdRRtvO-PO0Q0bKqTJ4Y3J6yxlESo
 universal_mcp/tools/docstring_parser.py,sha256=efEOE-ME7G5Jbbzpn7pN2xNuyu2M5zfZ1Tqu1lRB0Gk,8392
 universal_mcp/tools/func_metadata.py,sha256=F4jd--hoZWKPBbZihVtluYKUsIdXdq4a0VWRgMl5k-Q,10838
 universal_mcp/tools/manager.py,sha256=24Rkn5Uvv_AuYAtjeMq986bJ7uzTaGE1290uB9eDtRE,10435
-universal_mcp/tools/registry.py,sha256=EA-xJ6GCYGajUVCrRmPIpr9Xekwxnqhmso8ztfsTeE8,1401
+universal_mcp/tools/registry.py,sha256=etluwUwf2EfiGBoqQFZ1nf2xcPWtrJn0N4Qhcg7UGCU,2440
 universal_mcp/tools/tools.py,sha256=Lk-wUO3rfhwdxaRANtC7lQr5fXi7nclf0oHzxNAb79Q,4927
 universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
 universal_mcp/utils/common.py,sha256=3aJK3AnBkmYf-dbsFLaEu_dGuXQ0Qi2HuqYTueLVhXQ,10968
@@ -73,8 +72,8 @@ universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vH
 universal_mcp/utils/openapi/test_generator.py,sha256=h44gQXEXmrw4pD3-XNHKB7T9c2lDomqrJxVO6oszCqM,12186
 universal_mcp/utils/templates/README.md.j2,sha256=Mrm181YX-o_-WEfKs01Bi2RJy43rBiq2j6fTtbWgbTA,401
 universal_mcp/utils/templates/api_client.py.j2,sha256=972Im7LNUAq3yZTfwDcgivnb-b8u6_JLKWXwoIwXXXQ,908
-universal_mcp-0.1.24rc7.dist-info/METADATA,sha256=agZ4cb79U2UCRPE6V_NXT5pL-_gAxB2Gz04jsc9rVCs,3143
-universal_mcp-0.1.24rc7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-universal_mcp-0.1.24rc7.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
-universal_mcp-0.1.24rc7.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
-universal_mcp-0.1.24rc7.dist-info/RECORD,,
+universal_mcp-0.1.24rc8.dist-info/METADATA,sha256=7ioJQnlDsraVLDJ-rGDX0xb-W5yBgZQkTMzPtke-7JQ,3143
+universal_mcp-0.1.24rc8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.24rc8.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.24rc8.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.24rc8.dist-info/RECORD,,

universal_mcp/agentr/agentr.py

@@ -1,37 +0,0 @@
-import os
-
-from universal_mcp.tools import Tool, ToolFormat, ToolManager
-
-from .client import AgentrClient
-from .registry import AgentrRegistry
-
-
-class Agentr:
-    def __init__(
-        self,
-        api_key: str | None = None,
-        base_url: str | None = None,
-        registry: AgentrRegistry | None = None,
-        format: ToolFormat | None = None,
-        manager: ToolManager | None = None,
-    ):
-        self.api_key = api_key or os.getenv("AGENTR_API_KEY")
-        self.base_url = base_url or os.getenv("AGENTR_BASE_URL")
-        self.client = AgentrClient(api_key=self.api_key, base_url=self.base_url)
-        self.registry = registry or AgentrRegistry(client=self.client)
-        self.format = format or ToolFormat.NATIVE
-        self.manager = manager or ToolManager()
-
-    def load_tools(self, tool_names: list[str]) -> None:
-        self.registry.load_tools(tool_names, self.manager)
-        return
-
-    def list_tools(self, format: ToolFormat | None = None) -> list[Tool]:
-        return self.manager.list_tools(format=format or self.format)
-
-    def search_tools(
-        self,
-        query: str,
-    ) -> list[str]:
-        """Retrieve a tool to use, given a search query."""
-        return self.registry.search_tools(query)