> ## Documentation Index
> Fetch the complete documentation index at: https://docs.praison.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Load MCP Tools

> Wire configured MCP servers into agents with one line

Load MCP tools from your configured servers with a single function call, following the agent-centric design principles.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    subgraph "MCP Tool Loading"
        Config[📋 JSON/TOML Config] --> Load[🔄 load_mcp_tools()]
        Load --> Tools[🧰 MCP Tools]
        Tools --> Agent[🤖 Agent]
    end
    
    classDef config fill:#6366F1,stroke:#7C90A0,color:#fff
    classDef process fill:#F59E0B,stroke:#7C90A0,color:#fff  
    classDef output fill:#10B981,stroke:#7C90A0,color:#fff
    
    class Config config
    class Load process
    class Tools,Agent output
```

## Quick Start

<Steps>
  <Step title="Load All Enabled Servers">
    Wire all enabled MCP servers from your configuration:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonaiagents import Agent
    from praisonaiagents.mcp import load_mcp_tools

    agent = Agent(name="assistant", tools=load_mcp_tools())
    agent.start("List files in /tmp")
    ```
  </Step>

  <Step title="Load Specific Servers">
    Load only the servers you need by name:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonaiagents import Agent
    from praisonaiagents.mcp import load_mcp_tools

    tools = load_mcp_tools(["filesystem", "github"])
    agent = Agent(name="coder", tools=tools)
    agent.start("Read the README file and create a GitHub issue")
    ```
  </Step>
</Steps>

***

## How It Works

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
sequenceDiagram
    participant User
    participant Agent
    participant Loader
    participant Config
    participant MCP
    
    User->>Agent: Request with MCP tools
    Agent->>Loader: load_mcp_tools()
    Loader->>Config: Read ~/.praisonai/mcp/
    Config-->>Loader: Enabled configs
    Loader->>MCP: Create MCP instances
    MCP-->>Loader: Ready tools
    Loader-->>Agent: List of MCP clients
    Agent-->>User: Response with tool results
```

The loader bridges configuration and agent setup by:

1. **Reading configs** from `~/.praisonai/mcp/` directory
2. **Filtering** by enabled status and optional name selection
3. **Converting** each config to an MCP client instance
4. **Returning** ready-to-use tool instances

***

## Configuration Options

| Parameter      | Type              | Default | Description                                                                           |
| -------------- | ----------------- | ------- | ------------------------------------------------------------------------------------- |
| `names`        | `List[str]`       | `None`  | Specific config names to load (None = all enabled)                                    |
| `configs`      | `List[MCPConfig]` | `None`  | Optional injected configs from wrapper TOML loader                                    |
| `prefix_tools` | `bool`            | `True`  | Prefix tool names when multiple servers loaded (collision avoidance — currently stub) |

***

## Common Patterns

### Load All Enabled Servers

The simplest approach - load everything that's enabled:

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent
from praisonaiagents.mcp import load_mcp_tools

agent = Agent(
    name="multi-tool-assistant",
    instructions="Help with various tasks using available tools",
    tools=load_mcp_tools()
)
```

### Load Specific Servers

Target specific capabilities for focused agents:

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent
from praisonaiagents.mcp import load_mcp_tools

# File operations only
file_agent = Agent(
    name="file-assistant", 
    tools=load_mcp_tools(["filesystem"])
)

# Development tools
dev_agent = Agent(
    name="dev-assistant",
    tools=load_mcp_tools(["filesystem", "github", "postgres"])
)
```

### Inject Configs from TOML

Advanced usage with wrapper TOML loading:

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent
from praisonaiagents.mcp import load_mcp_tools
from praisonai.cli.configuration import get_config_loader

# Load from wrapper TOML config
loader = get_config_loader()
config = loader.load()
toml_configs = [MCPConfig(...) for server in config.mcp.servers]

# Use injected configs
tools = load_mcp_tools(configs=toml_configs)
agent = Agent(name="toml-configured", tools=tools)
```

***

## Best Practices

<AccordionGroup>
  <Accordion title="Configure Once, Use Everywhere">
    Set up your MCP servers once using `praisonai mcp create`, then any agent can pick them up automatically via `load_mcp_tools()`. This follows the "configure once, use everywhere" principle.
  </Accordion>

  <Accordion title="Filter by Purpose">
    Use specific server names rather than loading everything. A file processing agent only needs `["filesystem"]`, while a development agent might need `["filesystem", "github", "postgres"]`.
  </Accordion>

  <Accordion title="Handle Missing Configs Gracefully">
    The loader silently skips disabled or missing configs. Always check that your expected servers are enabled with `praisonai mcp list`.
  </Accordion>

  <Accordion title="Tool Name Collision Awareness">
    When loading multiple servers that might have overlapping tool names, be aware that `prefix_tools=True` is currently a stub. Plan your server selection to avoid conflicts.
  </Accordion>
</AccordionGroup>

***

## Related

<CardGroup cols={2}>
  <Card title="MCP Tool Filtering" icon="filter" href="/features/mcp-tool-filtering">
    Restrict which MCP tools an agent can see and call
  </Card>

  <Card title="MCP CLI" icon="terminal" href="/cli/mcp">
    Configure and manage MCP servers from the command line
  </Card>
</CardGroup>