mcp-use 1.3.11__py3-none-any.whl → 1.3.13__py3-none-any.whl

mcp_use/agents/adapters/base.py

@@ -0,0 +1,193 @@
+"""
+Base adapter interface for MCP tools.
+
+This module provides the abstract base class that all MCP tool adapters should inherit from.
+"""
+
+from abc import ABC, abstractmethod
+from typing import TypeVar
+
+from mcp.types import Prompt, Resource, Tool
+
+from mcp_use.client.client import MCPClient
+from mcp_use.client.connectors.base import BaseConnector
+from mcp_use.logging import logger
+from mcp_use.telemetry.telemetry import telemetry
+
+# Generic type for the tools created by the adapter
+T = TypeVar("T")
+
+
+class BaseAdapter(ABC):
+    """Abstract base class for converting MCP tools to other framework formats.
+
+    This class defines the common interface that all adapter implementations
+    should follow to ensure consistency across different frameworks.
+    """
+
+    def __init__(self, disallowed_tools: list[str] | None = None) -> None:
+        """Initialize a new adapter.
+
+        Args:
+            disallowed_tools: list of tool names that should not be available.
+        """
+        self.disallowed_tools = disallowed_tools or []
+        self._connector_tool_map: dict[BaseConnector, list[T]] = {}
+
+    @telemetry("adapter_create_tools")
+    async def create_tools(self, client: "MCPClient") -> list[T]:
+        """Create tools from an MCPClient instance.
+
+        This is the recommended way to create tools from an MCPClient, as it handles
+        session creation and connector extraction automatically.
+
+        Args:
+            client: The MCPClient to extract tools from.
+
+        Returns:
+            A list of tools in the target framework's format.
+
+        Example:
+            ```python
+            from mcp_use.client import MCPClient
+            from mcp_use.adapters import YourAdapter
+
+            client = MCPClient.from_config_file("config.json")
+            tools = await YourAdapter.create_tools(client)
+            ```
+        """
+        # Ensure we have active sessions
+        if not client.active_sessions:
+            logger.info("No active sessions found, creating new ones...")
+            await client.create_all_sessions()
+
+        # Get all active sessions
+        sessions = client.get_all_active_sessions()
+
+        # Extract connectors from sessions
+        connectors = [session.connector for session in sessions.values()]
+
+        # Create tools from connectors
+        return await self._create_tools_from_connectors(connectors)
+
+    @telemetry("adapter_load_tools")
+    async def load_tools_for_connector(self, connector: BaseConnector) -> list[T]:
+        """Dynamically load tools for a specific connector.
+
+        Args:
+            connector: The connector to load tools for.
+
+        Returns:
+            The list of tools that were loaded in the target framework's format.
+        """
+        # Check if we already have tools for this connector
+        if connector in self._connector_tool_map:
+            logger.debug(f"Returning {len(self._connector_tool_map[connector])} existing tools for connector")
+            return self._connector_tool_map[connector]
+
+        # Create tools for this connector
+
+        # Make sure the connector is initialized and has tools
+        success = await self._ensure_connector_initialized(connector)
+        if not success:
+            return []
+
+        connector_tools = []
+        # Now create tools for each MCP tool
+        for tool in await connector.list_tools():
+            # Convert the tool and add it to the list if conversion was successful
+            converted_tool = self._convert_tool(tool, connector)
+            if converted_tool:
+                connector_tools.append(converted_tool)
+
+        # Convert resources to tools so that agents can access resource content directly
+        resources_list = await connector.list_resources() or []
+        if resources_list:
+            for resource in resources_list:
+                converted_resource = self._convert_resource(resource, connector)
+                if converted_resource:
+                    connector_tools.append(converted_resource)
+
+        # Convert prompts to tools so that agents can retrieve prompt content
+        prompts_list = await connector.list_prompts() or []
+        if prompts_list:
+            for prompt in prompts_list:
+                converted_prompt = self._convert_prompt(prompt, connector)
+                if converted_prompt:
+                    connector_tools.append(converted_prompt)
+        # ------------------------------
+
+        # Store the tools for this connector
+        self._connector_tool_map[connector] = connector_tools
+
+        # Log available tools for debugging
+        logger.debug(
+            f"Loaded {len(connector_tools)} new tools for connector: "
+            f"{[getattr(tool, 'name', str(tool)) for tool in connector_tools]}"
+        )
+
+        return connector_tools
+
+    @abstractmethod
+    def _convert_tool(self, mcp_tool: Tool, connector: BaseConnector) -> T:
+        """Convert an MCP tool to the target framework's tool format."""
+        pass
+
+    @abstractmethod
+    def _convert_resource(self, mcp_resource: Resource, connector: BaseConnector) -> T:
+        """Convert an MCP resource to the target framework's resource format."""
+        pass
+
+    @abstractmethod
+    def _convert_prompt(self, mcp_prompt: Prompt, connector: BaseConnector) -> T:
+        """Convert an MCP prompt to the target framework's prompt format."""
+        pass
+
+    async def _create_tools_from_connectors(self, connectors: list[BaseConnector]) -> list[T]:
+        """Create tools from MCP tools in all provided connectors.
+
+        Args:
+            connectors: list of MCP connectors to create tools from.
+
+        Returns:
+            A list of tools in the target framework's format.
+        """
+        tools = []
+        for connector in connectors:
+            # Create tools for this connector
+            connector_tools = await self.load_tools_for_connector(connector)
+            tools.extend(connector_tools)
+
+        # Log available tools for debugging
+        logger.debug(f"Available tools: {len(tools)}")
+        return tools
+
+    def _check_connector_initialized(self, connector: BaseConnector) -> bool:
+        """Check if a connector is initialized and has tools.
+
+        Args:
+            connector: The connector to check.
+
+        Returns:
+            True if the connector is initialized and has tools, False otherwise.
+        """
+        return hasattr(connector, "tools") and connector.tools
+
+    async def _ensure_connector_initialized(self, connector: BaseConnector) -> bool:
+        """Ensure a connector is initialized.
+
+        Args:
+            connector: The connector to initialize.
+
+        Returns:
+            True if initialization succeeded, False otherwise.
+        """
+        if not self._check_connector_initialized(connector):
+            logger.debug("Connector doesn't have tools, initializing it")
+            try:
+                await connector.initialize()
+                return True
+            except Exception as e:
+                logger.error(f"Error initializing connector: {e}")
+                return False
+        return True

mcp_use/agents/adapters/langchain_adapter.py

@@ -0,0 +1,228 @@
+"""
+LangChain adapter for MCP tools.
+
+This module provides utilities to convert MCP tools to LangChain tools.
+"""
+
+import re
+from typing import Any, NoReturn
+
+from jsonschema_pydantic import jsonschema_to_pydantic
+from langchain_core.tools import BaseTool
+from mcp.types import (
+    CallToolResult,
+    Prompt,
+    ReadResourceRequestParams,
+    Resource,
+)
+from pydantic import BaseModel, Field, create_model
+
+from mcp_use.agents.adapters.base import BaseAdapter
+from mcp_use.client.connectors.base import BaseConnector
+from mcp_use.errors.error_formatting import format_error
+from mcp_use.logging import logger
+from mcp_use.telemetry.telemetry import telemetry
+
+
+class LangChainAdapter(BaseAdapter):
+    """Adapter for converting MCP tools to LangChain tools."""
+
+    def __init__(self, disallowed_tools: list[str] | None = None) -> None:
+        """Initialize a new LangChain adapter.
+
+        Args:
+            disallowed_tools: list of tool names that should not be available.
+        """
+        super().__init__(disallowed_tools)
+        self._connector_tool_map: dict[BaseConnector, list[BaseTool]] = {}
+
+    @telemetry("adapter_fix_schema")
+    def fix_schema(self, schema: dict) -> dict:
+        """Convert JSON Schema 'type': ['string', 'null'] to 'anyOf' format and fix enum handling.
+
+        Args:
+            schema: The JSON schema to fix.
+
+        Returns:
+            The fixed JSON schema.
+        """
+        if isinstance(schema, dict):
+            if "type" in schema and isinstance(schema["type"], list):
+                schema["anyOf"] = [{"type": t} for t in schema["type"]]
+                del schema["type"]  # Remove 'type' and standardize to 'anyOf'
+
+            # Fix enum handling - ensure enum fields are properly typed as strings
+            if "enum" in schema and "type" not in schema:
+                schema["type"] = "string"
+
+            for key, value in schema.items():
+                schema[key] = self.fix_schema(value)  # Apply recursively
+        return schema
+
+    @telemetry("adapter_convert_tool")
+    def _convert_tool(self, mcp_tool: dict[str, Any], connector: BaseConnector) -> BaseTool:
+        """Convert an MCP tool to LangChain's tool format.
+
+        Args:
+            mcp_tool: The MCP tool to convert.
+            connector: The connector that provides this tool.
+
+        Returns:
+            A LangChain BaseTool.
+        """
+        # Skip disallowed tools
+        if mcp_tool.name in self.disallowed_tools:
+            return None
+
+        # This is a dynamic class creation, we need to work with the self reference
+        adapter_self = self
+
+        class McpToLangChainAdapter(BaseTool):
+            name: str = mcp_tool.name or "NO NAME"
+            description: str = mcp_tool.description or ""
+            # Convert JSON schema to Pydantic model for argument validation
+            args_schema: type[BaseModel] = jsonschema_to_pydantic(
+                adapter_self.fix_schema(mcp_tool.inputSchema)  # Apply schema conversion
+            )
+            tool_connector: BaseConnector = connector  # Renamed variable to avoid name conflict
+            handle_tool_error: bool = True
+
+            def __repr__(self) -> str:
+                return f"MCP tool: {self.name}: {self.description}"
+
+            def _run(self, **kwargs: Any) -> NoReturn:
+                """Synchronous run method that always raises an error.
+
+                Raises:
+                    NotImplementedError: Always raises this error because MCP tools
+                        only support async operations.
+                """
+                raise NotImplementedError("MCP tools only support async operations")
+
+            async def _arun(self, **kwargs: Any) -> str | dict:
+                """Asynchronously execute the tool with given arguments.
+
+                Args:
+                    kwargs: The arguments to pass to the tool.
+
+                Returns:
+                    The result of the tool execution.
+
+                Raises:
+                    ToolException: If tool execution fails.
+                """
+                logger.debug(f'MCP tool: "{self.name}" received input: {kwargs}')
+
+                try:
+                    tool_result: CallToolResult = await self.tool_connector.call_tool(self.name, kwargs)
+                    try:
+                        return str(tool_result.content)
+                    except Exception as e:
+                        # Log the exception for debugging
+                        logger.error(f"Error parsing tool result: {e}")
+                        return format_error(e, tool=self.name, tool_content=tool_result.content)
+
+                except Exception as e:
+                    if self.handle_tool_error:
+                        return format_error(e, tool=self.name)  # Format the error to make LLM understand it
+                    raise
+
+        return McpToLangChainAdapter()
+
+    def _convert_resource(self, mcp_resource: Resource, connector: BaseConnector) -> BaseTool:
+        """Convert an MCP resource to LangChain's tool format.
+
+        Each resource becomes an async tool that returns its content when called.
+        The tool takes **no** arguments because the resource URI is fixed.
+        """
+
+        def _sanitize(name: str) -> str:
+            return re.sub(r"[^A-Za-z0-9_]+", "_", name).lower().strip("_")
+
+        class ResourceTool(BaseTool):
+            name: str = _sanitize(mcp_resource.name or f"resource_{mcp_resource.uri}")
+            description: str = (
+                mcp_resource.description or f"Return the content of the resource located at URI {mcp_resource.uri}."
+            )
+            args_schema: type[BaseModel] = ReadResourceRequestParams
+            tool_connector: BaseConnector = connector
+            handle_tool_error: bool = True
+
+            def _run(self, **kwargs: Any) -> NoReturn:
+                raise NotImplementedError("Resource tools only support async operations")
+
+            async def _arun(self, **kwargs: Any) -> Any:
+                logger.debug(f'Resource tool: "{self.name}" called')
+                try:
+                    result = await self.tool_connector.read_resource(mcp_resource.uri)
+                    for content in result.contents:
+                        # Attempt to decode bytes if necessary
+                        if isinstance(content, bytes):
+                            content_decoded = content.decode()
+                        else:
+                            content_decoded = str(content)
+
+                    return content_decoded
+                except Exception as e:
+                    if self.handle_tool_error:
+                        return format_error(e, tool=self.name)  # Format the error to make LLM understand it
+                    raise
+
+        return ResourceTool()
+
+    def _convert_prompt(self, mcp_prompt: Prompt, connector: BaseConnector) -> BaseTool:
+        """Convert an MCP prompt to LangChain's tool format.
+
+        The resulting tool executes `get_prompt` on the connector with the prompt's name and
+        the user-provided arguments (if any). The tool returns the decoded prompt content.
+        """
+        prompt_arguments = mcp_prompt.arguments
+
+        # Sanitize the prompt name to create a valid Python identifier for the model name
+        base_model_name = re.sub(r"[^a-zA-Z0-9_]", "_", mcp_prompt.name)
+        if not base_model_name or base_model_name[0].isdigit():
+            base_model_name = "PromptArgs_" + base_model_name
+        dynamic_model_name = f"{base_model_name}_InputSchema"
+
+        if prompt_arguments:
+            field_definitions_for_create: dict[str, Any] = {}
+            for arg in prompt_arguments:
+                param_type: type = getattr(arg, "type", str)
+                if arg.required:
+                    field_definitions_for_create[arg.name] = (
+                        param_type,
+                        Field(description=arg.description),
+                    )
+                else:
+                    field_definitions_for_create[arg.name] = (
+                        param_type | None,
+                        Field(None, description=arg.description),
+                    )
+
+            InputSchema = create_model(dynamic_model_name, **field_definitions_for_create, __base__=BaseModel)
+        else:
+            # Create an empty Pydantic model if there are no arguments
+            InputSchema = create_model(dynamic_model_name, __base__=BaseModel)
+
+        class PromptTool(BaseTool):
+            name: str = mcp_prompt.name
+            description: str = mcp_prompt.description
+
+            args_schema: type[BaseModel] = InputSchema
+            tool_connector: BaseConnector = connector
+            handle_tool_error: bool = True
+
+            def _run(self, **kwargs: Any) -> NoReturn:
+                raise NotImplementedError("Prompt tools only support async operations")
+
+            async def _arun(self, **kwargs: Any) -> Any:
+                logger.debug(f'Prompt tool: "{self.name}" called with args: {kwargs}')
+                try:
+                    result = await self.tool_connector.get_prompt(self.name, kwargs)
+                    return result.messages
+                except Exception as e:
+                    if self.handle_tool_error:
+                        return format_error(e, tool=self.name)  # Format the error to make LLM understand it
+                    raise
+
+        return PromptTool()

mcp_use/agents/base.py

@@ -7,7 +7,7 @@ This module provides a base class for agents that use MCP tools.
 from abc import ABC, abstractmethod
 from typing import Any
 
-from ..session import MCPSession
+from mcp_use.client.session import MCPSession
 
 
 class BaseAgent(ABC):

mcp_use/agents/managers/__init__.py

@@ -0,0 +1,19 @@
+from .server_manager import ServerManager
+from .tools import (
+    ConnectServerTool,
+    DisconnectServerTool,
+    GetActiveServerTool,
+    ListServersTool,
+    MCPServerTool,
+    SearchToolsTool,
+)
+
+__all__ = [
+    "ServerManager",
+    "MCPServerTool",
+    "ConnectServerTool",
+    "DisconnectServerTool",
+    "GetActiveServerTool",
+    "ListServersTool",
+    "SearchToolsTool",
+]

mcp_use/agents/managers/base.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+
+from langchain_core.tools import BaseTool
+
+
+class BaseServerManager(ABC):
+    """Abstract base class for server managers.
+
+    This class defines the interface for server managers that can be used with MCPAgent.
+    Custom server managers should inherit from this class and implement the required methods.
+    """
+
+    @abstractmethod
+    async def initialize(self) -> None:
+        """Initialize the server manager."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def tools(self) -> list[BaseTool]:
+        """Get all server management tools and tools from the active server.
+
+        Returns:
+            list of LangChain tools for server management plus tools from active server
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def has_tool_changes(self, current_tool_names: set[str]) -> bool:
+        """Check if the available tools have changed.
+        Args:
+            current_tool_names: Set of currently known tool names
+        Returns:
+            True if tools have changed, False otherwise
+        """
+        raise NotImplementedError

mcp_use/agents/managers/server_manager.py

@@ -0,0 +1,131 @@
+from langchain_core.tools import BaseTool
+
+from mcp_use.agents.adapters.base import BaseAdapter
+from mcp_use.agents.managers.base import BaseServerManager
+from mcp_use.agents.managers.tools import (
+    ConnectServerTool,
+    DisconnectServerTool,
+    GetActiveServerTool,
+    ListServersTool,
+    SearchToolsTool,
+)
+from mcp_use.client import MCPClient
+from mcp_use.logging import logger
+from mcp_use.telemetry.telemetry import telemetry
+
+
+class ServerManager(BaseServerManager):
+    """Manages MCP servers and provides tools for server selection and management.
+
+    This class allows an agent to discover and select which MCP server to use,
+    dynamically activating the tools for the selected server.
+    """
+
+    def __init__(self, client: MCPClient, adapter: BaseAdapter) -> None:
+        """Initialize the server manager.
+
+        Args:
+            client: The MCPClient instance managing server connections
+            adapter: The LangChainAdapter for converting MCP tools to LangChain tools
+        """
+        self.client = client
+        self.adapter = adapter
+        self.active_server: str | None = None
+        self.initialized_servers: dict[str, bool] = {}
+        self._server_tools: dict[str, list[BaseTool]] = {}
+
+    @telemetry("server_manager_initialize")
+    async def initialize(self) -> None:
+        """Initialize the server manager and prepare server management tools."""
+        # Make sure we have server configurations
+        if not self.client.get_server_names():
+            logger.warning("No MCP servers defined in client configuration")
+
+    async def _prefetch_server_tools(self) -> None:
+        """Pre-fetch tools for all servers to populate the tool search index."""
+        servers = self.client.get_server_names()
+        for server_name in servers:
+            try:
+                # Only create session if needed, don't set active
+                session = None
+                try:
+                    session = self.client.get_session(server_name)
+                    logger.debug(f"Using existing session for server '{server_name}' to prefetch tools.")
+                except ValueError:
+                    try:
+                        session = await self.client.create_session(server_name)
+                        logger.debug(f"Temporarily created session for '{server_name}' to prefetch tools")
+                    except Exception:
+                        logger.warning(f"Could not create session for '{server_name}' during prefetch")
+                        continue
+
+                # Fetch tools if session is available
+                if session:
+                    connector = session.connector
+                    tools = await self.adapter._create_tools_from_connectors([connector])
+
+                    # Check if this server's tools have changed
+                    if server_name not in self._server_tools or self._server_tools[server_name] != tools:
+                        self._server_tools[server_name] = tools  # Cache tools
+                        self.initialized_servers[server_name] = True  # Mark as initialized
+                        logger.debug(f"Prefetched {len(tools)} tools for server '{server_name}'.")
+                    else:
+                        logger.debug(f"Tools for server '{server_name}' unchanged, using cached version.")
+            except Exception as e:
+                logger.error(f"Error prefetching tools for server '{server_name}': {e}")
+
+    def get_active_server_tools(self) -> list[BaseTool]:
+        """Get tools from the currently active server.
+
+        Returns:
+            List of tools from the active server, or empty list if no server is active
+        """
+        if self.active_server and self.active_server in self._server_tools:
+            return self._server_tools[self.active_server]
+        return []
+
+    def get_management_tools(self) -> list[BaseTool]:
+        """Get the server management tools.
+
+        Returns:
+            List of server management tools
+        """
+        return [
+            ListServersTool(self),
+            ConnectServerTool(self),
+            GetActiveServerTool(self),
+            DisconnectServerTool(self),
+            SearchToolsTool(self),
+        ]
+
+    def has_tool_changes(self, current_tool_names: set[str]) -> bool:
+        """Check if the available tools have changed.
+
+        Args:
+            current_tool_names: Set of currently known tool names
+
+        Returns:
+            True if tools have changed, False otherwise
+        """
+        new_tool_names = {tool.name for tool in self.tools}
+        return new_tool_names != current_tool_names
+
+    @property
+    def tools(self) -> list[BaseTool]:
+        """Get all server management tools and tools from the active server.
+
+        Returns:
+            list of LangChain tools for server management plus tools from active server
+        """
+        management_tools = self.get_management_tools()
+
+        # Add tools from the active server if available
+        if self.active_server and self.active_server in self._server_tools:
+            server_tools = self._server_tools[self.active_server]
+            logger.debug(f"Including {len(server_tools)} tools from active server '{self.active_server}'")
+            logger.debug(f"Server tools: {[tool.name for tool in server_tools]}")
+            return management_tools + server_tools
+        else:
+            logger.debug("No active server - returning only management tools")
+
+        return management_tools

mcp_use/agents/managers/tools/__init__.py

@@ -0,0 +1,15 @@
+from .base_tool import MCPServerTool
+from .connect_server import ConnectServerTool
+from .disconnect_server import DisconnectServerTool
+from .get_active_server import GetActiveServerTool
+from .list_servers_tool import ListServersTool
+from .search_tools import SearchToolsTool
+
+__all__ = [
+    "MCPServerTool",
+    "ConnectServerTool",
+    "DisconnectServerTool",
+    "GetActiveServerTool",
+    "ListServersTool",
+    "SearchToolsTool",
+]

mcp_use/agents/managers/tools/base_tool.py

@@ -0,0 +1,19 @@
+from typing import ClassVar
+
+from langchain_core.tools import BaseTool
+
+
+class MCPServerTool(BaseTool):
+    """Base tool for MCP server operations."""
+
+    name: ClassVar[str] = "mcp_server_tool"
+    description: ClassVar[str] = "Base tool for MCP server operations."
+
+    def __init__(self, server_manager):
+        """Initialize with server manager."""
+        super().__init__()
+        self._server_manager = server_manager
+
+    @property
+    def server_manager(self):
+        return self._server_manager