mcp-use 1.1.5__py3-none-any.whl → 1.2.6__py3-none-any.whl

mcp_use/__init__.py

@@ -11,7 +11,7 @@ from .agents.mcpagent import MCPAgent
 from .client import MCPClient
 from .config import load_config_file
 from .connectors import BaseConnector, HttpConnector, StdioConnector, WebSocketConnector
-from .logging import logger
+from .logging import MCP_USE_DEBUG, Logger, logger
 from .session import MCPSession
 
 __version__ = version("mcp-use")
@@ -27,4 +27,17 @@ __all__ = [
     "create_session_from_config",
     "load_config_file",
     "logger",
+    "MCP_USE_DEBUG",
+    "Logger",
+    "set_debug",
 ]
+
+
+# Helper function to set debug mode
+def set_debug(debug=2):
+    """Set the debug mode for mcp_use.
+
+    Args:
+        debug: Whether to enable debug mode (default: True)
+    """
+    Logger.set_debug(debug)

mcp_use/adapters/__init__.py

@@ -0,0 +1,10 @@
+"""
+Adapters for converting MCP tools to different frameworks.
+
+This package provides adapters for converting MCP tools to different frameworks.
+"""
+
+from .base import BaseAdapter
+from .langchain_adapter import LangChainAdapter
+
+__all__ = ["BaseAdapter", "LangChainAdapter"]

mcp_use/adapters/base.py

@@ -0,0 +1,178 @@
+"""
+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 Any, TypeVar
+
+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]] = {}
+
+    @classmethod
+    async def create_tools(
+        cls, client: "MCPClient", disallowed_tools: list[str] | None = None
+    ) -> 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.
+            disallowed_tools: Optional list of tool names to exclude.
+
+        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)
+            ```
+        """
+        # Create the adapter
+        adapter = cls(disallowed_tools=disallowed_tools)
+
+        # 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 adapter._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
+        connector_tools = []
+
+        # Make sure the connector is initialized and has tools
+        success = await self._ensure_connector_initialized(connector)
+        if not success:
+            return []
+
+        # Now create tools for each MCP tool
+        for tool in connector.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)
+
+        # 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: dict[str, Any], connector: BaseConnector) -> T:
+        """Convert an MCP tool to the target framework's tool format.
+
+        Args:
+            mcp_tool: The MCP tool to convert.
+            connector: The connector that provides this tool.
+
+        Returns:
+            A tool in the target framework's 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/adapters/langchain_adapter.py

@@ -0,0 +1,161 @@
+"""
+LangChain adapter for MCP tools.
+
+This module provides utilities to convert MCP tools to LangChain tools.
+"""
+
+from typing import Any, NoReturn
+
+from jsonschema_pydantic import jsonschema_to_pydantic
+from langchain_core.tools import BaseTool, ToolException
+from mcp.types import CallToolResult, EmbeddedResource, ImageContent, TextContent
+from pydantic import BaseModel
+
+from ..connectors.base import BaseConnector
+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.
+
+        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'
+            for key, value in schema.items():
+                schema[key] = self.fix_schema(value)  # Apply recursively
+        return schema
+
+    def _parse_mcp_tool_result(self, tool_result: CallToolResult) -> str:
+        """Parse the content of a CallToolResult into a string.
+
+        Args:
+            tool_result: The result object from calling an MCP tool.
+
+        Returns:
+            A string representation of the tool result content.
+
+        Raises:
+            ToolException: If the tool execution failed, returned no content,
+                        or contained unexpected content types.
+        """
+        if tool_result.isError:
+            raise ToolException(f"Tool execution failed: {tool_result.content}")
+
+        if not tool_result.content:
+            raise ToolException("Tool execution returned no content")
+
+        decoded_result = ""
+        for item in tool_result.content:
+            match item.type:
+                case "text":
+                    item: TextContent
+                    decoded_result += item.text
+                case "image":
+                    item: ImageContent
+                    decoded_result += item.data  # Assuming data is string-like or base64
+                case "resource":
+                    resource: EmbeddedResource = item.resource
+                    if hasattr(resource, "text"):
+                        decoded_result += resource.text
+                    elif hasattr(resource, "blob"):
+                        # Assuming blob needs decoding or specific handling; adjust as needed
+                        decoded_result += (
+                            resource.blob.decode()
+                            if isinstance(resource.blob, bytes)
+                            else str(resource.blob)
+                        )
+                    else:
+                        raise ToolException(f"Unexpected resource type: {resource.type}")
+                case _:
+                    raise ToolException(f"Unexpected content type: {item.type}")
+
+        return decoded_result
+
+    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 _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) -> Any:
+                """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:
+                        # Use the helper function to parse the result
+                        return adapter_self._parse_mcp_tool_result(tool_result)
+                    except Exception as e:
+                        # Log the exception for debugging
+                        logger.error(f"Error parsing tool result: {e}")
+                        return f"Error parsing result: {e!s}; Raw content: {tool_result.content!r}"
+
+                except Exception as e:
+                    if self.handle_tool_error:
+                        return f"Error executing MCP tool: {str(e)}"
+                    raise
+
+        return McpToLangChainAdapter()

mcp_use/agents/__init__.py

@@ -6,7 +6,11 @@ that are pre-configured for using MCP tools.
 """
 
 from .base import BaseAgent
-from .langchain_agent import LangChainAgent
 from .mcpagent import MCPAgent
+from .server_manager import ServerManager
 
-__all__ = ["BaseAgent", "LangChainAgent", "MCPAgent"]
+__all__ = [
+    "BaseAgent",
+    "MCPAgent",
+    "ServerManager",
+]