mcp-use 1.3.12__py3-none-any.whl → 1.4.0__py3-none-any.whl

mcp_use/__init__.py

@@ -12,7 +12,7 @@ from importlib.metadata import version
 from .logging import MCP_USE_DEBUG, Logger, logger  # isort: skip
 
 # Now import other modules - observability must come after logging
-from . import observability  # noqa: E402
+from .agents import observability  # noqa: E402
 from .agents.mcpagent import MCPAgent
 from .client import MCPClient
 from .config import load_config_file

mcp_use/adapters/__init__.py

@@ -1,10 +1,21 @@
-"""
-Adapters for converting MCP tools to different frameworks.
+# mcp_use/adapters/__init__.py
+import warnings
 
-This package provides adapters for converting MCP tools to different frameworks.
-"""
+from typing_extensions import deprecated
 
-from .base import BaseAdapter
-from .langchain_adapter import LangChainAdapter
+from mcp_use.agents.adapters import BaseAdapter as _BaseAdapter
+from mcp_use.agents.adapters import LangChainAdapter as _LangChainAdapter
 
-__all__ = ["BaseAdapter", "LangChainAdapter"]
+warnings.warn(
+    "mcp_use.adapters is deprecated. Use mcp_use.agents.adapters. This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+
+@deprecated("Use mcp_use.agents.adapters.BaseAdapter")
+class BaseAdapter(_BaseAdapter): ...
+
+
+@deprecated("Use mcp_use.agents.adapters.LangChainAdapter")
+class LangChainAdapter(_LangChainAdapter): ...

mcp_use/adapters/base.py

@@ -1,190 +1,17 @@
-"""
-Base adapter interface for MCP tools.
+# mcp_use/adapters/base.py
+import warnings
 
-This module provides the abstract base class that all MCP tool adapters should inherit from.
-"""
+from typing_extensions import deprecated
 
-from abc import ABC, abstractmethod
-from typing import TypeVar
+from mcp_use.agents.adapters.base import BaseAdapter as _BaseAdapter
 
-from mcp.types import Prompt, Resource, Tool
+warnings.warn(
+    "mcp_use.adapters.base is deprecated. Use mcp_use.agents.adapters.base. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-from ..client import MCPClient
-from ..connectors.base import BaseConnector
-from ..logging import logger
 
-# 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]] = {}
-
-    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)
-
-    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
+@deprecated("Use mcp_use.agents.adapters.base.BaseAdapter")
+class BaseAdapter(_BaseAdapter): ...

mcp_use/adapters/langchain_adapter.py

@@ -1,225 +1,18 @@
-"""
-LangChain adapter for MCP tools.
+# mcp_use/adapters/langchain_adapter.py
+import warnings
 
-This module provides utilities to convert MCP tools to LangChain tools.
-"""
+from typing_extensions import deprecated
 
-import re
-from typing import Any, NoReturn
+from mcp_use.agents.adapters.langchain_adapter import LangChainAdapter as _LangChainAdapter
 
-from jsonschema_pydantic import jsonschema_to_pydantic
-from langchain_core.tools import BaseTool
-from mcp.types import (
-    CallToolResult,
-    Prompt,
-    ReadResourceRequestParams,
-    Resource,
+warnings.warn(
+    "mcp_use.adapters.langchain_adapter is deprecated. "
+    "Use mcp_use.agents.adapters.langchain_adapter. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
 )
-from pydantic import BaseModel, Field, create_model
 
-from ..connectors.base import BaseConnector
-from ..errors.error_formatting import format_error
-from ..logging import logger
-from .base import BaseAdapter
 
-
-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]] = {}
-
-    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
-
-    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()
+@deprecated("Use mcp_use.agents.adapters.langchain_adapter.LangChainAdapter")
+class LangChainAdapter(_LangChainAdapter): ...

mcp_use/agents/adapters/__init__.py

@@ -0,0 +1,17 @@
+"""
+Adapters for converting MCP tools to different frameworks.
+
+This package provides adapters for converting MCP tools to different frameworks.
+"""
+
+from .anthropic import AnthropicMCPAdapter
+from .base import BaseAdapter
+from .langchain_adapter import LangChainAdapter
+from .openai import OpenAIMCPAdapter
+
+try:
+    from .google import GoogleMCPAdapter
+
+    __all__ = ["BaseAdapter", "LangChainAdapter", "OpenAIMCPAdapter", "AnthropicMCPAdapter", "GoogleMCPAdapter"]
+except ImportError:
+    __all__ = ["BaseAdapter", "LangChainAdapter", "OpenAIMCPAdapter", "AnthropicMCPAdapter"]

mcp_use/agents/adapters/anthropic.py

@@ -0,0 +1,93 @@
+import re
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+from mcp.types import Prompt, Resource, Tool
+
+from mcp_use.agents.adapters.base import BaseAdapter
+from mcp_use.client.connectors.base import BaseConnector
+
+
+def _sanitize_for_tool_name(name: str) -> str:
+    """Sanitizes a string to be a valid tool name for Anthropic."""
+    # Anthropic tool names can only contain a-z, A-Z, 0-9, and underscores,
+    # and must be 64 characters or less.
+    return re.sub(r"[^a-zA-Z0-9_]+", "_", name).strip("_")[:64]
+
+
+class AnthropicMCPAdapter(BaseAdapter):
+    def __init__(self, disallowed_tools: list[str] | None = None) -> None:
+        """Initialize a new Anthropic adapter.
+
+        Args:
+            disallowed_tools: list of tool names that should not be available.
+        """
+        super().__init__(disallowed_tools)
+        # This map stores the actual async function to call for each tool.
+        self.tool_executors: dict[str, Callable[..., Coroutine[Any, Any, Any]]] = {}
+
+        self._connector_tool_map: dict[BaseConnector, list[dict[str, Any]]] = {}
+        self._connector_resource_map: dict[BaseConnector, list[dict[str, Any]]] = {}
+        self._connector_prompt_map: dict[BaseConnector, list[dict[str, Any]]] = {}
+
+        self.tools: list[dict[str, Any]] = []
+        self.resources: list[dict[str, Any]] = []
+        self.prompts: list[dict[str, Any]] = []
+
+    def _convert_tool(self, mcp_tool: Tool, connector: BaseConnector) -> dict[str, Any]:
+        """Convert an MCP tool to the Anthropic tool format."""
+        if mcp_tool.name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[mcp_tool.name] = (
+            lambda connector=connector, name=mcp_tool.name, **kwargs: connector.call_tool(name, kwargs)
+        )
+
+        fixed_schema = self.fix_schema(mcp_tool.inputSchema)
+        return {"name": mcp_tool.name, "description": mcp_tool.description, "input_schema": fixed_schema}
+
+    def _convert_resource(self, mcp_resource: Resource, connector: BaseConnector) -> dict[str, Any]:
+        """Convert an MCP resource to a readable tool in Anthropic format."""
+        tool_name = _sanitize_for_tool_name(f"resource_{mcp_resource.name}")
+
+        if tool_name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[tool_name] = (
+            lambda connector=connector, uri=mcp_resource.uri, **kwargs: connector.read_resource(uri)
+        )
+
+        return {
+            "name": tool_name,
+            "description": mcp_resource.description,
+            "input_schema": {"type": "object", "properties": {}},
+        }
+
+    def _convert_prompt(self, mcp_prompt: Prompt, connector: BaseConnector) -> dict[str, Any]:
+        """Convert an MCP prompt to a usable tool in Anthropic format."""
+        if mcp_prompt.name in self.disallowed_tools:
+            return None
+
+        self.tool_executors[mcp_prompt.name] = (
+            lambda connector=connector, name=mcp_prompt.name, **kwargs: connector.get_prompt(name, kwargs)
+        )
+
+        properties = {}
+        required_args = []
+        if mcp_prompt.arguments:
+            for arg in mcp_prompt.arguments:
+                prop = {"type": "string"}
+                if arg.description:
+                    prop["description"] = arg.description
+                properties[arg.name] = prop
+                if arg.required:
+                    required_args.append(arg.name)
+        parameters_schema = {"type": "object", "properties": properties}
+        if required_args:
+            parameters_schema["required"] = required_args
+
+        return {
+            "name": mcp_prompt.name,
+            "description": mcp_prompt.description,
+            "input_schema": parameters_schema,
+        }