mcp-use 1.2.12__py3-none-any.whl → 1.3.0__py3-none-any.whl

mcp_use/adapters/base.py

@@ -5,7 +5,9 @@ This module provides the abstract base class that all MCP tool adapters should i
 """
 
 from abc import ABC, abstractmethod
-from typing import Any, TypeVar
+from typing import TypeVar
+
+from mcp.types import Prompt, Resource, Tool
 
 from ..client import MCPClient
 from ..connectors.base import BaseConnector
@@ -90,13 +92,13 @@ class BaseAdapter(ABC):
             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 []
 
+        connector_tools = []
         # 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
@@ -104,6 +106,23 @@ class BaseAdapter(ABC):
             if converted_tool:
                 connector_tools.append(converted_tool)
 
+        # Convert resources to tools so that agents can access resource content directly
+        resources_list = connector.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 = connector.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
 
@@ -116,16 +135,18 @@ class BaseAdapter(ABC):
         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.
+    def _convert_tool(self, mcp_tool: Tool, connector: BaseConnector) -> T:
+        """Convert an MCP tool to the target framework's tool format."""
+        pass
 
-        Args:
-            mcp_tool: The MCP tool to convert.
-            connector: The connector that provides this tool.
+    @abstractmethod
+    def _convert_resource(self, mcp_resource: Resource, connector: BaseConnector) -> T:
+        """Convert an MCP resource to the target framework's resource format."""
+        pass
 
-        Returns:
-            A tool in the target framework's format.
-        """
+    @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]:

mcp_use/adapters/langchain_adapter.py

@@ -4,12 +4,21 @@ 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, ToolException
-from mcp.types import CallToolResult, EmbeddedResource, ImageContent, TextContent
-from pydantic import BaseModel
+from mcp.types import (
+    CallToolResult,
+    EmbeddedResource,
+    ImageContent,
+    Prompt,
+    ReadResourceRequestParams,
+    Resource,
+    TextContent,
+)
+from pydantic import BaseModel, Field, create_model
 
 from ..connectors.base import BaseConnector
 from ..logging import logger
@@ -162,3 +171,104 @@ class LangChainAdapter(BaseAdapter):
                     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 f"Error reading resource: {str(e)}"
+                    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 f"Error fetching prompt: {str(e)}"
+                    raise
+
+        return PromptTool()

mcp_use/agents/mcpagent.py

@@ -9,6 +9,7 @@ import logging
 from collections.abc import AsyncIterator
 
 from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain.agents.output_parsers.tools import ToolAgentAction
 from langchain.globals import set_debug
 from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
 from langchain.schema import AIMessage, BaseMessage, HumanMessage, SystemMessage
@@ -21,7 +22,6 @@ from langchain_core.utils.input import get_color_mapping
 
 from mcp_use.client import MCPClient
 from mcp_use.connectors.base import BaseConnector
-from mcp_use.session import MCPSession
 
 from ..adapters.langchain_adapter import LangChainAdapter
 from ..logging import logger
@@ -102,9 +102,7 @@ class MCPAgent:
 
         # State tracking
         self._agent_executor: AgentExecutor | None = None
-        self._sessions: dict[str, MCPSession] = {}
         self._system_message: SystemMessage | None = None
-        self._tools: list[BaseTool] = []
 
     async def initialize(self) -> None:
         """Initialize the MCP client and agent."""
@@ -346,20 +344,18 @@ class MCPAgent:
         history_to_use = (
             external_history if external_history is not None else self._conversation_history
         )
-        langchain_history: list[BaseMessage] = [
-            m for m in history_to_use if isinstance(m, HumanMessage | AIMessage)
-        ]
-        inputs = {"input": query, "chat_history": langchain_history}
+        inputs = {"input": query, "chat_history": history_to_use}
 
         # 3. Stream & diff -------------------------------------------------------
-        accumulated = ""
         async for event in self._agent_executor.astream_events(inputs):
+            if event.get("event") == "on_chain_end":
+                output = event["data"]["output"]
+                if isinstance(output, list):
+                    for message in output:
+                        if not isinstance(message, ToolAgentAction):
+                            self.add_to_history(message)
             yield event
 
-        # 4. Persist assistant message ------------------------------------------
-        if self.memory_enabled and accumulated:
-            self.add_to_history(AIMessage(content=accumulated))
-
         # 5. House-keeping -------------------------------------------------------
         if initialised_here and manage_connector:
             await self.close()

mcp_use/client.py

@@ -12,6 +12,7 @@ from typing import Any
 from .config import create_connector_from_config, load_config_file
 from .logging import logger
 from .session import MCPSession
+from .types.clientoptions import ClientOptions
 
 
 class MCPClient:
@@ -24,14 +25,17 @@ class MCPClient:
     def __init__(
         self,
         config: str | dict[str, Any] | None = None,
+        options: ClientOptions | None = None,
     ) -> None:
         """Initialize a new MCP client.
 
         Args:
             config: Either a dict containing configuration or a path to a JSON config file.
                    If None, an empty configuration is used.
+            options: Configuration options for the client.
         """
         self.config: dict[str, Any] = {}
+        self.options = options or {}
         self.sessions: dict[str, MCPSession] = {}
         self.active_sessions: list[str] = []
 
@@ -43,22 +47,24 @@ class MCPClient:
                 self.config = config
 
     @classmethod
-    def from_dict(cls, config: dict[str, Any]) -> "MCPClient":
+    def from_dict(cls, config: dict[str, Any], options: ClientOptions | None = None) -> "MCPClient":
         """Create a MCPClient from a dictionary.
 
         Args:
             config: The configuration dictionary.
+            options: Optional client configuration options.
         """
-        return cls(config=config)
+        return cls(config=config, options=options)
 
     @classmethod
-    def from_config_file(cls, filepath: str) -> "MCPClient":
+    def from_config_file(cls, filepath: str, options: ClientOptions | None = None) -> "MCPClient":
         """Create a MCPClient from a configuration file.
 
         Args:
             filepath: The path to the configuration file.
+            options: Optional client configuration options.
         """
-        return cls(config=load_config_file(filepath))
+        return cls(config=load_config_file(filepath), options=options)
 
     def add_server(
         self,
@@ -111,6 +117,7 @@ class MCPClient:
 
         Args:
             server_name: The name of the server to create a session for.
+            auto_initialize: Whether to automatically initialize the session.
 
         Returns:
             The created MCPSession.
@@ -128,7 +135,9 @@ class MCPClient:
             raise ValueError(f"Server '{server_name}' not found in config")
 
         server_config = servers[server_name]
-        connector = create_connector_from_config(server_config)
+
+        # Create connector with options
+        connector = create_connector_from_config(server_config, options=self.options)
 
         # Create the session
         session = MCPSession(connector)
@@ -146,16 +155,16 @@ class MCPClient:
         self,
         auto_initialize: bool = True,
     ) -> dict[str, MCPSession]:
-        """Create a session for the specified server.
+        """Create sessions for all configured servers.
 
         Args:
-            auto_initialize: Whether to automatically initialize the session.
+            auto_initialize: Whether to automatically initialize the sessions.
 
         Returns:
-            The created MCPSession. If server_name is None, returns the first created session.
+            Dictionary mapping server names to their MCPSession instances.
 
         Warns:
-            Warning: If no servers are configured.
+            UserWarning: If no servers are configured.
         """
         # Get server config
         servers = self.config.get("mcpServers", {})

mcp_use/config.py

@@ -7,7 +7,15 @@ This module provides functionality to load MCP configuration from JSON files.
 import json
 from typing import Any
 
-from .connectors import BaseConnector, HttpConnector, StdioConnector, WebSocketConnector
+from .connectors import (
+    BaseConnector,
+    HttpConnector,
+    SandboxConnector,
+    StdioConnector,
+    WebSocketConnector,
+)
+from .connectors.utils import is_stdio_server
+from .types.clientoptions import ClientOptions
 
 
 def load_config_file(filepath: str) -> dict[str, Any]:
@@ -23,23 +31,41 @@ def load_config_file(filepath: str) -> dict[str, Any]:
         return json.load(f)
 
 
-def create_connector_from_config(server_config: dict[str, Any]) -> BaseConnector:
+def create_connector_from_config(
+    server_config: dict[str, Any],
+    options: ClientOptions | None = None,
+) -> BaseConnector:
     """Create a connector based on server configuration.
-
+    This function can be called with just the server_config parameter:
+    create_connector_from_config(server_config)
     Args:
         server_config: The server configuration section
+        options: Optional client configuration options including sandboxing preferences.
+                 If None, default client options will be used.
 
     Returns:
         A configured connector instance
     """
+    # Use default options if none provided
+    options = options or {"is_sandboxed": False}
+
     # Stdio connector (command-based)
-    if "command" in server_config and "args" in server_config:
+    if is_stdio_server(server_config) and not options.get("is_sandboxed", False):
         return StdioConnector(
             command=server_config["command"],
             args=server_config["args"],
             env=server_config.get("env", None),
         )
 
+    # Sandboxed connector
+    elif is_stdio_server(server_config) and options.get("is_sandboxed", False):
+        return SandboxConnector(
+            command=server_config["command"],
+            args=server_config["args"],
+            env=server_config.get("env", None),
+            e2b_options=options.get("sandbox_options", {}),
+        )
+
     # HTTP connector
     elif "url" in server_config:
         return HttpConnector(

mcp_use/connectors/__init__.py

@@ -5,9 +5,16 @@ This module provides interfaces for connecting to MCP implementations
 through different transport mechanisms.
 """
 
-from .base import BaseConnector
-from .http import HttpConnector
-from .stdio import StdioConnector
-from .websocket import WebSocketConnector
+from .base import BaseConnector  # noqa: F401
+from .http import HttpConnector  # noqa: F401
+from .sandbox import SandboxConnector  # noqa: F401
+from .stdio import StdioConnector  # noqa: F401
+from .websocket import WebSocketConnector  # noqa: F401
 
-__all__ = ["BaseConnector", "StdioConnector", "WebSocketConnector", "HttpConnector"]
+__all__ = [
+    "BaseConnector",
+    "StdioConnector",
+    "HttpConnector",
+    "WebSocketConnector",
+    "SandboxConnector",
+]

mcp_use/connectors/base.py

@@ -9,7 +9,8 @@ from abc import ABC, abstractmethod
 from typing import Any
 
 from mcp import ClientSession
-from mcp.types import CallToolResult, Tool
+from mcp.shared.exceptions import McpError
+from mcp.types import CallToolResult, GetPromptResult, Prompt, ReadResourceResult, Resource, Tool
 
 from ..logging import logger
 from ..task_managers import ConnectionManager
@@ -26,6 +27,8 @@ class BaseConnector(ABC):
         self.client: ClientSession | None = None
         self._connection_manager: ConnectionManager | None = None
         self._tools: list[Tool] | None = None
+        self._resources: list[Resource] | None = None
+        self._prompts: list[Prompt] | None = None
         self._connected = False
 
     @abstractmethod
@@ -74,6 +77,8 @@ class BaseConnector(ABC):
 
         # Reset tools
         self._tools = None
+        self._resources = None
+        self._prompts = None
 
         if errors:
             logger.warning(f"Encountered {len(errors)} errors during resource cleanup")
@@ -88,21 +93,58 @@ class BaseConnector(ABC):
         # Initialize the session
         result = await self.client.initialize()
 
-        # Get available tools
-        tools_result = await self.client.list_tools()
-        self._tools = tools_result.tools
-
-        logger.debug(f"MCP session initialized with {len(self._tools)} tools")
+        server_capabilities = result.capabilities
+
+        if server_capabilities.tools:
+            # Get available tools
+            tools_result = await self.list_tools()
+            self._tools = tools_result or []
+        else:
+            self._tools = []
+
+        if server_capabilities.resources:
+            # Get available resources
+            resources_result = await self.list_resources()
+            self._resources = resources_result or []
+        else:
+            self._resources = []
+
+        if server_capabilities.prompts:
+            # Get available prompts
+            prompts_result = await self.list_prompts()
+            self._prompts = prompts_result or []
+        else:
+            self._prompts = []
+
+        logger.debug(
+            f"MCP session initialized with {len(self._tools)} tools, "
+            f"{len(self._resources)} resources, "
+            f"and {len(self._prompts)} prompts"
+        )
 
         return result
 
     @property
     def tools(self) -> list[Tool]:
         """Get the list of available tools."""
-        if not self._tools:
+        if self._tools is None:
             raise RuntimeError("MCP client is not initialized")
         return self._tools
 
+    @property
+    def resources(self) -> list[Resource]:
+        """Get the list of available resources."""
+        if self._resources is None:
+            raise RuntimeError("MCP client is not initialized")
+        return self._resources
+
+    @property
+    def prompts(self) -> list[Prompt]:
+        """Get the list of available prompts."""
+        if self._prompts is None:
+            raise RuntimeError("MCP client is not initialized")
+        return self._prompts
+
     async def call_tool(self, name: str, arguments: dict[str, Any]) -> CallToolResult:
         """Call an MCP tool with the given arguments."""
         if not self.client:
@@ -113,43 +155,64 @@ class BaseConnector(ABC):
         logger.debug(f"Tool '{name}' called with result: {result}")
         return result
 
-    async def list_resources(self) -> list[dict[str, Any]]:
+    async def list_tools(self) -> list[Tool]:
+        """List all available tools from the MCP implementation."""
+        if not self.client:
+            raise RuntimeError("MCP client is not connected")
+
+        logger.debug("Listing tools")
+        try:
+            result = await self.client.list_tools()
+            return result.tools
+        except McpError as e:
+            logger.error(f"Error listing tools: {e}")
+            return []
+
+    async def list_resources(self) -> list[Resource]:
         """List all available resources from the MCP implementation."""
         if not self.client:
             raise RuntimeError("MCP client is not connected")
 
         logger.debug("Listing resources")
-        resources = await self.client.list_resources()
-        return resources
-
-    async def read_resource(self, uri: str) -> tuple[bytes, str]:
+        try:
+            result = await self.client.list_resources()
+            return result.resources
+        except McpError as e:
+            logger.error(f"Error listing resources: {e}")
+            return []
+
+    async def read_resource(self, uri: str) -> ReadResourceResult:
         """Read a resource by URI."""
         if not self.client:
             raise RuntimeError("MCP client is not connected")
 
         logger.debug(f"Reading resource: {uri}")
-        resource = await self.client.read_resource(uri)
-        return resource.content, resource.mimeType
+        result = await self.client.read_resource(uri)
+        return result
 
-    async def list_prompts(self) -> list[dict[str, Any]]:
+    async def list_prompts(self) -> list[Prompt]:
         """List all available prompts from the MCP implementation."""
         if not self.client:
             raise RuntimeError("MCP client is not connected")
 
         logger.debug("Listing prompts")
-        prompts = await self.client.list_prompts()
-        return prompts
+        try:
+            result = await self.client.list_prompts()
+            return result.prompts
+        except McpError as e:
+            logger.error(f"Error listing prompts: {e}")
+            return []
 
     async def get_prompt(
         self, name: str, arguments: dict[str, Any] | None = None
-    ) -> tuple[bytes, str]:
+    ) -> GetPromptResult:
         """Get a prompt by name."""
         if not self.client:
             raise RuntimeError("MCP client is not connected")
 
         logger.debug(f"Getting prompt: {name}")
-        prompt = await self.client.get_prompt(name, arguments)
-        return prompt
+        result = await self.client.get_prompt(name, arguments)
+        return result
 
     async def request(self, method: str, params: dict[str, Any] | None = None) -> Any:
         """Send a raw request to the MCP implementation."""