mcp-use 1.2.7__tar.gz → 1.2.8__tar.gz

{mcp_use-1.2.7 → mcp_use-1.2.8}/.github/workflows/tests.yml

@@ -22,7 +22,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install .[dev,anthropic,openai]
+          pip install .[dev,anthropic,openai,search]
       - name: Lint with ruff
         run: |
           ruff check .

{mcp_use-1.2.7 → mcp_use-1.2.8}/.pre-commit-config.yaml

@@ -4,10 +4,10 @@ repos:
     rev: v0.3.2
     hooks:
     -   id: ruff
-        args: [--fix, --exit-non-zero-on-fix, --config=pyproject.toml]
+        args: [--fix, --exit-non-zero-on-fix, --config=ruff.toml]
         types: [python]
     -   id: ruff-format
-        args: [--config=pyproject.toml]
+        args: [--config=ruff.toml]
         types: [python]
 
 -   repo: https://github.com/pre-commit/pre-commit-hooks

mcp_use-1.2.8/CONTRIBUTING.md

@@ -0,0 +1,146 @@
+# Contributing to MCP-Use
+
+Thank you for your interest in contributing to MCP-Use! This document provides guidelines and instructions for contributing to this project.
+
+## Table of Contents
+
+- [Getting Started](#getting-started)
+  - [Development Environment](#development-environment)
+  - [Installation from Source](#installation-from-source)
+- [Development Workflow](#development-workflow)
+  - [Branching Strategy](#branching-strategy)
+  - [Commit Messages](#commit-messages)
+  - [Code Style](#code-style)
+  - [Pre-commit Hooks](#pre-commit-hooks)
+- [Testing](#testing)
+  - [Running Tests](#running-tests)
+  - [Adding Tests](#adding-tests)
+- [Pull Requests](#pull-requests)
+  - [Creating a Pull Request](#creating-a-pull-request)
+  - [Pull Request Template](#pull-request-template)
+- [Documentation](#documentation)
+- [Release Process](#release-process)
+- [Getting Help](#getting-help)
+
+## Getting Started
+
+### Development Environment
+
+MCP-Use requires:
+- Python 3.11 or later
+
+### Installation from Source
+
+1. Fork the repository on GitHub.
+2. Clone your fork locally:
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/mcp-use.git
+   cd mcp-use
+   ```
+3. Install the package in development mode:
+   ```bash
+   pip install -e ".[dev,search]"
+   ```
+4. Set up pre-commit hooks:
+   ```bash
+   pip install pre-commit
+   pre-commit install
+   ```
+
+## Development Workflow
+
+### Branching Strategy
+
+- `main` branch contains the latest stable code
+- Create feature branches from `main` named according to the feature you're implementing: `feature/your-feature-name`
+- For bug fixes, use: `fix/bug-description`
+
+### Commit Messages
+
+For now no commit style is enforced, try to keep your commit messages informational.
+### Code Style
+
+We use [Ruff](https://github.com/astral-sh/ruff) for code formatting and linting. The configuration is in `ruff.toml`.
+
+Key style guidelines:
+- Line length: 100 characters
+- Use double quotes for strings
+- Follow PEP 8 naming conventions
+- Add type hints to function signatures
+
+### Pre-commit Hooks
+
+We use pre-commit hooks to ensure code quality before committing. The configuration is in `.pre-commit-config.yaml`.
+
+The hooks will:
+- Format code using Ruff
+- Run linting checks
+- Check for trailing whitespace and fix it
+- Ensure files end with a newline
+- Validate YAML files
+- Check for large files
+- Remove debug statements
+
+## Testing
+
+### Running Tests
+
+Run the test suite with pytest:
+
+```bash
+pytest
+```
+
+To run specific test categories:
+
+```bash
+pytest tests/
+```
+
+### Adding Tests
+
+- Add unit tests for new functionality in `tests/unit/`
+- For slow or network-dependent tests, mark them with `@pytest.mark.slow` or `@pytest.mark.integration`
+- Aim for high test coverage of new code
+
+## Pull Requests
+
+### Creating a Pull Request
+
+1. Ensure your code passes all tests and pre-commit hooks
+2. Push your changes to your fork
+3. Submit a pull request to the main repository
+4. Follow the pull request template
+
+## Documentation
+
+- Update docstrings for new or modified functions, classes, and methods
+- Use Google-style docstrings:
+  ```python
+  def function_name(param1: type, param2: type) -> return_type:
+      """Short description.
+
+      Longer description if needed.
+
+      Args:
+          param1: Description of param1
+          param2: Description of param2
+
+      Returns:
+          Description of return value
+
+      Raises:
+          ExceptionType: When and why this exception is raised
+      """
+  ```
+- Update README.md for user-facing changes
+
+## Getting Help
+
+If you need help with your contribution:
+
+- Open an issue for discussion
+- Reach out to the maintainers
+- Check existing code for examples
+
+Thank you for contributing to MCP-Use!

{mcp_use-1.2.7 → mcp_use-1.2.8}/PKG-INFO

@@ -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 → mcp_use-1.2.8}/README.md

@@ -24,13 +24,13 @@
 
 | 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
@@ -571,7 +571,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 → mcp_use-1.2.8}/docs/docs.json

@@ -27,6 +27,7 @@
               "essentials/llm-integration",
               "essentials/debugging",
               "essentials/connection-types",
+              "essentials/server-manager",
               "building-custom-agents"
             ]
           },

mcp_use-1.2.8/docs/essentials/server-manager.mdx

@@ -0,0 +1,342 @@
+---
+title: 'Server Manager'
+description: 'Intelligent management of multiple MCP servers and tool discovery'
+---
+
+# Server Manager
+
+The Server Manager is a powerful feature that helps manage connections to multiple MCP servers efficiently and enables tool discovery across servers. When your agent has access to tools from different servers, the Server Manager intelligently selects the appropriate server and helps discover the most relevant tools for each task.
+
+## Overview
+
+When building agents that need to interact with multiple MCP servers (such as combining web browsing with file operations or 3D modeling), the Server Manager:
+
+- Dynamically connects to the appropriate server based on the task at hand
+- Provides tool discovery and search capabilities across all configured servers
+- Minimizes unnecessary connections by only connecting to servers when needed
+- Reduces agent confusion by organizing tool sets appropriately
+- Improves overall performance and efficiency of multi-server operations
+
+## Enabling the Server Manager
+
+The Server Manager can be enabled by setting `use_server_manager=True` during the initialization of an `MCPAgent`:
+
+```python
+from mcp_use import MCPClient, MCPAgent
+from langchain_openai import ChatOpenAI
+
+# Create client with multiple servers
+client = MCPClient.from_config_file("multi_server_config.json")
+
+# Create agent with the Server Manager enabled
+agent = MCPAgent(
+    llm=ChatOpenAI(model="gpt-4o"),
+    client=client,
+    use_server_manager=True  # Enable the Server Manager
+)
+
+# The agent will now intelligently manage server connections
+```
+
+## Server Management Tools
+
+When the Server Manager is enabled, it provides the following management tools to the agent:
+
+1. **list_mcp_servers** - Lists all available MCP servers and their tools
+2. **connect_to_mcp_server** - Connects to a specific MCP server
+3. **get_active_mcp_server** - Shows which server is currently active
+4. **disconnect_from_mcp_server** - Disconnects from the current server
+5. **search_mcp_tools** - Searches for tools across all MCP servers
+6. **use_tool_from_server** - Uses a specific tool from a specific server without switching the active connection
+
+These tools allow the agent to discover available servers, connect to the appropriate server for a given task, search for specific tools, and manage server connections throughout its operation.
+
+## Tool Discovery and Search
+
+### Listing Available Servers and Their Tools
+
+The `list_mcp_servers` tool provides a comprehensive overview of all available servers and their tools:
+
+```python
+# Example of using the Server Manager for listing servers and tools
+result = await agent.run(
+    "What tools do I have available? List all servers and their tools."
+)
+```
+
+This will return output similar to:
+
+```
+Available MCP servers:
+1. playwright
+   Tools: navigate_browser, click_element, get_page_content, ...
+2. file_system
+   Tools: read_file, write_file, list_directory, ...
+```
+
+This allows the agent to understand which tools are available on each server before deciding which one to connect to.
+
+### Searching for Tools Across Servers
+
+The `search_mcp_tools` tool is especially powerful, allowing agents to search for specific tools across all servers based on functionality needed:
+
+```python
+# Example of searching for tools across servers
+result = await agent.run(
+    "I need to find tools that can help me navigate a website. Can you search for relevant tools?"
+)
+```
+
+This will search across all servers and return a ranked list of tools that match the query:
+
+```
+Search results for: 'navigate website'
+
+[1] Tool: navigate_browser (95.2% match)
+    Server: playwright
+    Description: Navigates to a specified URL in a web browser
+
+[2] Tool: click_element (87.4% match)
+    Server: playwright
+    Description: Clicks on an element on the page identified by a selector
+
+[3] Tool: get_page_content (82.1% match)
+    Server: playwright
+    Description: Retrieves the HTML content of the current page
+
+...
+
+To use a tool, connect to the appropriate server first, then invoke the tool.
+```
+
+This search functionality helps agents quickly find the most relevant tools for their tasks without needing to manually inspect all available tools across all servers.
+
+### Direct Tool Execution Across Servers
+
+The `use_tool_from_server` tool enables direct execution of a tool from a specific server without explicitly connecting to it first:
+
+```python
+# Example of using a tool from a specific server without switching context
+result = await agent.run(
+    "I need to navigate to https://example.com but I don't want to disrupt my current server connection. Can you use the navigate_browser tool from the playwright server directly?"
+)
+```
+
+This is especially useful for one-off operations where you don't want to disconnect from the current server just to perform a single action on another server.
+
+### Detailed Tool Information
+
+When an agent connects to a server, the Server Manager provides detailed descriptions of all available tools:
+
+```
+Connected to MCP server 'playwright'. 25 tools are now available.
+
+Available tools for this server:
+1. navigate_browser: Navigates to a specified URL in a web browser
+2. click_element: Clicks on an element on the page identified by a selector
+3. get_page_content: Retrieves the HTML content of the current page
+...
+```
+
+This detailed information helps the agent understand the purpose and capabilities of each tool, enabling it to make better decisions about which tool to use for a specific task.
+
+## Benefits of Using the Server Manager
+
+### 1. Reduced Connection Overhead
+
+Without the Server Manager, the agent might connect to all configured servers at once, even if only one server is needed for a particular task. The Server Manager ensures that only the necessary connections are established.
+
+### 2. Improved Tool Selection
+
+When an agent has access to dozens or even hundreds of tools from different servers, it can be challenging for the LLM to select the right tool for a specific task. The Server Manager helps organize tools by server and provides search capabilities, making it easier for the LLM to make appropriate selections.
+
+### 3. Efficient Resource Management
+
+The Server Manager monitors server usage and can close inactive connections, freeing up resources when they're no longer needed.
+
+### 4. Reduced Cognitive Load
+
+Agents don't need to memorize all available tools across all servers; they can discover and search for them at runtime.
+
+### 5. Dynamic Tool Selection
+
+Agents can adapt to available tools at runtime, connecting to the appropriate server for each task.
+
+### 6. Cross-Server Tool Usage
+
+The `use_tool_from_server` capability allows agents to use tools from different servers without disrupting their current workflow or connection state.
+
+## Example: Multi-Server Agent with Server Manager
+
+```python
+import asyncio
+from mcp_use import MCPClient, MCPAgent
+from langchain_anthropic import ChatAnthropic
+
+async def main():
+    # Create client with multiple servers
+    client = MCPClient.from_dict({
+        "mcpServers": {
+            "playwright": {
+                "command": "npx",
+                "args": ["@playwright/mcp@latest"],
+                "env": {"DISPLAY": ":1"}
+            },
+            "database": {
+                "command": "npx",
+                "args": ["@database/mcp-server"]
+            },
+            "file_system": {
+                "command": "npx",
+                "args": ["@file/mcp-server"]
+            }
+        }
+    })
+
+    # Create agent with the Server Manager
+    agent = MCPAgent(
+        llm=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
+        client=client,
+        use_server_manager=True  # Enable the Server Manager
+    )
+
+    try:
+        # Run a complex task requiring tools from multiple servers
+        result = await agent.run(
+            """Task: Extract data from a website, save it to a file, and then load it into a database.
+
+            Start by figuring out which tools you need and which servers provide them,
+            then complete the task step by step."""
+        )
+        print(result)
+    finally:
+        # Clean up all sessions
+        await client.close_all_sessions()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+In this example, the agent will:
+1. Use `list_mcp_servers` or `search_mcp_tools` to discover available tools across all servers
+2. Connect to the appropriate server for each step of the task
+3. Use the most suitable tools to complete each part of the workflow
+4. Optionally use `use_tool_from_server` for one-off operations on other servers
+
+## How the Server Manager Works
+
+Internally, the Server Manager operates through these key mechanisms:
+
+1. **Tool Organization**: Server Manager maintains a registry of which tools belong to which servers
+2. **Server Management**: It manages connections to servers, only connecting when necessary
+3. **Tool Search**: It provides search capabilities across all available tools from all servers
+4. **Tool Updates**: It updates the available tools based on the currently active server
+5. **Connection Lifecycle**: It handles connecting and disconnecting from servers as needed
+6. **Cross-Server Operations**: It enables using tools from non-active servers when needed
+
+## Advanced Usage Examples
+
+### Example 1: Tool Search Workflow
+
+```python
+# The agent searches for tools that can help with a specific task
+result = await agent.run(
+    """I need to perform the following tasks:
+    1. Navigate to a website
+    2. Take a screenshot of the page
+    3. Save the screenshot to a file
+
+    First, search for tools that could help me with each of these tasks."""
+)
+```
+
+The agent will use the `search_mcp_tools` tool to find relevant tools for each part of the task, which might return results like:
+
+```
+[1] Tool: navigate_browser (96.5% match)
+    Server: playwright
+    Description: Navigates to a specified URL in a web browser
+
+[2] Tool: take_screenshot (95.1% match)
+    Server: playwright
+    Description: Captures a screenshot of the current page
+
+[3] Tool: write_file (92.8% match)
+    Server: file_system
+    Description: Writes data to a file at the specified path
+```
+
+### Example 2: Cross-Server Tool Usage
+
+```python
+# The agent is connected to the database server, but needs to use a web tool
+result = await agent.run(
+    """I'm currently analyzing database data, but I need to quickly check a website
+    for reference information. Can you help me navigate to https://example.com without
+    disrupting my database connection?"""
+)
+```
+
+The agent will use the `use_tool_from_server` tool to invoke the web navigation tool directly:
+
+```python
+# The agent invokes use_tool_from_server
+"I'll help you check the website without disrupting your database connection. I'll use the navigate_browser tool from the playwright server directly."
+
+# Tool execution
+tool_result = await use_tool_from_server(
+    server_name="playwright",
+    tool_name="navigate_browser",
+    tool_input={"url": "https://example.com"}
+)
+
+# After the tool execution, the agent remains connected to the database server
+```
+
+## Using Server Manager in Custom Implementations
+
+If you're building a custom agent, you can also leverage the Server Manager directly:
+
+```python
+from mcp_use import MCPClient, ServerManager
+from mcp_use.adapters.langchain_adapter import LangChainAdapter
+
+# Create client and adapter
+client = MCPClient.from_config_file("config.json")
+adapter = LangChainAdapter()
+
+# Create server manager
+server_manager = ServerManager(client=client, adapter=adapter)
+await server_manager.initialize()
+
+# Get server management tools
+management_tools = await server_manager.get_server_management_tools()
+
+# List available servers
+servers_info = await server_manager.list_servers()
+print(servers_info)
+
+# Connect to a specific server
+connection_result = await server_manager.connect_to_server("playwright")
+print(connection_result)
+
+# Get tools from the active server
+active_server_tools = await server_manager.get_active_server_tools()
+
+# Get all tools (management + active server)
+all_tools = await server_manager.get_all_tools()
+
+# Search for tools across all servers
+search_results = await server_manager.search_tools("navigate web page")
+print(search_results)
+
+# Use a tool from a specific server
+result = await server_manager.use_tool_from_server(
+    server_name="playwright",
+    tool_name="navigate_browser",
+    tool_input={"url": "https://example.com"}
+)
+```
+## Conclusion
+
+The Server Manager is a powerful feature that enhances the capabilities of multi-server MCP agents. By intelligently managing server connections, providing comprehensive tool discovery and search functionality, and enabling cross-server tool usage, it enables more complex and efficient agent workflows that combine capabilities from different MCP servers. Agents can dynamically discover, select, and use the most appropriate tools for each task, resulting in more effective task completion and better resource utilization.

{mcp_use-1.2.7 → mcp_use-1.2.8}/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-1.2.7 → mcp_use-1.2.8}/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-1.2.7 → mcp_use-1.2.8}/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: