AI models like Claude are incredibly capable, but they achieve their true potential when connected to your unique tools and data sources. This allows them to move beyond general knowledge and perform specific, high-value tasks within your organization's ecosystem. The question is: how do you expose your internal APIs to these models safely and efficiently?

The answer is a standardized approach called the Model Context Protocol (MCP). It's a specification that lets your application communicate its capabilities to an AI. This guide will show you how to build a robust MCP server using FastAPI and the fastapi_mcp library, transforming your existing API into a powerful extension for any MCP-compatible AI.

What is the Model Context Protocol (MCP)?

Think of the Model Context Protocol (MCP) as an OpenAPI or Swagger specification, but designed specifically for AI models. It defines a standard way for a server to describe a set of "tools" (your API endpoints) that an AI can use. It informs the model about the available functions, the required inputs, and the expected outputs.

This standardization is a game-changer. It creates a common language between AI agents and tool providers, enabling models to securely and reliably discover and interact with APIs. Instead of building custom, one-off integrations for every AI model, you can expose one MCP endpoint that any compliant model can use.

The interaction flow between an AI model and an MCP server.

Why Integrate MCP with Your Existing FastAPI App?

A common temptation is to build a dedicated, standalone server just for MCP. I'd argue against this. The best strategy is to integrate MCP directly into your existing FastAPI application. This approach has several distinct advantages:

Code Reuse: You don't need to rewrite your business logic. Your existing API endpoints, data models, and helper functions become the foundation for your MCP tools.
Unified Infrastructure: You manage, deploy, and scale a single application. This simplifies your CI/CD pipeline, monitoring, and overall operational overhead.
Consistent Authentication: Your MCP endpoints can be protected by the same authentication and authorization middleware you already trust for your regular API.

The fastapi_mcp library is a lightweight tool that integrates smoothly with FastAPI. From my experience, it's more elegant and easier to set up than some alternatives, and its support for FastAPI's hot-reload feature makes for a fantastic development workflow.

How to Build Your MCP Server: A Step-by-Step Guide

Let's build a practical MCP server. This server will expose a couple of internal API endpoints as tools for an AI model.

Prerequisites

Python 3.11 or newer.
uv, a fast Python package installer and manager from Astral.

Step 1: Set Up Your Project

First, initialize a new project and create a virtual environment using uv.

# Create a new directory for your project
mkdir my-mcp-server && cd my-mcp-server

# Initialize a new virtual environment
uv venv

With the environment activated, add your core dependencies.

# Add FastAPI, the MCP library, and python-dotenv
uv add fastapi
uv add fastapi-mcp
uv add python-dotenv

For development, you'll need uvicorn to run the server. Add it as a development dependency.

# Add uvicorn as a dev dependency
uv add --dev uvicorn

You'll also need a .env file to manage sensitive information, such as API keys. Create a file named .env in your project root:

# Generate a secure random string for this token in a real project
INTERNAL_TOKEN="your-super-secret-token"

Step 2: Create the Core FastAPI Application

Now, let's write the code. Create a file named main.py. We'll start with a basic FastAPI application and then layer in the MCP functionality.

# main.py
import os
from typing import Optional, Dict, Any
from fastapi import FastAPI, Depends, HTTPException, Request
from pydantic import BaseModel
from dotenv import load_dotenv

# Load environment variables from the .env file
load_dotenv()

app = FastAPI(
    title="Apxml Awesome MCP",
    description="API services for internal use.",
)

@app.get("/")
async def root():
    return {"message": "Server is running"}

You can run this server with Uvicorn and uv. The --reload flag will automatically restart the server whenever you make changes to the code.

uv run uvicorn main:app --reload

Step 3: Add and Expose Tools

Now, let's define the functions we want to expose as tools. These are just regular FastAPI endpoints. The key is to use a descriptive operation_id and, most importantly, the description. The quality of your description is important, as it's the main piece of information the LLM uses to decide which tool is appropriate for a given task. A clear and accurate description directly impacts the model's performance.

# main.py (continued)

class Order(BaseModel):
    order_id: str
    customer_id: int
    status: str
    total_amount: float
    currency: str

class Customer(BaseModel):
    customer_id: int
    name: str
    email: str
    join_date: str

# --- Tool Endpoints ---

@app.get(
    "/orders/{order_id}",
    operation_id="get_order_details",
    description="Fetches detailed information for a specific order by its ID.",
    tags=["orders"],
    response_model=Order,
)
async def get_order_details(order_id: str) -> Dict[str, Any]:
    """
    Example endpoint to simulate fetching order data.
    In a real application, this would query a database.
    """
    # Placeholder data
    if order_id == "ORD12345":
        return {
            "order_id": order_id,
            "customer_id": 101,
            "status": "shipped",
            "total_amount": 199.99,
            "currency": "USD",
        }
    raise HTTPException(status_code=404, detail="Order not found")

@app.get(
    "/customers/{customer_id}",
    operation_id="get_customer_profile",
    description="Retrieves the profile of a customer by their unique ID.",
    tags=["customers"],
    response_model=Customer,
)
async def get_customer_profile(customer_id: int) -> Dict[str, Any]:
    """
    Example endpoint to simulate fetching customer data.
    """
    # Placeholder data
    if customer_id == 101:
        return {
            "customer_id": customer_id,
            "name": "Jane Doe",
            "email": "jane.doe@example.com",
            "join_date": "2023-05-20",
        }
    raise HTTPException(status_code=404, detail="Customer not found")

Step 4: Secure and Mount the MCP Server

Security is essential if you are creating a private MCP. We'll create a simple dependency that checks for a Bearer token in the Authorization header. This token will be read from our .env file.

Then, we instantiate FastApiMCP, telling it which operations to include and how to authenticate requests.

# main.py (continued)
from fastapi_mcp import FastApiMCP, AuthConfig

# --- Authentication ---
def verify_auth(request: Request):
    """Dependency to verify the internal bearer token."""
    auth_header: Optional[str] = request.headers.get("Authorization")
    if auth_header is None or not auth_header.startswith("Bearer "):
        raise HTTPException(status_code=401, detail="Unauthorized")

    token = auth_header.split(" ")[1]
    expected_token = os.getenv("INTERNAL_TOKEN")
    if token != expected_token:
        raise HTTPException(status_code=403, detail="Forbidden")

# --- MCP Integration ---
mcp = FastApiMCP(
    app,
    name="Apxml API Services",
    description="Tools for managing orders and customers.",
    describe_all_responses=True,
    describe_full_response_schema=True,
    # Only expose the endpoints with these operation_ids
    include_operations=[
        "get_order_details",
        "get_customer_profile",
    ],
    auth_config=AuthConfig(
        dependencies=[Depends(verify_auth)],
    ),
)
# Mount the MCP server on a specific path
mcp.mount(mount_path="/mcp")

# This final call scans the app for routes and finalizes the MCP setup.
# It must be called *after* all routes and the MCP mount are defined.
mcp.setup_server()

Your complete main.py is now a fully functional API server with a secure, discoverable MCP endpoint at the /mcp path.

Optional: Creating Multiple Specialized MCP Servers

LLMs have a context length limit. Providing too many tools in a single MCP server can overwhelm the model, degrading its performance and ability to choose the correct tool. A better approach for complex applications is to create multiple, specialized MCP servers, each focused on a specific domain (e.g., "User Management," "Billing," "Reporting").

You can easily achieve this by instantiating FastApiMCP multiple times and mounting each instance on a unique path.

# Example of adding a second, admin-focused MCP server
admin_mcp = FastApiMCP(
    app,
    name="Apxml Awesome Admin MCP",
    description="Tools for administrative tasks.",
    include_operations=[
        "create_user", # Assume this endpoint exists
        "delete_invoice", # Assume this endpoint exists
    ],
    auth_config=AuthConfig(
        dependencies=[Depends(verify_auth)], # Could use different auth
    ),
)
admin_mcp.mount(mount_path="/mcp/admin")
admin_mcp.setup_server()

This modular approach keeps your toolsets manageable and helps the LLM perform more accurately.

Testing Your MCP Server with the Inspector

Before connecting to an AI, you should verify that your MCP server is working correctly. The official MCP Inspector is a web-based tool perfect for this.

Install the Inspector: You'll need Node.js (v22+) and npm installed.
```
npm install -g @modelcontextprotocol/inspector
```
Run the UI:
```
npx @modelcontextprotocol/inspector
```
Connect to Your Server:
- Make sure your FastAPI application is running (uv run uvicorn main:app --reload).
- Open the Inspector UI in your browser (usually http://localhost:5173).
- Set Transport Type to SSE.
- Enter the MCP server URL: http://localhost:8000/mcp.
- Click the Authentication tab. Under Custom Headers, add a new header:
  - Header Name: Authorization
  - Header Value: Bearer your-super-secret-token
- Click Connect.

You should now see your two tools, get_order_details and get_customer_profile, listed with their descriptions and schemas. This confirms your server is correctly broadcasting its capabilities.

Connecting to Claude Desktop

Now for the final piece: connecting your MCP server to a real AI application. We'll use the Claude Desktop app as an example.

Download the App: If you haven't already, download and install the Claude Desktop app from the official site: claude.ai/download.
Locate the Configuration File: On macOS, the file is located at ~/Library/Application Support/Claude/claude_desktop_config.json. On other operating systems, check Claude's documentation for the location.

Update the Configuration: Add the mcpServers block to this JSON file. This tells Claude how to launch and communicate with your local server via mcp-remote, a small proxy that injects the required authentication header.

{
  "mcpServers": {
    "apxml-awesome-mcp": {
      "command": "npx",
      "args": [
        "-p", "node@22",
        "-p", "mcp-remote@latest",
        "--",
        "mcp-remote",
        "http://localhost:8000/mcp",
        "--header", "Authorization: Bearer ${INTERNAL_TOKEN}"
      ],
      "env": {
        "INTERNAL_TOKEN": "your-super-secret-token"
      }
    }
  }
}

Make sure the INTERNAL_TOKEN here matches the one in your .env file.

Verify the Connection:
- Ensure your FastAPI server is running.
- Restart the Claude Desktop app completely.
- Click the 'Search & Tools' button (the controls icon) in the chat input.

You should see your MCP app listed as an available tool source. Once you enable it, you can ask Claude questions like, "What are the details for order ORD12345?" and it will use your API to find the answer.

Conclusion

You have now successfully built a secure, functional MCP server and integrated it directly into a FastAPI application. By adding MCP capabilities to your existing services, you reuse your tested code and infrastructure, creating a direct and maintainable bridge between your internal systems and powerful AI models.

This method enables you to develop sophisticated, context-aware AI applications tailored to your specific business needs. The combination of FastAPI's performance and fastapi_mcp's simplicity provides a solid foundation for creating the next generation of AI-powered tools.

How To Build a MCP Server with FastAPI (FastAPI-MCP)