mcp-use 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

mcp_use/adapters/base.py

@@ -33,8 +33,7 @@ class BaseAdapter(ABC):
         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]:
+    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
@@ -42,7 +41,6 @@ class BaseAdapter(ABC):
 
         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.
@@ -56,9 +54,6 @@ class BaseAdapter(ABC):
             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...")
@@ -71,7 +66,7 @@ class BaseAdapter(ABC):
         connectors = [session.connector for session in sessions.values()]
 
         # Create tools from connectors
-        return await adapter._create_tools_from_connectors(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.

mcp_use/agents/mcpagent.py

@@ -7,7 +7,7 @@ to provide a simple interface for using MCP tools with different LLMs.
 
 import logging
 import time
-from collections.abc import AsyncIterator
+from collections.abc import AsyncGenerator, AsyncIterator
 
 from langchain.agents import AgentExecutor, create_tool_calling_agent
 from langchain.agents.output_parsers.tools import ToolAgentAction
@@ -106,9 +106,10 @@ class MCPAgent:
                 raise ValueError("Client must be provided when using server manager")
             self.server_manager = ServerManager(self.client, self.adapter)
 
-        # State tracking
+        # State tracking - initialize _tools as empty list
         self._agent_executor: AgentExecutor | None = None
         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)
@@ -304,150 +305,54 @@ class MCPAgent:
         """
         return self.disallowed_tools
 
-    async def _generate_response_chunks_async(
+    async def _consume_and_return(
         self,
-        query: str,
-        max_steps: int | None = None,
-        manage_connector: bool = True,
-        external_history: list[BaseMessage] | None = None,
-    ) -> AsyncIterator[StreamEvent]:
-        """Internal async generator yielding response chunks.
-
-        The implementation purposefully keeps the logic compact:
-        1. Ensure the agent is initialised (optionally handling connector
-           lifecycle).
-        2. Forward the *same* inputs we use for ``run`` to LangChain's
-           ``AgentExecutor.astream``.
-        3. Diff the growing ``output`` field coming from LangChain and yield
-           only the new part so the caller receives *incremental* chunks.
-        4. Persist conversation history when memory is enabled.
-        """
-
-        # 1. Initialise on-demand ------------------------------------------------
-        initialised_here = False
-        if (manage_connector and not self._initialized) or (not self._initialized and self.auto_initialize):
-            await self.initialize()
-            initialised_here = True
-
-        if not self._agent_executor:
-            raise RuntimeError("MCP agent failed to initialise – call initialise() first?")
-
-        # 2. Build inputs --------------------------------------------------------
-        effective_max_steps = max_steps or self.max_steps
-        self._agent_executor.max_iterations = effective_max_steps
-
-        if self.memory_enabled:
-            self.add_to_history(HumanMessage(content=query))
-
-        history_to_use = external_history if external_history is not None else self._conversation_history
-        inputs = {"input": query, "chat_history": history_to_use}
+        generator: AsyncGenerator[tuple[AgentAction, str], str],
+    ) -> str:
+        """Consume the generator and return the final result.
 
-        # 3. Stream & diff -------------------------------------------------------
-        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
-        # 5. House-keeping -------------------------------------------------------
-        # Restrict agent cleanup in _generate_response_chunks_async to only occur
-        #  when the agent was initialized in this generator and is not client-managed
-        #  and the user does want us to manage the connection.
-        if not self.client and initialised_here and manage_connector:
-            logger.info("🧹 Closing agent after generator completion")
-            await self.close()
+        This method manually iterates through the generator to consume the steps.
+        In Python, async generators cannot return values directly, so we expect
+        the final result to be yielded as a special marker.
 
-    async def astream(
-        self,
-        query: str,
-        max_steps: int | None = None,
-        manage_connector: bool = True,
-        external_history: list[BaseMessage] | None = None,
-    ) -> AsyncIterator[str]:
-        """Asynchronous streaming interface.
-
-        Example::
+        Args:
+            generator: The async generator that yields steps and a final result.
 
-            async for chunk in agent.astream("hello"):
-                print(chunk, end="|", flush=True)
+        Returns:
+            The final result from the generator.
         """
-        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(
+        final_result = ""
+        steps_taken = 0
+        tools_used_names = []
+        async for item in generator:
+            # If it's a string, it's the final result
+            if isinstance(item, str):
+                final_result = item
+                break
+            # Otherwise it's a step tuple, just consume it
+            steps_taken += 1
+            tools_used_names.append(item[0].tool)
+        return final_result, steps_taken, tools_used_names
+
+    async def stream(
         self,
         query: str,
         max_steps: int | None = None,
         manage_connector: bool = True,
         external_history: list[BaseMessage] | None = None,
-    ) -> str:
-        """Run a query using the MCP tools with unified step-by-step execution.
-
-        This method handles connecting to the MCP server, initializing the agent,
-        running the query, and then cleaning up the connection.
+        track_execution: bool = True,
+    ) -> AsyncGenerator[tuple[AgentAction, str] | str, None]:
+        """Run the agent and yield intermediate steps as an async generator.
 
         Args:
             query: The query to run.
             max_steps: Optional maximum number of steps to take.
             manage_connector: Whether to handle the connector lifecycle internally.
-                If True, this method will connect, initialize, and disconnect from
-                the connector automatically. If False, the caller is responsible
-                for managing the connector lifecycle.
             external_history: Optional external history to use instead of the
                 internal conversation history.
 
-        Returns:
-            The result of running the query.
+        Yields:
+            Intermediate steps as (AgentAction, str) tuples, followed by the final result as a string.
         """
         result = ""
         initialized_here = False
@@ -546,11 +451,13 @@ class MCPAgent:
                         result = next_step_output.return_values.get("output", "No output generated")
                         break
 
-                    # If it's actions/steps, add to intermediate steps
+                    # If it's actions/steps, add to intermediate steps and yield them
                     intermediate_steps.extend(next_step_output)
 
-                    # Log tool calls and track tool usage
-                    for action, output in next_step_output:
+                    # Yield each step and track tool usage
+                    for agent_step in next_step_output:
+                        yield agent_step
+                        action, observation = agent_step
                         tool_name = action.tool
                         tools_used_names.append(tool_name)
                         tool_input_str = str(action.tool_input)
@@ -559,11 +466,11 @@ class MCPAgent:
                             tool_input_str = tool_input_str[:97] + "..."
                         logger.info(f"🔧 Tool call: {tool_name} with input: {tool_input_str}")
                         # Truncate long outputs for readability
-                        output_str = str(output)
-                        if len(output_str) > 100:
-                            output_str = output_str[:97] + "..."
-                        output_str = output_str.replace("\n", " ")
-                        logger.info(f"📄 Tool result: {output_str}")
+                        observation_str = str(observation)
+                        if len(observation_str) > 100:
+                            observation_str = observation_str[:97] + "..."
+                        observation_str = observation_str.replace("\n", " ")
+                        logger.info(f"📄 Tool result: {observation_str}")
 
                     # Check for return_direct on the last action taken
                     if len(next_step_output) > 0:
@@ -597,12 +504,14 @@ class MCPAgent:
 
             logger.info(f"🎉 Agent execution complete in {time.time() - start_time} seconds")
             success = True
-            return result
+
+            # Yield the final result as a string
+            yield result
 
         except Exception as e:
             logger.error(f"❌ Error running query: {e}")
             if initialized_here and manage_connector:
-                logger.info("🧹 Cleaning up resources after initialization error in run")
+                logger.info("🧹 Cleaning up resources after initialization error in stream")
                 await self.close()
             raise
 
@@ -617,13 +526,84 @@ class MCPAgent:
                 server_count = len(self.connectors)
 
             conversation_history_length = len(self._conversation_history) if self.memory_enabled else 0
+
+            # Safely access _tools in case initialization failed
+            tools_available = getattr(self, "_tools", [])
+
+            if track_execution:
+                self.telemetry.track_agent_execution(
+                    execution_method="stream",
+                    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(tools_available),
+                    tools_available_names=[tool.name for tool in tools_available],
+                    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 initialized_here:
+                logger.info("🧹 Closing agent after stream completion")
+                await self.close()
+
+    async def run(
+        self,
+        query: str,
+        max_steps: int | None = None,
+        manage_connector: bool = True,
+        external_history: list[BaseMessage] | None = None,
+    ) -> str:
+        """Run a query using the MCP tools and return the final result.
+
+        This method uses the streaming implementation internally and returns
+        the final result after consuming all intermediate steps.
+
+        Args:
+            query: The query to run.
+            max_steps: Optional maximum number of steps to take.
+            manage_connector: Whether to handle the connector lifecycle internally.
+                If True, this method will connect, initialize, and disconnect from
+                the connector automatically. If False, the caller is responsible
+                for managing the connector lifecycle.
+            external_history: Optional external history to use instead of the
+                internal conversation history.
+
+        Returns:
+            The result of running the query.
+        """
+        success = True
+        start_time = time.time()
+        generator = self.stream(query, max_steps, manage_connector, external_history, track_execution=False)
+        try:
+            result, steps_taken, tools_used_names = await self._consume_and_return(generator)
+        except Exception as e:
+            success = False
+            error = str(e)
+            logger.error(f"❌ Error during agent execution: {e}")
+            raise
+        finally:
             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_count=len(self.client.get_all_active_sessions()) if self.client else len(self.connectors),
                 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],
@@ -637,16 +617,132 @@ class MCPAgent:
                 tools_used_count=len(tools_used_names),
                 tools_used_names=tools_used_names,
                 response=result,
+                execution_time_ms=int((time.time() - start_time) * 1000),
+                error_type=error,
+                conversation_history_length=len(self._conversation_history),
+            )
+        return result
+
+    async def _generate_response_chunks_async(
+        self,
+        query: str,
+        max_steps: int | None = None,
+        manage_connector: bool = True,
+        external_history: list[BaseMessage] | None = None,
+    ) -> AsyncIterator[StreamEvent]:
+        """Internal async generator yielding response chunks.
+
+        The implementation purposefully keeps the logic compact:
+        1. Ensure the agent is initialised (optionally handling connector
+           lifecycle).
+        2. Forward the *same* inputs we use for ``run`` to LangChain's
+           ``AgentExecutor.astream``.
+        3. Diff the growing ``output`` field coming from LangChain and yield
+           only the new part so the caller receives *incremental* chunks.
+        4. Persist conversation history when memory is enabled.
+        """
+
+        # 1. Initialise on-demand ------------------------------------------------
+        initialised_here = False
+        if (manage_connector and not self._initialized) or (not self._initialized and self.auto_initialize):
+            await self.initialize()
+            initialised_here = True
+
+        if not self._agent_executor:
+            raise RuntimeError("MCP agent failed to initialise – call initialise() first?")
+
+        # 2. Build inputs --------------------------------------------------------
+        effective_max_steps = max_steps or self.max_steps
+        self._agent_executor.max_iterations = effective_max_steps
+
+        if self.memory_enabled:
+            self.add_to_history(HumanMessage(content=query))
+
+        history_to_use = external_history if external_history is not None else self._conversation_history
+        inputs = {"input": query, "chat_history": history_to_use}
+
+        # 3. Stream & diff -------------------------------------------------------
+        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
+        # 5. House-keeping -------------------------------------------------------
+        # Restrict agent cleanup in _generate_response_chunks_async to only occur
+        #  when the agent was initialized in this generator and is not client-managed
+        #  and the user does want us to manage the connection.
+        if not self.client and initialised_here and manage_connector:
+            logger.info("🧹 Closing agent after generator completion")
+            await self.close()
+
+    async def stream_events(
+        self,
+        query: str,
+        max_steps: int | None = None,
+        manage_connector: bool = True,
+        external_history: list[BaseMessage] | None = None,
+    ) -> AsyncIterator[str]:
+        """Asynchronous streaming interface.
+
+        Example::
+
+            async for chunk in agent.astream("hello"):
+                print(chunk, end="|", flush=True)
+        """
+        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="stream_events",
+                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 "execution_error",
+                error_type=None if success else "streaming_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")
-                await self.close()
-
     async def close(self) -> None:
         """Close the MCP connection with improved error handling."""
         logger.info("🔌 Closing agent and cleaning up resources...")
@@ -659,7 +755,8 @@ class MCPAgent:
             if self.client:
                 logger.info("🔄 Closing sessions through client")
                 await self.client.close_all_sessions()
-                self._sessions = {}
+                if hasattr(self, "_sessions"):
+                    self._sessions = {}
             # If using direct connector, disconnect
             elif self.connectors:
                 for connector in self.connectors:
@@ -677,6 +774,8 @@ class MCPAgent:
             logger.error(f"❌ Error during agent closure: {e}")
             # Still try to clean up references even if there was an error
             self._agent_executor = None
-            self._tools = []
-            self._sessions = {}
+            if hasattr(self, "_tools"):
+                self._tools = []
+            if hasattr(self, "_sessions"):
+                self._sessions = {}
             self._initialized = False

mcp_use/client.py

@@ -189,9 +189,7 @@ class MCPClient:
 
         # Create sessions for all servers
         for name in servers:
-            session = await self.create_session(name, auto_initialize)
-            if auto_initialize:
-                await session.initialize()
+            await self.create_session(name, auto_initialize)
 
         return self.sessions
 

mcp_use/connectors/base.py

@@ -11,6 +11,7 @@ from typing import Any
 from mcp import ClientSession
 from mcp.shared.exceptions import McpError
 from mcp.types import CallToolResult, GetPromptResult, Prompt, ReadResourceResult, Resource, Tool
+from pydantic import AnyUrl
 
 from ..logging import logger
 from ..task_managers import ConnectionManager
@@ -30,6 +31,7 @@ class BaseConnector(ABC):
         self._resources: list[Resource] | None = None
         self._prompts: list[Prompt] | None = None
         self._connected = False
+        self._initialized = False  # Track if client_session.initialize() has been called
         self.auto_reconnect = True  # Whether to automatically reconnect on connection loss (not configurable for now)
 
     @abstractmethod
@@ -86,6 +88,7 @@ class BaseConnector(ABC):
         self._tools = None
         self._resources = None
         self._prompts = None
+        self._initialized = False  # Reset initialization flag
 
         if errors:
             logger.warning(f"Encountered {len(errors)} errors during resource cleanup")
@@ -95,38 +98,40 @@ class BaseConnector(ABC):
         if not self.client_session:
             raise RuntimeError("MCP client is not connected")
 
-        logger.debug("Initializing MCP session")
+        # Check if already initialized
+        if self._initialized:
+            return {"status": "already_initialized"}
 
         # Initialize the session
         result = await self.client_session.initialize()
+        self._initialized = True  # Mark as initialized
 
         server_capabilities = result.capabilities
 
         if server_capabilities.tools:
-            # Get available tools
-            tools_result = await self.list_tools()
-            self._tools = tools_result or []
+            # Get available tools directly from client session
+            tools_result = await self.client_session.list_tools()
+            self._tools = tools_result.tools if tools_result else []
         else:
             self._tools = []
 
         if server_capabilities.resources:
-            # Get available resources
-            resources_result = await self.list_resources()
-            self._resources = resources_result or []
+            # Get available resources directly from client session
+            resources_result = await self.client_session.list_resources()
+            self._resources = resources_result.resources if resources_result else []
         else:
             self._resources = []
 
         if server_capabilities.prompts:
-            # Get available prompts
-            prompts_result = await self.list_prompts()
-            self._prompts = prompts_result or []
+            # Get available prompts directly from client session
+            prompts_result = await self.client_session.list_prompts()
+            self._prompts = prompts_result.prompts if prompts_result else []
         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"
+            "{len(self._resources)} resources, and {len(self._prompts)} prompts"
         )
 
         return result
@@ -287,10 +292,9 @@ class BaseConnector(ABC):
             logger.error(f"Error listing resources: {e}")
             return []
 
-    async def read_resource(self, uri: str) -> ReadResourceResult:
+    async def read_resource(self, uri: AnyUrl) -> ReadResourceResult:
         """Read a resource by URI."""
-        if not self.client_session:
-            raise RuntimeError("MCP client is not connected")
+        await self._ensure_connected()
 
         logger.debug(f"Reading resource: {uri}")
         result = await self.client_session.read_resource(uri)
@@ -298,7 +302,6 @@ class BaseConnector(ABC):
 
     async def list_prompts(self) -> list[Prompt]:
         """List all available prompts from the MCP implementation."""
-        # Ensure we're connected
         await self._ensure_connected()
 
         logger.debug("Listing prompts")
@@ -311,7 +314,6 @@ class BaseConnector(ABC):
 
     async def get_prompt(self, name: str, arguments: dict[str, Any] | None = None) -> GetPromptResult:
         """Get a prompt by name."""
-        # Ensure we're connected
         await self._ensure_connected()
 
         logger.debug(f"Getting prompt: {name}")
@@ -320,7 +322,6 @@ class BaseConnector(ABC):
 
     async def request(self, method: str, params: dict[str, Any] | None = None) -> Any:
         """Send a raw request to the MCP implementation."""
-        # Ensure we're connected
         await self._ensure_connected()
 
         logger.debug(f"Sending request: {method} with params: {params}")

mcp_use/connectors/http.py

@@ -81,12 +81,37 @@ class HttpConnector(BaseConnector):
 
             try:
                 # Try to initialize - this is where streamable HTTP vs SSE difference should show up
-                await test_client.initialize()
+                result = await test_client.initialize()
 
                 # If we get here, streamable HTTP works
 
                 self.client_session = test_client
                 self.transport_type = "streamable HTTP"
+                self._initialized = True  # Mark as initialized since we just called initialize()
+
+                # Populate tools, resources, and prompts since we've initialized
+                server_capabilities = result.capabilities
+
+                if server_capabilities.tools:
+                    # Get available tools directly from client session
+                    tools_result = await self.client_session.list_tools()
+                    self._tools = tools_result.tools if tools_result else []
+                else:
+                    self._tools = []
+
+                if server_capabilities.resources:
+                    # Get available resources directly from client session
+                    resources_result = await self.client_session.list_resources()
+                    self._resources = resources_result.resources if resources_result else []
+                else:
+                    self._resources = []
+
+                if server_capabilities.prompts:
+                    # Get available prompts directly from client session
+                    prompts_result = await self.client_session.list_prompts()
+                    self._prompts = prompts_result.prompts if prompts_result else []
+                else:
+                    self._prompts = []
 
             except Exception as init_error:
                 # Clean up the test client

mcp_use/connectors/sandbox.py

@@ -65,9 +65,8 @@ class SandboxConnector(BaseConnector):
         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')."
+                "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
@@ -79,8 +78,8 @@ class SandboxConnector(BaseConnector):
         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 'sandbox_options.api_key' "
-                "or the E2B_API_KEY environment variable."
+                "E2B API key is required. Provide it via 'sandbox_options.api_key'"
+                " or the E2B_API_KEY environment variable."
             )
 
         self.sandbox_template_id = _e2b_options.get("sandbox_template_id", "base")
@@ -88,7 +87,7 @@ class SandboxConnector(BaseConnector):
 
         self.sandbox: Sandbox | None = None
         self.process: CommandHandle | None = None
-        self.client: ClientSession | None = None
+        self.client_session: ClientSession | None = None
         self.errlog = sys.stderr
         self.base_url: str | None = None
         self._connected = False
@@ -218,8 +217,8 @@ class SandboxConnector(BaseConnector):
             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__()
+            self.client_session = ClientSession(read_stream, write_stream, sampling_callback=None)
+            await self.client_session.__aenter__()
 
             # Mark as connected
             self._connected = True

mcp_use/managers/tools/search_tools.py

@@ -1,8 +1,8 @@
 import asyncio
+import math
 import time
 from typing import ClassVar
 
-import numpy as np
 from langchain_core.tools import BaseTool
 from pydantic import BaseModel, Field
 
@@ -205,10 +205,8 @@ class ToolSearchEngine:
         # Calculate similarity scores
         scores = {}
         for tool_name, embedding in self.tool_embeddings.items():
-            # Calculate cosine similarity
-            similarity = np.dot(query_embedding, embedding) / (
-                np.linalg.norm(query_embedding) * np.linalg.norm(embedding)
-            )
+            # Calculate cosine similarity using pure Python
+            similarity = self._cosine_similarity(query_embedding, embedding)
             scores[tool_name] = float(similarity)
 
         # Sort by score and get top_k results
@@ -304,3 +302,27 @@ class ToolSearchEngine:
         formatted_output += "\nTo use a tool, connect to the appropriate server first, then invoke the tool."
 
         return formatted_output
+
+    def _cosine_similarity(self, vec1: list[float], vec2: list[float]) -> float:
+        """Calculate cosine similarity between two vectors.
+
+        Args:
+            vec1: First vector
+            vec2: Second vector
+
+        Returns:
+            Cosine similarity between the vectors
+        """
+        # Calculate dot product
+        dot_product = sum(a * b for a, b in zip(vec1, vec2, strict=False))
+
+        # Calculate magnitudes
+        magnitude1 = math.sqrt(sum(a * a for a in vec1))
+        magnitude2 = math.sqrt(sum(b * b for b in vec2))
+
+        # Avoid division by zero
+        if magnitude1 == 0 or magnitude2 == 0:
+            return 0.0
+
+        # Calculate cosine similarity
+        return dot_product / (magnitude1 * magnitude2)

{mcp_use-1.3.3.dist-info → mcp_use-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.3.3
+Version: 1.3.5
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -15,20 +15,13 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
 Requires-Dist: aiohttp>=3.9.0
-Requires-Dist: anyio>=4.0.0
-Requires-Dist: authlib>=1.5.2
-Requires-Dist: httpx>=0.28.1
 Requires-Dist: jsonschema-pydantic>=0.1.0
-Requires-Dist: langchain-community>=0.0.10
 Requires-Dist: langchain>=0.1.0
 Requires-Dist: mcp>=1.9.3
 Requires-Dist: posthog>=4.8.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: scarf-sdk>=0.1.0
-Requires-Dist: starlette>=0.41.0
-Requires-Dist: typing-extensions>=4.8.0
-Requires-Dist: uvicorn>=0.32.0
 Requires-Dist: websockets>=12.0
 Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic; extra == 'anthropic'
@@ -50,6 +43,7 @@ Provides-Extra: search
 Requires-Dist: fastembed>=0.0.1; extra == 'search'
 Description-Content-Type: text/markdown
 
+<div align="center">
 <div align="center" style="margin: 0 auto; max-width: 80%;">
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="static/logo_white.svg">
@@ -58,24 +52,23 @@ Description-Content-Type: text/markdown
   </picture>
 </div>
 
-<h1 align="center">Unified MCP Client Library </h1>
+<br>
+
+# Connect any LLM to any MCP server
+
 <p align="center">
+    <a href="https://github.com/pietrozullo/mcp-use/stargazers" alt="GitHub stars">
+        <img src="https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social" /></a>
     <a href="https://pypi.org/project/mcp_use/" alt="PyPI Version">
         <img src="https://img.shields.io/pypi/v/mcp_use.svg"/></a>
-    <a href="https://pypi.org/project/mcp_use/" alt="PyPI Downloads">
-        <img src="https://static.pepy.tech/badge/mcp-use" /></a>
-    <a href="https://pypi.org/project/mcp_use/" alt="Python Versions">
-        <img src="https://img.shields.io/pypi/pyversions/mcp_use.svg" /></a>
-    <a href="https://docs.mcp-use.io" alt="Documentation">
-        <img src="https://img.shields.io/badge/docs-mcp--use.io-blue" /></a>
-    <a href="https://mcp-use.io" alt="Website">
-        <img src="https://img.shields.io/badge/website-mcp--use.io-blue" /></a>
     <a href="https://github.com/pietrozullo/mcp-use/blob/main/LICENSE" alt="License">
         <img src="https://img.shields.io/github/license/pietrozullo/mcp-use" /></a>
-    <a href="https://github.com/astral-sh/ruff" alt="Code style: Ruff">
-        <img src="https://img.shields.io/badge/code%20style-ruff-000000.svg" /></a>
-    <a href="https://github.com/pietrozullo/mcp-use/stargazers" alt="GitHub stars">
-        <img src="https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social" /></a>
+    <a href="https://pypi.org/project/mcp_use/" alt="PyPI Downloads">
+        <img src="https://static.pepy.tech/badge/mcp-use" /></a>
+    <a href="https://docs.mcp-use.com" alt="Documentation">
+        <img src="https://img.shields.io/badge/docs-mcp--use.com-blue" /></a>
+    <a href="https://mcp-use.com" alt="Website">
+        <img src="https://img.shields.io/badge/website-mcp--use.com-blue" /></a>
     </p>
     <p align="center">
     <a href="https://x.com/pietrozullo" alt="Twitter Follow - Pietro">
@@ -85,15 +78,19 @@ Description-Content-Type: text/markdown
     <a href="https://discord.gg/XkNkSkMz3V" alt="Discord">
         <img src="https://dcbadge.limes.pink/api/server/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.
+</div>
 
-💬 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>.
+🌐 MCP-Use is the open source way to connect **any LLM to any MCP server** and build custom MCP agents that have tool access, without using closed source or application clients.
 
 💡 Let developers easily connect any LLM to tools like web browsing, file operations, and more.
 
+- Visit the [mcp-use.com website](https://mcp-use.com/) to know how to build and deploy MCP agents.
+- Visit the [mcp-use docs](https://docs.mcp-use.com/) to get started with mcp-use library
+
+💬 Get started quickly - chat with your servers on our <b>hosted version</b>! [Try mcp-use chat (beta)](https://chat.mcp-use.com).
+
 # Features
 
-## ✨ Key Features
 <table>
   <tr>
     <th width="400">Feature</th>
@@ -108,8 +105,8 @@ Description-Content-Type: text/markdown
     <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>
+    <td>🌐 <a href="https://mcp-use.com/builder"><strong>Code Builder</strong></a></td>
+    <td>Explore MCP capabilities and generate starter code with the interactive <a href="https://mcp-use.com/builder">code builder</a>.</td>
   </tr>
   <tr>
     <td>🔗 <a href="#http-connection-example"><strong>HTTP Support</strong></a></td>
@@ -132,7 +129,7 @@ Description-Content-Type: text/markdown
     <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>❓ <a href="https://mcp-use.com/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>
@@ -164,6 +161,7 @@ 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.
 
 ```bash
@@ -719,7 +717,7 @@ async def main():
 
     # Create a custom LangChain agent
     llm_with_tools = llm.bind_tools(tools)
-    result = await llm_with_tools.ainvoke("What tools do you have avilable ? ")
+    result = await llm_with_tools.ainvoke("What tools do you have available ? ")
     print(result)
 
 
@@ -800,7 +798,6 @@ Thanks to all our amazing contributors!
   <img src="https://contrib.rocks/image?repo=mcp-use/mcp-use" />
 </a>
 
-
 ## Top Starred Dependents
 
 <!-- gh-dependents-info-used-by-start -->
@@ -863,6 +860,7 @@ Thanks to all our amazing contributors!
 # License
 
 MIT
+
 # Citation
 
 If you use MCP-Use in your research or project, please cite:
@@ -876,3 +874,5 @@ If you use MCP-Use in your research or project, please cite:
   url = {https://github.com/pietrozullo/mcp-use}
 }
 ```
+
+<img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=732589b6-6850-4b8c-aa25-906c0979e426&page=README.md" />

{mcp_use-1.3.3.dist-info → mcp_use-1.3.5.dist-info}/RECORD

@@ -1,21 +1,21 @@
 mcp_use/__init__.py,sha256=I3gFxw6Id45RksUBIZS1kxBW3ItjFXuAfoReJabpnW0,1055
-mcp_use/client.py,sha256=sAyZY6n5XHRW5dWKinfMZ-ovnUYi0s4u7T1mFfEHGLs,9476
+mcp_use/client.py,sha256=9u_GZxsyVoZY_g1dWGK8JiLmTatY6YvwGb4IM8idYZs,9391
 mcp_use/config.py,sha256=jRjTVNMxi7pkqFHMJhzSWpwukE4PbdYU8Pe_IZ33sYI,2433
 mcp_use/logging.py,sha256=CRtkPwR-bkXK_kQ0QOL86RikMWOHzEOi7A8VRHkNsZw,4270
 mcp_use/session.py,sha256=4kwcB_IkTt_3FiBSTI1H17KhL1W_6N5oai3HTxFrTH4,2496
 mcp_use/utils.py,sha256=QavJcVq2WxUUUCCpPCUeOB5bqIS0FFmpK-RAZkGc6aA,720
 mcp_use/adapters/__init__.py,sha256=-xCrgPThuX7x0PHGFDdjb7M-mgw6QV3sKu5PM7ShnRg,275
-mcp_use/adapters/base.py,sha256=tX5vNcz1HZtim4aID_KTfCeI6mQ6qI3bywTWJv0HaZs,7120
+mcp_use/adapters/base.py,sha256=U1z_UzojC-bytb4ZuKTRpEgEp-2F_BVBgqEXbUqLYB4,6901
 mcp_use/adapters/langchain_adapter.py,sha256=LdlpRyLORhl8NZvtAmisgPelXkhEbBErSNdGHb8SF18,10860
 mcp_use/agents/__init__.py,sha256=N3eVYP2PxqNO2KcQv5fY8UMUX2W3eLTNkkzuFIJ1DUA,261
 mcp_use/agents/base.py,sha256=EN-dRbwOi9vIqofFg3jmi5yT2VKlwEr9Cwi1DZgB3eE,1591
-mcp_use/agents/mcpagent.py,sha256=7AsU8NE7vWmtTp2N2t1N0j4D-gxBFpBlC3XAjyVULWE,31297
+mcp_use/agents/mcpagent.py,sha256=ke912HbpkXxcv1DpjiFTEg3hoIEMSFlTS62IRxYaTDs,35656
 mcp_use/agents/prompts/system_prompt_builder.py,sha256=E86STmxcl2Ic763_114awNqFB2RyLrQlbvgRmJajQjI,4116
 mcp_use/agents/prompts/templates.py,sha256=AZKrGWuI516C-PmyOPvxDBibNdqJtN24sOHTGR06bi4,1933
 mcp_use/connectors/__init__.py,sha256=cUF4yT0bNr8qeLkSzg28SHueiV5qDaHEB1l1GZ2K0dc,536
-mcp_use/connectors/base.py,sha256=yajYF5P924VzggCJ-kt37Rh_srCu__Seb7KUBhjvFdQ,12255
-mcp_use/connectors/http.py,sha256=Aw0DVQN-7fYebDKuX3bvlH9GAFS7Mq9CM_HylXdNqEI,6274
-mcp_use/connectors/sandbox.py,sha256=Id6THKdBvPxFzOFJ2tSK300CiiRFE_EtN5Gu6NRfUTU,10870
+mcp_use/connectors/base.py,sha256=GnI2WCrcxjOaB0R6Hj9pTpAZ0I1YRwkz1gGt-tvuZa0,12609
+mcp_use/connectors/http.py,sha256=oZbLLVDNwUaY6EwK2rVnjoZEKsBLf5-AXtPvGtbMmwc,7559
+mcp_use/connectors/sandbox.py,sha256=cnybcNW55k-S0hUtRR1M3KcGXwnaeDMVm8wDTsfF1Mk,10875
 mcp_use/connectors/stdio.py,sha256=rnJoLaHf1cIjk1KqfxfSsUs-iGTJ7KZonxgIc3kXeCM,2791
 mcp_use/connectors/utils.py,sha256=zQ8GdNQx0Twz3by90BoU1RsWPf9wODGof4K3-NxPXeA,366
 mcp_use/connectors/websocket.py,sha256=G7ZeLJNPVl9AG6kCmiNJz1N2Ing_QxT7pSswigTKi8Y,9650
@@ -27,7 +27,7 @@ mcp_use/managers/tools/connect_server.py,sha256=MGYQCl11q-w6gSIYuT44dDk7ILV3Oh7k
 mcp_use/managers/tools/disconnect_server.py,sha256=Y3kJN31efzsjfJwxUhpBxS-bgU21DCfGbn_LgEbzyvI,1586
 mcp_use/managers/tools/get_active_server.py,sha256=tCaib76gYU3L5G82tEOTq4Io2cuCXWjOjPselb-92i8,964
 mcp_use/managers/tools/list_servers_tool.py,sha256=OPDSMNe-VuAhlUyhDnR4CiuZFpoMhnhWpAablwO5S0k,1897
-mcp_use/managers/tools/search_tools.py,sha256=Vxbi8j50q3DyV9dvWCdPeN4vWFG5ksuLG5sERpdlmWg,12226
+mcp_use/managers/tools/search_tools.py,sha256=4vso7ln-AfG6lQAMq9FA_CyeVtSEDYEWlHtdHtfnLps,12911
 mcp_use/managers/tools/use_tool.py,sha256=gMNjgJrI9XDitPyJglcJcAvowbEWkO5z57yt4DT2Lpc,6626
 mcp_use/observability/__init__.py,sha256=kTUcP0d6L5_3ktfldhdAk-3AWckzVHs7ztG-R6cye64,186
 mcp_use/observability/laminar.py,sha256=WWjmVXP55yCfAlqlayeuJmym1gdrv8is7UyrIp4Tbn0,839
@@ -43,7 +43,7 @@ mcp_use/telemetry/events.py,sha256=K5xqbmkum30r4gM2PWtTiUWGF8oZzGZw2DYwco1RfOQ,3
 mcp_use/telemetry/telemetry.py,sha256=ck2MDFMtooafriR1W_zi41dWq-0O-ucF89pCkdkyc9E,11724
 mcp_use/telemetry/utils.py,sha256=kDVTqt2oSeWNJbnTOlXOehr2yFO0PMyx2UGkrWkfJiw,1769
 mcp_use/types/sandbox.py,sha256=opJ9r56F1FvaqVvPovfAj5jZbsOexgwYx5wLgSlN8_U,712
-mcp_use-1.3.3.dist-info/METADATA,sha256=jSYbhWFST3n6kc8I9fiNWzIEwuR1AXKu_cyla5xMqTU,28729
-mcp_use-1.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_use-1.3.3.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
-mcp_use-1.3.3.dist-info/RECORD,,
+mcp_use-1.3.5.dist-info/METADATA,sha256=dMpM6hZi0cuGyKdbTVB5_YuUJhcZSIeBNn_riJSkbZ0,28534
+mcp_use-1.3.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.3.5.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.3.5.dist-info/RECORD,,