mcp-use 1.2.7__py3-none-any.whl → 1.2.9__py3-none-any.whl

mcp_use/managers/tools/search_tools.py

@@ -0,0 +1,303 @@
+import asyncio
+import time
+from typing import ClassVar
+
+import numpy as np
+from fastembed import TextEmbedding
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from ...logging import logger
+from .base_tool import MCPServerTool
+
+
+class ToolSearchInput(BaseModel):
+    """Input for searching for tools across MCP servers"""
+
+    query: str = Field(description="The search query to find relevant tools")
+    top_k: int = Field(
+        default=100,
+        description="The maximum number of tools to return (defaults to 100)",
+    )
+
+
+class SearchToolsTool(MCPServerTool):
+    """Tool for searching for tools across all MCP servers using semantic search."""
+
+    name: ClassVar[str] = "search_mcp_tools"
+    description: ClassVar[str] = (
+        "Search for relevant tools across all MCP servers using semantic search. "
+        "Provide a description of the tool you think you might need to be able to perform "
+        "the task you are assigned. Do not be too specific, the search will give you many "
+        "options. It is important you search for the tool, not for the goal. "
+        "If your first search doesn't yield relevant results, try using different keywords "
+        "or more general terms."
+    )
+    args_schema: ClassVar[type[BaseModel]] = ToolSearchInput
+
+    def __init__(self, server_manager):
+        """Initialize with server manager and create a search tool."""
+        super().__init__(server_manager)
+        self._search_tool = ToolSearchEngine(server_manager=server_manager)
+
+    async def _arun(self, query: str, top_k: int = 100) -> str:
+        """Search for tools across all MCP servers using semantic search."""
+        # Make sure the index is ready, and if not, allow the search_tools method to handle it
+        # No need to manually check or build the index here as the search_tools method will do that
+
+        # Perform search using our search tool instance
+        results = await self._search_tool.search_tools(
+            query, top_k=top_k, active_server=self.server_manager.active_server
+        )
+        return self.format_search_results(results)
+
+    def _run(self, query: str, top_k: int = 100) -> str:
+        """Synchronous version that raises a NotImplementedError - use _arun instead."""
+        raise NotImplementedError("SearchToolsTool requires async execution. Use _arun instead.")
+
+    def format_search_results(self, results: list[tuple[BaseTool, str, float]]) -> str:
+        """Format search results in a consistent format."""
+
+        # Only show top_k results
+        results = results
+
+        formatted_output = "Search results\n\n"
+
+        for i, (tool, server_name, score) in enumerate(results):
+            # Format score as percentage
+            if i < 5:
+                score_pct = f"{score * 100:.1f}%"
+                logger.info(f"{i}: {tool.name} ({score_pct} match)")
+            formatted_output += f"[{i + 1}] Tool: {tool.name} ({score_pct} match)\n"
+            formatted_output += f"    Server: {server_name}\n"
+            formatted_output += f"    Description: {tool.description}\n\n"
+
+        # Add footer with information about how to use the results
+        formatted_output += (
+            "\nTo use a tool, connect to the appropriate server first, then invoke the tool."
+        )
+
+        return formatted_output
+
+
+class ToolSearchEngine:
+    """
+    Provides semantic search capabilities for MCP tools.
+    Uses vector similarity for semantic search with optional result caching.
+    """
+
+    def __init__(self, server_manager=None, use_caching: bool = True):
+        """
+        Initialize the tool search engine.
+
+        Args:
+            server_manager: The ServerManager instance to get tools from
+            use_caching: Whether to cache query results
+        """
+        self.server_manager = server_manager
+        self.use_caching = use_caching
+        self.is_indexed = False
+
+        # Initialize model components (loaded on demand)
+        self.model = None
+        self.embedding_function = None
+
+        # Data storage
+        self.tool_embeddings = {}  # Maps tool name to embedding vector
+        self.tools_by_name = {}  # Maps tool name to tool instance
+        self.server_by_tool = {}  # Maps tool name to server name
+        self.tool_texts = {}  # Maps tool name to searchable text
+        self.query_cache = {}  # Caches search results by query
+
+    def _load_model(self) -> bool:
+        """Load the embedding model for semantic search if not already loaded."""
+        if self.model is not None:
+            return True
+
+        try:
+            self.model = TextEmbedding(model_name="BAAI/bge-small-en-v1.5")
+            self.embedding_function = lambda texts: list(self.model.embed(texts))
+            return True
+        except Exception:
+            return False
+
+    async def start_indexing(self) -> None:
+        """Index the tools from the server manager."""
+        if not self.server_manager:
+            return
+
+        # Get tools from server manager
+        server_tools = self.server_manager._server_tools
+
+        if not server_tools:
+            # Try to prefetch tools first
+            if hasattr(self.server_manager, "_prefetch_server_tools"):
+                await self.server_manager._prefetch_server_tools()
+                server_tools = self.server_manager._server_tools
+
+        if server_tools:
+            await self.index_tools(server_tools)
+
+    async def index_tools(self, server_tools: dict[str, list[BaseTool]]) -> None:
+        """
+        Index all tools from all servers for search.
+
+        Args:
+            server_tools: dictionary mapping server names to their tools
+        """
+        # Clear previous indexes
+        self.tool_embeddings = {}
+        self.tools_by_name = {}
+        self.server_by_tool = {}
+        self.tool_texts = {}
+        self.query_cache = {}
+        self.is_indexed = False
+
+        # Collect all tools and their descriptions
+        for server_name, tools in server_tools.items():
+            for tool in tools:
+                # Create text representation for search
+                tool_text = f"{tool.name}: {tool.description}"
+
+                # Store tool information
+                self.tools_by_name[tool.name] = tool
+                self.server_by_tool[tool.name] = server_name
+                self.tool_texts[tool.name] = tool_text.lower()  # For case-insensitive search
+
+        if not self.tool_texts:
+            return
+
+        # Generate embeddings
+        if self._load_model():
+            tool_names = list(self.tool_texts.keys())
+            tool_texts = [self.tool_texts[name] for name in tool_names]
+
+            try:
+                embeddings = self.embedding_function(tool_texts)
+                for name, embedding in zip(tool_names, embeddings, strict=True):
+                    self.tool_embeddings[name] = embedding
+
+                # Mark as indexed if we successfully embedded tools
+                self.is_indexed = len(self.tool_embeddings) > 0
+            except Exception:
+                return
+
+    def search(self, query: str, top_k: int = 5) -> list[tuple[BaseTool, str, float]]:
+        """
+        Search for tools that match the query using semantic search.
+
+        Args:
+            query: The search query
+            top_k: Number of top results to return
+
+        Returns:
+            list of tuples containing (tool, server_name, score)
+        """
+        if not self.is_indexed:
+            return []
+
+        # Check cache first
+        cache_key = f"semantic:{query}:{top_k}"
+        if self.use_caching and cache_key in self.query_cache:
+            return self.query_cache[cache_key]
+
+        # Ensure model and embeddings exist
+        if not self._load_model() or not self.tool_embeddings:
+            return []
+
+        # Generate embedding for the query
+        try:
+            query_embedding = self.embedding_function([query])[0]
+        except Exception:
+            return []
+
+        # 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)
+            )
+            scores[tool_name] = float(similarity)
+
+        # Sort by score and get top_k results
+        sorted_results = sorted(scores.items(), key=lambda x: x[1], reverse=True)[:top_k]
+
+        # Format results
+        results = []
+        for tool_name, score in sorted_results:
+            tool = self.tools_by_name.get(tool_name)
+            server_name = self.server_by_tool.get(tool_name)
+            if tool and server_name:
+                results.append((tool, server_name, score))
+
+        # Cache results
+        if self.use_caching:
+            self.query_cache[cache_key] = results
+
+        return results
+
+    async def search_tools(self, query: str, top_k: int = 100, active_server: str = None) -> str:
+        """
+        Search for tools across all MCP servers using semantic search.
+
+        Args:
+            query: The search query to find relevant tools
+            top_k: Number of top results to return
+            active_server: Name of the currently active server (for highlighting)
+
+        Returns:
+            String with formatted search results
+        """
+        # Ensure the index is built or build it
+        if not self.is_indexed:
+            # Try to build the index
+            if self.server_manager and self.server_manager._server_tools:
+                await self.index_tools(self.server_manager._server_tools)
+            else:
+                # If we don't have server_manager or tools, try to index directly
+                await self.start_indexing()
+
+            # Wait for indexing to complete (maximum 10 seconds)
+            start_time = time.time()
+            timeout = 10  # seconds
+            while not self.is_indexed and (time.time() - start_time) < timeout:
+                await asyncio.sleep(0.5)
+
+            # If still not indexed, return a friendly message
+            if not self.is_indexed:
+                return (
+                    "I'm still preparing the tool index. Please try your search again in a moment. "
+                    "This usually takes just a few seconds to complete."
+                )
+
+        # If the server manager has an active server but it wasn't provided, use it
+        if (
+            active_server is None
+            and self.server_manager
+            and hasattr(self.server_manager, "active_server")
+        ):
+            active_server = self.server_manager.active_server
+
+        results = self.search(query, top_k=top_k)
+        if not results:
+            return (
+                "No relevant tools found. The search provided no results. "
+                "You can try searching again with different keywords. "
+                "Try using more general terms or focusing on the capability you need."
+            )
+
+        # If there's an active server, mark it in the results
+        if active_server:
+            # Create a new results list with marked active server
+            marked_results = []
+            for tool, server_name, score in results:
+                # If this is the active server, add "(ACTIVE)" marker
+                display_server = (
+                    f"{server_name} (ACTIVE)" if server_name == active_server else server_name
+                )
+                marked_results.append((tool, display_server, score))
+            results = marked_results
+
+        # Format and return the results
+        return results

mcp_use/managers/tools/use_tool.py

@@ -0,0 +1,167 @@
+import json
+from typing import Any, ClassVar
+
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+from mcp_use.logging import logger
+
+from .base_tool import MCPServerTool
+
+
+class UseToolInput(BaseModel):
+    """Input for using a tool from a specific server"""
+
+    server_name: str = Field(description="The name of the MCP server containing the tool")
+    tool_name: str = Field(description="The name of the tool to execute")
+    tool_input: dict[str, Any] | str = Field(
+        description="The input to pass to the tool. Can be a dictionary of parameters or a string"
+    )
+
+
+class UseToolFromServerTool(MCPServerTool):
+    """Tool for directly executing a tool from a specific server."""
+
+    name: ClassVar[str] = "use_tool_from_server"
+    description: ClassVar[str] = (
+        "Execute a specific tool on a specific server without first connecting to it. "
+        "This is a direct execution shortcut that combines connection and tool execution "
+        "into a single step. Specify the server name, tool name, and the input to the tool."
+    )
+    args_schema: ClassVar[type[BaseModel]] = UseToolInput
+
+    async def _arun(
+        self, server_name: str, tool_name: str, tool_input: dict[str, Any] | str
+    ) -> str:
+        """Execute a tool from a specific server."""
+        # Check if server exists
+        servers = self.server_manager.client.get_server_names()
+        if server_name not in servers:
+            available = ", ".join(servers) if servers else "none"
+            return f"Server '{server_name}' not found. Available servers: {available}"
+
+        # Connect to the server if not already connected or not the active server
+        is_connected = server_name == self.server_manager.active_server
+
+        if not is_connected:
+            try:
+                # Create or get session for this server
+                try:
+                    session = self.server_manager.client.get_session(server_name)
+                    logger.debug(f"Using existing session for server '{server_name}'")
+                except ValueError:
+                    logger.debug(f"Creating new session for server '{server_name}' for tool use")
+                    session = await self.server_manager.client.create_session(server_name)
+
+                # Check if we have tools for this server, if not get them
+                if server_name not in self.server_manager._server_tools:
+                    connector = session.connector
+                    self.server_manager._server_tools[
+                        server_name
+                    ] = await self.server_manager.adapter._create_tools_from_connectors([connector])
+                    self.server_manager.initialized_servers[server_name] = True
+            except Exception as e:
+                logger.error(f"Error connecting to server '{server_name}' for tool use: {e}")
+                return f"Failed to connect to server '{server_name}': {str(e)}"
+
+        # Get tools for the server
+        server_tools = self.server_manager._server_tools.get(server_name, [])
+        if not server_tools:
+            return f"No tools found for server '{server_name}'"
+
+        # Find the requested tool
+        target_tool = None
+        for tool in server_tools:
+            if tool.name == tool_name:
+                target_tool = tool
+                break
+
+        if not target_tool:
+            tool_names = [t.name for t in server_tools]
+            return (
+                f"Tool '{tool_name}' not found on server '{server_name}'. "
+                f"Available tools: {', '.join(tool_names)}"
+            )
+
+        # Execute the tool with the provided input
+        try:
+            # Parse the input based on target tool's schema
+            structured_input = self._parse_tool_input(target_tool, tool_input)
+            if structured_input is None:
+                return (
+                    f"Could not parse input for tool '{tool_name}'."
+                    " Please check the input format and try again."
+                )
+
+            # Store the previous active server
+            previous_active = self.server_manager.active_server
+
+            # Temporarily set this server as active
+            self.server_manager.active_server = server_name
+
+            # Execute the tool
+            logger.info(
+                f"Executing tool '{tool_name}' on server '{server_name}'"
+                "with input: {structured_input}"
+            )
+            result = await target_tool._arun(**structured_input)
+
+            # Restore the previous active server
+            self.server_manager.active_server = previous_active
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Error executing tool '{tool_name}' on server '{server_name}': {e}")
+            return (
+                f"Error executing tool '{tool_name}' on server '{server_name}': {str(e)}. "
+                f"Make sure the input format is correct for this tool."
+            )
+
+    def _parse_tool_input(self, tool: BaseTool, input_data: dict[str, Any] | str) -> dict[str, Any]:
+        """
+        Parse the input data according to the tool's schema.
+
+        Args:
+            tool: The target tool
+            input_data: The input data, either a dictionary or a string
+
+        Returns:
+            A dictionary with properly structured input for the tool
+        """
+        # If input is already a dict, use it directly
+        if isinstance(input_data, dict):
+            return input_data
+
+        # Try to parse as JSON first
+        if isinstance(input_data, str):
+            try:
+                return json.loads(input_data)
+            except json.JSONDecodeError:
+                pass
+
+            # For string input, we need to determine which parameter name to use
+            if hasattr(tool, "args_schema") and tool.args_schema:
+                schema_cls = tool.args_schema
+                field_names = list(schema_cls.__fields__.keys())
+
+                # If schema has only one field, use that
+                if len(field_names) == 1:
+                    return {field_names[0]: input_data}
+
+                # Look for common input field names
+                for name in field_names:
+                    if name.lower() in ["input", "query", "url", tool.name.lower()]:
+                        return {name: input_data}
+
+                # Default to first field if we can't determine
+                return {field_names[0]: input_data}
+
+        # If we get here something went wrong
+        return None
+
+    def _run(self, server_name: str, tool_name: str, tool_input: dict[str, Any] | str) -> str:
+        """Synchronous version that raises a NotImplementedError."""
+        raise NotImplementedError(
+            "UseToolFromServerTool requires async execution. Use _arun instead."
+        )

{mcp_use-1.2.7.dist-info → mcp_use-1.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.2.7
+Version: 1.2.9
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -35,6 +35,8 @@ Requires-Dist: pytest>=7.4.0; extra == 'dev'
 Requires-Dist: ruff>=0.1.0; extra == 'dev'
 Provides-Extra: openai
 Requires-Dist: openai>=1.10.0; extra == 'openai'
+Provides-Extra: search
+Requires-Dist: fastembed>=0.0.1; extra == 'search'
 Description-Content-Type: text/markdown
 
 <picture>
@@ -48,6 +50,7 @@ Description-Content-Type: text/markdown
 [![PyPI Version](https://img.shields.io/pypi/v/mcp_use.svg)](https://pypi.org/project/mcp_use/)
 [![Python Versions](https://img.shields.io/pypi/pyversions/mcp_use.svg)](https://pypi.org/project/mcp_use/)
 [![Documentation](https://img.shields.io/badge/docs-mcp--use.io-blue)](https://docs.mcp-use.io)
+[![Website](https://img.shields.io/badge/website-mcp--use.io-blue)](https://mcp-use.io)
 [![License](https://img.shields.io/github/license/pietrozullo/mcp-use)](https://github.com/pietrozullo/mcp-use/blob/main/LICENSE)
 [![Code style: Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 [![GitHub stars](https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social)](https://github.com/pietrozullo/mcp-use/stargazers)
@@ -63,13 +66,14 @@ Description-Content-Type: text/markdown
 
 | Feature | Description |
 |---------|-------------|
-| 🔄 **Ease of use** | Create your first MCP capable agent you need only 6 lines of code |
-| 🤖 **LLM Flexibility** | Works with any langchain supported LLM that supports tool calling (OpenAI, Anthropic, Groq, LLama etc.) |
-| 🌐 **HTTP Support** | Direct connection to MCP servers running on specific HTTP ports |
-| ⚙️ **Dynamic Server Selection** | Agents can dynamically choose the most appropriate MCP server for a given task from the available pool |
-| 🧩 **Multi-Server Support** | Use multiple MCP servers simultaneously in a single agent |
-| 🛡️ **Tool Restrictions** | Restrict potentially dangerous tools like file system or network access |
-| 🔧 **Custom Agents** | Build your own agents with any framework using the LangChain adapter or create new adapters |
+| 🔄 [**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 |
 
 
 # Quick start
@@ -182,6 +186,43 @@ Example configuration file (`browser_mcp.json`):
 
 For other settings, models, and more, check out the documentation.
 
+## Streaming Agent Output
+
+MCP-Use supports asynchronous streaming of agent output using the `astream` method on `MCPAgent`. This allows you to receive incremental results, tool actions, and intermediate steps as they are generated by the agent, enabling real-time feedback and progress reporting.
+
+### How to use
+
+Call `agent.astream(query)` and iterate over the results asynchronously:
+
+```python
+async for chunk in agent.astream("Find the best restaurant in San Francisco"):
+    print(chunk["messages"], end="", flush=True)
+```
+
+Each chunk is a dictionary containing keys such as `actions`, `steps`, `messages`, and (on the last chunk) `output`. This enables you to build responsive UIs or log agent progress in real time.
+
+#### Example: Streaming in Practice
+
+```python
+import asyncio
+import os
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from mcp_use import MCPAgent, MCPClient
+
+async def main():
+    load_dotenv()
+    client = MCPClient.from_config_file("browser_mcp.json")
+    llm = ChatOpenAI(model="gpt-4o")
+    agent = MCPAgent(llm=llm, client=client, max_steps=30)
+    async for chunk in agent.astream("Look for job at nvidia for machine learning engineer."):
+        print(chunk["messages"], end="", flush=True)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+This streaming interface is ideal for applications that require real-time updates, such as chatbots, dashboards, or interactive notebooks.
 
 # Example Use Cases
 
@@ -342,7 +383,7 @@ if __name__ == "__main__":
 
 ## HTTP Connection Example
 
-MCP-Use now supports HTTP connections, allowing you to connect to MCP servers running on specific HTTP ports. This feature is particularly useful for integrating with web-based MCP servers.
+MCP-Use supports HTTP connections, allowing you to connect to MCP servers running on specific HTTP ports. This feature is particularly useful for integrating with web-based MCP servers.
 
 Here's an example of how to use the HTTP connection feature:
 
@@ -610,7 +651,7 @@ This is useful when you only need to see the agent's steps and decision-making p
 
 # Contributing
 
-We love contributions! Feel free to open issues for bugs or feature requests.
+We love contributions! Feel free to open issues for bugs or feature requests. Look at [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
 
 # Requirements
 

{mcp_use-1.2.7.dist-info → mcp_use-1.2.9.dist-info}/RECORD

@@ -5,24 +5,33 @@ mcp_use/logging.py,sha256=UhQdMx0H0q08-ZPjY_hAJVErkEUAkU1oahHqwdfdK_U,4274
 mcp_use/session.py,sha256=Z4EZTUnQUX0QyGMzkJIrMRTX4SDk6qQUoBld408LIJE,3449
 mcp_use/adapters/__init__.py,sha256=-xCrgPThuX7x0PHGFDdjb7M-mgw6QV3sKu5PM7ShnRg,275
 mcp_use/adapters/base.py,sha256=ixLHXp8FWdyZPx7Kh6s-4jEVs3qT4DWrApSLXfqzNws,6141
-mcp_use/adapters/langchain_adapter.py,sha256=mbOkWHMgHJJNJYFXYLCk3JjIT0CRW_iiu5eZtxsWEmk,6309
-mcp_use/agents/__init__.py,sha256=7QCfjE9WA50r-W8CS7IzUZMuhLgm8xSuKH1kYWdFU64,324
+mcp_use/adapters/langchain_adapter.py,sha256=s8IHPPtqqXMmWQfeBqwESs3SZA6_ECSiGRwdTOIWki0,6417
+mcp_use/agents/__init__.py,sha256=N3eVYP2PxqNO2KcQv5fY8UMUX2W3eLTNkkzuFIJ1DUA,261
 mcp_use/agents/base.py,sha256=bfuldi_89AbSbNc8KeTiCArRT9V62CNxHOWYkLHWjyA,1605
-mcp_use/agents/mcpagent.py,sha256=kSNqmF728LrEYfzfvW8h8llqC877vJLcn-DJodYVucU,23988
-mcp_use/agents/server_manager.py,sha256=ShmjrvDtmU7dJtfVlw_srC3t5f_B-QtifzIiV4mfsRA,11315
+mcp_use/agents/mcpagent.py,sha256=1U2HHOk-P-W4O81wdmEXaVWcGU2VQ9xyGaWykK1VCVQ,26954
 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/base.py,sha256=5TcXB-I5zrwPtedB6dShceNucsK3wHBeGC2yDVq8X48,4885
+mcp_use/connectors/base.py,sha256=5V8XHh3K-_zMBG22c6cxHynLyZps7M8FTIMt29OJa8o,5599
 mcp_use/connectors/http.py,sha256=2ZG5JxcK1WZ4jkTfTir6bEQLMxXBTPHyi0s42RHGeFs,2837
 mcp_use/connectors/stdio.py,sha256=MTzsqmVVihACUKngE-g5BignK3jAFds2CFv3aSzbJfs,2608
 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
+mcp_use/managers/tools/__init__.py,sha256=JrA5iTRdtbgwROJE8pQ7GH1sYnqBRcgj4NzFVADKbQ4,510
+mcp_use/managers/tools/base_tool.py,sha256=Jbbp7SwmHKDk8jT_6yVIv7iNsn6KaV_PljWuhhLcbXg,509
+mcp_use/managers/tools/connect_server.py,sha256=MGYQCl11q-w6gSIYuT44dDk7ILV3Oh7kGAJ4fsNXbso,2923
+mcp_use/managers/tools/disconnect_server.py,sha256=4487QlLbXAh9JyfGioc6DMWd0n_dkaa8RLMvsoNZv3E,1602
+mcp_use/managers/tools/get_active_server.py,sha256=LRcHbKZopMl1PiO4D4JS4s0fwtrvtMtvb4kpnoAE8fQ,1015
+mcp_use/managers/tools/list_servers_tool.py,sha256=OPDSMNe-VuAhlUyhDnR4CiuZFpoMhnhWpAablwO5S0k,1897
+mcp_use/managers/tools/search_tools.py,sha256=0BfFesCBJsdCAG2tPCM-c49tmBJLwLQoR_U-sj-rp2s,11628
+mcp_use/managers/tools/use_tool.py,sha256=r7k7uMYzrk353qw7M5h1utu_IR2G85uMZkrNcg2RyZA,6824
 mcp_use/task_managers/__init__.py,sha256=4dgW5N61iiPLpwjU2rrn_uqrL8mmDJFDaF9Lukzk65A,486
 mcp_use/task_managers/base.py,sha256=ksNdxTwq8N-zqymxVoKGnWXq9iqkLYC61uB91o6Mh-4,4888
 mcp_use/task_managers/sse.py,sha256=WysmjwqRI3meXMZY_F4y9tSBMvSiUZfTJQfitM5l6jQ,2529
 mcp_use/task_managers/stdio.py,sha256=DEISpXv4mo3d5a-WT8lkWbrXJwUh7QW0nMT_IM3fHGg,2269
 mcp_use/task_managers/websocket.py,sha256=ZbCqdGgzCRtsXzRGFws-f2OzH8cPAkN4sJNDwEpRmCc,1915
-mcp_use-1.2.7.dist-info/METADATA,sha256=GsNTID4AHT6Th_2Z1Us2tlcE9dKu4F9BxNTtFZK05jk,18163
-mcp_use-1.2.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_use-1.2.7.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
-mcp_use-1.2.7.dist-info/RECORD,,
+mcp_use-1.2.9.dist-info/METADATA,sha256=s84Li3g9TI5YdlKS25fd3m7hEEDydMIFkXbdn1axMmA,20198
+mcp_use-1.2.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.2.9.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.2.9.dist-info/RECORD,,