from mcp_use import MCPClient

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

from mcp_use import MCPClient

config = {
  "mcpServers": {
    "my_server": {
      "command": "npx",
      "args": ["@my-mcp/server"],
      "env": {
        "PORT": "3000"
      }
    }
  }
}

client = MCPClient.from_dict(config=config)

from mcp_use import MCPClient
from mcp_use.types.sandbox import SandboxOptions

# Define sandbox options
sandbox_options: SandboxOptions = {
    "api_key": "your_e2b_api_key",
    "sandbox_template_id": "code-interpreter-v1"
}

# Create client with sandboxed mode enabled
client = MCPClient.from_config_file(
    config_path="config.json",
    sandbox=True,
    sandbox_options=sandbox_options
)

session = await client.create_session(server_name="my_server")

await client.close_session(session_id="session_id")

await client.close_all_sessions()

server = client.get_server(name="my_server")

from mcp_use import MCPAgent, MCPClient
from langchain_openai import ChatOpenAI

agent = MCPAgent(
    llm=ChatOpenAI(model="gpt-4o", temperature=0.7),
    client=MCPClient.from_config_file("config.json"),
    max_steps=30,
    session_options={"timeout": 60.0},
    auto_initialize=True,
    memory_enabled=True,
    system_prompt=None,
    system_prompt_template=None,
    additional_instructions=None,
    disallowed_tools=None,
    use_server_manager=False
)

result = await agent.run(
    query="Find information about Python libraries",
    max_steps=25,
    stop_on_first_result=False
)

agent.reset()

history = agent.get_history()

agent.set_disallowed_tools(["tool1", "tool2"])

disallowed = agent.get_disallowed_tools()

{
  "mcpServers": {
    "server_name": {
      "command": "command_to_run",
      "args": ["arg1", "arg2"],
      "env": {
        "ENV_VAR": "value"
      },
      "timeout": 30.0,
      "retry": {
        "max_attempts": 3,
        "backoff_factor": 1.5
      }
    }
  }
}

from mcp_use.exceptions import MCPConnectionError, MCPTimeoutError

try:
    result = await agent.run("Find information")
except MCPConnectionError:
    # Handle connection issues
    print("Failed to connect to the MCP server")
except MCPTimeoutError:
    # Handle timeout issues
    print("Operation timed out")
except Exception as e:
    # Handle other exceptions
    print(f"An error occurred: {e}")

from mcp_use import MCPClient, MCPAgent
from langchain_openai import ChatOpenAI

# Create client with multiple servers
client = MCPClient.from_dict({
    "mcpServers": {
        "browser": {
            "command": "npx",
            "args": ["@playwright/mcp@latest"]
        },
        "custom_server": {
            "command": "python",
            "args": ["-m", "my_custom_mcp_server"]
        }
    }
})

# Create agent
agent = MCPAgent(llm=ChatOpenAI(model="gpt-4o"), client=client)

# Run with specific server
result_browser = await agent.run(
    "Search the web for Python libraries",
    server_name="browser"
)

# Run with different server
result_custom = await agent.run(
    "Perform custom operation",
    server_name="custom_server"
)

from langchain.schema import OutputParser
from mcp_use import MCPAgent, MCPClient

class CustomOutputParser(OutputParser):
    def parse(self, text):
        # Custom parsing logic
        return processed_result

# Use the custom parser
agent = MCPAgent(
    llm=llm,
    client=client,
    output_parser=CustomOutputParser()
)

from mcp_use import MCPAgent, MCPClient
from langchain_openai import ChatOpenAI

# Create agent with restricted tools
agent = MCPAgent(
    llm=ChatOpenAI(model="gpt-4o"),
    client=client,
    disallowed_tools=["file_system", "network", "shell"]  # Restrict potentially dangerous tools
)

# Update restrictions after initialization
agent.set_disallowed_tools(["file_system", "network", "shell", "database"])
await agent.initialize()  # Reinitialize to apply changes

# Check current restrictions
restricted_tools = agent.get_disallowed_tools()
print(f"Restricted tools: {restricted_tools}")

import os
from dotenv import load_dotenv
from mcp_use import MCPClient, MCPAgent
from mcp_use.types.sandbox import SandboxOptions
from langchain_anthropic import ChatAnthropic

# Load environment variables
load_dotenv()

# Define sandbox options
sandbox_options: SandboxOptions = {
    "api_key": os.getenv("E2B_API_KEY"),
    "sandbox_template_id": "code-interpreter-v1"
}

# Create client with multiple sandboxed servers
client = MCPClient.from_dict(
    {
        "mcpServers": {
            "browser": {
                "command": "npx",
                "args": ["@playwright/mcp@latest"]
            },
            "command": {
                "command": "npx",
                "args": ["-y", "@modelcontextprotocol/server-everything"]
            }
        }
    },
    is_sandboxed=True,
    sandbox_options=sandbox_options
)

# Create agent with server manager enabled
agent = MCPAgent(
    llm=ChatAnthropic(model="claude-3-5-sonnet"),
    client=client,
    use_server_manager=True  # Automatically selects the appropriate server
)

# Run a task that will use tools from both servers
result = await agent.run(
    "Search for information about Python and then use the command line to check the latest version"
)

from mcp_use.exceptions import MCPConnectionError, MCPTimeoutError

try:
    result = await agent.run("Find information")
except MCPConnectionError:
    # Handle connection issues
    print("Failed to connect to the MCP server")
except MCPTimeoutError:
    # Handle timeout issues
    print("Operation timed out")
except Exception as e:
    # Handle other exceptions
    print(f"An error occurred: {e}")