---
schema: rendered-html/v1
title: "Pydantic AI 🤝 FastMCP - FastMCP"
source_url: https://gofastmcp.com/integrations/pydantic-ai
generated_at: 2026-06-11T19:38:03.258396+00:00
---




[FastMCP home page![light logo](images/gofastmcp__com__integrations__pydantic-ai__wordmark.avif)![dark logo](images/gofastmcp__com__integrations__pydantic-ai__wordmark-white.avif)](gofastmcp__com.md)







AI SDKs

Pydantic AI 🤝 FastMCP



















  - [Anthropic API](gofastmcp__com__integrations__anthropic.md)
  - [Gemini SDK](gofastmcp__com__integrations__gemini.md)
  - [OpenAI API](gofastmcp__com__integrations__openai.md)
  - [Pydantic AI](/integrations/pydantic-ai)




- [Install](#install)
- [Create a Server](#create-a-server)
- [In-Memory](#in-memory)
- [Streamable HTTP](#streamable-http)
- [STDIO](#stdio)
- [MCP Configuration](#mcp-configuration)
- [Authentication](#authentication)

AI SDKs

# Pydantic AI 🤝 FastMCP


Connect FastMCP servers to Pydantic AI agents using the FastMCPToolset


[Pydantic AI](https://ai.pydantic.dev/) ships a [`FastMCPToolset`](https://ai.pydantic.dev/mcp/fastmcp-client/) that lets a Pydantic AI agent call tools exposed by any MCP server through the [FastMCP Client](gofastmcp__com__clients__client.md). Because the toolset is built on the FastMCP Client, it works with FastMCP servers as well as any other MCP server, and supports the full range of [transports](gofastmcp__com__clients__transports.md): in-memory, STDIO, Streamable HTTP, and SSE.
This page shows how to point `FastMCPToolset` at a FastMCP server, with examples for each transport. For the toolset’s full API, see the [Pydantic AI documentation](https://ai.pydantic.dev/mcp/fastmcp-client/).

The `FastMCPToolset` currently exposes **tools** to the agent. Other MCP features such as elicitation and sampling are not yet supported through this toolset; use Pydantic AI’s standard [`MCPServer`](https://ai.pydantic.dev/mcp/client/) client if you need them.

## [​](#install) Install

`FastMCPToolset` lives in `pydantic-ai-slim` behind the `fastmcp` optional group:

pip install "pydantic-ai-slim[fastmcp]"

## [​](#create-a-server) Create a Server

Create a FastMCP server with the tools you want to expose. We’ll use a single dice-rolling tool throughout this guide.


import random

mcp = FastMCP(name="Dice Roller")

def roll_dice(n_dice: int) -> list[int]:
    """Roll `n_dice` 6-sided dice and return the results."""
    return [random.randint(1, 6) for _ in range(n_dice)]

    mcp.run(transport="http", port=8000)

## [​](#in-memory) In-Memory

If your FastMCP server lives in the same process as your agent, pass the `FastMCP` instance directly. The toolset reuses an [in-memory transport](gofastmcp__com__clients__transports.md), which avoids a network round trip and is the fastest option for tests and embedded use.

import asyncio
import random
from pydantic_ai import Agent
from pydantic_ai.toolsets.fastmcp import FastMCPToolset

mcp = FastMCP(name="Dice Roller")

def roll_dice(n_dice: int) -> list[int]:
    return [random.randint(1, 6) for _ in range(n_dice)]

toolset = FastMCPToolset(mcp)
agent = Agent("openai:gpt-4.1", toolsets=[toolset])

async def main():
    result = await agent.run("Roll 3 dice!")
    print(result.output)

    asyncio.run(main())

## [​](#streamable-http) Streamable HTTP

For a remote FastMCP server reachable over HTTP, pass the URL as a string. The toolset infers the [Streamable HTTP transport](gofastmcp__com__clients__transports.md) from the URL.

from pydantic_ai import Agent
from pydantic_ai.toolsets.fastmcp import FastMCPToolset

toolset = FastMCPToolset("https://your-server-url.com/mcp")
agent = Agent("openai:gpt-4.1", toolsets=[toolset])

For [SSE](gofastmcp__com__clients__transports.md), use a `/sse` URL instead.

## [​](#stdio) STDIO

To launch a FastMCP server as a subprocess, pass a script path and the toolset will use the [STDIO transport](gofastmcp__com__clients__transports.md).

from pydantic_ai import Agent
from pydantic_ai.toolsets.fastmcp import FastMCPToolset

toolset = FastMCPToolset("server.py")
agent = Agent("openai:gpt-4.1", toolsets=[toolset])

You can also pass a [`StdioTransport`](gofastmcp__com__clients__transports.md) directly when you need control over the command, args, or environment.

## [​](#mcp-configuration) MCP Configuration

To wire up multiple servers at once, pass an [MCP configuration](gofastmcp__com__integrations__mcp-json-configuration.md) dictionary. The toolset opens one client per server and exposes all of their tools to the agent.

from pydantic_ai import Agent
from pydantic_ai.toolsets.fastmcp import FastMCPToolset

mcp_config = {
    "mcpServers": {
        "dice": {"command": "python", "args": ["server.py"]},
        "weather": {"url": "https://weather.example.com/mcp"},

toolset = FastMCPToolset(mcp_config)
agent = Agent("openai:gpt-4.1", toolsets=[toolset])

## [​](#authentication) Authentication

Because `FastMCPToolset` wraps a [FastMCP `Client`](gofastmcp__com__clients__client.md), it inherits the client’s full [authentication](gofastmcp__com__clients__auth__bearer.md) story. To pass credentials such as a bearer token to a remote server, build a `Client` (or `StreamableHttpTransport`) yourself and hand it to the toolset.

from fastmcp.client.transports import StreamableHttpTransport
from pydantic_ai import Agent
from pydantic_ai.toolsets.fastmcp import FastMCPToolset

transport = StreamableHttpTransport(
    url="https://your-server-url.com/mcp",
    headers={"Authorization": "Bearer your-access-token"},

toolset = FastMCPToolset(Client(transport))
agent = Agent("openai:gpt-4.1", toolsets=[toolset])

For OAuth flows, use FastMCP’s [`OAuth` helper](gofastmcp__com__clients__auth__oauth.md) when constructing the `Client`. For server-side token verification, see [Token Verification](gofastmcp__com__servers__auth__token-verification.md).

[OpenAI API 🤝 FastMCP

Previous](gofastmcp__com__integrations__openai.md)[MCP JSON Configuration 🤝 FastMCP

Next](gofastmcp__com__integrations__mcp-json-configuration.md)






