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

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/sandbox.py

@@ -0,0 +1,291 @@
+"""
+Sandbox connector for MCP implementations.
+
+This module provides a connector for communicating with MCP implementations
+that are executed inside a sandbox environment (currently using E2B).
+"""
+
+import asyncio
+import os
+import sys
+import time
+
+import aiohttp
+from mcp import ClientSession
+
+from ..logging import logger
+from ..task_managers import SseConnectionManager
+
+# Import E2B SDK components (optional dependency)
+try:
+    logger.debug("Attempting to import e2b_code_interpreter...")
+    from e2b_code_interpreter import (
+        CommandHandle,
+        Sandbox,
+    )
+
+    logger.debug("Successfully imported e2b_code_interpreter")
+except ImportError as e:
+    logger.debug(f"Failed to import e2b_code_interpreter: {e}")
+    CommandHandle = None
+    Sandbox = None
+
+from ..types.sandbox import SandboxOptions
+from .base import BaseConnector
+
+
+class SandboxConnector(BaseConnector):
+    """Connector for MCP implementations running in a sandbox environment.
+
+    This connector runs a user-defined stdio command within a sandbox environment,
+    currently implemented using E2B, potentially wrapped by a utility like 'supergateway'
+    to expose its stdio.
+    """
+
+    def __init__(
+        self,
+        command: str,
+        args: list[str],
+        env: dict[str, str] | None = None,
+        e2b_options: SandboxOptions | None = None,
+        timeout: float = 5,
+        sse_read_timeout: float = 60 * 5,
+    ):
+        """Initialize a new sandbox connector.
+
+        Args:
+            command: The user's MCP server command to execute in the sandbox.
+            args: Command line arguments for the user's MCP server command.
+            env: Environment variables for the user's MCP server command.
+            e2b_options: Configuration options for the E2B sandbox environment.
+                        See SandboxOptions for available options and defaults.
+            timeout: Timeout for the sandbox process in seconds.
+            sse_read_timeout: Timeout for the SSE connection in seconds.
+        """
+        super().__init__()
+        if Sandbox is None:
+            raise ImportError(
+                "E2B SDK (e2b-code-interpreter) not found. "
+                "Please install it with 'pip install mcp-use[e2b]' "
+                "(or 'pip install e2b-code-interpreter')."
+            )
+
+        self.user_command = command
+        self.user_args = args or []
+        self.user_env = env or {}
+
+        _e2b_options = e2b_options or {}
+
+        self.api_key = _e2b_options.get("api_key") or os.environ.get("E2B_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "E2B API key is required. Provide it via 'e2b_options.api_key' "
+                "or the E2B_API_KEY environment variable."
+            )
+
+        self.sandbox_template_id = _e2b_options.get("sandbox_template_id", "base")
+        self.supergateway_cmd_parts = _e2b_options.get(
+            "supergateway_command", "npx -y supergateway"
+        )
+
+        self.sandbox: Sandbox | None = None
+        self.process: CommandHandle | None = None
+        self.client: ClientSession | None = None
+        self.errlog = sys.stderr
+        self.base_url: str | None = None
+        self._connected = False
+        self._connection_manager: SseConnectionManager | None = None
+
+        # SSE connection parameters
+        self.headers = {}
+        self.timeout = timeout
+        self.sse_read_timeout = sse_read_timeout
+
+        self.stdout_lines: list[str] = []
+        self.stderr_lines: list[str] = []
+        self._server_ready = asyncio.Event()
+
+    def _handle_stdout(self, data: str) -> None:
+        """Handle stdout data from the sandbox process."""
+        self.stdout_lines.append(data)
+        logger.debug(f"[SANDBOX STDOUT] {data}", end="", flush=True)
+
+    def _handle_stderr(self, data: str) -> None:
+        """Handle stderr data from the sandbox process."""
+        self.stderr_lines.append(data)
+        logger.debug(f"[SANDBOX STDERR] {data}", file=self.errlog, end="", flush=True)
+
+    async def wait_for_server_response(self, base_url: str, timeout: int = 30) -> bool:
+        """Wait for the server to respond to HTTP requests.
+        Args:
+            base_url: The base URL to check for server readiness
+            timeout: Maximum time to wait in seconds
+        Returns:
+            True if server is responding, raises TimeoutError otherwise
+        """
+        logger.info(f"Waiting for server at {base_url} to respond...")
+        sys.stdout.flush()
+
+        start_time = time.time()
+        ping_url = f"{base_url}/sse"
+
+        # Try to connect to the server
+        while time.time() - start_time < timeout:
+            try:
+                async with aiohttp.ClientSession() as session:
+                    try:
+                        # First try the endpoint
+                        async with session.get(ping_url, timeout=2) as response:
+                            if response.status == 200:
+                                elapsed = time.time() - start_time
+                                logger.info(
+                                    f"Server is ready! "
+                                    f"SSE endpoint responded with 200 after {elapsed:.1f}s"
+                                )
+                                return True
+                    except Exception:
+                        # If sse endpoint doesn't work, try the base URL
+                        async with session.get(base_url, timeout=2) as response:
+                            if response.status < 500:  # Accept any non-server error
+                                elapsed = time.time() - start_time
+                                logger.info(
+                                    f"Server is ready! Base URL responded with "
+                                    f"{response.status} after {elapsed:.1f}s"
+                                )
+                                return True
+            except Exception:
+                # Wait a bit before trying again
+                await asyncio.sleep(0.5)
+                continue
+
+            # If we get here, the request failed
+            await asyncio.sleep(0.5)
+
+            # Log status every 5 seconds
+            elapsed = time.time() - start_time
+            if int(elapsed) % 5 == 0:
+                logger.info(f"Still waiting for server to respond... ({elapsed:.1f}s elapsed)")
+                sys.stdout.flush()
+
+        # If we get here, we timed out
+        raise TimeoutError(f"Timeout waiting for server to respond (waited {timeout} seconds)")
+
+    async def connect(self):
+        """Connect to the sandbox and start the MCP server."""
+
+        if self._connected:
+            logger.debug("Already connected to MCP implementation")
+            return
+
+        logger.debug("Connecting to MCP implementation in sandbox")
+
+        try:
+            # Create and start the sandbox
+            self.sandbox = Sandbox(
+                template=self.sandbox_template_id,
+                api_key=self.api_key,
+            )
+
+            # Get the host for the sandbox
+            host = self.sandbox.get_host(3000)
+            self.base_url = f"https://{host}".rstrip("/")
+
+            # Append command with args
+            command = f"{self.user_command} {' '.join(self.user_args)}"
+
+            # Construct the full command with supergateway
+            full_command = f'{self.supergateway_cmd_parts} \
+                --base-url {self.base_url} \
+                --port 3000 \
+                --cors \
+                --stdio "{command}"'
+
+            logger.debug(f"Full command: {full_command}")
+
+            # Start the process in the sandbox with our stdout/stderr handlers
+            self.process: CommandHandle = self.sandbox.commands.run(
+                full_command,
+                envs=self.user_env,
+                timeout=1000 * 60 * 10,  # 10 minutes timeout
+                background=True,
+                on_stdout=self._handle_stdout,
+                on_stderr=self._handle_stderr,
+            )
+
+            # Wait for the server to be ready
+            await self.wait_for_server_response(self.base_url, timeout=30)
+            logger.debug("Initializing connection manager...")
+
+            # Create the SSE connection URL
+            sse_url = f"{self.base_url}/sse"
+
+            # Create and start the connection manager
+            self._connection_manager = SseConnectionManager(
+                sse_url, self.headers, self.timeout, self.sse_read_timeout
+            )
+            read_stream, write_stream = await self._connection_manager.start()
+
+            # Create the client session
+            self.client = ClientSession(read_stream, write_stream, sampling_callback=None)
+            await self.client.__aenter__()
+
+            # Mark as connected
+            self._connected = True
+            logger.debug(
+                f"Successfully connected to MCP implementation via HTTP/SSE: {self.base_url}"
+            )
+
+        except Exception as e:
+            logger.error(f"Failed to connect to MCP implementation: {e}")
+
+            # Clean up any resources if connection failed
+            await self._cleanup_resources()
+
+            raise e
+
+    async def _cleanup_resources(self) -> None:
+        """Clean up all resources associated with this connector, including the sandbox.
+        This method extends the base implementation to also terminate the sandbox instance
+        and clean up any processes running in the sandbox.
+        """
+        logger.debug("Cleaning up sandbox resources")
+
+        # Terminate any running process
+        if self.process:
+            try:
+                logger.debug("Terminating sandbox process")
+                self.process.kill()
+            except Exception as e:
+                logger.warning(f"Error terminating sandbox process: {e}")
+            finally:
+                self.process = None
+
+        # Close the sandbox
+        if self.sandbox:
+            try:
+                logger.debug("Closing sandbox instance")
+                self.sandbox.kill()
+                logger.debug("Sandbox instance closed successfully")
+            except Exception as e:
+                logger.warning(f"Error closing sandbox: {e}")
+            finally:
+                self.sandbox = None
+
+        # Then call the parent method to clean up the rest
+        await super()._cleanup_resources()
+
+        # Clear any collected output
+        self.stdout_lines = []
+        self.stderr_lines = []
+        self.base_url = None
+
+    async def disconnect(self) -> None:
+        """Close the connection to the MCP implementation."""
+        if not self._connected:
+            logger.debug("Not connected to MCP implementation")
+            return
+
+        logger.debug("Disconnecting from MCP implementation")
+        await self._cleanup_resources()
+        self._connected = False
+        logger.debug("Disconnected from MCP implementation")

mcp_use/connectors/utils.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+
+def is_stdio_server(server_config: dict[str, Any]) -> bool:
+    """Check if the server configuration is for a stdio server.
+
+    Args:
+        server_config: The server configuration section
+
+    Returns:
+        True if the server is a stdio server, False otherwise
+    """
+    return "command" in server_config and "args" in server_config

mcp_use/types/clientoptions.py

@@ -0,0 +1,23 @@
+"""
+Options for MCP client configuration.
+
+This module provides data classes and type definitions for configuring the MCP client.
+"""
+
+from typing import NotRequired, TypedDict
+
+from .sandbox import SandboxOptions
+
+
+class ClientOptions(TypedDict):
+    """Options for configuring the MCP client.
+
+    This class encapsulates all configuration options for the MCPClient,
+    making it easier to extend the API without breaking backward compatibility.
+    """
+
+    is_sandboxed: NotRequired[bool]
+    """Whether to use sandboxed execution mode for running MCP servers."""
+
+    sandbox_options: NotRequired[SandboxOptions]
+    """Options for sandbox configuration when is_sandboxed=True."""

mcp_use/types/sandbox.py

@@ -0,0 +1,23 @@
+"""Type definitions for sandbox-related configurations."""
+
+from typing import NotRequired, TypedDict
+
+
+class SandboxOptions(TypedDict):
+    """Configuration options for sandbox execution.
+
+    This type defines the configuration options available when running
+    MCP servers in a sandboxed environment (e.g., using E2B).
+    """
+
+    api_key: str
+    """Direct API key for sandbox provider (e.g., E2B API key).
+    If not provided, will use E2B_API_KEY environment variable."""
+
+    sandbox_template_id: NotRequired[str]
+    """Template ID for the sandbox environment.
+    Default: 'base'"""
+
+    supergateway_command: NotRequired[str]
+    """Command to run supergateway.
+    Default: 'npx -y supergateway'"""

{mcp_use-1.2.13.dist-info → mcp_use-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.2.13
+Version: 1.3.0
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -33,6 +33,8 @@ Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
 Requires-Dist: pytest>=7.4.0; extra == 'dev'
 Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: e2b
+Requires-Dist: e2b-code-interpreter>=1.5.0; extra == 'e2b'
 Provides-Extra: openai
 Requires-Dist: openai>=1.10.0; extra == 'openai'
 Provides-Extra: search
@@ -67,30 +69,64 @@ Description-Content-Type: text/markdown
         <img src="https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social" /></a>
     </p>
     <p align="center">
-    <a href="https://x.com/pietrozullo" alt="Twitter Follow">
+    <a href="https://x.com/pietrozullo" alt="Twitter Follow - Pietro">
         <img src="https://img.shields.io/twitter/follow/Pietro?style=social" /></a>
+    <a href="https://x.com/pederzh" alt="Twitter Follow - Luigi">
+        <img src="https://img.shields.io/twitter/follow/Luigi?style=social" /></a>
     <a href="https://discord.gg/XkNkSkMz3V" alt="Discord">
         <img src="https://dcbadge.limes.pink/api/server/https://discord.gg/XkNkSkMz3V?style=flat" /></a>
 </p>
 🌐 MCP-Use is the open source way to connect **any LLM to any MCP server** and build custom agents that have tool access, without using closed source or application clients.
 
+💬 Get started quickly - chat with your servers on our <b>hosted version</b>! <b>[Try mcp-use chat *(beta)* ](https://chat.mcp-use.io)</b>.
+
 💡 Let developers easily connect any LLM to tools like web browsing, file operations, and more.
 
 # Features
 
 ## ✨ Key Features
-
-| Feature | Description |
-|---------|-------------|
-| 🔄 [**Ease of use**](#quick-start) | Create your first MCP capable agent you need only 6 lines of code |
-| 🤖 [**LLM Flexibility**](#installing-langchain-providers) | Works with any langchain supported LLM that supports tool calling (OpenAI, Anthropic, Groq, LLama etc.) |
-| 🌐 [**Code Builder**](https://mcp-use.io/builder) | Explore MCP capabilities and generate starter code with the interactive [code builder](https://mcp-use.io/builder). |
-| 🔗 [**HTTP Support**](#http-connection-example) | Direct connection to MCP servers running on specific HTTP ports |
-| ⚙️ [**Dynamic Server Selection**](#dynamic-server-selection-server-manager) | Agents can dynamically choose the most appropriate MCP server for a given task from the available pool |
-| 🧩 [**Multi-Server Support**](#multi-server-support) | Use multiple MCP servers simultaneously in a single agent |
-| 🛡️ [**Tool Restrictions**](#tool-access-control) | Restrict potentially dangerous tools like file system or network access |
-| 🔧 [**Custom Agents**](#build-a-custom-agent) | Build your own agents with any framework using the LangChain adapter or create new adapters |
-
+<table>
+  <tr>
+    <th width="400">Feature</th>
+    <th>Description</th>
+  </tr>
+  <tr>
+    <td>🔄 <a href="#quick-start"><strong>Ease of use</strong></a></td>
+    <td>Create your first MCP capable agent you need only 6 lines of code</td>
+  </tr>
+  <tr>
+    <td>🤖 <a href="#installing-langchain-providers"><strong>LLM Flexibility</strong></a></td>
+    <td>Works with any langchain supported LLM that supports tool calling (OpenAI, Anthropic, Groq, LLama etc.)</td>
+  </tr>
+  <tr>
+    <td>🌐 <a href="https://mcp-use.io/builder"><strong>Code Builder</strong></a></td>
+    <td>Explore MCP capabilities and generate starter code with the interactive <a href="https://mcp-use.io/builder">code builder</a>.</td>
+  </tr>
+  <tr>
+    <td>🔗 <a href="#http-connection-example"><strong>HTTP Support</strong></a></td>
+    <td>Direct connection to MCP servers running on specific HTTP ports</td>
+  </tr>
+  <tr>
+    <td>⚙️ <a href="#dynamic-server-selection-server-manager"><strong>Dynamic Server Selection</strong></a></td>
+    <td>Agents can dynamically choose the most appropriate MCP server for a given task from the available pool</td>
+  </tr>
+  <tr>
+    <td>🧩 <a href="#multi-server-support"><strong>Multi-Server Support</strong></a></td>
+    <td>Use multiple MCP servers simultaneously in a single agent</td>
+  </tr>
+  <tr>
+    <td>🛡️ <a href="#tool-access-control"><strong>Tool Restrictions</strong></a></td>
+    <td>Restrict potentially dangerous tools like file system or network access</td>
+  </tr>
+  <tr>
+    <td>🔧 <a href="#build-a-custom-agent"><strong>Custom Agents</strong></a></td>
+    <td>Build your own agents with any framework using the LangChain adapter or create new adapters</td>
+  </tr>
+  <tr>
+    <td>❓ <a href="https://mcp-use.io/what-should-we-build-next"><strong>What should we build next</strong></a></td>
+    <td>Let us know what you'd like us to build next</td>
+  </tr>
+</table>
 
 # Quick start
 
@@ -118,11 +154,8 @@ pip install langchain-openai
 
 # For Anthropic
 pip install langchain-anthropic
-
-# For other providers, check the [LangChain chat models documentation](https://python.langchain.com/docs/integrations/chat/)
 ```
-
-and add your API keys for the provider you want to use to your `.env` file.
+For other providers, check the [LangChain chat models documentation](https://python.langchain.com/docs/integrations/chat/) and add your API keys for the provider you want to use to your `.env` file.
 
 ```bash
 OPENAI_API_KEY=
@@ -561,6 +594,101 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+# Sandboxed Execution
+
+MCP-Use supports running MCP servers in a sandboxed environment using E2B's cloud infrastructure. This allows you to run MCP servers without having to install dependencies locally, making it easier to use tools that might have complex setups or system requirements.
+
+## Installation
+
+To use sandboxed execution, you need to install the E2B dependency:
+
+```bash
+# Install mcp-use with E2B support
+pip install "mcp-use[e2b]"
+
+# Or install the dependency directly
+pip install e2b-code-interpreter
+```
+
+You'll also need an E2B API key. You can sign up at [e2b.dev](https://e2b.dev) to get your API key.
+
+## Configuration
+
+To enable sandboxed execution, use the `ClientOptions` parameter when creating your `MCPClient`:
+
+```python
+import asyncio
+import os
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from mcp_use import MCPAgent, MCPClient
+from mcp_use.types.sandbox import SandboxOptions
+from mcp_use.types.clientoptions import ClientOptions
+
+async def main():
+    # Load environment variables (needs E2B_API_KEY)
+    load_dotenv()
+
+    # Define MCP server configuration
+    server_config = {
+        "mcpServers": {
+            "everything": {
+                "command": "npx",
+                "args": ["-y", "@modelcontextprotocol/server-everything"],
+            }
+        }
+    }
+
+    # Define sandbox options
+    sandbox_options: SandboxOptions = {
+        "api_key": os.getenv("E2B_API_KEY"),  # API key can also be provided directly
+        "sandbox_template_id": "base",  # Use base template
+    }
+
+    # Create client options for sandboxed mode
+    client_options: ClientOptions = {
+        "is_sandboxed": True,
+        "sandbox_options": sandbox_options
+    }
+
+    # Create client with sandboxed mode enabled
+    client = MCPClient(
+        config=server_config,
+        options=client_options
+    )
+
+    # Create agent with the sandboxed client
+    llm = ChatOpenAI(model="gpt-4o")
+    agent = MCPAgent(llm=llm, client=client)
+
+    # Run your agent
+    result = await agent.run("Use the command line tools to help me add 1+1")
+    print(result)
+
+    # Clean up
+    await client.close_all_sessions()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Sandbox Options
+
+The `SandboxOptions` type provides configuration for the sandbox environment:
+
+| Option                 | Description                                                                              | Default               |
+| ---------------------- | ---------------------------------------------------------------------------------------- | --------------------- |
+| `api_key`              | E2B API key. Required - can be provided directly or via E2B_API_KEY environment variable | None                  |
+| `sandbox_template_id`  | Template ID for the sandbox environment                                                  | "base"                |
+| `supergateway_command` | Command to run supergateway                                                              | "npx -y supergateway" |
+
+## Benefits of Sandboxed Execution
+
+- **No local dependencies**: Run MCP servers without installing dependencies locally
+- **Isolation**: Execute code in a secure, isolated environment
+- **Consistent environment**: Ensure consistent behavior across different systems
+- **Resource efficiency**: Offload resource-intensive tasks to cloud infrastructure
+
 # Build a Custom Agent:
 
 You can also build your own custom agent using the LangChain adapter:
@@ -652,7 +780,6 @@ agent = MCPAgent(
 
 This is useful when you only need to see the agent's steps and decision-making process without all the low-level debug information from other components.
 
-
 # Roadmap
 
 <ul>

{mcp_use-1.2.13.dist-info → mcp_use-1.3.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 mcp_use/__init__.py,sha256=FikKagS6u8mugJOeslN3xfSA-tBLhjOywZSEcQ-y23g,1006
-mcp_use/client.py,sha256=3mEiAtGlC28iv0zeEtQcMI6cfTlllyjSvS0dwuoVBrw,8317
-mcp_use/config.py,sha256=O9V4pa-shZ2mPokRTrd7KZQ2GpuTcYBGUslefl1fosw,1653
+mcp_use/client.py,sha256=n0sJtRmntJtsVnmI1qCSTY8iuY9xYFybmA7V8rn09bE,8863
+mcp_use/config.py,sha256=ks-aX1Kzk_iUBbUAA2_-BRGN4oltYU3CN5CKanMfPUs,2564
 mcp_use/logging.py,sha256=UhQdMx0H0q08-ZPjY_hAJVErkEUAkU1oahHqwdfdK_U,4274
 mcp_use/session.py,sha256=IPVzYASFMZx7-xpK4X_MR5chcsIwGvcs6vYXiO1hutM,2604
 mcp_use/adapters/__init__.py,sha256=-xCrgPThuX7x0PHGFDdjb7M-mgw6QV3sKu5PM7ShnRg,275
@@ -8,13 +8,15 @@ mcp_use/adapters/base.py,sha256=bPVjHERySX6Vw16mEmgFaJuy4Yc_sM8JPtOAqJrP6Rg,7164
 mcp_use/adapters/langchain_adapter.py,sha256=nrsOYDQu-nlLw14f2uNHM-pH8l-yQfZelWXZLhBSMeQ,11008
 mcp_use/agents/__init__.py,sha256=N3eVYP2PxqNO2KcQv5fY8UMUX2W3eLTNkkzuFIJ1DUA,261
 mcp_use/agents/base.py,sha256=bfuldi_89AbSbNc8KeTiCArRT9V62CNxHOWYkLHWjyA,1605
-mcp_use/agents/mcpagent.py,sha256=xZr-ihW5CW2wKAi0Gi-9GIXlJE0MGu-18xR8vi-Fu6Q,27025
+mcp_use/agents/mcpagent.py,sha256=1T6ZJkuMvXdR9dP-59V-m40wJ0dgO0Hxoz14jaTYPCE,26913
 mcp_use/agents/prompts/system_prompt_builder.py,sha256=GH5Pvl49IBpKpZA9YTI83xMsdYSkRN_hw4LFHkKtxbg,4122
 mcp_use/agents/prompts/templates.py,sha256=AZKrGWuI516C-PmyOPvxDBibNdqJtN24sOHTGR06bi4,1933
-mcp_use/connectors/__init__.py,sha256=jnd-7pPPJMb0UNJ6aD9lInj5Tlamc8lA_mFyG8RWJpo,385
+mcp_use/connectors/__init__.py,sha256=cUF4yT0bNr8qeLkSzg28SHueiV5qDaHEB1l1GZ2K0dc,536
 mcp_use/connectors/base.py,sha256=uJFU80kIpr0bVRAHDXTWRziIwdb_5Yjf2HsDNokZw-M,7731
 mcp_use/connectors/http.py,sha256=2ZG5JxcK1WZ4jkTfTir6bEQLMxXBTPHyi0s42RHGeFs,2837
+mcp_use/connectors/sandbox.py,sha256=SxSOOLOCDPtlVTCxxZSRbVfvva6rzDWfBLa56ne7esc,10902
 mcp_use/connectors/stdio.py,sha256=MTzsqmVVihACUKngE-g5BignK3jAFds2CFv3aSzbJfs,2608
+mcp_use/connectors/utils.py,sha256=zQ8GdNQx0Twz3by90BoU1RsWPf9wODGof4K3-NxPXeA,366
 mcp_use/connectors/websocket.py,sha256=LeU53YI3zjbwKq5GzFRziqA_z9Dn5qACiNyxWDrn2ns,9540
 mcp_use/managers/__init__.py,sha256=rzsJbOhtlmxNQLGcdmtmHaiExEXmiQiUuzPrAgKhAJw,439
 mcp_use/managers/server_manager.py,sha256=YVl5ciNIQfVzP-BR9hA0ac6YSwq0WChpA_Lxvh2e9HE,3984
@@ -31,7 +33,9 @@ mcp_use/task_managers/base.py,sha256=xBrS9_GdlR0tr6sKN5pyMGUrQVGKRD6Qlk6hhOFcxRE
 mcp_use/task_managers/sse.py,sha256=nLKt99OiqoJxFT62zCeNwSZUmdPPg4SD7M1pCEPOa3c,2391
 mcp_use/task_managers/stdio.py,sha256=MJcW03lUZUs_HEUxwFPaqy7m8QLbmdn6LagpcfZdjc8,2130
 mcp_use/task_managers/websocket.py,sha256=POB4YwCff6IJ0vj4eGpYqfDwLiqA0_fEUS4hbborGa4,1848
-mcp_use-1.2.13.dist-info/METADATA,sha256=Jhij8qlF_RqgiiRlVSVZYIlP6TgGYjcr3j_2LLSe0bo,20966
-mcp_use-1.2.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_use-1.2.13.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
-mcp_use-1.2.13.dist-info/RECORD,,
+mcp_use/types/clientoptions.py,sha256=COzZPg19OlVm5F5ou6RhgzDVkPRs88Jz4c4uBanq5Ko,687
+mcp_use/types/sandbox.py,sha256=opJ9r56F1FvaqVvPovfAj5jZbsOexgwYx5wLgSlN8_U,712
+mcp_use-1.3.0.dist-info/METADATA,sha256=45e-TFXg17LD7sE8kyBgUqCYaeDVebgn63fED2vEznI,25427
+mcp_use-1.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.3.0.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.3.0.dist-info/RECORD,,