This tutorial demonstrates how to integrate your Large Language Model (LLM) with external tools using the Model Context Protocol (MCP) and FastAPI. We'll build a simple web application using FastAPI and convert it into an MCP server, enabling your LLM to access and utilize the application's functionalities.

Table of Contents

• FastAPI and MCP: A Powerful Combination
• Introducing FastAPI-MCP
• API Compatibility with FastAPI-MCP
• Hands-on: Building an MCP Server with FastAPI-MCP
• FastAPI Configuration
• Cursor Configuration
• Testing Your MCP Server
• Conclusion

FastAPI and MCP: A Powerful Combination

FastAPI simplifies the creation of web applications and APIs using Python. It's known for its ease of use and speed. MCP, an open standard protocol from Anthropic, allows LLMs to interact with external data sources and tools. Combining FastAPI with MCP empowers your LLM by providing access to a wide range of web-based tools.

The above diagram illustrates an MCP server connected to an API endpoint, which could be a FastAPI endpoint or another third-party API.

Introducing FastAPI-MCP

FastAPI-MCP is a library that seamlessly transforms your FastAPI applications into tools readily usable by LLMs such as ChatGPT or Claude. It simplifies the process of integrating your FastAPI endpoints into an AI ecosystem.

API Compatibility with FastAPI-MCP

FastAPI-MCP supports various FastAPI endpoint types:

• GET endpoints: Converted into MCP resources.
• POST, PUT, DELETE endpoints: Converted into MCP tools.
• Custom utility functions: Can be integrated as additional MCP tools.

The library automatically detects and converts these endpoints, preserving their schema and documentation.

Hands-on: Building an MCP Server with FastAPI-MCP

Let's build a simple weather application using the weather.gov API (no API key required) and convert it into an MCP server.

FastAPI Configuration

1. Install dependencies:

pip install fastapi fastapi-mcp uvicorn mcp-proxy

2. Import dependencies: (in main.py)

from fastapi import FastAPI, HTTPException, Query
import httpx
from fastapi_mcp import FastApiMCP

3. Define FastAPI app:

app = FastAPI(title="Weather Updates API")

4. Define routes and functions: (This example uses a simplified city coordinate lookup. A production application would use a proper geocoding service.)

CITY_COORDINATES = {  # ... (City coordinate data as in original example) ... }

@app.get("/weather")
async def get_weather(stateCode: str = Query(..., description="State code"), city: str = Query(..., description="City name")):
    # ... (Weather API interaction as in original example) ...

5. Set up MCP Server:

mcp = FastApiMCP(app, name="Weather Updates API", description="API for retrieving weather data")
mcp.mount()

6. Start the app:

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

Cursor Configuration

1. Download and install Cursor.
2. Create a mcp.json file with the following configuration (adjust the port if necessary):

{
  "mcpServers": {
    "WeatherAPI": {
      "command": "mcp-proxy",
      "args": ["http://127.0.0.1:8000/mcp"]
    }
  }
}

3. Add the mcp.json configuration to Cursor's MCP settings.

Testing Your MCP Server

Now, use Cursor to query your weather API. For example: "What's the weather in San Francisco?"

Conclusion

By combining FastAPI and MCP with the fastapi-mcp library, you can easily integrate your existing or new APIs into your LLM workflow, significantly expanding its capabilities. This approach streamlines the process of creating custom tools for your LLM, allowing it to access and utilize a vast array of online resources.

The above is the detailed content of FastAPI-MCP Tutorial for Beginners and Experts - Analytics Vidhya. For more information, please follow other related articles on the PHP Chinese website!