mcp-use 1.2.7__py3-none-any.whl → 1.2.8__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

@@ -23,9 +23,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 +42,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 +58,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 +70,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 +111,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"
@@ -391,7 +388,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 +409,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/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)

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.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.2.7
+Version: 1.2.8
 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>
@@ -63,13 +65,13 @@ 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.) |
+| 🌐 [**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
@@ -610,7 +612,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.8.dist-info}/RECORD

@@ -5,11 +5,10 @@ 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=khzBFeW-mJxA4YeCA6v0jD7czu9MwOjtIXD0_WzNkQE,23795
 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
@@ -17,12 +16,22 @@ mcp_use/connectors/base.py,sha256=5TcXB-I5zrwPtedB6dShceNucsK3wHBeGC2yDVq8X48,48
 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.8.dist-info/METADATA,sha256=ld-cA_dlzxM-D5VkJMLqgr3WeyGzHVRx_pQ_sKQxRL8,18493
+mcp_use-1.2.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_use-1.2.8.dist-info/licenses/LICENSE,sha256=7Pw7dbwJSBw8zH-WE03JnR5uXvitRtaGTP9QWPcexcs,1068
+mcp_use-1.2.8.dist-info/RECORD,,

mcp_use/agents/server_manager.py

@@ -1,282 +0,0 @@
-from langchain_core.tools import BaseTool, StructuredTool
-from pydantic import BaseModel, Field
-
-from mcp_use.client import MCPClient
-from mcp_use.logging import logger
-
-from ..adapters.langchain_adapter import LangChainAdapter
-
-
-class ServerActionInput(BaseModel):
-    """Base input for server-related actions"""
-
-    server_name: str = Field(description="The name of the MCP server")
-
-
-class DisconnectServerInput(BaseModel):
-    """Empty input for disconnecting from the current server"""
-
-    pass
-
-
-class ListServersInput(BaseModel):
-    """Empty input for listing available servers"""
-
-    pass
-
-
-class CurrentServerInput(BaseModel):
-    """Empty input for checking current server"""
-
-    pass
-
-
-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: LangChainAdapter) -> 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 get_server_management_tools(self) -> list[BaseTool]:
-        """Get tools for managing server connections.
-
-        Returns:
-            List of LangChain tools for server management
-        """
-        # Create structured tools for server management with direct parameter passing
-        list_servers_tool = StructuredTool.from_function(
-            coroutine=self.list_servers,
-            name="list_mcp_servers",
-            description="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=ListServersInput,
-        )
-
-        connect_server_tool = StructuredTool.from_function(
-            coroutine=self.connect_to_server,
-            name="connect_to_mcp_server",
-            description="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=ServerActionInput,
-        )
-
-        get_active_server_tool = StructuredTool.from_function(
-            coroutine=self.get_active_server,
-            name="get_active_mcp_server",
-            description="Get the currently active MCP (Model Context Protocol) server",
-            args_schema=CurrentServerInput,
-        )
-
-        disconnect_server_tool = StructuredTool.from_function(
-            func=None,
-            coroutine=self.disconnect_from_server,
-            name="disconnect_from_mcp_server",
-            description="Disconnect from the currently active MCP (Model Context Protocol) server",
-            args_schema=DisconnectServerInput,
-        )
-
-        return [
-            list_servers_tool,
-            connect_server_tool,
-            get_active_server_tool,
-            disconnect_server_tool,
-        ]
-
-    async def list_servers(self) -> str:
-        """List all available MCP servers along with their available tools.
-
-        Returns:
-            String listing all available servers and their tools.
-        """
-        servers = self.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.active_server else ""
-            result += f"{i + 1}. {server_name}{active_marker}\n"
-
-            tools: list[BaseTool] = []
-            try:
-                # Check cache first
-                if server_name in self._server_tools:
-                    tools = self._server_tools[server_name]
-                else:
-                    # Attempt to get/create session without setting active
-                    session = None
-                    try:
-                        session = self.client.get_session(server_name)
-                        logger.debug(
-                            f"Using existing session for server '{server_name}' to list tools."
-                        )
-                    except ValueError:
-                        try:
-                            # Only create session if needed, don't set active
-                            session = await self.client.create_session(server_name)
-                            logger.debug(f"Temporarily created session for server '{server_name}'")
-                        except Exception:
-                            logger.warning(f"Could not create session for server '{server_name}'")
-
-                    # Fetch tools if session is available
-                    if session:
-                        try:
-                            connector = session.connector
-                            fetched_tools = await self.adapter._create_tools_from_connectors(
-                                [connector]
-                            )
-                            self._server_tools[server_name] = fetched_tools  # Cache tools
-                            self.initialized_servers[server_name] = True  # Mark as initialized
-                            tools = fetched_tools
-                            logger.debug(f"Fetched {len(tools)} tools for server '{server_name}'.")
-                        except Exception as e:
-                            logger.warning(f"Could not fetch tools for server '{server_name}': {e}")
-                            # Keep tools as empty list if fetching failed
-
-                # Append tool names to the result string
-                if tools:
-                    tool_names = ", ".join([tool.name for tool in tools])
-                    result += f"   Tools: {tool_names}\n"
-                else:
-                    result += "   Tools: (Could not retrieve or none available)\n"
-
-            except Exception as e:
-                logger.error(f"Unexpected error listing tools for server '{server_name}': {e}")
-                result += "   Tools: (Error retrieving tools)\n"
-
-        return result
-
-    async def connect_to_server(self, server_name: str) -> str:
-        """Connect to a specific MCP server.
-
-        Args:
-            server_name: The name of the server to connect to
-
-        Returns:
-            Status message about the connection
-        """
-        # Check if server exists
-        servers = self.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.active_server == server_name:
-            return f"Already connected to MCP server '{server_name}'"
-
-        try:
-            # Create or get session for this server
-            try:
-                session = self.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.client.create_session(server_name)
-
-            # Set as active server
-            self.active_server = server_name
-
-            # Initialize server tools if not already initialized
-            if server_name not in self._server_tools:
-                connector = session.connector
-                self._server_tools[server_name] = await self.adapter._create_tools_from_connectors(
-                    [connector]
-                )
-                self.initialized_servers[server_name] = True
-
-            server_tools = self._server_tools.get(server_name, [])
-            num_tools = len(server_tools)
-
-            tool_descriptions = "\nAvailable tools for this server:\n"
-            for i, tool in enumerate(server_tools):
-                tool_descriptions += f"{i + 1}. {tool.name}: {tool.description}\n"
-
-            return (
-                f"Connected to MCP server '{server_name}'. "
-                f"{num_tools} tools are now available."
-                f"{tool_descriptions}"
-            )
-
-        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)}"
-
-    async def get_active_server(self) -> str:
-        """Get the currently active MCP server.
-
-        Returns:
-            Name of the active server or message if none is active
-        """
-        if not self.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.active_server}"
-
-    async def disconnect_from_server(self) -> str:
-        """Disconnect from the currently active MCP server.
-
-        Returns:
-            Status message about the disconnection
-        """
-
-        if not self.active_server:
-            return "No MCP server is currently active, so there's nothing to disconnect from."
-
-        server_name = self.active_server
-        try:
-            # Clear the active server
-            self.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
-            # TODO: consider closing the sessions
-
-            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 get_active_server_tools(self) -> list[BaseTool]:
-        """Get the tools for the currently active server.
-
-        Returns:
-            List of LangChain tools for the active server or empty list if no active server
-        """
-        if not self.active_server:
-            return []
-
-        return self._server_tools.get(self.active_server, [])
-
-    async def get_all_tools(self) -> list[BaseTool]:
-        """Get all tools - both server management tools and tools for the active server.
-
-        Returns:
-            Combined list of server management tools and active server tools
-        """
-        management_tools = await self.get_server_management_tools()
-        active_server_tools = await self.get_active_server_tools()
-        return management_tools + active_server_tools