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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc6
+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
@@ -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.24rc8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "universal-mcp"
-version = "0.1.24-rc6"
+version = "0.1.24-rc8"
 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.24rc8}/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.24rc8}/src/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-0.1.24rc8/src/universal_mcp/agentr/client.py

@@ -0,0 +1,209 @@
+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.
+        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, 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"
+        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.
+
+        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},
+        )
+        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)
+            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):
+        """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):
+        """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):
+        """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):
+        """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, 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
+              specific app at this endpoint.
+
+        Returns:
+            List[Dict[str, Any]]: A list of tool configurations.
+        """
+        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):
+        """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):
+        """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, 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.
+        """
+        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-0.1.24rc8/src/universal_mcp/agentr/registry.py

@@ -0,0 +1,182 @@
+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
+
+
+class AgentrRegistry(ToolRegistry):
+    """Platform manager implementation for AgentR platform."""
+
+    def __init__(self, client: AgentrClient | None = None, **kwargs):
+        """Initialize the AgentR platform manager."""
+
+        self.client = client or AgentrClient(**kwargs)
+        self.tool_manager = ToolManager()
+        logger.debug("AgentrRegistry initialized successfully")
+
+    async def list_all_apps(self) -> list[dict[str, Any]]:
+        """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 = 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, Any]:
+        """Get detailed information about a specific app from AgentR.
+
+        Args:
+            app_id: The ID of the app to get details for
+
+        Returns:
+            Dictionary containing app details
+        """
+        try:
+            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 {}
+
+    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)
+            tool_manager: The tool manager to register tools with
+        """
+        logger.info(f"Loading all tools: {tools}")
+        tools_by_app = {}
+        for tool_name in tools:
+            app_name, _ = _get_app_and_tool_name(tool_name)
+            tools_by_app.setdefault(app_name, []).append(tool_name)
+
+        for app_name, tool_names in tools_by_app.items():
+            self._load_tools(app_name, tool_names, tool_manager)
+
+    def _load_tools_from_tool_config(self, tool_config: ToolConfig, tool_manager: ToolManager) -> None:
+        """Load tools from ToolConfig and register them as tools.
+
+        Args:
+            tool_config: The tool configuration containing app names and tools
+            tool_manager: The tool manager to register tools with
+        """
+        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-0.1.24rc8/src/universal_mcp/agents/__init__.py

@@ -0,0 +1,6 @@
+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
+
+__all__ = ["BaseAgent", "ReactAgent", "SimpleAgent", "AutoAgent"]

{universal_mcp-0.1.24rc6 → universal_mcp-0.1.24rc8}/src/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 .base import BaseAgent
-from .llm import get_llm
-
 # Auto Agent
 # Working
 # 1. For every message, and given list of tools, figure out if external tools are needed
@@ -61,9 +60,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 +521,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 +562,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}")