mcp-use 1.3.1__py3-none-any.whl → 1.3.3__py3-none-any.whl

mcp_use/__init__.py

@@ -7,6 +7,7 @@ to MCP tools through existing LangChain adapters.
 
 from importlib.metadata import version
 
+from . import observability
 from .agents.mcpagent import MCPAgent
 from .client import MCPClient
 from .config import load_config_file
@@ -30,6 +31,7 @@ __all__ = [
     "MCP_USE_DEBUG",
     "Logger",
     "set_debug",
+    "observability",
 ]
 
 

mcp_use/adapters/base.py

@@ -34,9 +34,7 @@ class BaseAdapter(ABC):
         self._connector_tool_map: dict[BaseConnector, list[T]] = {}
 
     @classmethod
-    async def create_tools(
-        cls, client: "MCPClient", disallowed_tools: list[str] | None = None
-    ) -> list[T]:
+    async def create_tools(cls, client: "MCPClient", disallowed_tools: list[str] | None = None) -> list[T]:
         """Create tools from an MCPClient instance.
 
         This is the recommended way to create tools from an MCPClient, as it handles
@@ -86,9 +84,7 @@ class BaseAdapter(ABC):
         """
         # Check if we already have tools for this connector
         if connector in self._connector_tool_map:
-            logger.debug(
-                f"Returning {len(self._connector_tool_map[connector])} existing tools for connector"
-            )
+            logger.debug(f"Returning {len(self._connector_tool_map[connector])} existing tools for connector")
             return self._connector_tool_map[connector]
 
         # Create tools for this connector

mcp_use/adapters/langchain_adapter.py

@@ -89,9 +89,7 @@ class LangChainAdapter(BaseAdapter):
                     elif hasattr(resource, "blob"):
                         # Assuming blob needs decoding or specific handling; adjust as needed
                         decoded_result += (
-                            resource.blob.decode()
-                            if isinstance(resource.blob, bytes)
-                            else str(resource.blob)
+                            resource.blob.decode() if isinstance(resource.blob, bytes) else str(resource.blob)
                         )
                     else:
                         raise ToolException(f"Unexpected resource type: {resource.type}")
@@ -154,9 +152,7 @@ class LangChainAdapter(BaseAdapter):
                 logger.debug(f'MCP tool: "{self.name}" received input: {kwargs}')
 
                 try:
-                    tool_result: CallToolResult = await self.tool_connector.call_tool(
-                        self.name, kwargs
-                    )
+                    tool_result: CallToolResult = await self.tool_connector.call_tool(self.name, kwargs)
                     try:
                         # Use the helper function to parse the result
                         return adapter_self._parse_mcp_tool_result(tool_result)
@@ -185,8 +181,7 @@ class LangChainAdapter(BaseAdapter):
         class ResourceTool(BaseTool):
             name: str = _sanitize(mcp_resource.name or f"resource_{mcp_resource.uri}")
             description: str = (
-                mcp_resource.description
-                or f"Return the content of the resource located at URI {mcp_resource.uri}."
+                mcp_resource.description or f"Return the content of the resource located at URI {mcp_resource.uri}."
             )
             args_schema: type[BaseModel] = ReadResourceRequestParams
             tool_connector: BaseConnector = connector
@@ -243,9 +238,7 @@ class LangChainAdapter(BaseAdapter):
                         Field(None, description=arg.description),
                     )
 
-            InputSchema = create_model(
-                dynamic_model_name, **field_definitions_for_create, __base__=BaseModel
-            )
+            InputSchema = create_model(dynamic_model_name, **field_definitions_for_create, __base__=BaseModel)
         else:
             # Create an empty Pydantic model if there are no arguments
             InputSchema = create_model(dynamic_model_name, __base__=BaseModel)

mcp_use/agents/base.py

@@ -48,9 +48,7 @@ class BaseAgent(ABC):
         pass
 
     @abstractmethod
-    async def step(
-        self, query: str, previous_steps: list[dict[str, Any]] | None = None
-    ) -> dict[str, Any]:
+    async def step(self, query: str, previous_steps: list[dict[str, Any]] | None = None) -> dict[str, Any]:
         """Perform a single step of the agent.
 
         Args:

mcp_use/agents/mcpagent.py

@@ -23,7 +23,7 @@ from langchain_core.utils.input import get_color_mapping
 
 from mcp_use.client import MCPClient
 from mcp_use.connectors.base import BaseConnector
-from mcp_use.telemetry.posthog import Telemetry
+from mcp_use.telemetry.telemetry import Telemetry
 from mcp_use.telemetry.utils import extract_model_info
 
 from ..adapters.langchain_adapter import LangChainAdapter
@@ -122,9 +122,7 @@ class MCPAgent:
             # 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"
-            )
+            logger.info(f"🔧 Server manager mode active with {len(management_tools)} management tools")
 
             # Create the system message based on available tools
             await self._create_system_message_from_tools(self._tools)
@@ -190,9 +188,7 @@ class MCPAgent:
 
         # Update conversation history if memory is enabled
         if self.memory_enabled:
-            history_without_system = [
-                msg for msg in self._conversation_history if not isinstance(msg, SystemMessage)
-            ]
+            history_without_system = [msg for msg in self._conversation_history if not isinstance(msg, SystemMessage)]
             self._conversation_history = [self._system_message] + history_without_system
 
     def _create_agent(self) -> AgentExecutor:
@@ -223,9 +219,7 @@ class MCPAgent:
         agent = create_tool_calling_agent(llm=self.llm, tools=self._tools, prompt=prompt)
 
         # Use the standard AgentExecutor
-        executor = AgentExecutor(
-            agent=agent, tools=self._tools, max_iterations=self.max_steps, verbose=self.verbose
-        )
+        executor = AgentExecutor(agent=agent, tools=self._tools, max_iterations=self.max_steps, verbose=self.verbose)
         logger.debug(f"Created agent executor with max_iterations={self.max_steps}")
         return executor
 
@@ -273,9 +267,7 @@ class MCPAgent:
         # Update conversation history if memory is enabled
         if self.memory_enabled:
             # Remove old system message if it exists
-            history_without_system = [
-                msg for msg in self._conversation_history if not isinstance(msg, SystemMessage)
-            ]
+            history_without_system = [msg for msg in self._conversation_history if not isinstance(msg, SystemMessage)]
             self._conversation_history = history_without_system
 
             # Add new system message
@@ -300,9 +292,7 @@ class MCPAgent:
         # If the agent is already initialized, we need to reinitialize it
         # to apply the changes to the available tools
         if self._initialized:
-            logger.debug(
-                "Agent already initialized. Changes will take effect on next initialization."
-            )
+            logger.debug("Agent already initialized. Changes will take effect on next initialization.")
             # We don't automatically reinitialize here as it could be disruptive
             # to ongoing operations. The user can call initialize() explicitly if needed.
 
@@ -335,9 +325,7 @@ class MCPAgent:
 
         # 1. Initialise on-demand ------------------------------------------------
         initialised_here = False
-        if (manage_connector and not self._initialized) or (
-            not self._initialized and self.auto_initialize
-        ):
+        if (manage_connector and not self._initialized) or (not self._initialized and self.auto_initialize):
             await self.initialize()
             initialised_here = True
 
@@ -351,9 +339,7 @@ class MCPAgent:
         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
-        )
+        history_to_use = external_history if external_history is not None else self._conversation_history
         inputs = {"input": query, "chat_history": history_to_use}
 
         # 3. Stream & diff -------------------------------------------------------
@@ -365,9 +351,12 @@ class MCPAgent:
                         if not isinstance(message, ToolAgentAction):
                             self.add_to_history(message)
             yield event
-
         # 5. House-keeping -------------------------------------------------------
-        if initialised_here and manage_connector:
+        # Restrict agent cleanup in _generate_response_chunks_async to only occur
+        #  when the agent was initialized in this generator and is not client-managed
+        #  and the user does want us to manage the connection.
+        if not self.client and initialised_here and manage_connector:
+            logger.info("🧹 Closing agent after generator completion")
             await self.close()
 
     async def astream(
@@ -411,9 +400,7 @@ class MCPAgent:
             elif self.connectors:
                 server_count = len(self.connectors)
 
-            conversation_history_length = (
-                len(self._conversation_history) if self.memory_enabled else 0
-            )
+            conversation_history_length = len(self._conversation_history) if self.memory_enabled else 0
 
             self.telemetry.track_agent_execution(
                 execution_method="astream",
@@ -486,11 +473,7 @@ class MCPAgent:
             if self._agent_executor:
                 self._agent_executor.max_iterations = steps
 
-            display_query = (
-                query[:50].replace("\n", " ") + "..."
-                if len(query) > 50
-                else query.replace("\n", " ")
-            )
+            display_query = query[:50].replace("\n", " ") + "..." if len(query) > 50 else query.replace("\n", " ")
             logger.info(f"💬 Received query: '{display_query}'")
 
             # Add the user query to conversation history if memory is enabled
@@ -498,9 +481,7 @@ class MCPAgent:
                 self.add_to_history(HumanMessage(content=query))
 
             # Use the provided history or the internal history
-            history_to_use = (
-                external_history if external_history is not None else self._conversation_history
-            )
+            history_to_use = external_history if external_history is not None else self._conversation_history
 
             # Convert messages to format expected by LangChain agent input
             # Exclude the main system message as it's part of the agent's prompt
@@ -516,9 +497,7 @@ class MCPAgent:
 
             # Construct a mapping of tool name to tool for easy lookup
             name_to_tool_map = {tool.name: tool for tool in self._tools}
-            color_mapping = get_color_mapping(
-                [tool.name for tool in self._tools], excluded_colors=["green", "red"]
-            )
+            color_mapping = get_color_mapping([tool.name for tool in self._tools], excluded_colors=["green", "red"])
 
             logger.info(f"🏁 Starting agent execution with max_steps={steps}")
 
@@ -532,7 +511,7 @@ class MCPAgent:
 
                     if current_tool_names != existing_tool_names:
                         logger.info(
-                            f"🔄 Tools changed before step {step_num + 1}, updating agent. "
+                            f"🔄 Tools changed before step {step_num + 1}, updating agent."
                             f"New tools: {', '.join(current_tool_names)}"
                         )
                         self._tools = current_tools
@@ -637,9 +616,7 @@ class MCPAgent:
             elif self.connectors:
                 server_count = len(self.connectors)
 
-            conversation_history_length = (
-                len(self._conversation_history) if self.memory_enabled else 0
-            )
+            conversation_history_length = len(self._conversation_history) if self.memory_enabled else 0
             self.telemetry.track_agent_execution(
                 execution_method="run",
                 query=query,

mcp_use/agents/prompts/system_prompt_builder.py

@@ -2,9 +2,7 @@ from langchain.schema import SystemMessage
 from langchain_core.tools import BaseTool
 
 
-def generate_tool_descriptions(
-    tools: list[BaseTool], disallowed_tools: list[str] | None = None
-) -> list[str]:
+def generate_tool_descriptions(tools: list[BaseTool], disallowed_tools: list[str] | None = None) -> list[str]:
     """
     Generates a list of formatted tool descriptions, excluding disallowed tools.
 

mcp_use/client.py

@@ -77,9 +77,7 @@ class MCPClient:
             sandbox: Whether to use sandboxed execution mode for running MCP servers.
             sandbox_options: Optional sandbox configuration options.
         """
-        return cls(
-            config=load_config_file(filepath), sandbox=sandbox, sandbox_options=sandbox_options
-        )
+        return cls(config=load_config_file(filepath), sandbox=sandbox, sandbox_options=sandbox_options)
 
     def add_server(
         self,

mcp_use/connectors/base.py

@@ -30,7 +30,7 @@ class BaseConnector(ABC):
         self._resources: list[Resource] | None = None
         self._prompts: list[Prompt] | None = None
         self._connected = False
-        self.auto_reconnect = True  # Whether to automatically reconnect on connection loss (not configurable for now), may be made configurable through the connector_config
+        self.auto_reconnect = True  # Whether to automatically reconnect on connection loss (not configurable for now)
 
     @abstractmethod
     async def connect(self) -> None:
@@ -123,7 +123,11 @@ class BaseConnector(ABC):
         else:
             self._prompts = []
 
-        logger.debug(f"MCP session initialized with {len(self._tools)} tools, " f"{len(self._resources)} resources, " f"and {len(self._prompts)} prompts")
+        logger.debug(
+            f"MCP session initialized with {len(self._tools)} tools, "
+            f"{len(self._resources)} resources, "
+            f"and {len(self._prompts)} prompts"
+        )
 
         return result
 
@@ -222,7 +226,9 @@ class BaseConnector(ABC):
                 except Exception as e:
                     raise RuntimeError(f"Failed to reconnect to MCP server: {e}") from e
             else:
-                raise RuntimeError("Connection to MCP server has been lost. " "Auto-reconnection is disabled. Please reconnect manually.")
+                raise RuntimeError(
+                    "Connection to MCP server has been lost. Auto-reconnection is disabled. Please reconnect manually."
+                )
 
     async def call_tool(self, name: str, arguments: dict[str, Any]) -> CallToolResult:
         """Call an MCP tool with automatic reconnection handling.

mcp_use/connectors/http.py

@@ -111,9 +111,7 @@ class HttpConnector(BaseConnector):
             if isinstance(streamable_error, httpx.HTTPStatusError):
                 if streamable_error.response.status_code in [404, 405]:
                     should_fallback = True
-            elif "405 Method Not Allowed" in str(streamable_error) or "404 Not Found" in str(
-                streamable_error
-            ):
+            elif "405 Method Not Allowed" in str(streamable_error) or "404 Not Found" in str(streamable_error):
                 should_fallback = True
             else:
                 # For other errors, still try fallback but they might indicate
@@ -131,16 +129,13 @@ class HttpConnector(BaseConnector):
                     read_stream, write_stream = await connection_manager.start()
 
                     # Create the client session for SSE
-                    self.client_session = ClientSession(
-                        read_stream, write_stream, sampling_callback=None
-                    )
+                    self.client_session = ClientSession(read_stream, write_stream, sampling_callback=None)
                     await self.client_session.__aenter__()
                     self.transport_type = "SSE"
 
                 except Exception as sse_error:
                     logger.error(
-                        f"Both transport methods failed. Streamable HTTP: {streamable_error}, "
-                        f"SSE: {sse_error}"
+                        f"Both transport methods failed. Streamable HTTP: {streamable_error}, SSE: {sse_error}"
                     )
                     raise sse_error
             else:
@@ -149,10 +144,7 @@ class HttpConnector(BaseConnector):
         # Store the successful connection manager and mark as connected
         self._connection_manager = connection_manager
         self._connected = True
-        logger.debug(
-            f"Successfully connected to MCP implementation via"
-            f" {self.transport_type}: {self.base_url}"
-        )
+        logger.debug(f"Successfully connected to MCP implementation via {self.transport_type}: {self.base_url}")
 
     @property
     def public_identifier(self) -> str:

mcp_use/connectors/sandbox.py

@@ -84,9 +84,7 @@ class SandboxConnector(BaseConnector):
             )
 
         self.sandbox_template_id = _e2b_options.get("sandbox_template_id", "base")
-        self.supergateway_cmd_parts = _e2b_options.get(
-            "supergateway_command", "npx -y supergateway"
-        )
+        self.supergateway_cmd_parts = _e2b_options.get("supergateway_command", "npx -y supergateway")
 
         self.sandbox: Sandbox | None = None
         self.process: CommandHandle | None = None
@@ -138,10 +136,7 @@ class SandboxConnector(BaseConnector):
                         async with session.get(ping_url, timeout=2) as response:
                             if response.status == 200:
                                 elapsed = time.time() - start_time
-                                logger.info(
-                                    f"Server is ready! "
-                                    f"SSE endpoint responded with 200 after {elapsed:.1f}s"
-                                )
+                                logger.info(f"Server is ready! SSE endpoint responded with 200 after {elapsed:.1f}s")
                                 return True
                     except Exception:
                         # If sse endpoint doesn't work, try the base URL
@@ -149,8 +144,7 @@ class SandboxConnector(BaseConnector):
                             if response.status < 500:  # Accept any non-server error
                                 elapsed = time.time() - start_time
                                 logger.info(
-                                    f"Server is ready! Base URL responded with "
-                                    f"{response.status} after {elapsed:.1f}s"
+                                    f"Server is ready! Base URL responded with {response.status} after {elapsed:.1f}s"
                                 )
                                 return True
             except Exception:
@@ -220,9 +214,7 @@ class SandboxConnector(BaseConnector):
             sse_url = f"{self.base_url}/sse"
 
             # Create and start the connection manager
-            self._connection_manager = SseConnectionManager(
-                sse_url, self.headers, self.timeout, self.sse_read_timeout
-            )
+            self._connection_manager = SseConnectionManager(sse_url, self.headers, self.timeout, self.sse_read_timeout)
             read_stream, write_stream = await self._connection_manager.start()
 
             # Create the client session
@@ -231,9 +223,7 @@ class SandboxConnector(BaseConnector):
 
             # Mark as connected
             self._connected = True
-            logger.debug(
-                f"Successfully connected to MCP implementation via HTTP/SSE: {self.base_url}"
-            )
+            logger.debug(f"Successfully connected to MCP implementation via HTTP/SSE: {self.base_url}")
 
         except Exception as e:
             logger.error(f"Failed to connect to MCP implementation: {e}")

mcp_use/connectors/stdio.py

@@ -52,9 +52,7 @@ class StdioConnector(BaseConnector):
         logger.debug(f"Connecting to MCP implementation: {self.command}")
         try:
             # Create server parameters
-            server_params = StdioServerParameters(
-                command=self.command, args=self.args, env=self.env
-            )
+            server_params = StdioServerParameters(command=self.command, args=self.args, env=self.env)
 
             # Create and start the connection manager
             self._connection_manager = StdioConnectionManager(server_params, self.errlog)

mcp_use/connectors/websocket.py

@@ -64,9 +64,7 @@ class WebSocketConnector(BaseConnector):
             self.ws = await self._connection_manager.start()
 
             # Start the message receiver task
-            self._receiver_task = asyncio.create_task(
-                self._receive_messages(), name="websocket_receiver_task"
-            )
+            self._receiver_task = asyncio.create_task(self._receive_messages(), name="websocket_receiver_task")
 
             # Mark as connected
             self._connected = True

mcp_use/logging.py

@@ -12,7 +12,7 @@ import sys
 from langchain.globals import set_debug as langchain_set_debug
 
 # Global debug flag - can be set programmatically or from environment
-MCP_USE_DEBUG = False
+MCP_USE_DEBUG = 1
 
 
 class Logger:

mcp_use/managers/server_manager.py

@@ -49,19 +49,13 @@ class ServerManager:
                 session = None
                 try:
                     session = self.client.get_session(server_name)
-                    logger.debug(
-                        f"Using existing session for server '{server_name}' to prefetch tools."
-                    )
+                    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"
-                        )
+                        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"
-                        )
+                        logger.warning(f"Could not create session for '{server_name}' during prefetch")
                         continue
 
                 # Fetch tools if session is available
@@ -70,17 +64,12 @@ class ServerManager:
                     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
-                    ):
+                    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."
-                        )
+                        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}")
 

mcp_use/managers/tools/disconnect_server.py

@@ -17,9 +17,7 @@ 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"
-    )
+    description: ClassVar[str] = "Disconnect from the currently active MCP (Model Context Protocol) server"
     args_schema: ClassVar[type[BaseModel]] = DisconnectServerInput
 
     def _run(self, **kwargs) -> str:

mcp_use/managers/tools/get_active_server.py

@@ -21,10 +21,7 @@ class GetActiveServerTool(MCPServerTool):
     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 "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:

mcp_use/managers/tools/search_tools.py

@@ -48,36 +48,12 @@ class SearchToolsTool(MCPServerTool):
         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)
+        return 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:
     """
@@ -115,13 +91,18 @@ class ToolSearchEngine:
 
         try:
             from fastembed import TextEmbedding  # optional dependency install with [search]
-        except ImportError:
+        except ImportError as exc:
             logger.error(
                 "The 'fastembed' library is not installed. "
                 "To use the search functionality, please install it by running: "
                 "pip install mcp-use[search]"
             )
-            return False
+            raise ImportError(
+                "The 'fastembed' library is not installed. "
+                "To use the server_manager functionality, please install it by running: "
+                "pip install mcp-use[search] "
+                "or disable the server_manager by setting use_server_manager=False in the MCPAgent constructor."
+            ) from exc
 
         try:
             self.model = TextEmbedding(model_name="BAAI/bge-small-en-v1.5")
@@ -282,11 +263,7 @@ class ToolSearchEngine:
                 )
 
         # 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")
-        ):
+        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)
@@ -303,11 +280,27 @@ class ToolSearchEngine:
             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
-                )
+                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
+        return self._format_search_results(results)
+
+    def _format_search_results(self, results: list[tuple[BaseTool, str, float]]) -> str:
+        """Format search results in a consistent format."""
+        formatted_output = "Search results\n\n"
+
+        for i, (tool, server_name, score) in enumerate(results):
+            # Format score as percentage
+            score_pct = f"{score * 100:.1f}%"
+            if i < 5:
+                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