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

mcp_use/adapters/langchain_adapter.py

@@ -118,6 +118,9 @@ class LangChainAdapter(BaseAdapter):
             tool_connector: BaseConnector = connector  # Renamed variable to avoid name conflict
             handle_tool_error: bool = True
 
+            def __repr__(self) -> str:
+                return f"MCP tool: {self.name}: {self.description}"
+
             def _run(self, **kwargs: Any) -> NoReturn:
                 """Synchronous run method that always raises an error.
 

mcp_use/agents/__init__.py

@@ -7,10 +7,8 @@ that are pre-configured for using MCP tools.
 
 from .base import BaseAgent
 from .mcpagent import MCPAgent
-from .server_manager import ServerManager
 
 __all__ = [
     "BaseAgent",
     "MCPAgent",
-    "ServerManager",
 ]

mcp_use/agents/mcpagent.py

@@ -6,6 +6,7 @@ to provide a simple interface for using MCP tools with different LLMs.
 """
 
 import logging
+from collections.abc import AsyncIterator
 
 from langchain.agents import AgentExecutor, create_tool_calling_agent
 from langchain.globals import set_debug
@@ -23,9 +24,9 @@ from mcp_use.session import MCPSession
 
 from ..adapters.langchain_adapter import LangChainAdapter
 from ..logging import logger
+from ..managers.server_manager import ServerManager
 from .prompts.system_prompt_builder import create_system_message
 from .prompts.templates import DEFAULT_SYSTEM_PROMPT_TEMPLATE, SERVER_MANAGER_SYSTEM_PROMPT_TEMPLATE
-from .server_manager import ServerManager
 
 set_debug(logger.level == logging.DEBUG)
 
@@ -42,7 +43,6 @@ class MCPAgent:
         llm: BaseLanguageModel,
         client: MCPClient | None = None,
         connectors: list[BaseConnector] | None = None,
-        server_name: str | None = None,
         max_steps: int = 5,
         auto_initialize: bool = False,
         memory_enabled: bool = True,
@@ -59,7 +59,6 @@ class MCPAgent:
             llm: The LangChain LLM to use.
             client: The MCPClient to use. If provided, connector is ignored.
             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.
             memory_enabled: Whether to maintain conversation history for context.
@@ -72,7 +71,6 @@ class MCPAgent:
         self.llm = llm
         self.client = client
         self.connectors = connectors or []
-        self.server_name = server_name
         self.max_steps = max_steps
         self.auto_initialize = auto_initialize
         self.memory_enabled = memory_enabled
@@ -114,7 +112,7 @@ class MCPAgent:
         if self.use_server_manager and self.server_manager:
             await self.server_manager.initialize()
             # Get server management tools
-            management_tools = await self.server_manager.get_server_management_tools()
+            management_tools = self.server_manager.tools
             self._tools = management_tools
             logger.info(
                 f"🔧 Server manager mode active with {len(management_tools)} management tools"
@@ -307,6 +305,86 @@ class MCPAgent:
         """
         return self.disallowed_tools
 
+    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[str]:
+        """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
+        )
+        langchain_history: list[BaseMessage] = [
+            m for m in history_to_use if isinstance(m, HumanMessage | AIMessage)
+        ]
+        inputs = {"input": query, "chat_history": langchain_history}
+
+        # 3. Stream & diff -------------------------------------------------------
+        accumulated = ""
+        async for event in self._agent_executor.astream(inputs):
+            yield event
+
+        # 4. Persist assistant message ------------------------------------------
+        if self.memory_enabled and accumulated:
+            self.add_to_history(AIMessage(content=accumulated))
+
+        # 5. House-keeping -------------------------------------------------------
+        if initialised_here and manage_connector:
+            await self.close()
+
+    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::
+
+            async for chunk in agent.astream("hello"):
+                print(chunk, end="|", flush=True)
+        """
+        async for chunk in self._generate_response_chunks_async(
+            query=query,
+            max_steps=max_steps,
+            manage_connector=manage_connector,
+            external_history=external_history,
+        ):
+            yield chunk
+
     async def run(
         self,
         query: str,
@@ -391,7 +469,7 @@ class MCPAgent:
             for step_num in range(steps):
                 # --- Check for tool updates if using server manager ---
                 if self.use_server_manager and self.server_manager:
-                    current_tools = await self.server_manager.get_all_tools()
+                    current_tools = self.server_manager.tools
                     current_tool_names = {tool.name for tool in current_tools}
                     existing_tool_names = {tool.name for tool in self._tools}
 
@@ -412,7 +490,7 @@ class MCPAgent:
                             [tool.name for tool in self._tools], excluded_colors=["green", "red"]
                         )
 
-                logger.info(f"🔍 Step {step_num + 1}/{steps}")
+                logger.info(f"👣 Step {step_num + 1}/{steps}")
 
                 # --- Plan and execute the next step ---
                 try:

mcp_use/connectors/base.py

@@ -131,6 +131,26 @@ class BaseConnector(ABC):
         resource = await self.client.read_resource(uri)
         return resource.content, resource.mimeType
 
+    async def list_prompts(self) -> list[dict[str, Any]]:
+        """List all available prompts from the MCP implementation."""
+        if not self.client:
+            raise RuntimeError("MCP client is not connected")
+
+        logger.debug("Listing prompts")
+        prompts = await self.client.list_prompts()
+        return prompts
+
+    async def get_prompt(
+        self, name: str, arguments: dict[str, Any] | None = None
+    ) -> tuple[bytes, str]:
+        """Get a prompt by name."""
+        if not self.client:
+            raise RuntimeError("MCP client is not connected")
+
+        logger.debug(f"Getting prompt: {name}")
+        prompt = await self.client.get_prompt(name, arguments)
+        return prompt
+
     async def request(self, method: str, params: dict[str, Any] | None = None) -> Any:
         """Send a raw request to the MCP implementation."""
         if not self.client:

mcp_use/managers/__init__.py

@@ -0,0 +1,21 @@
+from .server_manager import ServerManager
+from .tools import (
+    ConnectServerTool,
+    DisconnectServerTool,
+    GetActiveServerTool,
+    ListServersTool,
+    MCPServerTool,
+    SearchToolsTool,
+    UseToolFromServerTool,
+)
+
+__all__ = [
+    "ServerManager",
+    "ListServersTool",
+    "ConnectServerTool",
+    "GetActiveServerTool",
+    "DisconnectServerTool",
+    "SearchToolsTool",
+    "MCPServerTool",
+    "UseToolFromServerTool",
+]

mcp_use/managers/server_manager.py

@@ -0,0 +1,101 @@
+from langchain_core.tools import BaseTool
+
+from mcp_use.client import MCPClient
+from mcp_use.logging import logger
+
+from ..adapters.base import BaseAdapter
+from .tools import (
+    ConnectServerTool,
+    DisconnectServerTool,
+    GetActiveServerTool,
+    ListServersTool,
+    SearchToolsTool,
+    UseToolFromServerTool,
+)
+
+
+class ServerManager:
+    """Manages MCP servers and provides tools for server selection and management.
+
+    This class allows an agent to discover and select which MCP server to use,
+    dynamically activating the tools for the selected server.
+    """
+
+    def __init__(self, client: MCPClient, adapter: BaseAdapter) -> None:
+        """Initialize the server manager.
+
+        Args:
+            client: The MCPClient instance managing server connections
+            adapter: The LangChainAdapter for converting MCP tools to LangChain tools
+        """
+        self.client = client
+        self.adapter = adapter
+        self.active_server: str | None = None
+        self.initialized_servers: dict[str, bool] = {}
+        self._server_tools: dict[str, list[BaseTool]] = {}
+
+    async def initialize(self) -> None:
+        """Initialize the server manager and prepare server management tools."""
+        # Make sure we have server configurations
+        if not self.client.get_server_names():
+            logger.warning("No MCP servers defined in client configuration")
+
+    async def _prefetch_server_tools(self) -> None:
+        """Pre-fetch tools for all servers to populate the tool search index."""
+        servers = self.client.get_server_names()
+        for server_name in servers:
+            try:
+                # Only create session if needed, don't set active
+                session = None
+                try:
+                    session = self.client.get_session(server_name)
+                    logger.debug(
+                        f"Using existing session for server '{server_name}' to prefetch tools."
+                    )
+                except ValueError:
+                    try:
+                        session = await self.client.create_session(server_name)
+                        logger.debug(
+                            f"Temporarily created session for '{server_name}' to prefetch tools"
+                        )
+                    except Exception:
+                        logger.warning(
+                            f"Could not create session for '{server_name}' during prefetch"
+                        )
+                        continue
+
+                # Fetch tools if session is available
+                if session:
+                    connector = session.connector
+                    tools = await self.adapter._create_tools_from_connectors([connector])
+
+                    # Check if this server's tools have changed
+                    if (
+                        server_name not in self._server_tools
+                        or self._server_tools[server_name] != tools
+                    ):
+                        self._server_tools[server_name] = tools  # Cache tools
+                        self.initialized_servers[server_name] = True  # Mark as initialized
+                        logger.debug(f"Prefetched {len(tools)} tools for server '{server_name}'.")
+                    else:
+                        logger.debug(
+                            f"Tools for server '{server_name}' unchanged, using cached version."
+                        )
+            except Exception as e:
+                logger.error(f"Error prefetching tools for server '{server_name}': {e}")
+
+    @property
+    def tools(self) -> list[BaseTool]:
+        """Get all server management tools.
+
+        Returns:
+            list of LangChain tools for server management
+        """
+        return [
+            ListServersTool(self),
+            ConnectServerTool(self),
+            GetActiveServerTool(self),
+            DisconnectServerTool(self),
+            SearchToolsTool(self),
+            UseToolFromServerTool(self),
+        ]

mcp_use/managers/tools/__init__.py

@@ -0,0 +1,17 @@
+from .base_tool import MCPServerTool
+from .connect_server import ConnectServerTool
+from .disconnect_server import DisconnectServerTool
+from .get_active_server import GetActiveServerTool
+from .list_servers_tool import ListServersTool
+from .search_tools import SearchToolsTool
+from .use_tool import UseToolFromServerTool
+
+__all__ = [
+    "MCPServerTool",
+    "ListServersTool",
+    "ConnectServerTool",
+    "GetActiveServerTool",
+    "DisconnectServerTool",
+    "SearchToolsTool",
+    "UseToolFromServerTool",
+]

mcp_use/managers/tools/base_tool.py

@@ -0,0 +1,19 @@
+from typing import ClassVar
+
+from langchain_core.tools import BaseTool
+
+
+class MCPServerTool(BaseTool):
+    """Base tool for MCP server operations."""
+
+    name: ClassVar[str] = "mcp_server_tool"
+    description: ClassVar[str] = "Base tool for MCP server operations."
+
+    def __init__(self, server_manager):
+        """Initialize with server manager."""
+        super().__init__()
+        self._server_manager = server_manager
+
+    @property
+    def server_manager(self):
+        return self._server_manager

mcp_use/managers/tools/connect_server.py

@@ -0,0 +1,69 @@
+from typing import ClassVar
+
+from pydantic import BaseModel, Field
+
+from mcp_use.logging import logger
+
+from .base_tool import MCPServerTool
+
+
+class ServerActionInput(BaseModel):
+    """Base input for server-related actions"""
+
+    server_name: str = Field(description="The name of the MCP server")
+
+
+class ConnectServerTool(MCPServerTool):
+    """Tool for connecting to a specific MCP server."""
+
+    name: ClassVar[str] = "connect_to_mcp_server"
+    description: ClassVar[str] = (
+        "Connect to a specific MCP (Model Context Protocol) server to use its "
+        "tools. Use this tool to connect to a specific server and use its tools."
+    )
+    args_schema: ClassVar[type[BaseModel]] = ServerActionInput
+
+    async def _arun(self, server_name: str) -> str:
+        """Connect to a specific MCP 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}"
+
+        # If we're already connected to this server, just return
+        if self.server_manager.active_server == server_name:
+            return f"Already connected to MCP server '{server_name}'"
+
+        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}'")
+                session = await self.server_manager.client.create_session(server_name)
+
+            # Set as active server
+            self.server_manager.active_server = server_name
+
+            # Initialize server tools if not already initialized
+            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
+
+            server_tools = self.server_manager._server_tools.get(server_name, [])
+            num_tools = len(server_tools)
+
+            return f"Connected to MCP server '{server_name}'. {num_tools} tools are now available."
+
+        except Exception as e:
+            logger.error(f"Error connecting to server '{server_name}': {e}")
+            return f"Failed to connect to server '{server_name}': {str(e)}"
+
+    def _run(self, server_name: str) -> str:
+        """Synchronous version that raises a NotImplementedError - use _arun instead."""
+        raise NotImplementedError("ConnectServerTool requires async execution. Use _arun instead.")

mcp_use/managers/tools/disconnect_server.py

@@ -0,0 +1,45 @@
+from typing import ClassVar
+
+from pydantic import BaseModel
+
+from mcp_use.logging import logger
+
+from .base_tool import MCPServerTool
+
+
+class DisconnectServerInput(BaseModel):
+    """Empty input for disconnecting from the current server"""
+
+    pass
+
+
+class DisconnectServerTool(MCPServerTool):
+    """Tool for disconnecting from the currently active MCP server."""
+
+    name: ClassVar[str] = "disconnect_from_mcp_server"
+    description: ClassVar[str] = (
+        "Disconnect from the currently active MCP (Model Context Protocol) server"
+    )
+    args_schema: ClassVar[type[BaseModel]] = DisconnectServerInput
+
+    def _run(self, **kwargs) -> str:
+        """Disconnect from the currently active MCP server."""
+        if not self.server_manager.active_server:
+            return "No MCP server is currently active, so there's nothing to disconnect from."
+
+        server_name = self.server_manager.active_server
+        try:
+            # Clear the active server
+            self.server_manager.active_server = None
+
+            # Note: We're not actually closing the session here, just 'deactivating'
+            # This way we keep the session cache without requiring reconnection if needed again
+
+            return f"Successfully disconnected from MCP server '{server_name}'."
+        except Exception as e:
+            logger.error(f"Error disconnecting from server '{server_name}': {e}")
+            return f"Failed to disconnect from server '{server_name}': {str(e)}"
+
+    async def _arun(self, **kwargs) -> str:
+        """Async implementation of _run."""
+        return self._run(**kwargs)

mcp_use/managers/tools/get_active_server.py

@@ -0,0 +1,32 @@
+from typing import ClassVar
+
+from pydantic import BaseModel
+
+from .base_tool import MCPServerTool
+
+
+class CurrentServerInput(BaseModel):
+    """Empty input for checking current server"""
+
+    pass
+
+
+class GetActiveServerTool(MCPServerTool):
+    """Tool for getting the currently active MCP server."""
+
+    name: ClassVar[str] = "get_active_mcp_server"
+    description: ClassVar[str] = "Get the currently active MCP (Model Context Protocol) server"
+    args_schema: ClassVar[type[BaseModel]] = CurrentServerInput
+
+    def _run(self, **kwargs) -> str:
+        """Get the currently active MCP server."""
+        if not self.server_manager.active_server:
+            return (
+                "No MCP server is currently active. "
+                "Use connect_to_mcp_server to connect to a server."
+            )
+        return f"Currently active MCP server: {self.server_manager.active_server}"
+
+    async def _arun(self, **kwargs) -> str:
+        """Async implementation of _run."""
+        return self._run(**kwargs)

mcp_use/managers/tools/list_servers_tool.py

@@ -0,0 +1,52 @@
+from typing import ClassVar
+
+from pydantic import BaseModel
+
+from mcp_use.logging import logger
+
+from .base_tool import MCPServerTool
+
+
+class listServersInput(BaseModel):
+    """Empty input for listing available servers"""
+
+    pass
+
+
+class ListServersTool(MCPServerTool):
+    """Tool for listing available MCP servers."""
+
+    name: ClassVar[str] = "list_mcp_servers"
+    description: ClassVar[str] = (
+        "Lists all available MCP (Model Context Protocol) servers that can be "
+        "connected to, along with the tools available on each server. "
+        "Use this tool to discover servers and see what functionalities they offer."
+    )
+    args_schema: ClassVar[type[BaseModel]] = listServersInput
+
+    def _run(self, **kwargs) -> str:
+        """List all available MCP servers along with their available tools."""
+        servers = self.server_manager.client.get_server_names()
+        if not servers:
+            return "No MCP servers are currently defined."
+
+        result = "Available MCP servers:\n"
+        for i, server_name in enumerate(servers):
+            active_marker = " (ACTIVE)" if server_name == self.server_manager.active_server else ""
+            result += f"{i + 1}. {server_name}{active_marker}\n"
+
+            tools: list = []
+            try:
+                # Check cache first
+                if server_name in self.server_manager._server_tools:
+                    tools = self.server_manager._server_tools[server_name]
+                    tool_count = len(tools)
+                    result += f"   {tool_count} tools available for this server\n"
+            except Exception as e:
+                logger.error(f"Unexpected error listing tools for server '{server_name}': {e}")
+
+        return result
+
+    async def _arun(self, **kwargs) -> str:
+        """Async implementation of _run - calls the synchronous version."""
+        return self._run(**kwargs)