MCP Use

🚀 MCP-Use Usage Guide

This guide provides a detailed introduction to the MCP-Use library, including installation, usage examples, detailed instructions, and more.

🚀 Quick Start

📦 Installation

You can install the mcp-use library using the following command:

pip install mcp-use

💻 Basic Usage

Here is a simple example to help you get started quickly:

import asyncio
from mcp_use.client import MCPClient
from mcp_use.adapters.langchain_adapter import LangChainAdapter
from dotenv import load_dotenv

load_dotenv()

async def main():
    client = MCPClient.from_config_file("examples/browser_mcp.json")
    adapter = LangChainAdapter()
    tools = await adapter.create_tools(client)
    
    # Create an LLM bound to tools
    llm_with_tools = llm.bind_tools(tools)
    result = await llm_with_tools.ainvoke("What tools can you use?")
    print(result)

if __name__ == "__main__":
    asyncio.run(main())

💻 Usage Examples

Using Multiple MCP Services

import asyncio
from mcp_use.client import MCPClient
from langchain_openai import ChatOpenAI

async def main():
    client = MCPClient.from_config_files(
        config_files=["config1.json", "config2.json"]
    )
    
    # Create a proxy
    async with client:
        llm = ChatOpenAI(model="gpt-4")
        tools = await client.get_tools()
        
        # Use all available tools
        result = await llm.invoke("What can you do?", tools=tools)
        print(result)

asyncio.run(main())

Connecting to MCP Services via HTTP

import asyncio
from mcp_use.client import MCPClient
from langchain_openai import ChatOpenAI

async def main():
    client = MCPClient.from_url("ws://localhost:3000/ws")
    
    async with client:
        llm = ChatOpenAI(model="gpt-4")
        tools = await client.get_tools()
        
        result = await llm.invoke("What tools can you use?", tools=tools)
        print(result)

asyncio.run(main())

Customizing Adapters

import asyncio
from mcp_use.client import MCPClient, BaseMCPAdapter
from typing import Any

class CustomAdapter(BaseMCPAdapter):
    async def get_action(self, observation: Any) -> str:
        # Implement custom logic
        pass
    
async def main():
    client = MCPClient.from_config_file("config.json")
    
    adapter = CustomAdapter()
    async with client:
        action = await adapter.get_action("Observation result")
        print(action)

asyncio.run(main())

📚 Documentation

Quick Start

1. Install Dependencies

pip install mcp-use langchain openai anthropic playwright

2. Create a Configuration File Here is an example of the content of config.json:

{
    "browser": {
        "type": "playwright",
        "args": {"headless": false}
    },
    "file_system": {
        "root": "./data"
    }
}

Configuring the MCP Client

• Load Configuration from a File

  client = MCPClient.from_config_file("config.json")
  

• Load Configuration from a URL

  client = MCPClient.from_url("ws://localhost:3000/ws")
  

Creating a Proxy

async with client:
    # Get available tools
    tools = await client.get_tools()
    
    # Use the OpenAI model
    llm = ChatOpenAI(model="gpt-4")
    result = await llm.invoke("Task description", tools=tools)

Client API

• MCPClient: Manages connections to multiple MCP services.
• BaseMCPAdapter: Defines the adapter interface for interacting with different MCP implementations.

Tool Examples

from mcp_use.tools import (
    Tool,
    BrowserTool,
    FileSystemTool,
    DatabaseTool,
    SearchEngineTool
)

🔧 Advanced Features

Concurrent Execution

import asyncio
from mcp_use.client import MCPClient
from langchain_openai import ChatOpenAI

async def main():
    client = MCPClient.from_config_file("config.json")
    
    async with client:
        # Create multiple tasks
        tasks = []
        for i in range(5):
            task = asyncio.create_task(client.request(f"Request {i+1}"))
            tasks.append(task)
        
        # Wait for all tasks to complete
        results = await asyncio.gather(*tasks)
        print(results)

asyncio.run(main())

Extending the Toolset

from mcp_use import Tool

class CustomTool(Tool):
    def __init__(self, custom_param: str):
        super().__init__()
        self.custom_param = custom_param
    
    async def execute(self, command: str) -> str:
        # Custom logic
        return f"Custom tool execution result: {command}"

🐞 Debugging and Troubleshooting

Enabling Debug Logs

export MCP_USE_DEBUG=1

Common Issues

• Connection Issues: Check the network and the status of the target service.
• Permission Issues: Ensure you have sufficient permissions to access resources.

🤝 Contributing to the Project

Submitting Code

1. Fork the repository.
2. Create a new branch.
3. Commit your changes.
4. Push to the remote repository.
5. Submit a Pull Request.

👥 Community Support

Join the community Discord:

https://discord.gg/example

📄 License

This project is licensed under the MIT License.

👨‍💻 Contributors

• Developer: [Your Name]
• Contributor List: [contributor1], [contributor2]