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

mcp_use/agents/mcpagent.py

@@ -6,9 +6,11 @@ to provide a simple interface for using MCP tools with different LLMs.
 """
 
 import logging
+import time
 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 +23,8 @@ 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 mcp_use.telemetry.posthog import Telemetry
+from mcp_use.telemetry.utils import extract_model_info
 
 from ..adapters.langchain_adapter import LangChainAdapter
 from ..logging import logger
@@ -93,6 +96,9 @@ class MCPAgent:
         # Create the adapter for tool conversion
         self.adapter = LangChainAdapter(disallowed_tools=self.disallowed_tools)
 
+        # Initialize telemetry
+        self.telemetry = Telemetry()
+
         # Initialize server manager if requested
         self.server_manager = None
         if self.use_server_manager:
@@ -102,9 +108,10 @@ 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] = []
+
+        # Track model info for telemetry
+        self._model_provider, self._model_name = extract_model_info(self.llm)
 
     async def initialize(self) -> None:
         """Initialize the MCP client and agent."""
@@ -132,6 +139,7 @@ class MCPAgent:
                 if not self._sessions:
                     logger.info("🔄 No active sessions found, creating new ones...")
                     self._sessions = await self.client.create_all_sessions()
+                    self.connectors = [session.connector for session in self._sessions.values()]
                     logger.info(f"✅ Created {len(self._sessions)} new sessions")
 
                 # Create LangChain tools directly from the client using the adapter
@@ -143,7 +151,7 @@ class MCPAgent:
                 connectors_to_use = self.connectors
                 logger.info(f"🔗 Connecting to {len(connectors_to_use)} direct connectors...")
                 for connector in connectors_to_use:
-                    if not hasattr(connector, "client") or connector.client is None:
+                    if not hasattr(connector, "client_session") or connector.client_session is None:
                         await connector.connect()
 
                 # Create LangChain tools using the adapter with connectors
@@ -346,20 +354,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()
@@ -378,13 +384,58 @@ class MCPAgent:
             async for chunk in agent.astream("hello"):
                 print(chunk, end="|", flush=True)
         """
-        async for chunk in self._generate_response_chunks_async(
-            query=query,
-            max_steps=max_steps,
-            manage_connector=manage_connector,
-            external_history=external_history,
-        ):
-            yield chunk
+        start_time = time.time()
+        success = False
+        chunk_count = 0
+        total_response_length = 0
+
+        try:
+            async for chunk in self._generate_response_chunks_async(
+                query=query,
+                max_steps=max_steps,
+                manage_connector=manage_connector,
+                external_history=external_history,
+            ):
+                chunk_count += 1
+                if isinstance(chunk, str):
+                    total_response_length += len(chunk)
+                yield chunk
+            success = True
+        finally:
+            # Track comprehensive execution data for streaming
+            execution_time_ms = int((time.time() - start_time) * 1000)
+
+            server_count = 0
+            if self.client:
+                server_count = len(self.client.get_all_active_sessions())
+            elif self.connectors:
+                server_count = len(self.connectors)
+
+            conversation_history_length = (
+                len(self._conversation_history) if self.memory_enabled else 0
+            )
+
+            self.telemetry.track_agent_execution(
+                execution_method="astream",
+                query=query,
+                success=success,
+                model_provider=self._model_provider,
+                model_name=self._model_name,
+                server_count=server_count,
+                server_identifiers=[connector.public_identifier for connector in self.connectors],
+                total_tools_available=len(self._tools) if self._tools else 0,
+                tools_available_names=[tool.name for tool in self._tools],
+                max_steps_configured=self.max_steps,
+                memory_enabled=self.memory_enabled,
+                use_server_manager=self.use_server_manager,
+                max_steps_used=max_steps,
+                manage_connector=manage_connector,
+                external_history_used=external_history is not None,
+                response=f"[STREAMED RESPONSE - {total_response_length} chars]",
+                execution_time_ms=execution_time_ms,
+                error_type=None if success else "streaming_error",
+                conversation_history_length=conversation_history_length,
+            )
 
     async def run(
         self,
@@ -413,6 +464,10 @@ class MCPAgent:
         """
         result = ""
         initialized_here = False
+        start_time = time.time()
+        tools_used_names = []
+        steps_taken = 0
+        success = False
 
         try:
             # Initialize if needed
@@ -468,6 +523,7 @@ class MCPAgent:
             logger.info(f"🏁 Starting agent execution with max_steps={steps}")
 
             for step_num in range(steps):
+                steps_taken = step_num + 1
                 # --- Check for tool updates if using server manager ---
                 if self.use_server_manager and self.server_manager:
                     current_tools = self.server_manager.tools
@@ -514,9 +570,10 @@ class MCPAgent:
                     # If it's actions/steps, add to intermediate steps
                     intermediate_steps.extend(next_step_output)
 
-                    # Log tool calls
+                    # Log tool calls and track tool usage
                     for action, output in next_step_output:
                         tool_name = action.tool
+                        tools_used_names.append(tool_name)
                         tool_input_str = str(action.tool_input)
                         # Truncate long inputs for readability
                         if len(tool_input_str) > 100:
@@ -559,7 +616,8 @@ class MCPAgent:
             if self.memory_enabled:
                 self.add_to_history(AIMessage(content=result))
 
-            logger.info("🎉 Agent execution complete")
+            logger.info(f"🎉 Agent execution complete in {time.time() - start_time} seconds")
+            success = True
             return result
 
         except Exception as e:
@@ -570,6 +628,43 @@ class MCPAgent:
             raise
 
         finally:
+            # Track comprehensive execution data
+            execution_time_ms = int((time.time() - start_time) * 1000)
+
+            server_count = 0
+            if self.client:
+                server_count = len(self.client.get_all_active_sessions())
+            elif self.connectors:
+                server_count = len(self.connectors)
+
+            conversation_history_length = (
+                len(self._conversation_history) if self.memory_enabled else 0
+            )
+            self.telemetry.track_agent_execution(
+                execution_method="run",
+                query=query,
+                success=success,
+                model_provider=self._model_provider,
+                model_name=self._model_name,
+                server_count=server_count,
+                server_identifiers=[connector.public_identifier for connector in self.connectors],
+                total_tools_available=len(self._tools) if self._tools else 0,
+                tools_available_names=[tool.name for tool in self._tools],
+                max_steps_configured=self.max_steps,
+                memory_enabled=self.memory_enabled,
+                use_server_manager=self.use_server_manager,
+                max_steps_used=max_steps,
+                manage_connector=manage_connector,
+                external_history_used=external_history is not None,
+                steps_taken=steps_taken,
+                tools_used_count=len(tools_used_names),
+                tools_used_names=tools_used_names,
+                response=result,
+                execution_time_ms=execution_time_ms,
+                error_type=None if success else "execution_error",
+                conversation_history_length=conversation_history_length,
+            )
+
             # Clean up if necessary (e.g., if not using client-managed sessions)
             if manage_connector and not self.client and not initialized_here:
                 logger.info("🧹 Closing agent after query completion")

mcp_use/client.py

@@ -9,6 +9,8 @@ import json
 import warnings
 from typing import Any
 
+from mcp_use.types.sandbox import SandboxOptions
+
 from .config import create_connector_from_config, load_config_file
 from .logging import logger
 from .session import MCPSession
@@ -24,14 +26,20 @@ class MCPClient:
     def __init__(
         self,
         config: str | dict[str, Any] | None = None,
+        sandbox: bool = False,
+        sandbox_options: SandboxOptions | 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.
+            sandbox: Whether to use sandboxed execution mode for running MCP servers.
+            sandbox_options: Optional sandbox configuration options.
         """
         self.config: dict[str, Any] = {}
+        self.sandbox = sandbox
+        self.sandbox_options = sandbox_options
         self.sessions: dict[str, MCPSession] = {}
         self.active_sessions: list[str] = []
 
@@ -43,22 +51,35 @@ class MCPClient:
                 self.config = config
 
     @classmethod
-    def from_dict(cls, config: dict[str, Any]) -> "MCPClient":
+    def from_dict(
+        cls,
+        config: dict[str, Any],
+        sandbox: bool = False,
+        sandbox_options: SandboxOptions | None = None,
+    ) -> "MCPClient":
         """Create a MCPClient from a dictionary.
 
         Args:
             config: The configuration dictionary.
+            sandbox: Whether to use sandboxed execution mode for running MCP servers.
+            sandbox_options: Optional sandbox configuration options.
         """
-        return cls(config=config)
+        return cls(config=config, sandbox=sandbox, sandbox_options=sandbox_options)
 
     @classmethod
-    def from_config_file(cls, filepath: str) -> "MCPClient":
+    def from_config_file(
+        cls, filepath: str, sandbox: bool = False, sandbox_options: SandboxOptions | None = None
+    ) -> "MCPClient":
         """Create a MCPClient from a configuration file.
 
         Args:
             filepath: The path to the configuration file.
+            sandbox: Whether to use sandboxed execution mode for running MCP servers.
+            sandbox_options: Optional sandbox configuration options.
         """
-        return cls(config=load_config_file(filepath))
+        return cls(
+            config=load_config_file(filepath), sandbox=sandbox, sandbox_options=sandbox_options
+        )
 
     def add_server(
         self,
@@ -111,6 +132,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 +150,11 @@ 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, sandbox=self.sandbox, sandbox_options=self.sandbox_options
+        )
 
         # Create the session
         session = MCPSession(connector)
@@ -146,16 +172,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,16 @@ 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 mcp_use.types.sandbox import SandboxOptions
+
+from .connectors import (
+    BaseConnector,
+    HttpConnector,
+    SandboxConnector,
+    StdioConnector,
+    WebSocketConnector,
+)
+from .connectors.utils import is_stdio_server
 
 
 def load_config_file(filepath: str) -> dict[str, Any]:
@@ -23,23 +32,40 @@ 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],
+    sandbox: bool = False,
+    sandbox_options: SandboxOptions | 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
+        sandbox: Whether to use sandboxed execution mode for running MCP servers.
+        sandbox_options: Optional sandbox configuration options.
 
     Returns:
         A configured connector instance
     """
+
     # Stdio connector (command-based)
-    if "command" in server_config and "args" in server_config:
+    if is_stdio_server(server_config) and not sandbox:
         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 sandbox:
+        return SandboxConnector(
+            command=server_config["command"],
+            args=server_config["args"],
+            env=server_config.get("env", None),
+            e2b_options=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",
+]