mcp-use 1.1.5__tar.gz → 1.2.6__tar.gz

mcp_use-1.2.6/.github/pull_request_template.md

@@ -0,0 +1,43 @@
+# Pull Request Description
+
+## Changes
+
+Describe the changes introduced by this PR in a concise manner.
+
+## Implementation Details
+
+1. List the specific implementation details
+2. Include code organization, architectural decisions
+3. Note any dependencies that were added or modified
+
+## Example Usage (Before)
+
+```python
+# Include example code showing how things worked before (if applicable)
+```
+
+## Example Usage (After)
+
+```python
+# Include example code showing how things work after your changes
+```
+
+## Documentation Updates
+
+* List any documentation files that were updated
+* Explain what was changed in each file
+
+## Testing
+
+Describe how you tested these changes:
+- Unit tests added/modified
+- Manual testing performed
+- Edge cases considered
+
+## Backwards Compatibility
+
+Explain whether these changes are backwards compatible. If not, describe what users will need to do to adapt to these changes.
+
+## Related Issues
+
+Closes #[issue_number]

{mcp_use-1.1.5 → mcp_use-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp-use
-Version: 1.1.5
+Version: 1.2.6
 Summary: MCP Library for LLMs
 Author-email: Pietro Zullo <pietro.zullo@gmail.com>
 License: MIT
@@ -41,9 +41,9 @@ Description-Content-Type: text/markdown
   <img alt="" src="./static/image.jpg"  width="full">
 </picture>
 
-<h1 align="center">Open Source MCP CLient Library </h1>
+<h1 align="center">Unified MCP Client Library </h1>
 
-[![](https://img.shields.io/pypi/dd/mcp_use.svg)](https://pypi.org/project/mcp_use/)
+[![](https://img.shields.io/pypi/dw/mcp_use.svg)](https://pypi.org/project/mcp_use/)
 [![PyPI Downloads](https://img.shields.io/pypi/dm/mcp_use.svg)](https://pypi.org/project/mcp_use/)
 [![PyPI Version](https://img.shields.io/pypi/v/mcp_use.svg)](https://pypi.org/project/mcp_use/)
 [![Python Versions](https://img.shields.io/pypi/pyversions/mcp_use.svg)](https://pypi.org/project/mcp_use/)
@@ -51,8 +51,9 @@ Description-Content-Type: text/markdown
 [![License](https://img.shields.io/github/license/pietrozullo/mcp-use)](https://github.com/pietrozullo/mcp-use/blob/main/LICENSE)
 [![Code style: Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 [![GitHub stars](https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social)](https://github.com/pietrozullo/mcp-use/stargazers)
+[![Twitter Follow](https://img.shields.io/twitter/follow/Pietro?style=social)](https://x.com/pietrozullo)
 
-🌐 MCP-Use is the open source way to connect any LLM to MCP tools and build custom agents that have tool access, without using closed source or application clients.
+🌐 MCP-Use is the open source way to connect **any LLM to any MCP server** and build custom agents that have tool access, without using closed source or application clients.
 
 💡 Let developers easily connect any LLM to tools like web browsing, file operations, and more.
 
@@ -65,8 +66,10 @@ Description-Content-Type: text/markdown
 | 🔄 **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 |
 
 
 # Quick start
@@ -388,7 +391,7 @@ This example demonstrates how to connect to an MCP server running on a specific
 
 # Multi-Server Support
 
-MCP-Use supports working with multiple MCP servers simultaneously, allowing you to combine tools from different servers in a single agent. This is useful for complex tasks that require multiple capabilities, such as web browsing combined with file operations or 3D modeling.
+MCP-Use allows configuring and connecting to multiple MCP servers simultaneously using the `MCPClient`. This enables complex workflows that require tools from different servers, such as web browsing combined with file operations or 3D modeling.
 
 ## Configuration
 
@@ -414,7 +417,28 @@ You can configure multiple servers in your configuration file:
 
 ## Usage
 
-The `MCPClient` class provides several methods for managing multiple servers:
+The `MCPClient` class provides methods for managing connections to multiple servers. When creating an `MCPAgent`, you can provide an `MCPClient` configured with multiple servers.
+
+By default, the agent will have access to tools from all configured servers. If you need to target a specific server for a particular task, you can specify the `server_name` when calling the `agent.run()` method.
+
+```python
+# Example: Manually selecting a server for a specific task
+result = await agent.run(
+    "Search for Airbnb listings in Barcelona",
+    server_name="airbnb" # Explicitly use the airbnb server
+)
+
+result_google = await agent.run(
+    "Find restaurants near the first result using Google Search",
+    server_name="playwright" # Explicitly use the playwright server
+)
+```
+
+## Dynamic Server Selection (Server Manager)
+
+For enhanced efficiency and to reduce potential agent confusion when dealing with many tools from different servers, you can enable the Server Manager by setting `use_server_manager=True` during `MCPAgent` initialization.
+
+When enabled, the agent intelligently selects the correct MCP server based on the tool chosen by the LLM for a specific step. This minimizes unnecessary connections and ensures the agent uses the appropriate tools for the task.
 
 ```python
 import asyncio
@@ -428,7 +452,8 @@ async def main():
     # Create agent with the client
     agent = MCPAgent(
         llm=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
-        client=client
+        client=client,
+        use_server_manager=True  # Enable the Server Manager
     )
 
     try:
@@ -479,6 +504,98 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+# Build a Custom Agent:
+
+You can also build your own custom agent using the LangChain adapter:
+
+```python
+import asyncio
+from langchain_openai import ChatOpenAI
+from mcp_use.client import MCPClient
+from mcp_use.adapters.langchain_adapter import LangChainAdapter
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+async def main():
+    # Initialize MCP client
+    client = MCPClient.from_config_file("examples/browser_mcp.json")
+    llm = ChatOpenAI(model="gpt-4o")
+
+    # Create adapter instance
+    adapter = LangChainAdapter()
+    # Get LangChain tools with a single line
+    tools = await adapter.create_tools(client)
+
+    # Create a custom LangChain agent
+    llm_with_tools = llm.bind_tools(tools)
+    result = await llm_with_tools.ainvoke("What tools do you have avilable ? ")
+    print(result)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+
+```
+
+# Debugging
+
+MCP-Use provides a built-in debug mode that increases log verbosity and helps diagnose issues in your agent implementation.
+
+## Enabling Debug Mode
+
+There are two primary ways to enable debug mode:
+
+### 1. Environment Variable (Recommended for One-off Runs)
+
+Run your script with the `DEBUG` environment variable set to the desired level:
+
+```bash
+# Level 1: Show INFO level messages
+DEBUG=1 python3.11 examples/browser_use.py
+
+# Level 2: Show DEBUG level messages (full verbose output)
+DEBUG=2 python3.11 examples/browser_use.py
+```
+
+This sets the debug level only for the duration of that specific Python process.
+
+Alternatively you can set the following environment variable to the desired logging level:
+
+```bash
+export MCP_USE_DEBUG=1 # or 2
+```
+
+### 2. Setting the Debug Flag Programmatically
+
+You can set the global debug flag directly in your code:
+
+```python
+import mcp_use
+
+mcp_use.set_debug(1)  # INFO level
+# or
+mcp_use.set_debug(2)  # DEBUG level (full verbose output)
+```
+
+### 3. Agent-Specific Verbosity
+
+If you only want to see debug information from the agent without enabling full debug logging, you can set the `verbose` parameter when creating an MCPAgent:
+
+```python
+# Create agent with increased verbosity
+agent = MCPAgent(
+    llm=your_llm,
+    client=your_client,
+    verbose=True  # Only shows debug messages from the agent
+)
+```
+
+This is useful when you only need to see the agent's steps and decision-making process without all the low-level debug information from other components.
+
+
 # Roadmap
 
 <ul>
@@ -487,6 +604,10 @@ if __name__ == "__main__":
 <li>[ ] ... </li>
 </ul>
 
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=pietrozullo/mcp-use&type=Date)](https://www.star-history.com/#pietrozullo/mcp-use&Date)
+
 # Contributing
 
 We love contributions! Feel free to open issues for bugs or feature requests.

{mcp_use-1.1.5 → mcp_use-1.2.6}/README.md

@@ -2,9 +2,9 @@
   <img alt="" src="./static/image.jpg"  width="full">
 </picture>
 
-<h1 align="center">Open Source MCP CLient Library </h1>
+<h1 align="center">Unified MCP Client Library </h1>
 
-[![](https://img.shields.io/pypi/dd/mcp_use.svg)](https://pypi.org/project/mcp_use/)
+[![](https://img.shields.io/pypi/dw/mcp_use.svg)](https://pypi.org/project/mcp_use/)
 [![PyPI Downloads](https://img.shields.io/pypi/dm/mcp_use.svg)](https://pypi.org/project/mcp_use/)
 [![PyPI Version](https://img.shields.io/pypi/v/mcp_use.svg)](https://pypi.org/project/mcp_use/)
 [![Python Versions](https://img.shields.io/pypi/pyversions/mcp_use.svg)](https://pypi.org/project/mcp_use/)
@@ -12,8 +12,9 @@
 [![License](https://img.shields.io/github/license/pietrozullo/mcp-use)](https://github.com/pietrozullo/mcp-use/blob/main/LICENSE)
 [![Code style: Ruff](https://img.shields.io/badge/code%20style-ruff-000000.svg)](https://github.com/astral-sh/ruff)
 [![GitHub stars](https://img.shields.io/github/stars/pietrozullo/mcp-use?style=social)](https://github.com/pietrozullo/mcp-use/stargazers)
+[![Twitter Follow](https://img.shields.io/twitter/follow/Pietro?style=social)](https://x.com/pietrozullo)
 
-🌐 MCP-Use is the open source way to connect any LLM to MCP tools and build custom agents that have tool access, without using closed source or application clients.
+🌐 MCP-Use is the open source way to connect **any LLM to any MCP server** and build custom agents that have tool access, without using closed source or application clients.
 
 💡 Let developers easily connect any LLM to tools like web browsing, file operations, and more.
 
@@ -26,8 +27,10 @@
 | 🔄 **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 |
 
 
 # Quick start
@@ -349,7 +352,7 @@ This example demonstrates how to connect to an MCP server running on a specific
 
 # Multi-Server Support
 
-MCP-Use supports working with multiple MCP servers simultaneously, allowing you to combine tools from different servers in a single agent. This is useful for complex tasks that require multiple capabilities, such as web browsing combined with file operations or 3D modeling.
+MCP-Use allows configuring and connecting to multiple MCP servers simultaneously using the `MCPClient`. This enables complex workflows that require tools from different servers, such as web browsing combined with file operations or 3D modeling.
 
 ## Configuration
 
@@ -375,7 +378,28 @@ You can configure multiple servers in your configuration file:
 
 ## Usage
 
-The `MCPClient` class provides several methods for managing multiple servers:
+The `MCPClient` class provides methods for managing connections to multiple servers. When creating an `MCPAgent`, you can provide an `MCPClient` configured with multiple servers.
+
+By default, the agent will have access to tools from all configured servers. If you need to target a specific server for a particular task, you can specify the `server_name` when calling the `agent.run()` method.
+
+```python
+# Example: Manually selecting a server for a specific task
+result = await agent.run(
+    "Search for Airbnb listings in Barcelona",
+    server_name="airbnb" # Explicitly use the airbnb server
+)
+
+result_google = await agent.run(
+    "Find restaurants near the first result using Google Search",
+    server_name="playwright" # Explicitly use the playwright server
+)
+```
+
+## Dynamic Server Selection (Server Manager)
+
+For enhanced efficiency and to reduce potential agent confusion when dealing with many tools from different servers, you can enable the Server Manager by setting `use_server_manager=True` during `MCPAgent` initialization.
+
+When enabled, the agent intelligently selects the correct MCP server based on the tool chosen by the LLM for a specific step. This minimizes unnecessary connections and ensures the agent uses the appropriate tools for the task.
 
 ```python
 import asyncio
@@ -389,7 +413,8 @@ async def main():
     # Create agent with the client
     agent = MCPAgent(
         llm=ChatAnthropic(model="claude-3-5-sonnet-20240620"),
-        client=client
+        client=client,
+        use_server_manager=True  # Enable the Server Manager
     )
 
     try:
@@ -440,6 +465,98 @@ if __name__ == "__main__":
     asyncio.run(main())
 ```
 
+# Build a Custom Agent:
+
+You can also build your own custom agent using the LangChain adapter:
+
+```python
+import asyncio
+from langchain_openai import ChatOpenAI
+from mcp_use.client import MCPClient
+from mcp_use.adapters.langchain_adapter import LangChainAdapter
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+async def main():
+    # Initialize MCP client
+    client = MCPClient.from_config_file("examples/browser_mcp.json")
+    llm = ChatOpenAI(model="gpt-4o")
+
+    # Create adapter instance
+    adapter = LangChainAdapter()
+    # Get LangChain tools with a single line
+    tools = await adapter.create_tools(client)
+
+    # Create a custom LangChain agent
+    llm_with_tools = llm.bind_tools(tools)
+    result = await llm_with_tools.ainvoke("What tools do you have avilable ? ")
+    print(result)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+
+```
+
+# Debugging
+
+MCP-Use provides a built-in debug mode that increases log verbosity and helps diagnose issues in your agent implementation.
+
+## Enabling Debug Mode
+
+There are two primary ways to enable debug mode:
+
+### 1. Environment Variable (Recommended for One-off Runs)
+
+Run your script with the `DEBUG` environment variable set to the desired level:
+
+```bash
+# Level 1: Show INFO level messages
+DEBUG=1 python3.11 examples/browser_use.py
+
+# Level 2: Show DEBUG level messages (full verbose output)
+DEBUG=2 python3.11 examples/browser_use.py
+```
+
+This sets the debug level only for the duration of that specific Python process.
+
+Alternatively you can set the following environment variable to the desired logging level:
+
+```bash
+export MCP_USE_DEBUG=1 # or 2
+```
+
+### 2. Setting the Debug Flag Programmatically
+
+You can set the global debug flag directly in your code:
+
+```python
+import mcp_use
+
+mcp_use.set_debug(1)  # INFO level
+# or
+mcp_use.set_debug(2)  # DEBUG level (full verbose output)
+```
+
+### 3. Agent-Specific Verbosity
+
+If you only want to see debug information from the agent without enabling full debug logging, you can set the `verbose` parameter when creating an MCPAgent:
+
+```python
+# Create agent with increased verbosity
+agent = MCPAgent(
+    llm=your_llm,
+    client=your_client,
+    verbose=True  # Only shows debug messages from the agent
+)
+```
+
+This is useful when you only need to see the agent's steps and decision-making process without all the low-level debug information from other components.
+
+
 # Roadmap
 
 <ul>
@@ -448,6 +565,10 @@ if __name__ == "__main__":
 <li>[ ] ... </li>
 </ul>
 
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=pietrozullo/mcp-use&type=Date)](https://www.star-history.com/#pietrozullo/mcp-use&Date)
+
 # Contributing
 
 We love contributions! Feel free to open issues for bugs or feature requests.

{mcp_use-1.1.5 → mcp_use-1.2.6}/docs/api-reference/introduction.mdx

@@ -128,7 +128,8 @@ agent = MCPAgent(
     system_prompt=None,
     system_prompt_template=None,
     additional_instructions=None,
-    disallowed_tools=None
+    disallowed_tools=None,
+    use_server_manager=False
 )
 ```
 
@@ -146,6 +147,7 @@ agent = MCPAgent(
 | `additional_instructions` | str                 | No       | None    | Additional instructions for the agent                        |
 | `session_options`         | dict                | No       | {}      | Additional options for session creation                      |
 | `output_parser`           | OutputParser        | No       | None    | Custom output parser for LLM responses                       |
+| `use_server_manager`      | bool                | No       | False   | If `True`, enables automatic selection of the appropriate server based on the chosen tool when multiple servers are configured via `MCPClient`. |
 | `disallowed_tools`        | list[str]           | No       | None    | List of tool names that should not be available to the agent |
 
 **When to use different parameters**:
@@ -178,6 +180,9 @@ agent = MCPAgent(
 - **session_options**:
   - Customize timeout for long-running server operations
   - Set retry parameters for unstable connections
+- **use_server_manager**:
+  - Set to `True` when using an `MCPClient` configured with multiple servers to enable efficient, automatic server selection per tool call. This can reduce agent confusion and minimize unnecessary server connections.
+  - Keep as `False` (default) if using a single server or if you prefer to manually specify the target server using the `server_name` parameter in `agent.run()` or rely on the agent to handle tool availability across all connected servers.
 - **disallowed_tools**:
   - Use to restrict which tools the agent can access
   - Helpful for security or to limit agent capabilities

mcp_use-1.2.6/docs/building-custom-agents.mdx

@@ -0,0 +1,175 @@
+---
+title: Building Custom Agents
+description: Learn how to build custom agents using MCPClient and integrate tools with different agent frameworks
+---
+
+# Building Custom Agents
+
+MCP-Use provides flexible options for building custom agents that can utilize MCP tools. This guide will show you how to create your own agents by leveraging the existing adapters, particularly focusing on the LangChain adapter.
+
+## Overview
+
+MCP-Use allows you to:
+
+1. Access powerful tools from MCP through connectors
+2. Convert those tools to different frameworks using adapters
+3. Build custom agents that utilize these tools
+
+While MCP-Use provides a built-in `MCPAgent` class, you may want to create your own custom agent implementation for more flexibility or to integrate with other frameworks.
+
+## Using the LangChain Adapter
+
+The `LangChainAdapter` is a powerful component that converts MCP tools to LangChain tools, enabling you to use MCP tools with any LangChain-compatible agent.
+
+### Basic Example
+
+Here's a simple example of creating a custom agent using the LangChain adapter with the simplified API:
+
+```python
+import asyncio
+from langchain_openai import ChatOpenAI
+from langchain.agents import AgentExecutor, create_tool_calling_agent
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+from mcp_use.client import MCPClient
+from mcp_use.adapters import LangChainAdapter
+
+async def main():
+    # Initialize the MCP client
+    client = MCPClient.from_config_file("path/to/config.json")
+
+    # Create adapter instance
+    adapter = LangChainAdapter()
+
+    # Get LangChain tools directly from the client with a single line
+    tools = await adapter.create_tools(client)
+
+    # Initialize your language model
+    llm = ChatOpenAI(model="gpt-4o")
+
+    # Create a prompt template
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are a helpful assistant with access to powerful tools."),
+        MessagesPlaceholder(variable_name="chat_history"),
+        ("human", "{input}"),
+        MessagesPlaceholder(variable_name="agent_scratchpad"),
+    ])
+
+    # Create the agent
+    agent = create_tool_calling_agent(llm=llm, tools=tools, prompt=prompt)
+
+    # Create the agent executor
+    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+    # Run the agent
+    result = await agent_executor.ainvoke({"input": "What can you do?"})
+    print(result["output"])
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Note how the API simplifies tool creation - all you need is to create an adapter instance and call its `create_tools` method:
+```python
+adapter = LangChainAdapter()
+tools = await adapter.create_tools(client)
+```
+
+You don't need to worry about sessions, connectors, or initialization. The adapter handles everything for you.
+
+## Contributing New Adapters
+
+MCP-Use welcomes contributions for integrating with different agent frameworks. The adapter architecture is designed to make this process straightforward.
+
+### Adapter Architecture
+
+MCP-Use provides a `BaseAdapter` abstract class that handles most of the common functionality:
+- Managing tool caching
+- Loading tools from connectors
+- Handling connector initialization
+- Iterating through tools from multiple connectors
+
+To create an adapter for a new framework, you only need to implement one required method:
+
+- `_convert_tool`: Convert a single MCP tool to your framework's tool format
+
+### Creating a New Adapter
+
+Here's a simple template for creating a new adapter:
+
+```python
+from typing import Any
+
+from mcp_use.adapters.base import BaseAdapter
+from mcp_use.connectors.base import BaseConnector
+from your_framework import YourFrameworkTool  # Import your framework's tool class
+
+class YourFrameworkAdapter(BaseAdapter):
+    """Adapter for converting MCP tools to YourFramework tools."""
+
+    def _convert_tool(self, mcp_tool: dict[str, Any], connector: BaseConnector) -> YourFrameworkTool:
+        """Convert an MCP tool to your framework's tool format.
+
+        Args:
+            mcp_tool: The MCP tool to convert.
+            connector: The connector that provides this tool.
+
+        Returns:
+            A tool in your framework's format, or None if conversion failed.
+        """
+        try:
+            # Implement your framework-specific conversion logic
+            converted_tool = YourFrameworkTool(
+                name=mcp_tool.name,
+                description=mcp_tool.description,
+                # Map the MCP tool properties to your framework's tool properties
+                # You might need custom handling for argument schemas, function execution, etc.
+            )
+
+            return converted_tool
+        except Exception as e:
+            self.logger.error(f"Error converting tool {mcp_tool.name}: {e}")
+            return None
+```
+
+### Using Your Custom Adapter
+
+Once you've implemented your adapter, you can use it with the simplified API:
+
+```python
+from your_module import YourFrameworkAdapter
+from mcp_use.client import MCPClient
+
+# Initialize the client
+client = MCPClient.from_config_file("config.json")
+
+# Create an adapter instance
+adapter = YourFrameworkAdapter()
+
+# Get tools with a single line
+tools = await adapter.create_tools(client)
+
+# Use the tools with your framework
+agent = your_framework.create_agent(tools=tools)
+```
+
+### Tips for Implementing an Adapter
+
+1. **Schema Conversion**: Most frameworks have their own way of handling argument schemas. You'll need to convert the MCP tool's JSON Schema to your framework's format.
+
+2. **Tool Execution**: When a tool is called in your framework, you'll need to pass the call to the connector's `call_tool` method and handle the result.
+
+3. **Result Parsing**: MCP tools return structured data with types like text, images, or embedded resources. Your adapter should parse these into a format your framework understands.
+
+4. **Error Handling**: Ensure your adapter handles errors gracefully, both during tool conversion and execution.
+
+
+## Conclusion
+
+Building custom agents with MCP-Use offers tremendous flexibility while leveraging the power of MCP tools. By combining different connectors and adapters, you can create specialized agents tailored to specific tasks or integrate MCP capabilities into existing agent frameworks.
+
+The adapter architecture makes it easy to extend MCP-Use to support new frameworks - you just need to implement the `_convert_tool` method to bridge between MCP tools and your framework of choice.
+
+With the simplified API, you can create tools for your framework directly from an MCPClient by instantiating the appropriate adapter and calling its `create_tools` method, hiding all the complexity of session and connector management.
+
+We welcome contributions to expand the adapter ecosystem - if you develop an adapter for a new framework, please consider contributing it back to the project!

{mcp_use-1.1.5 → mcp_use-1.2.6}/docs/docs.json

@@ -15,19 +15,32 @@
         "groups": [
           {
             "group": "Getting Started",
-            "pages": ["introduction", "quickstart"]
+            "pages": [
+              "introduction",
+              "quickstart"
+            ]
           },
           {
             "group": "Essentials",
-            "pages": ["essentials/configuration", "essentials/llm-integration"]
+            "pages": [
+              "essentials/configuration",
+              "essentials/llm-integration",
+              "essentials/debugging",
+              "essentials/connection-types",
+              "building-custom-agents"
+            ]
           },
           {
             "group": "API Reference",
-            "pages": ["api-reference/introduction"]
+            "pages": [
+              "api-reference/introduction"
+            ]
           },
           {
             "group": "Development",
-            "pages": ["development"]
+            "pages": [
+              "development"
+            ]
           }
         ]
       }

{mcp_use-1.1.5 → mcp_use-1.2.6}/docs/essentials/configuration.mdx

@@ -66,7 +66,7 @@ The configuration is defined in a JSON file with the following structure:
 }
 ```
 
-MCP servers can use different connection types (STDIO, HTTP, or WebSocket). For details on these connection types and how to configure them, see the [Connection Types](./connection-types) guide.
+MCP servers can use different connection types (STDIO, HTTP). For details on these connection types and how to configure them, see the [Connection Types](./connection-types) guide.
 
 ### Configuration Options