mcp-use 1.3.12__py3-none-any.whl → 1.3.13__py3-none-any.whl

mcp_use/managers/server_manager.py

@@ -1,124 +1,18 @@
-from langchain_core.tools import BaseTool
+# mcp_use/managers/server_manager.py
+import warnings
 
-from mcp_use.client import MCPClient
-from mcp_use.logging import logger
+from typing_extensions import deprecated
 
-from ..adapters.base import BaseAdapter
-from .base import BaseServerManager
-from .tools import ConnectServerTool, DisconnectServerTool, GetActiveServerTool, ListServersTool, SearchToolsTool
+from mcp_use.agents.managers.server_manager import ServerManager as _ServerManager
 
+warnings.warn(
+    "mcp_use.managers.server_manager is deprecated. "
+    "Use mcp_use.agents.managers.server_manager. "
+    "This import will be removed in version 1.4.0",
+    DeprecationWarning,
+    stacklevel=2,
+)
 
-class ServerManager(BaseServerManager):
-    """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}")
-
-    def get_active_server_tools(self) -> list[BaseTool]:
-        """Get tools from the currently active server.
-
-        Returns:
-            List of tools from the active server, or empty list if no server is active
-        """
-        if self.active_server and self.active_server in self._server_tools:
-            return self._server_tools[self.active_server]
-        return []
-
-    def get_management_tools(self) -> list[BaseTool]:
-        """Get the server management tools.
-
-        Returns:
-            List of server management tools
-        """
-        return [
-            ListServersTool(self),
-            ConnectServerTool(self),
-            GetActiveServerTool(self),
-            DisconnectServerTool(self),
-            SearchToolsTool(self),
-        ]
-
-    def has_tool_changes(self, current_tool_names: set[str]) -> bool:
-        """Check if the available tools have changed.
-
-        Args:
-            current_tool_names: Set of currently known tool names
-
-        Returns:
-            True if tools have changed, False otherwise
-        """
-        new_tool_names = {tool.name for tool in self.tools}
-        return new_tool_names != current_tool_names
-
-    @property
-    def tools(self) -> list[BaseTool]:
-        """Get all server management tools and tools from the active server.
-
-        Returns:
-            list of LangChain tools for server management plus tools from active server
-        """
-        management_tools = self.get_management_tools()
-
-        # Add tools from the active server if available
-        if self.active_server and self.active_server in self._server_tools:
-            server_tools = self._server_tools[self.active_server]
-            logger.debug(f"Including {len(server_tools)} tools from active server '{self.active_server}'")
-            logger.debug(f"Server tools: {[tool.name for tool in server_tools]}")
-            return management_tools + server_tools
-        else:
-            logger.debug("No active server - returning only management tools")
-
-        return management_tools
+@deprecated("Use mcp_use.agents.managers.server_manager.ServerManager")
+class ServerManager(_ServerManager): ...

mcp_use/managers/tools/__init__.py

@@ -1,15 +1,45 @@
-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
-
-__all__ = [
-    "MCPServerTool",
-    "ConnectServerTool",
-    "DisconnectServerTool",
-    "GetActiveServerTool",
-    "ListServersTool",
-    "SearchToolsTool",
-]
+# mcp_use/managers/tools/__init__.py
+from typing_extensions import deprecated
+
+from mcp_use.agents.managers.tools import (
+    ConnectServerTool as _ConnectServerTool,
+)
+from mcp_use.agents.managers.tools import (
+    DisconnectServerTool as _DisconnectServerTool,
+)
+from mcp_use.agents.managers.tools import (
+    GetActiveServerTool as _GetActiveServerTool,
+)
+from mcp_use.agents.managers.tools import (
+    ListServersTool as _ListServersTool,
+)
+from mcp_use.agents.managers.tools import (
+    MCPServerTool as _MCPServerTool,
+)
+from mcp_use.agents.managers.tools import (
+    SearchToolsTool as _SearchToolsTool,
+)
+
+
+@deprecated("Use mcp_use.agents.managers.tools.MCPServerTool")
+class MCPServerTool(_MCPServerTool): ...
+
+
+@deprecated("Use mcp_use.agents.managers.tools.ConnectServerTool")
+class ConnectServerTool(_ConnectServerTool): ...
+
+
+@deprecated("Use mcp_use.agents.managers.tools.DisconnectServerTool")
+class DisconnectServerTool(_DisconnectServerTool): ...
+
+
+@deprecated("Use mcp_use.agents.managers.tools.GetActiveServerTool")
+class GetActiveServerTool(_GetActiveServerTool): ...
+
+
+@deprecated("Use mcp_use.agents.managers.tools.ListServersTool")
+class ListServersTool(_ListServersTool): ...
+
+
+@deprecated("Use mcp_use.agents.managers.tools.SearchToolsTool")
+class SearchToolsTool(_SearchToolsTool): ...

mcp_use/managers/tools/base_tool.py

@@ -1,19 +1,8 @@
-from typing import ClassVar
+# mcp_use/managers/tools/base_tool.py
+from typing_extensions import deprecated
 
-from langchain_core.tools import BaseTool
+from mcp_use.agents.managers.tools.base_tool import MCPServerTool as _MCPServerTool
 
 
-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
+@deprecated("Use mcp_use.agents.managers.tools.base_tool.MCPServerTool")
+class MCPServerTool(_MCPServerTool): ...

mcp_use/managers/tools/connect_server.py

@@ -1,70 +1,8 @@
-from typing import ClassVar
+# mcp_use/managers/tools/connect_server.py
+from typing_extensions import deprecated
 
-from pydantic import BaseModel, Field
+from mcp_use.agents.managers.tools.connect_server import ConnectServerTool as _ConnectServerTool
 
-from mcp_use.errors.error_formatting import format_error
-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 format_error(e, server_name=server_name)
-
-    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.")
+@deprecated("Use mcp_use.agents.managers.tools.connect_server.ConnectServerTool")
+class ConnectServerTool(_ConnectServerTool): ...

mcp_use/managers/tools/disconnect_server.py

@@ -1,44 +1,8 @@
-from typing import ClassVar
+# mcp_use/managers/tools/disconnect_server.py
+from typing_extensions import deprecated
 
-from pydantic import BaseModel
+from mcp_use.agents.managers.tools.disconnect_server import DisconnectServerTool as _DisconnectServerTool
 
-from mcp_use.errors.error_formatting import format_error
-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 format_error(e, server_name=server_name)
-
-    async def _arun(self, **kwargs) -> str:
-        """Async implementation of _run."""
-        return self._run(**kwargs)
+@deprecated("Use mcp_use.agents.managers.tools.disconnect_server.DisconnectServerTool")
+class DisconnectServerTool(_DisconnectServerTool): ...

mcp_use/managers/tools/get_active_server.py

@@ -1,29 +1,8 @@
-from typing import ClassVar
+# mcp_use/managers/tools/get_active_server.py
+from typing_extensions import deprecated
 
-from pydantic import BaseModel
+from mcp_use.agents.managers.tools.get_active_server import GetActiveServerTool as _GetActiveServerTool
 
-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)
+@deprecated("Use mcp_use.agents.managers.tools.get_active_server.GetActiveServerTool")
+class GetActiveServerTool(_GetActiveServerTool): ...

mcp_use/managers/tools/list_servers_tool.py

@@ -1,54 +1,8 @@
-from typing import ClassVar
+# mcp_use/managers/tools/list_servers_tool.py
+from typing_extensions import deprecated
 
-from pydantic import BaseModel
+from mcp_use.agents.managers.tools.list_servers_tool import ListServersTool as _ListServersTool
 
-from mcp_use.errors.error_formatting import format_error
-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 format_error(e, server=server_name, operation="list_tools")
-
-        return result
-
-    async def _arun(self, **kwargs) -> str:
-        """Async implementation of _run - calls the synchronous version."""
-        return self._run(**kwargs)
+@deprecated("Use mcp_use.agents.managers.tools.list_servers_tool.ListServersTool")
+class ListServersTool(_ListServersTool): ...