universal-mcp 0.1.21rc2__py3-none-any.whl → 0.1.22rc1__py3-none-any.whl

universal_mcp/applications/__init__.py

@@ -35,7 +35,6 @@ def _install_or_upgrade_package(package_name: str, repository_path: str):
     """
     Helper to install a package via pip from the universal-mcp GitHub repository.
     """
-
     uv_path = os.getenv("UV_PATH")
     uv_executable = str(Path(uv_path) / "uv") if uv_path else "uv"
     logger.info(f"Using uv executable: {uv_executable}")

universal_mcp/integrations/integration.py

@@ -3,9 +3,8 @@ from typing import Any
 import httpx
 from loguru import logger
 
-from universal_mcp.exceptions import NotAuthorizedError
-from universal_mcp.stores import BaseStore
-from universal_mcp.stores.store import KeyNotFoundError, MemoryStore
+from universal_mcp.exceptions import KeyNotFoundError, NotAuthorizedError
+from universal_mcp.stores import BaseStore, MemoryStore
 from universal_mcp.utils.agentr import AgentrClient
 
 
@@ -34,10 +33,7 @@ class Integration:
 
     def __init__(self, name: str, store: BaseStore | None = None):
         self.name = name
-        if store is None:
-            self.store = MemoryStore()
-        else:
-            self.store = store
+        self.store = store or MemoryStore()
 
     def authorize(self) -> str | dict[str, Any]:
         """Authorize the integration.
@@ -329,7 +325,7 @@ class AgentRIntegration(Integration):
         ValueError: If no API key is provided or found in environment variables
     """
 
-    def __init__(self, name: str, api_key: str = None, **kwargs):
+    def __init__(self, name: str, api_key: str, **kwargs):
         super().__init__(name, **kwargs)
         self.client = AgentrClient(api_key=api_key)
         self._credentials = None

universal_mcp/servers/server.py

@@ -4,6 +4,7 @@ from typing import Any
 import httpx
 from loguru import logger
 from mcp.server.fastmcp import FastMCP
+from mcp.server.fastmcp.server import MCPTool
 from mcp.types import TextContent
 from pydantic import ValidationError
 
@@ -13,7 +14,7 @@ from universal_mcp.exceptions import ConfigurationError, ToolError
 from universal_mcp.integrations import AgentRIntegration, integration_from_config
 from universal_mcp.stores import BaseStore, store_from_config
 from universal_mcp.tools import ToolManager
-from universal_mcp.tools.adapters import ToolFormat
+from universal_mcp.tools.adapters import ToolFormat, format_to_mcp_result
 from universal_mcp.utils.agentr import AgentrClient
 
 
@@ -34,6 +35,7 @@ class BaseServer(FastMCP):
             logger.info(f"Initializing server: {config.name} ({config.type}) with store: {config.store}")
             self.config = config
             self._tool_manager = tool_manager or ToolManager(warn_on_duplicate_tools=True)
+            # Validate config after setting attributes to ensure proper initialization
             ServerConfig.model_validate(config)
         except Exception as e:
             logger.error(f"Failed to initialize server: {e}", exc_info=True)
@@ -48,10 +50,9 @@ class BaseServer(FastMCP):
         Raises:
             ValueError: If tool is invalid
         """
-
         self._tool_manager.add_tool(tool)
 
-    async def list_tools(self) -> list[dict]:
+    async def list_tools(self) -> list:
         """List all available tools in MCP format.
 
         Returns:
@@ -59,23 +60,6 @@ class BaseServer(FastMCP):
         """
         return self._tool_manager.list_tools(format=ToolFormat.MCP)
 
-    def _format_tool_result(self, result: Any) -> list[TextContent]:
-        """Format tool result into TextContent list.
-
-        Args:
-            result: Raw tool result
-
-        Returns:
-            List of TextContent objects
-        """
-        if isinstance(result, str):
-            return [TextContent(type="text", text=result)]
-        elif isinstance(result, list) and all(isinstance(item, TextContent) for item in result):
-            return result
-        else:
-            logger.warning(f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent.")
-            return [TextContent(type="text", text=str(result))]
-
     async def call_tool(self, name: str, arguments: dict[str, Any]) -> list[TextContent]:
         """Call a tool with comprehensive error handling.
 
@@ -99,7 +83,7 @@ class BaseServer(FastMCP):
         try:
             result = await self._tool_manager.call_tool(name, arguments)
             logger.info(f"Tool '{name}' completed successfully")
-            return self._format_tool_result(result)
+            return format_to_mcp_result(result)
         except Exception as e:
             logger.error(f"Tool '{name}' failed: {e}", exc_info=True)
             raise ToolError(f"Tool execution failed: {str(e)}") from e
@@ -219,12 +203,23 @@ class AgentRServer(BaseServer):
     """
 
     def __init__(self, config: ServerConfig, **kwargs):
+        # Initialize API key and client before calling super().__init__
         self.api_key = config.api_key.get_secret_value() if config.api_key else None
+        if not self.api_key:
+            raise ValueError("API key is required for AgentR server")
+
         logger.info(f"Initializing AgentR server with API key: {self.api_key}")
         self.client = AgentrClient(api_key=self.api_key)
         super().__init__(config, **kwargs)
-        self.integration = AgentRIntegration(name="agentr", api_key=self.client.api_key)
-        self._load_apps()
+        self.integration = AgentRIntegration(name="agentr", api_key=self.api_key)
+        # Don't load apps in __init__ for stateless operation
+        self._apps_loaded = False
+
+    def _ensure_apps_loaded(self) -> None:
+        """Ensure apps are loaded, loading them if necessary."""
+        if not self._apps_loaded:
+            self._load_apps()
+            self._apps_loaded = True
 
     def _fetch_apps(self) -> list[AppConfig]:
         """Fetch available apps from AgentR API with retry logic.
@@ -297,6 +292,16 @@ class AgentRServer(BaseServer):
             # Don't raise the exception to allow server to start with partial functionality
             logger.warning("Server will start with limited functionality due to app loading failures")
 
+    async def list_tools(self) -> list[MCPTool]:
+        """List available tools, ensuring apps are loaded first."""
+        self._ensure_apps_loaded()
+        return await super().list_tools()
+
+    async def call_tool(self, name: str, arguments: dict) -> list[TextContent]:
+        """Call a tool by name, ensuring apps are loaded first."""
+        self._ensure_apps_loaded()
+        return await super().call_tool(name, arguments)
+
 
 class SingleMCPServer(BaseServer):
     """
@@ -322,12 +327,12 @@ class SingleMCPServer(BaseServer):
         **kwargs,
     ):
         if not app_instance:
-            raise ValueError("app_instance is required")
-        if not config:
-            config = ServerConfig(
-                type="local",
-                name=f"{app_instance.name.title()} MCP Server for Local Development",
-                description=f"Minimal MCP server for the local {app_instance.name} application.",
-            )
+            raise ValueError("app_instance is required for SingleMCPServer")
+
+        config = config or ServerConfig(
+            type="local",
+            name=f"{app_instance.name.title()} MCP Server for Local Development",
+            description=f"Minimal MCP server for the local {app_instance.name} application.",
+        )
         super().__init__(config, **kwargs)
         self._tool_manager.register_tools_from_app(app_instance, tags="all")

universal_mcp/tools/adapters.py

@@ -1,5 +1,8 @@
 from enum import Enum
 
+from loguru import logger
+from mcp.types import TextContent
+
 from universal_mcp.tools.tools import Tool
 
 
@@ -23,6 +26,24 @@ def convert_tool_to_mcp_tool(
     )
 
 
+def format_to_mcp_result(result: any) -> list[TextContent]:
+    """Format tool result into TextContent list.
+
+    Args:
+        result: Raw tool result
+
+    Returns:
+        List of TextContent objects
+    """
+    if isinstance(result, str):
+        return [TextContent(type="text", text=result)]
+    elif isinstance(result, list) and all(isinstance(item, TextContent) for item in result):
+        return result
+    else:
+        logger.warning(f"Tool returned unexpected type: {type(result)}. Wrapping in TextContent.")
+        return [TextContent(type="text", text=str(result))]
+
+
 def convert_tool_to_langchain_tool(
     tool: Tool,
 ):

universal_mcp/tools/manager.py

@@ -1,4 +1,3 @@
-import re
 from collections.abc import Callable
 from typing import Any
 
@@ -18,28 +17,67 @@ from universal_mcp.tools.tools import Tool
 # Constants
 DEFAULT_IMPORTANT_TAG = "important"
 TOOL_NAME_SEPARATOR = "_"
+DEFAULT_APP_NAME = "common"
 
 
 def _filter_by_name(tools: list[Tool], tool_names: list[str] | None) -> list[Tool]:
+    """Filter tools by name using simple string matching.
+
+    Args:
+        tools: List of tools to filter.
+        tool_names: List of tool names to match against.
+
+    Returns:
+        Filtered list of tools.
+    """
     if not tool_names:
         return tools
-    logger.debug(f"Filtering tools by name: {tool_names}")
+
+    logger.debug(f"Filtering tools by names: {tool_names}")
+    # Convert names to lowercase for case-insensitive matching
+    tool_names = [name.lower() for name in tool_names]
     filtered_tools = []
     for tool in tools:
-        for name in tool_names:
-            if re.search(name, tool.name):
+        for tool_name in tool_names:
+            if tool_name in tool.name.lower():
                 filtered_tools.append(tool)
+                logger.debug(f"Tool '{tool.name}' matched name filter")
+                break
+
     return filtered_tools
 
 
 def _filter_by_tags(tools: list[Tool], tags: list[str] | None) -> list[Tool]:
+    """Filter tools by tags with improved matching logic.
+
+    Args:
+        tools: List of tools to filter.
+        tags: List of tags to match against.
+
+    Returns:
+        Filtered list of tools.
+    """
+    if not tags:
+        return tools
+
     logger.debug(f"Filtering tools by tags: {tags}")
+
+    # Handle special "all" tag
     if "all" in tags:
         return tools
 
-    if not tags:
-        return tools
-    return [tool for tool in tools if any(tag in tool.tags for tag in tags)]
+    # Convert tags to lowercase for case-insensitive matching
+    tags_set = {tag.lower() for tag in tags}
+
+    filtered_tools = []
+    for tool in tools:
+        # Convert tool tags to lowercase for case-insensitive matching
+        tool_tags = {tag.lower() for tag in tool.tags}
+        if tags_set & tool_tags:  # Check for any matching tags
+            filtered_tools.append(tool)
+            logger.debug(f"Tool '{tool.name}' matched tags: {tags_set & tool_tags}")
+
+    return filtered_tools
 
 
 class ToolManager:
@@ -47,6 +85,7 @@ class ToolManager:
 
     This class provides functionality for registering, managing, and executing tools.
     It supports multiple tool formats and provides filtering capabilities based on names and tags.
+    Tools are organized by their source application for better management.
     """
 
     def __init__(self, warn_on_duplicate_tools: bool = True):
@@ -55,7 +94,8 @@ class ToolManager:
         Args:
             warn_on_duplicate_tools: Whether to warn when duplicate tool names are detected.
         """
-        self._tools: dict[str, Tool] = {}
+        self._tools_by_app: dict[str, dict[str, Tool]] = {}
+        self._all_tools: dict[str, Tool] = {}
         self.warn_on_duplicate_tools = warn_on_duplicate_tools
 
     def get_tool(self, name: str) -> Tool | None:
@@ -67,17 +107,36 @@ class ToolManager:
         Returns:
             The Tool instance if found, None otherwise.
         """
-        return self._tools.get(name)
+        return self._all_tools.get(name)
+
+    def get_tools_by_app(self, app_name: str | None = None) -> list[Tool]:
+        """Get all tools from a specific application.
+
+        Args:
+            app_name: The name of the application to get tools from.
+
+        Returns:
+            List of tools from the specified application.
+        """
+        if app_name:
+            return list(self._tools_by_app.get(app_name, {}).values())
+        else:
+            return list(self._all_tools.values())
 
     def list_tools(
         self,
         format: ToolFormat = ToolFormat.MCP,
         tags: list[str] | None = None,
-    ) -> list[Tool]:
+        app_name: str | None = None,
+        tool_names: list[str] | None = None,
+    ) -> list:
         """List all registered tools in the specified format.
 
         Args:
             format: The format to convert tools to.
+            tags: Optional list of tags to filter tools by.
+            app_name: Optional app name to filter tools by.
+            tool_names: Optional list of tool names to filter by.
 
         Returns:
             List of tools in the specified format.
@@ -85,26 +144,31 @@ class ToolManager:
         Raises:
             ValueError: If an invalid format is provided.
         """
+        # Start with app-specific tools or all tools
+        tools = self.get_tools_by_app(app_name)
+        # Apply filters
+        tools = _filter_by_tags(tools, tags)
+        tools = _filter_by_name(tools, tool_names)
 
-        tools = list(self._tools.values())
-        if tags:
-            tools = _filter_by_tags(tools, tags)
+        # Convert to requested format
         if format == ToolFormat.MCP:
-            tools = [convert_tool_to_mcp_tool(tool) for tool in tools]
+            return [convert_tool_to_mcp_tool(tool) for tool in tools]
         elif format == ToolFormat.LANGCHAIN:
-            tools = [convert_tool_to_langchain_tool(tool) for tool in tools]
+            return [convert_tool_to_langchain_tool(tool) for tool in tools]
         elif format == ToolFormat.OPENAI:
-            tools = [convert_tool_to_openai_tool(tool) for tool in tools]
+            return [convert_tool_to_openai_tool(tool) for tool in tools]
         else:
             raise ValueError(f"Invalid format: {format}")
-        return tools
 
-    def add_tool(self, fn: Callable[..., Any] | Tool, name: str | None = None) -> Tool:
+    def add_tool(
+        self, fn: Callable[..., Any] | Tool, name: str | None = None, app_name: str = DEFAULT_APP_NAME
+    ) -> Tool:
         """Add a tool to the manager.
 
         Args:
             fn: The tool function or Tool instance to add.
             name: Optional name override for the tool.
+            app_name: Application name to group the tool under.
 
         Returns:
             The registered Tool instance.
@@ -114,10 +178,7 @@ class ToolManager:
         """
         tool = fn if isinstance(fn, Tool) else Tool.from_function(fn, name=name)
 
-        if not tool.name or not isinstance(tool.name, str):
-            raise ValueError("Tool name must be a non-empty string")
-
-        existing = self._tools.get(tool.name)
+        existing = self._all_tools.get(tool.name)
         if existing:
             if self.warn_on_duplicate_tools:
                 if existing.fn is not tool.fn:
@@ -128,14 +189,25 @@ class ToolManager:
                     logger.debug(f"Tool '{tool.name}' with the same function already exists.")
             return existing
 
-        logger.debug(f"Adding tool: {tool.name}")
-        self._tools[tool.name] = tool
+        logger.debug(f"Adding tool: {tool.name} to app: {app_name}")
+        self._all_tools[tool.name] = tool
+
+        # Group tool by application
+        if app_name not in self._tools_by_app:
+            self._tools_by_app[app_name] = {}
+        self._tools_by_app[app_name][tool.name] = tool
+
         return tool
 
-    def register_tools(self, tools: list[Tool]) -> None:
-        """Register a list of tools."""
+    def register_tools(self, tools: list[Tool], app_name: str = DEFAULT_APP_NAME) -> None:
+        """Register a list of tools.
+
+        Args:
+            tools: List of tools to register.
+            app_name: Application name to group the tools under.
+        """
         for tool in tools:
-            self.add_tool(tool)
+            self.add_tool(tool, app_name=app_name)
 
     def remove_tool(self, name: str) -> bool:
         """Remove a tool by name.
@@ -146,14 +218,24 @@ class ToolManager:
         Returns:
             True if the tool was removed, False if it didn't exist.
         """
-        if name in self._tools:
-            del self._tools[name]
+        if name in self._all_tools:
+            self._all_tools[name]
+            del self._all_tools[name]
+
+            # Remove from app-specific grouping if present
+            for app_tools in self._tools_by_app.values():
+                if name in app_tools:
+                    del app_tools[name]
+                    # PERFORMANCE: Break after finding and removing to avoid unnecessary iterations
+                    break
+
             return True
         return False
 
     def clear_tools(self) -> None:
         """Remove all registered tools."""
-        self._tools.clear()
+        self._all_tools.clear()
+        self._tools_by_app.clear()
 
     def register_tools_from_app(
         self,
@@ -190,22 +272,27 @@ class ToolManager:
             try:
                 tool_instance = Tool.from_function(function)
                 tool_instance.name = f"{app.name}{TOOL_NAME_SEPARATOR}{tool_instance.name}"
-                tool_instance.tags.append(app.name) if app.name not in tool_instance.tags else None
+                # BUG FIX: Avoid duplicate tags - check if app.name is already in tags before adding
+                if app.name not in tool_instance.tags:
+                    tool_instance.tags.append(app.name)
                 tools.append(tool_instance)
             except Exception as e:
                 tool_name = getattr(function, "__name__", "unknown")
                 logger.error(f"Failed to create Tool from '{tool_name}' in {app.name}: {e}")
 
+        # BUG FIX: Apply filtering logic correctly - if both tool_names and tags are provided,
+        # we should filter by both, not use default important tag
         if tags:
             tools = _filter_by_tags(tools, tags)
 
         if tool_names:
             tools = _filter_by_name(tools, tool_names)
-        # If no tool names or tags are provided, use the default important tag
+
+        # BUG FIX: Only use default important tag if NO filters are provided at all
         if not tool_names and not tags:
             tools = _filter_by_tags(tools, [DEFAULT_IMPORTANT_TAG])
-        self.register_tools(tools)
-        return
+
+        self.register_tools(tools, app_name=app.name)
 
     async def call_tool(
         self,
@@ -227,16 +314,14 @@ class ToolManager:
             ToolError: If the tool is not found or execution fails.
         """
         logger.debug(f"Calling tool: {name} with arguments: {arguments}")
+        app_name = name.split(TOOL_NAME_SEPARATOR, 1)[0] if TOOL_NAME_SEPARATOR in name else DEFAULT_APP_NAME
         tool = self.get_tool(name)
         if not tool:
             raise ToolError(f"Unknown tool: {name}")
-
         try:
             result = await tool.run(arguments, context)
-            app_name = tool.name.split(TOOL_NAME_SEPARATOR)[0]
             analytics.track_tool_called(name, app_name, "success")
             return result
         except Exception as e:
-            app_name = tool.name.split(TOOL_NAME_SEPARATOR)[0]
             analytics.track_tool_called(name, app_name, "error", str(e))
             raise ToolError(f"Tool execution failed: {str(e)}") from e

universal_mcp/utils/agentr.py

@@ -1,5 +1,3 @@
-import os
-
 import httpx
 from loguru import logger
 
@@ -18,17 +16,9 @@ class AgentrClient:
         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):
-        if api_key:
-            self.api_key = api_key
-        elif os.getenv("AGENTR_API_KEY"):
-            self.api_key = os.getenv("AGENTR_API_KEY")
-        else:
-            logger.error(
-                "API key for AgentR is missing. Please visit https://agentr.dev to create an API key, then set it as AGENTR_API_KEY environment variable."
-            )
-            raise ValueError("AgentR API key required - get one at https://agentr.dev")
-        self.base_url = (base_url or os.getenv("AGENTR_BASE_URL", "https://api.agentr.dev")).rstrip("/")
+    def __init__(self, api_key: str, base_url: str = "https://api.agentr.dev"):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
         self.client = httpx.Client(
             base_url=self.base_url, headers={"X-API-KEY": self.api_key}, timeout=30, follow_redirects=True
         )