How to Build an MCP Server with FastAPI and Python

A FastAPI-based MCP server lets you use Python's async features to give AI agents access to custom tools and data. While the official MCP SDK handles the core protocol, FastAPI adds the routing, validation, and documentation you need for a production app.

FastAPI is a great choice for MCP because it's built for speed and handles asynchronous tasks easily. This is important when your agent is waiting on API calls or file transfers. Since more teams are moving toward agentic workflows, building your tools on a framework like FastAPI ensures your setup can handle more complexity as you grow.

Helpful references: Fast.io Workspaces, Fast.io Collaboration, and Fast.io AI.

Before you start coding, you need a stable Python environment. This tutorial assumes you are using Python 3.10 or higher so you can use modern type hinting and async features.

Using virtual environments is a best practice that prevents dependency conflicts. You can set up your project with these commands:

Create a project directory: mkdir fast-mcp-server && cd fast-mcp-server 2.

Initialize a virtual environment: python -m venv venv 3.

Activate the environment: source venv/bin/activate (or venv\Scripts\activate on Windows) 4.

Install core dependencies: pip install fastapi uvicorn mcp

You may also want to install the Fast.io Python client if you plan to use persistent storage for your agent's work. Fast.io offers a free agent tier with 50GB of storage and no credit card required, making it a good choice for development and testing.

A fast way to build an MCP server in Python is to wrap the MCP SDK logic within a FastAPI application. This gives you the benefit of FastAPI's documentation while staying compatible with MCP.

Here is a basic implementation of a FastAPI MCP server that exposes a single tool:

from fastapi import FastAPI
from mcp.server.fastapi import FastApiMcpServer

app = FastAPI(title="My Agent Tools")
mcp = FastApiMcpServer(app)

@mcp.tool()
async def calculate_roi(investment: float, return_amount: float) -> str:
    """
    Calculates the Return on Investment (ROI) for an agent's financial analysis.
    """
    roi = ((return_amount - investment) / investment) * 100
    return f"The ROI is {roi:.2f}%"

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

In this example, the @mcp.tool() decorator automatically registers the function so an AI agent can call it. FastAPI handles the incoming requests, while the MCP SDK manages the handshake and message passing.

Start with mcp server fastapi python on Fast.io

Fast.io gives teams shared workspaces, MCP tools, and searchable file context to run mcp server fastapi python workflows with reliable agent and human handoffs.

Sign Up Free

Once your MCP server is running, your agents need a place to work. Standard local storage doesn't work well if your agents need to share results with teammates or save their progress between sessions. Fast.io provides a workspace where your agent's work is easily accessible to the whole team.

Fast.io is more than just a place to store files. When you connect your FastAPI MCP server to a Fast.io workspace, you get over 250 specialized tools ready to use. These tools let your agents manage files, set permissions, and even hand over entire workspaces to human users when the job is done.

Key benefits for MCP agents:

• Free Agent Tier: 50GB of storage and 5,000 monthly credits. No credit card required.
• Intelligence Mode: Files are automatically indexed for semantic search and RAG.
• URL Import: Pull data directly from Google Drive or Dropbox without local downloads.
• File Locks: Stop agents from overwriting each other's work with built-in controls.

Fast.io's streaming is also faster than traditional downloads, which is important when agents are working with large video or audio files.

To test your FastAPI MCP server, you can connect it to the Claude Desktop client. This lets you interact with your Python tools through a natural language interface.

Locate your config file: Open ~/Library/Application Support/Claude/claude_desktop_config.json on macOS. 2.

Add your server: Insert a new entry in the mcpServers object. 3.

Use the SSE transport: Since FastAPI is a web framework, use the SSE (Server-Sent Events) transport type.

{
  "mcpServers": {
    "my-python-server": {
      "command": "python",
      "args": ["/path/to/your/main.py"],
      "env": { "FAST_IO_API_KEY": "your_key_here" }
    }
  }
}

After restarting Claude Desktop, you should see your FastAPI tools listed in the "Search and tools" section. You can then ask Claude to "Calculate the ROI of a $1000 investment that returned $1500," and it will run your Python function.

Great agent workflows do more than just answer questions. By using FastAPI's background tasks with Fast.io webhooks, you can build systems that react to file changes as they happen.

For example, you can set up a webhook to tell your FastAPI server when a client uploads a document. Your agent can then summarize that file and post it as a comment immediately. This keeps the whole team in the loop without anyone having to check for updates manually.

Ownership Transfer is another key feature. An agent can set up a full project, create a branded portal, and then hand ownership over to a person. The agent keeps its access to continue working, but the human user takes control of the billing and organization.