mcp-use 0.0.6__tar.gz → 1.0.0__tar.gz

{mcp_use-0.0.6 → mcp_use-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 0.0.6
+Version: 1.0.0
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -285,9 +285,70 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+# Multi-Server Support
+
+MCP-Use supports working with multiple MCP servers simultaneously, allowing you to combine tools from different servers in a single agent. This is useful for complex tasks that require multiple capabilities, such as web browsing combined with file operations or 3D modeling.
+
+## Configuration
+
+You can configure multiple servers in your configuration file:
+
+```json
+{
+  "mcpServers": {
+    "airbnb": {
+      "command": "npx",
+      "args": ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"]
+    },
+    "playwright": {
+      "command": "npx",
+      "args": ["@playwright/mcp@latest"],
+      "env": {
+        "DISPLAY": ":1"
+      }
+    }
+  }
+}
+```
+
+## Usage
+
+The `MCPClient` class provides several methods for managing multiple servers:
+
+```python
+import asyncio
+from mcp_use import MCPClient, MCPAgent
+from langchain_anthropic import ChatAnthropic
+
+async def main():
+    # Create client with multiple servers
+    client = MCPClient.from_config_file("multi_server_config.json")
+
+    # Create agent with the client
+    agent = MCPAgent(
+        llm=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
+        client=client
+    )
+
+    try:
+        # Run a query that uses tools from multiple servers
+        result = await agent.run(
+            "Search for a nice place to stay in Barcelona on Airbnb, "
+            "then use Google to find nearby restaurants and attractions."
+        )
+        print(result)
+    finally:
+        # Clean up all sessions
+        await client.close_all_sessions()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
 ## Roadmap
+
 <ul>
-<li>[ ] Multiple Servers at once </li>
+<li>[x] Multiple Servers at once </li>
 <li>[ ] Test remote connectors (http, ws)</li>
 <li>[ ] ... </li>
 </ul>

{mcp_use-0.0.6 → mcp_use-1.0.0}/README.md

@@ -246,9 +246,70 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+# Multi-Server Support
+
+MCP-Use supports working with multiple MCP servers simultaneously, allowing you to combine tools from different servers in a single agent. This is useful for complex tasks that require multiple capabilities, such as web browsing combined with file operations or 3D modeling.
+
+## Configuration
+
+You can configure multiple servers in your configuration file:
+
+```json
+{
+  "mcpServers": {
+    "airbnb": {
+      "command": "npx",
+      "args": ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"]
+    },
+    "playwright": {
+      "command": "npx",
+      "args": ["@playwright/mcp@latest"],
+      "env": {
+        "DISPLAY": ":1"
+      }
+    }
+  }
+}
+```
+
+## Usage
+
+The `MCPClient` class provides several methods for managing multiple servers:
+
+```python
+import asyncio
+from mcp_use import MCPClient, MCPAgent
+from langchain_anthropic import ChatAnthropic
+
+async def main():
+    # Create client with multiple servers
+    client = MCPClient.from_config_file("multi_server_config.json")
+
+    # Create agent with the client
+    agent = MCPAgent(
+        llm=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
+        client=client
+    )
+
+    try:
+        # Run a query that uses tools from multiple servers
+        result = await agent.run(
+            "Search for a nice place to stay in Barcelona on Airbnb, "
+            "then use Google to find nearby restaurants and attractions."
+        )
+        print(result)
+    finally:
+        # Clean up all sessions
+        await client.close_all_sessions()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
 ## Roadmap
+
 <ul>
-<li>[ ] Multiple Servers at once </li>
+<li>[x] Multiple Servers at once </li>
 <li>[ ] Test remote connectors (http, ws)</li>
 <li>[ ] ... </li>
 </ul>

mcp_use-1.0.0/examples/multi_server_example.py

@@ -0,0 +1,66 @@
+"""
+Example demonstrating how to use MCPClient with multiple servers.
+
+This example shows how to:
+1. Configure multiple MCP servers
+2. Create and manage sessions for each server
+3. Use tools from different servers in a single agent
+"""
+
+import asyncio
+
+from dotenv import load_dotenv
+from langchain_anthropic import ChatAnthropic
+
+from mcp_use import MCPAgent, MCPClient
+
+
+async def run_multi_server_example():
+    """Run an example using multiple MCP servers."""
+    # Load environment variables
+    load_dotenv()
+
+    # Create a configuration with multiple servers
+    config = {
+        "mcpServers": {
+            "airbnb": {
+                "command": "npx",
+                "args": ["-y", "@openbnb/mcp-server-airbnb", "--ignore-robots-txt"],
+            },
+            "playwright": {
+                "command": "npx",
+                "args": ["@playwright/mcp@latest"],
+                "env": {"DISPLAY": ":1"},
+            },
+            "filesystem": {
+                "command": "npx",
+                "args": [
+                    "-y",
+                    "@modelcontextprotocol/server-filesystem",
+                    "/home/pietro/projects/mcp-use/",
+                ],
+            },
+        }
+    }
+
+    # Create MCPClient with the multi-server configuration
+    client = MCPClient.from_dict(config)
+
+    # Create LLM
+    llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")
+
+    # Create agent with the client
+    agent = MCPAgent(llm=llm, client=client, max_steps=30)
+
+    # Example 1: Using tools from different servers in a single query
+    result = await agent.run(
+        "Search for a nice place to stay in Barcelona on Airbnb, "
+        "then use Google to find nearby restaurants and attractions."
+        "Write the result in the current directory in restarant.txt",
+        max_steps=30,
+    )
+    print(result)
+
+
+if __name__ == "__main__":
+    asyncio.run(run_multi_server_example())

{mcp_use-0.0.6 → mcp_use-1.0.0}/mcp_use/agents/langchain_agent.py

@@ -78,7 +78,7 @@ class LangChainAgent:
 
     def __init__(
         self,
-        connector: BaseConnector,
+        connectors: list[BaseConnector],
         llm: BaseLanguageModel,
         max_steps: int = 5,
         system_message: str | None = None,
@@ -91,7 +91,7 @@ class LangChainAgent:
             max_steps: The maximum number of steps to take.
             system_message: Optional custom system message to use.
         """
-        self.connector = connector
+        self.connectors = connectors
         self.llm = llm
         self.max_steps = max_steps
         self.system_message = system_message or self.DEFAULT_SYSTEM_MESSAGE
@@ -139,67 +139,70 @@ class LangChainAgent:
         Returns:
             A list of LangChain tools created from MCP tools.
         """
-        tools = self.connector.tools
-        local_connector = self.connector
-
-        # Wrap MCP tools into LangChain tools
         langchain_tools: list[BaseTool] = []
-        for tool in tools:
-            # Define adapter class to convert MCP tool to LangChain format
-            class McpToLangChainAdapter(BaseTool):
-                name: str = tool.name or "NO NAME"
-                description: str = tool.description or ""
-                # Convert JSON schema to Pydantic model for argument validation
-                args_schema: type[BaseModel] = jsonschema_to_pydantic(
-                    self.fix_schema(tool.inputSchema)  # Apply schema conversion
-                )
-                connector: BaseConnector = local_connector
-                handle_tool_error: bool = True
-
-                def _run(self, **kwargs: Any) -> NoReturn:
-                    """Synchronous run method that always raises an error.
-
-                    Raises:
-                        NotImplementedError: Always raises this error because MCP tools
-                            only support async operations.
-                    """
-                    raise NotImplementedError("MCP tools only support async operations")
-
-                async def _arun(self, **kwargs: Any) -> Any:
-                    """Asynchronously execute the tool with given arguments.
-
-                    Args:
-                        kwargs: The arguments to pass to the tool.
-
-                    Returns:
-                        The result of the tool execution.
-
-                    Raises:
-                        ToolException: If tool execution fails.
-                    """
-                    logger.info(f'MCP tool: "{self.name}" received input: {kwargs}')
-
-                    try:
-                        tool_result: CallToolResult = await self.connector.call_tool(
-                            self.name, kwargs
-                        )
+
+        for connector in self.connectors:
+            tools = connector.tools
+            local_connector = connector
+
+            # Wrap MCP tools into LangChain tools
+            for tool in tools:
+                # Define adapter class to convert MCP tool to LangChain format
+                class McpToLangChainAdapter(BaseTool):
+                    name: str = tool.name or "NO NAME"
+                    description: str = tool.description or ""
+                    # Convert JSON schema to Pydantic model for argument validation
+                    args_schema: type[BaseModel] = jsonschema_to_pydantic(
+                        self.fix_schema(tool.inputSchema)  # Apply schema conversion
+                    )
+                    connector: BaseConnector = local_connector
+                    handle_tool_error: bool = True
+
+                    def _run(self, **kwargs: Any) -> NoReturn:
+                        """Synchronous run method that always raises an error.
+
+                        Raises:
+                            NotImplementedError: Always raises this error because MCP tools
+                                only support async operations.
+                        """
+                        raise NotImplementedError("MCP tools only support async operations")
+
+                    async def _arun(self, **kwargs: Any) -> Any:
+                        """Asynchronously execute the tool with given arguments.
+
+                        Args:
+                            kwargs: The arguments to pass to the tool.
+
+                        Returns:
+                            The result of the tool execution.
+
+                        Raises:
+                            ToolException: If tool execution fails.
+                        """
+                        logger.info(f'MCP tool: "{self.name}" received input: {kwargs}')
+
                         try:
-                            # Use the helper function to parse the result
-                            return _parse_mcp_tool_result(tool_result)
-                        except Exception as e:
-                            # Log the exception for debugging
-                            logger.error(f"Error parsing tool result: {e}")
-                            # Shortened line:
-                            return (
-                                f"Error parsing result: {e!s}; Raw content: {tool_result.content!r}"
+                            tool_result: CallToolResult = await self.connector.call_tool(
+                                self.name, kwargs
                             )
+                            try:
+                                # Use the helper function to parse the result
+                                return _parse_mcp_tool_result(tool_result)
+                            except Exception as e:
+                                # Log the exception for debugging
+                                logger.error(f"Error parsing tool result: {e}")
+                                # Shortened line:
+                                return (
+                                    f"Error parsing result: {e!s};"
+                                    f" Raw content: {tool_result.content!r}"
+                                )
 
-                    except Exception as e:
-                        if self.handle_tool_error:
-                            return f"Error executing MCP tool: {str(e)}"
-                        raise
+                        except Exception as e:
+                            if self.handle_tool_error:
+                                return f"Error executing MCP tool: {str(e)}"
+                            raise
 
-            langchain_tools.append(McpToLangChainAdapter())
+                langchain_tools.append(McpToLangChainAdapter())
 
         # Log available tools for debugging
         logger.info(f"Available tools: {[tool.name for tool in langchain_tools]}")
@@ -256,25 +259,7 @@ class LangChainAgent:
         if chat_history is None:
             chat_history = []
 
-        # Add a hint to use tools for queries about current information
-        enhanced_query = query
-        if any(
-            keyword in query.lower()
-            for keyword in [
-                "weather",
-                "current",
-                "today",
-                "now",
-                "latest",
-                "news",
-                "price",
-                "stock",
-            ]
-        ):
-            # Just log this, don't modify the query
-            logger.info("Query involves current information that may benefit from tool use")
-
         # Invoke with all required variables
-        result = await self.agent.ainvoke({"input": enhanced_query, "chat_history": chat_history})
+        result = await self.agent.ainvoke({"input": query, "chat_history": chat_history})
 
         return result["output"]

{mcp_use-0.0.6 → mcp_use-1.0.0}/mcp_use/agents/mcpagent.py

@@ -31,7 +31,7 @@ class MCPAgent:
         self,
         llm: BaseLanguageModel,
         client: MCPClient | None = None,
-        connector: BaseConnector | None = None,
+        connectors: list[BaseConnector] | None = None,
         server_name: str | None = None,
         max_steps: int = 5,
         auto_initialize: bool = False,
@@ -45,7 +45,7 @@ class MCPAgent:
         Args:
             llm: The LangChain LLM to use.
             client: The MCPClient to use. If provided, connector is ignored.
-            connector: The MCP connector to use if client is not provided.
+            connectors: A list of MCP connectors to use if client is not provided.
             server_name: The name of the server to use if client is provided.
             max_steps: The maximum number of steps to take.
             auto_initialize: Whether to automatically initialize the agent when run is called.
@@ -56,7 +56,7 @@ class MCPAgent:
         """
         self.llm = llm
         self.client = client
-        self.connector = connector
+        self.connectors = connectors
         self.server_name = server_name
         self.max_steps = max_steps
         self.auto_initialize = auto_initialize
@@ -70,34 +70,35 @@ class MCPAgent:
         self.additional_instructions = additional_instructions
 
         # Either client or connector must be provided
-        if not client and not connector:
+        if not client and len(connectors) == 0:
             raise ValueError("Either client or connector must be provided")
 
         self._agent: LangChainAgent | None = None
-        self._session: MCPSession | None = None
+        self._sessions: dict[str, MCPSession] | None = None
         self._system_message: SystemMessage | None = None
 
     async def initialize(self) -> None:
         """Initialize the MCP client and agent."""
         # If using client, get or create a session
         if self.client:
-            try:
-                self._session = self.client.get_session(self.server_name)
-            except ValueError:
-                self._session = await self.client.create_session(self.server_name)
-            connector_to_use = self._session.connector
+            # First try to get existing sessions
+            self._sessions = self.client.get_all_active_sessions()
+
+            # If no active sessions exist, create new ones
+            if not self._sessions:
+                self._sessions = await self.client.create_all_sessions()
+            connectors_to_use = [session.connector for session in self._sessions.values()]
         else:
             # Using direct connector
-            connector_to_use = self.connector
-            await connector_to_use.connect()
-            await connector_to_use.initialize()
-
+            connectors_to_use = self.connectors
+            await [c_to_use.connect() for c_to_use in connectors_to_use]
+            await [c_to_use.initialize() for c_to_use in connectors_to_use]
         # Create the system message based on available tools
-        await self._create_system_message(connector_to_use)
+        await self._create_system_message(connectors_to_use)
 
         # Create the agent
         self._agent = LangChainAgent(
-            connector=connector_to_use,
+            connectors=connectors_to_use,
             llm=self.llm,
             max_steps=self.max_steps,
             system_message=(self._system_message.content if self._system_message else None),
@@ -107,7 +108,7 @@ class MCPAgent:
         await self._agent.initialize()
         self._initialized = True
 
-    async def _create_system_message(self, connector: BaseConnector) -> None:
+    async def _create_system_message(self, connectors: list[BaseConnector]) -> None:
         """Create the system message based on available tools.
 
         Args:
@@ -119,15 +120,17 @@ class MCPAgent:
             return
 
         # Otherwise, build the system prompt from the template and tool descriptions
-        tools = connector.tools
-
-        # Generate tool descriptions
         tool_descriptions = []
-        for tool in tools:
-            # Escape curly braces in the description by doubling them
-            # (sometimes e.g. blender mcp they are used in the description)
-            description = f"- {tool.name}: {tool.description.replace('{', '{{').replace('}', '}}')}"
-            tool_descriptions.append(description)
+        for connector in connectors:
+            tools = connector.tools
+            # Generate tool descriptions
+            for tool in tools:
+                # Escape curly braces in the description by doubling them
+                # (sometimes e.g. blender mcp they are used in the description)
+                description = (
+                    f"- {tool.name}: {tool.description.replace('{', '{{').replace('}', '}}')}"
+                )
+                tool_descriptions.append(description)
 
         # Format the system prompt template with tool descriptions
         system_prompt = self.system_prompt_template.format(
@@ -140,7 +143,6 @@ class MCPAgent:
 
         # Create the system message
         self._system_message = SystemMessage(content=system_prompt)
-        logger.info(f"Created system message with {len(tools)} tool descriptions")
 
     def get_conversation_history(self) -> list[BaseMessage]:
         """Get the current conversation history.
@@ -290,14 +292,15 @@ class MCPAgent:
                 self._agent = None
 
             # If using client with session, close the session through client
-            if self.client and self._session:
+            if self.client and self._sessions:
                 logger.debug("Closing session through client")
-                await self.client.close_session(self.server_name)
+                await self.client.close_all_sessions()
                 self._session = None
             # If using direct connector, disconnect
-            elif self.connector:
-                logger.debug("Disconnecting connector")
-                await self.connector.disconnect()
+            elif self.connectors:
+                for connector in self.connectors:
+                    logger.debug("Disconnecting connector")
+                    await connector.disconnect()
 
             self._initialized = False
             logger.info("Agent closed successfully")

{mcp_use-0.0.6 → mcp_use-1.0.0}/mcp_use/client.py

@@ -32,7 +32,7 @@ class MCPClient:
         """
         self.config: dict[str, Any] = {}
         self.sessions: dict[str, MCPSession] = {}
-        self.active_session: str | None = None
+        self.active_sessions: list[str] = []
 
         # Load configuration if provided
         if config is not None:
@@ -84,9 +84,9 @@ class MCPClient:
         if "mcpServers" in self.config and name in self.config["mcpServers"]:
             del self.config["mcpServers"][name]
 
-            # If we removed the active session, set active_session to None
-            if name == self.active_session:
-                self.active_session = None
+            # If we removed an active session, remove it from active_sessions
+            if name in self.active_sessions:
+                self.active_sessions.remove(name)
 
     def get_server_names(self) -> list[str]:
         """Get the list of configured server names.
@@ -105,17 +105,11 @@ class MCPClient:
         with open(filepath, "w") as f:
             json.dump(self.config, f, indent=2)
 
-    async def create_session(
-        self,
-        server_name: str | None = None,
-        auto_initialize: bool = True,
-    ) -> MCPSession:
+    async def create_session(self, server_name: str, auto_initialize: bool = True) -> MCPSession:
         """Create a session for the specified server.
 
         Args:
             server_name: The name of the server to create a session for.
-                        If None, uses the first available server.
-            auto_initialize: Whether to automatically initialize the session.
 
         Returns:
             The created MCPSession.
@@ -128,10 +122,6 @@ class MCPClient:
         if not servers:
             raise ValueError("No MCP servers defined in config")
 
-        # If server_name not specified, use the first one
-        if not server_name:
-            server_name = next(iter(servers.keys()))
-
         if server_name not in servers:
             raise ValueError(f"Server '{server_name}' not found in config")
 
@@ -140,57 +130,80 @@ class MCPClient:
 
         # Create the session
         session = MCPSession(connector)
-        self.sessions[server_name] = session
-
-        # Make this the active session
-        self.active_session = server_name
-
-        # Initialize if requested
         if auto_initialize:
             await session.initialize()
+        self.sessions[server_name] = session
+
+        # Add to active sessions
+        if server_name not in self.active_sessions:
+            self.active_sessions.append(server_name)
 
         return session
 
-    def get_session(self, server_name: str | None = None) -> MCPSession:
+    async def create_all_sessions(
+        self,
+        auto_initialize: bool = True,
+    ) -> dict[str, MCPSession]:
+        """Create a session for the specified server.
+
+        Args:
+            auto_initialize: Whether to automatically initialize the session.
+
+        Returns:
+            The created MCPSession. If server_name is None, returns the first created session.
+
+        Raises:
+            ValueError: If no servers are configured or the specified server doesn't exist.
+        """
+        # Get server config
+        servers = self.config.get("mcpServers", {})
+        if not servers:
+            raise ValueError("No MCP servers defined in config")
+
+        # Create sessions for all servers
+        for name in servers:
+            session = await self.create_session(name, auto_initialize)
+            if auto_initialize:
+                await session.initialize()
+
+        return self.sessions
+
+    def get_session(self, server_name: str) -> MCPSession:
         """Get an existing session.
 
         Args:
             server_name: The name of the server to get the session for.
-                        If None, uses the active session.
+                        If None, uses the first active session.
 
         Returns:
             The MCPSession for the specified server.
 
         Raises:
-            ValueError: If no active session exists or the specified session doesn't exist.
+            ValueError: If no active sessions exist or the specified session doesn't exist.
         """
-        if server_name is None:
-            if self.active_session is None:
-                raise ValueError("No active session")
-            server_name = self.active_session
-
         if server_name not in self.sessions:
             raise ValueError(f"No session exists for server '{server_name}'")
 
         return self.sessions[server_name]
 
-    async def close_session(self, server_name: str | None = None) -> None:
+    def get_all_active_sessions(self) -> dict[str, MCPSession]:
+        """Get all active sessions.
+
+        Returns:
+            Dictionary mapping server names to their MCPSession instances.
+        """
+        return {name: self.sessions[name] for name in self.active_sessions if name in self.sessions}
+
+    async def close_session(self, server_name: str) -> None:
         """Close a session.
 
         Args:
             server_name: The name of the server to close the session for.
-                        If None, uses the active session.
+                        If None, uses the first active session.
 
         Raises:
-            ValueError: If no active session exists or the specified session doesn't exist.
+            ValueError: If no active sessions exist or the specified session doesn't exist.
         """
-        # Determine which server to close
-        if server_name is None:
-            if self.active_session is None:
-                logger.warning("No active session to close")
-                return
-            server_name = self.active_session
-
         # Check if the session exists
         if server_name not in self.sessions:
             logger.warning(f"No session exists for server '{server_name}', nothing to close")
@@ -209,9 +222,9 @@ class MCPClient:
             # Remove the session regardless of whether disconnect succeeded
             del self.sessions[server_name]
 
-            # If we closed the active session, set active_session to None
-            if server_name == self.active_session:
-                self.active_session = None
+            # Remove from active_sessions
+            if server_name in self.active_sessions:
+                self.active_sessions.remove(server_name)
 
     async def close_all_sessions(self) -> None:
         """Close all active sessions.

{mcp_use-0.0.6 → mcp_use-1.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mcp-use"
-version = "0.0.6"
+version = "1.0.0"
 description = "MCP Library for LLMs"
 authors = [
     {name = "Pietro Zullo", email = "pietro.zullo@gmail.com"}