Multiple MCP Servers

Agno’s MCP integration supports connecting an Agent to multiple MCP servers at once. There are two approaches to this:

Using multiple MCPTools instances
Using a single MultiMCPTools instance

MultiMCPTools is deprecated and will be removed in a future version. Use multiple MCPTools instances instead.

Prerequisites

Set up your virtual environment

uv venv --python 3.12
source .venv/bin/activate

uv venv --python 3.12
.venv\Scripts\activate

Install the Python dependencies and Node.js, then verify the runtimes:

uv pip install -U "agno[mcp]" openai
node --version
npx --version

Export the keys used by the examples you run:

export OPENAI_API_KEY="your_openai_api_key_here"
export GOOGLE_MAPS_API_KEY="your_google_maps_api_key_here"
export BRAVE_API_KEY="your_brave_api_key_here"

The @modelcontextprotocol/server-google-maps and @modelcontextprotocol/server-brave-search npm packages are deprecated and no longer supported. The snippets below document these legacy servers. Use maintained MCP servers for new projects.

Using multiple `MCPTools` instances

multiple_mcp_servers.py

import asyncio
import os
from datetime import date, timedelta

from agno.agent import Agent
from agno.tools.mcp import MCPTools


async def run_agent(message: str) -> None:
    """Run the Airbnb and Google Maps agent with the given message."""

    env = {
        **os.environ,
        "GOOGLE_MAPS_API_KEY": os.getenv("GOOGLE_MAPS_API_KEY"),
    }

    # Initialize and connect to multiple MCP servers
    airbnb_tools = MCPTools(command="npx -y @openbnb/mcp-server-airbnb --ignore-robots-txt")
    google_maps_tools = MCPTools(command="npx -y @modelcontextprotocol/server-google-maps", env=env)
    await airbnb_tools.connect()
    await google_maps_tools.connect()

    try:
        agent = Agent(
            tools=[airbnb_tools, google_maps_tools],
            markdown=True,
        )

        await agent.aprint_response(message, stream=True)
    finally:
        await airbnb_tools.close()
        await google_maps_tools.close()


# Example usage
if __name__ == "__main__":
    check_in = date.today() + timedelta(days=30)
    check_out = check_in + timedelta(days=3)
    # Pull request example
    asyncio.run(
        run_agent(
            f"What listings are available in Cape Town for 2 people "
            f"from {check_in.isoformat()} to {check_out.isoformat()}?"
        )
    )

Using a single `MultiMCPTools` instance

multiple_mcp_servers.py

import asyncio
import os
from datetime import date, timedelta

from agno.agent import Agent
from agno.tools.mcp import MultiMCPTools


async def run_agent(message: str) -> None:
    """Run the Airbnb and Google Maps agent with the given message."""

    env = {
        **os.environ,
        "GOOGLE_MAPS_API_KEY": os.getenv("GOOGLE_MAPS_API_KEY"),
    }

    # Initialize and connect to multiple MCP servers
    mcp_tools = MultiMCPTools(
        commands=[
            "npx -y @openbnb/mcp-server-airbnb --ignore-robots-txt",
            "npx -y @modelcontextprotocol/server-google-maps",
        ],
        env=env,
    )
    await mcp_tools.connect()

    try:
        agent = Agent(
            tools=[mcp_tools],
            markdown=True,
        )

        await agent.aprint_response(message, stream=True)
    finally:
        # Always close the connection when done
        await mcp_tools.close()


# Example usage
if __name__ == "__main__":
    check_in = date.today() + timedelta(days=30)
    check_out = check_in + timedelta(days=3)
    # Pull request example
    asyncio.run(
        run_agent(
            f"What listings are available in Cape Town for 2 people "
            f"from {check_in.isoformat()} to {check_out.isoformat()}?"
        )
    )

Allowing partial failures with `MultiMCPTools`

If you are connecting to multiple MCP servers using the MultiMCPTools class, an error will be raised by default if connection to any MCP server fails. If you want to avoid raising in that case, you can set the allow_partial_failure parameter to True. This is useful if you are connecting to MCP servers that are not always available, and don’t want to exit your program if one of the servers is not available.

import asyncio
from datetime import date
from os import getenv

from agno.agent import Agent
from agno.tools.mcp import MultiMCPTools


async def run_agent(message: str) -> None:
    # Initialize the MCP tools
    mcp_tools = MultiMCPTools(
        [
            "npx -y @openbnb/mcp-server-airbnb --ignore-robots-txt",
            "npx -y @modelcontextprotocol/server-brave-search",
        ],
        env={
            "BRAVE_API_KEY": getenv("BRAVE_API_KEY"),
        },
        timeout_seconds=30,
        # Set the allow_partial_failure to True to allow for partial failure connecting to the MCP servers
        allow_partial_failure=True,
    )

    # Connect to the MCP servers
    await mcp_tools.connect()

    # Use the MCP tools with an Agent
    agent = Agent(
        tools=[mcp_tools],
        markdown=True,
    )
    await agent.aprint_response(message)

    # Close the MCP connection
    await mcp_tools.close()


# Example usage
if __name__ == "__main__":
    asyncio.run(
        run_agent(
            f"What listings are available in Barcelona on {date.today().isoformat()}?"
        )
    )
    asyncio.run(run_agent("What's the fastest way to get to Barcelona from London?"))

Avoiding tool name collisions

When using multiple MCP servers, you may encounter tool name collisions. This often happens when the same tool is available in multiple of the servers you are using. To avoid this, you can use the tool_name_prefix parameter. This will add the given prefix to all tool names coming from the MCPTools instance.

import asyncio

from agno.agent import Agent
from agno.tools.mcp import MCPTools


async def run_agent():
    # Development environment tools
    dev_tools = MCPTools(
        transport="streamable-http",
        url="https://docs.agno.com/mcp",
        # By providing this tool_name_prefix, all the tool names will be prefixed with "dev_"
        tool_name_prefix="dev",
    )
    await dev_tools.connect()

    agent = Agent(tools=[dev_tools])
    await agent.aprint_response("Which tools do you have access to? List them all.")

    await dev_tools.close()


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

Get Started

Basics

Advanced

Production

Providers

Other

Additional Resources

Multiple MCP Servers

Prerequisites

Using multiple `MCPTools` instances

Using a single `MultiMCPTools` instance

Allowing partial failures with `MultiMCPTools`

Avoiding tool name collisions

​Prerequisites

​Using multiple MCPTools instances

​Using a single MultiMCPTools instance

​Allowing partial failures with MultiMCPTools

​Avoiding tool name collisions

Prerequisites

Using multiple `MCPTools` instances

Using a single `MultiMCPTools` instance

Allowing partial failures with `MultiMCPTools`

Avoiding tool name collisions