universal-mcp 0.1.24rc6__tar.gz → 0.1.24rc7__tar.gz

{universal_mcp-0.1.24rc6 → universal_mcp-0.1.24rc7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc6
+Version: 0.1.24rc7
 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
@@ -9,9 +9,12 @@ Requires-Python: >=3.11
 Requires-Dist: black>=25.1.0
 Requires-Dist: cookiecutter>=2.6.0
 Requires-Dist: gql>=4.0.0
+Requires-Dist: httpx-aiohttp>=0.1.8
 Requires-Dist: jinja2>=3.1.3
 Requires-Dist: jsonref>=1.1.0
 Requires-Dist: keyring>=25.6.0
+Requires-Dist: langchain-anthropic>=0.3.19
+Requires-Dist: langchain-google-vertexai>=2.0.28
 Requires-Dist: langchain-mcp-adapters>=0.1.9
 Requires-Dist: langchain-openai>=0.3.27
 Requires-Dist: langgraph-cli[inmem]>=0.3.4

{universal_mcp-0.1.24rc6 → universal_mcp-0.1.24rc7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.24-rc6"
+version = "0.1.24-rc7"
 description = "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."
 readme = "README.md"
 authors = [
@@ -17,8 +17,11 @@ dependencies = [
     "black>=25.1.0",
     "cookiecutter>=2.6.0",
     "gql>=4.0.0",
+    "httpx-aiohttp>=0.1.8",
     "jsonref>=1.1.0",
     "keyring>=25.6.0",
+    "langchain-anthropic>=0.3.19",
+    "langchain-google-vertexai>=2.0.28",
     "langchain-mcp-adapters>=0.1.9",
     "langchain-openai>=0.3.27",
     "langgraph>=0.5.2",

{universal_mcp-0.1.24rc6 → universal_mcp-0.1.24rc7}/src/universal_mcp/agentr/README.md

@@ -1,20 +1,23 @@
 # AgentR Python SDK
 
 The official Python SDK for the AgentR platform, a component of the Universal MCP framework.
-Currently in beta, breaking changes are expected.
 
-The AgentR Python SDK provides convenient access to the AgentR REST API from any Python 3.10+
-application, allowing for dynamic loading and management of tools and integrations.
+*Currently in beta, breaking changes are expected.*
+
+The AgentR Python SDK provides convenient access to the AgentR REST API from any Python 3.10+ application, allowing for dynamic loading and management of tools and integrations.
 
 ## Installation
+
 ```bash
 pip install universal-mcp
 ```
 
 ## Usage
+
 The AgentR platform is designed to seamlessly integrate a wide array of tools into your agentic applications. The primary entry point for this is the `Agentr` class, which provides a high-level interface for loading and listing tools.
 
 ### High-Level Client (`Agentr`)
+
 This is the recommended way to get started. It abstracts away the details of the registry and tool management.
 
 ```python
@@ -29,7 +32,7 @@ agentr = Agentr(
 )
 
 # Load specific tools from the AgentR server into the tool manager
-agentr.load_tools(["reddit_search_subreddits", "google_drive_list_files"])
+agentr.load_tools(["reddit__search_subreddits", "google-drive__list_files"])
 
 # List the tools that are now loaded and ready to be used
 # You can specify a format compatible with your LLM (e.g., OPENAI)
@@ -41,10 +44,10 @@ print(tools)
 
 For more granular control over the AgentR platform, you can use the lower-level components directly.
 
-### AgentrClient
-The `AgentrClient` provides direct access to the AgentR REST API endpoints.
+#### AgentrClient
+
+The `AgentrClient` provides direct, one-to-one access to the AgentR REST API endpoints. The following examples have been updated to reflect the latest API structure.
 
-#### Methods
 ```python
 import os
 from universal_mcp.agentr import AgentrClient
@@ -55,39 +58,43 @@ client = AgentrClient(
     api_key=os.environ.get("AGENTR_API_KEY")
 )
 
-# Fetch all available applications from the AgentR server
-apps = client.fetch_apps()
-print(apps)
+# Fetch a list of available applications from the AgentR server
+apps = client.list_apps()
+print("Available Apps:", apps)
 
-# Get credentials for a specific integration
-# This will raise a NotAuthorizedError if the user needs to authenticate
+# Get credentials for a specific app by its ID (e.g., 'reddit')
+# This will raise a NotAuthorizedError if the user needs to authenticate.
 try:
-    credentials = client.get_credentials("reddit")
+    credentials = client.get_credentials(app_id="reddit")
     print("Reddit credentials found.")
 except NotAuthorizedError as e:
-    print(e) # "Please ask the user to visit the following url to authorize..."
-
-# Example of fetching a single app and its actions
-if apps:
-    app_id = apps[0].id  # Assuming AppConfig has an 'id' attribute
+    print(e)  # "Please ask the user to visit the following url to authorize..."
 
-    # Fetch a single app's configuration
-    app_config = client.fetch_app(app_id)
-    print(f"Fetched config for app {app_id}:", app_config)
+# List all available tools globally
+all_tools = client.list_tools()
+print("All Available Tools:", all_tools)
 
-    # List all actions for that app
-    actions = client.list_actions(app_id)
-    print(f"Actions for app {app_id}:", actions)
-
-# List all apps (returns raw JSON data)
-all_apps = client.list_all_apps()
-print("All available apps:", all_apps)
+# Example of fetching a single app and a single tool
+if apps:
+    # Note: We access dictionary keys, not attributes
+    app_id = apps[0]['id']
+
+    # Fetch a single app's details
+    app_details = client.get_app(app_id)
+    print(f"Fetched details for app '{app_id}':", app_details)
+
+if all_tools:
+    tool_id = all_tools[0]['id']
+    
+    # Fetch a single tool's details
+    tool_details = client.get_tool(tool_id)
+    print(f"Fetched details for tool '{tool_id}':", tool_details)
 ```
 
-### AgentrIntegration
+#### AgentrIntegration
+
 This class handles the authentication and authorization flow for a single integration (e.g., "reddit"). It's used under the hood by applications to acquire credentials.
 
-#### Methods
 ```python
 from universal_mcp.agentr import AgentrIntegration, AgentrClient
 from universal_mcp.exceptions import NotAuthorizedError
@@ -114,10 +121,10 @@ except NotAuthorizedError:
     print("Still not authorized.")
 ```
 
-### AgentrRegistry
+#### AgentrRegistry
+
 The registry is responsible for discovering which tools are available on the AgentR platform.
 
-#### Methods
 ```python
 import asyncio
 from universal_mcp.agentr import AgentrRegistry, AgentrClient
@@ -148,7 +155,8 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
-### AgentrServer
+#### AgentrServer
+
 For server-side deployments, `AgentrServer` can be used to load all configured applications and their tools from an AgentR instance on startup.
 
 ```python
@@ -170,6 +178,7 @@ print(tool_manager.list_tools())
 ```
 
 ## Executing Tools
+
 Once tools are loaded, you can execute them using the `call_tool` method on the `ToolManager` instance, which is available via `agentr.manager`.
 
 ```python
@@ -182,7 +191,7 @@ async def main():
     agentr = Agentr(api_key=os.environ.get("AGENTR_API_KEY"))
 
     # 2. Load the tool(s) you want to use
-    tool_name = "reddit_search_subreddits"
+    tool_name = "reddit__search_subreddits"
     agentr.load_tools([tool_name])
 
     # 3. Execute the tool using the tool manager

{universal_mcp-0.1.24rc6 → universal_mcp-0.1.24rc7}/src/universal_mcp/agentr/agentr.py

@@ -28,3 +28,10 @@ class Agentr:
 
     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)

universal_mcp-0.1.24rc7/src/universal_mcp/agentr/client.py

@@ -0,0 +1,177 @@
+import os
+from typing import Any
+
+import httpx
+from loguru import logger
+
+from universal_mcp.exceptions import NotAuthorizedError
+
+
+class AgentrClient:
+    """Helper class for AgentR API operations.
+
+    This class provides utility methods for interacting with the AgentR API,
+    including authentication, authorization, and credential management.
+
+    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.
+    """
+
+    def __init__(self, api_key: str | None = None, base_url: str | None = None):
+        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,
+        )
+
+    def get_credentials(self, app_id: str) -> dict[str, Any]:
+        """Get credentials for an integration from the AgentR API.
+
+        Args:
+            app_id (str): The ID of the app (e.g., 'asana', 'google-drive').
+
+        Returns:
+            dict: Credentials data from API response.
+
+        Raises:
+            NotAuthorizedError: If credentials are not found (404 response).
+            HTTPError: For other API errors.
+        """
+        response = self.client.get(
+            "/credentials/",
+            params={"app_id": app_id},
+        )
+        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)
+            raise NotAuthorizedError(action_url)
+        response.raise_for_status()
+        return response.json()
+
+    def get_authorization_url(self, app_id: str) -> str:
+        """Get the authorization URL to connect an app.
+
+        Args:
+            app_id (str): The ID of the app to authorize.
+
+        Returns:
+            str: A message containing the authorization URL.
+
+        Raises:
+            HTTPError: If the API request fails.
+        """
+        response = self.client.post("/connections/authorize", json={"app_id": app_id})
+        response.raise_for_status()
+        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]]:
+        """Fetch available apps from AgentR API.
+
+        Returns:
+            List[Dict[str, Any]]: A list of application data dictionaries.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        response = self.client.get("/apps/")
+        response.raise_for_status()
+        return response.json().get("items", [])
+
+    def list_my_apps(self) -> list[dict[str, Any]]:
+        """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.raise_for_status()
+        return response.json().get("items", [])
+
+    def list_my_connections(self) -> list[dict[str, Any]]:
+        """Fetch user connections from AgentR API.
+
+        Returns:
+            List[Dict[str, Any]]: A list of user connection data dictionaries.
+        """
+        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]:
+        """Fetch a specific app from AgentR API.
+
+        Args:
+            app_id (str): ID of the app to fetch.
+
+        Returns:
+            dict: App configuration data.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        response = self.client.get(f"/apps/{app_id}")
+        response.raise_for_status()
+        return response.json()
+
+    def list_all_tools(self) -> list[dict[str, Any]]:
+        """List all available tools from the AgentR API.
+
+        Note: In the backend, tools are globally listed and not tied to a
+              specific app at this endpoint.
+
+        Returns:
+            List[Dict[str, Any]]: A list of tool configurations.
+        """
+        response = self.client.get("/tools/")
+        response.raise_for_status()
+        return response.json().get("items", [])
+
+    def get_tool_details(self, tool_id: str) -> dict[str, Any]:
+        """Fetch a specific tool configuration from the AgentR API.
+
+        Args:
+            tool_id (str): ID of the tool to fetch.
+
+        Returns:
+            dict: Tool configuration data.
+
+        Raises:
+            httpx.HTTPError: If the API request fails.
+        """
+        response = self.client.get(f"/tools/{tool_id}")
+        response.raise_for_status()
+        return response.json()
+
+    def search_all_apps(self, query: str, limit: int = 2) -> list[dict[str, Any]]:
+        """Search for apps from the AgentR API.
+
+        Args:
+            query (str): The query to search for.
+            limit (int, optional): The number of apps to return. Defaults to 2.
+
+        Returns:
+            List[Dict[str, Any]]: A list of app data dictionaries.
+        """
+        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]]:
+        """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.
+        """
+        response = self.client.get("/tools/", params={"search": query, "limit": limit})
+        response.raise_for_status()
+        return response.json().get("items", [])

{universal_mcp-0.1.24rc6 → universal_mcp-0.1.24rc7}/src/universal_mcp/agentr/registry.py

@@ -17,26 +17,22 @@ class AgentrRegistry(ToolRegistry):
         self.client = client or AgentrClient(**kwargs)
         logger.debug("AgentrRegistry initialized successfully")
 
-    async def list_apps(self) -> list[dict[str, str]]:
+    def list_apps(self) -> list[dict[str, str]]:
         """Get list of available apps from AgentR.
 
         Returns:
             List of app dictionaries with id, name, description, and available fields
         """
+        if self.client is None:
+            raise ValueError("Client is not initialized")
         try:
-            all_apps = await self.client.list_all_apps()
-            available_apps = [
-                {"id": app["id"], "name": app["name"], "description": app.get("description", "")}
-                for app in all_apps
-                if app.get("available", False)
-            ]
-            logger.info(f"Found {len(available_apps)} available apps from AgentR")
-            return available_apps
+            all_apps = self.client.list_all_apps()
+            return all_apps
         except Exception as e:
             logger.error(f"Error fetching apps from AgentR: {e}")
             return []
 
-    async def get_app_details(self, app_id: str) -> dict[str, str]:
+    def get_app_details(self, app_id: str) -> dict[str, str]:
         """Get detailed information about a specific app from AgentR.
 
         Args:
@@ -46,23 +42,11 @@ class AgentrRegistry(ToolRegistry):
             Dictionary containing app details
         """
         try:
-            app_info = await self.client.fetch_app(app_id)
-            return {
-                "id": app_info.get("id"),
-                "name": app_info.get("name"),
-                "description": app_info.get("description"),
-                "category": app_info.get("category"),
-                "available": app_info.get("available", True),
-            }
+            app_info = self.client.get_app_details(app_id)
+            return app_info
         except Exception as e:
             logger.error(f"Error getting details for app {app_id}: {e}")
-            return {
-                "id": app_id,
-                "name": app_id,
-                "description": "Error loading details",
-                "category": "Unknown",
-                "available": True,
-            }
+            return {}
 
     def load_tools(self, tools: list[str] | None, tool_manager: ToolManager) -> None:
         """Load tools from AgentR and register them as tools.
@@ -89,3 +73,15 @@ class AgentrRegistry(ToolRegistry):
             app_instance = app(integration=integration)
             tool_manager.register_tools_from_app(app_instance, tool_names=tool_names)
         return
+
+    def search_tools(self, query: str, limit: int = 20) -> list[str]:
+        """Search for tools in AgentR.
+
+        Args:
+            query: The query to search for
+
+        Returns:
+            List of tool names
+        """
+        return self.client.search_all_tools(query, limit)
+    

universal_mcp-0.1.24rc7/src/universal_mcp/agents/__init__.py

@@ -0,0 +1,6 @@
+from universal_mcp.agents.auto import AutoAgent
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.react import ReactAgent
+from universal_mcp.agents.simple import SimpleAgent
+
+__all__ = ["BaseAgent", "ReactAgent", "SimpleAgent", "AutoAgent"]

{universal_mcp-0.1.24rc6 → universal_mcp-0.1.24rc7}/src/universal_mcp/agents/auto.py

@@ -16,8 +16,8 @@ from universal_mcp.tools import ToolManager
 from universal_mcp.tools.adapters import ToolFormat
 from universal_mcp.tools.registry import ToolRegistry
 
-from .base import BaseAgent
-from .llm import get_llm
+from universal_mcp.agents.base import BaseAgent
+from universal_mcp.agents.llm import load_chat_model
 
 # Auto Agent
 # Working
@@ -61,9 +61,9 @@ class AutoAgent(BaseAgent):
     def __init__(self, name: str, instructions: str, model: str, app_registry: ToolRegistry):
         super().__init__(name, instructions, model)
         self.app_registry = app_registry
-        self.llm_tools = get_llm(model, tags=["tools"])
-        self.llm_choice = get_llm(model, tags=["choice"])
-        self.llm_quiet = get_llm(model, tags=["quiet"])
+        self.llm_tools = load_chat_model(model, tags=["tools"])
+        self.llm_choice = load_chat_model(model, tags=["choice"])
+        self.llm_quiet = load_chat_model(model, tags=["quiet"])
         self.tool_manager = ToolManager()
 
         self.task_analysis_prompt = """You are a task analysis expert. Given a task description and available apps, determine:
@@ -522,7 +522,7 @@ Be friendly and concise, but list each set of apps clearly. Do not return any ot
             return result
 
         # Get all available apps from platform manager
-        available_apps = await self.app_registry.list_apps()
+        available_apps =  self.app_registry.list_apps()
 
         logger.info(f"Found {len(available_apps)} available apps")
 
@@ -563,10 +563,10 @@ if __name__ == "__main__":
 
     # Create platform manager
     app_registry = AgentrRegistry(api_key=agentr_api_key)
-    want_instructions = input("Do you want to add a system prompt/instructions? (Y/N)")
+    want_instructions = input("Do you want to add a system prompt/instructions? (Y/N): ")
     instructions = "" if want_instructions.upper() == "N" else input("Enter your instructions/system prompt: ")
 
-    agent = AutoAgent("Auto Agent", instructions, "gpt-4.1", app_registry=app_registry)
+    agent = AutoAgent("Auto Agent", instructions, "azure/gpt-4.1", app_registry=app_registry)
 
     print("AutoAgent created successfully!")
     print(f"Agent name: {agent.name}")

universal_mcp-0.1.24rc7/src/universal_mcp/agents/autoagent/__init__.py

@@ -0,0 +1,35 @@
+from universal_mcp.agentr.registry import AgentrRegistry
+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__(
+        self,
+        name: str,
+        instructions: str,
+        model: str,
+        tool_registry: ToolRegistry | None = None,
+        tool_manager: ToolManager | None = None,
+    ):
+        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()
+
+    def _build_graph(self):
+        builder = create_agent(self.tool_registry, self.tool_manager, self.instructions)
+        return builder.compile()
+
+    @property
+    def graph(self):
+        return self._graph
+
+
+__all__ = ["AutoAgent"]

universal_mcp-0.1.24rc7/src/universal_mcp/agents/autoagent/__main__.py

@@ -0,0 +1,21 @@
+import asyncio
+
+from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents.autoagent import AutoAgent
+
+
+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",
+        tool_registry=AgentrRegistry(),
+    )
+    result = await agent.run(
+        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)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

universal_mcp-0.1.24rc7/src/universal_mcp/agents/autoagent/context.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+from typing import Annotated
+
+from universal_mcp.agents.autoagent.prompts import SYSTEM_PROMPT
+
+
+@dataclass(kw_only=True)
+class Context:
+    """The context for the agent."""
+
+    system_prompt: str = field(
+        default=SYSTEM_PROMPT,
+        metadata={
+            "description": "The system prompt to use for the agent's interactions. "
+            "This prompt sets the context and behavior for the agent."
+        },
+    )
+
+    model: Annotated[str, {"__template_metadata__": {"kind": "llm"}}] = field(
+        default="anthropic/claude-4-sonnet-20250514",
+        metadata={
+            "description": "The name of the language model to use for the agent's main interactions. "
+            "Should be in the form: provider/model-name."
+        },
+    )