Multi-Server Setup

import asyncio
from langchain_openai import ChatOpenAI
from mcp_use import MCPAgent, MCPClient

async def main():
    # Load multi-server configuration
    client = MCPClient.from_config_file("multi_server_config.json")

    # Create agent (all servers will be connected)
    llm = ChatOpenAI(model="gpt-4")
    agent = MCPAgent(llm=llm, client=client)

    # Agent has access to tools from all servers
    result = await agent.run(
        "Search for Python tutorials online, save the best ones to a file, "
        "then create a database table to track my learning progress"
    )
    print(result)

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

import asyncio
from langchain_openai import ChatOpenAI
from mcp_use import MCPAgent, MCPClient

async def main():
    client = MCPClient.from_config_file("multi_server_config.json")
    llm = ChatOpenAI(model="gpt-4")

    # Enable server manager for dynamic server selection
    agent = MCPAgent(
        llm=llm,
        client=client,
        use_server_manager=True,  # Only connects to servers as needed
        max_steps=30
    )

    # The agent will automatically choose appropriate servers
    result = await agent.run(
        "Research the latest AI papers, summarize them in a markdown file, "
        "and commit the file to my research repository on GitHub"
    )
    print(result)

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

result = await agent.run(
    "Scrape product data from example-store.com, "
    "clean and analyze it with pandas, "
    "then save the results as CSV and Excel files"
)

result = await agent.run(
    "Create a new Python function to calculate fibonacci numbers, "
    "write unit tests for it, run the tests, "
    "and if they pass, commit the changes to the current git branch"
)

import os
import asyncio
from langchain_openai import ChatOpenAI
from mcp_use import MCPClient, MCPAgent

async def create_agent_with_available_servers():
    config = {"mcpServers": {}}

    # Always include filesystem
    config["mcpServers"]["filesystem"] = {
        "command": "mcp-server-filesystem",
        "args": ["/workspace"]
    }

    # Include GitHub server if token is available
    if os.getenv("GITHUB_TOKEN"):
        config["mcpServers"]["github"] = {
            "command": "mcp-server-github",
            "env": {"GITHUB_TOKEN": os.getenv("GITHUB_TOKEN")}
        }

    # Include database server if URL is available
    if os.getenv("DATABASE_URL"):
        config["mcpServers"]["postgres"] = {
            "command": "mcp-server-postgres",
            "env": {"DATABASE_URL": os.getenv("DATABASE_URL")}
        }

    client = MCPClient(config)
    return MCPAgent(llm=ChatOpenAI(model="gpt-4"), client=client)

# Restrict to specific tool types
agent = MCPAgent(
    llm=llm,
    client=client,
    allowed_tools=["file_read", "file_write", "web_search"],
    disallowed_tools=["system_exec", "network_request"]
)

# Or filter by server
agent = MCPAgent(
    llm=llm,
    client=client,
    allowed_servers=["filesystem", "playwright"],
    use_server_manager=True
)

import logging
from mcp_use import MCPAgent, MCPClient
from langchain_openai import ChatOpenAI

# Enable debug logging
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

# Create client with debug mode
client = MCPClient.from_config_file(
    "multi_server_config.json",
    debug=True,
    timeout=30  # Increase timeout for debugging
)

llm = ChatOpenAI(model="gpt-4")

# Create agent with verbose output
agent = MCPAgent(
    llm=llm,
    client=client,
    use_server_manager=True,
    debug=True,
    verbose=True
)