FastMCP ist ein fortschrittliches Python-Framework zum Aufbau von Model Context Protocol (MCP)-Servern und -Clients. Es zielt darauf ab, Entwicklern die schnelle und einfache Erstellung von Tools, die Bereitstellung von Ressourcen, die Definition von Prompts und die Verbindung von Komponenten zu ermöglichen. Das Projekt wird vom GitHub-Benutzer jlowin entwickelt und gepflegt und ist zu einem wichtigen Bestandteil des MCP-Ökosystems geworden.
Obwohl das MCP-Protokoll leistungsstark ist, erfordert seine Implementierung viel Boilerplate-Code - Servereinstellungen, Protokollhandler, Inhaltstypen, Fehlermanagement usw. FastMCP kümmert sich um alle komplexen Protokolldetails und das Servermanagement, sodass Sie sich auf die Entwicklung exzellenter Tools konzentrieren können.
Die Designziele von FastMCP:
FastMCP 1.0 hat den Aufbau von MCP-Servern so einfach gemacht, dass es nun Teil des offiziellen Model Context Protocol Python SDK ist!
FastMCP 2.0 baut darauf auf und führt eine Vielzahl neuer Funktionen ein:
Es wird empfohlen, FastMCP mit uv zu installieren:
uv pip install fastmcp
Entwicklungsinstallation:
git clone https://github.com/jlowin/fastmcp.git
cd fastmcp
uv sync
# server.py
from fastmcp import FastMCP
mcp = FastMCP("Demo")
@mcp.tool()
def add(a: int, b: int) -> int:
"""Add two numbers"""
return a + b
@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
"""Get a personalized greeting"""
return f"Hello, {name}!"
if __name__ == "__main__":
mcp.run()
Installation in Claude Desktop:
fastmcp install server.py
Repräsentiert das zentrale Objekt der MCP-Anwendung, das Verbindungen, Protokolldetails und Routing verarbeitet:
from fastmcp import FastMCP
mcp = FastMCP("My App")
mcp = FastMCP("My App", dependencies=["pandas", "numpy"])
Ermöglichen es LLMs, Operationen durch Ausführen von Python-Funktionen auszuführen, geeignet für Berechnungen, externe API-Aufrufe oder Nebenwirkungen:
import httpx
from pydantic import BaseModel
class UserInfo(BaseModel):
user_id: int
notify: bool = False
@mcp.tool()
async def send_notification(user: UserInfo, message: str) -> dict:
"""Sends a notification to a user if requested."""
if user.notify:
print(f"Notifying user {user.user_id}: {message}")
return {"status": "sent", "user_id": user.user_id}
return {"status": "skipped", "user_id": user.user_id}
@mcp.tool()
def get_stock_price(ticker: str) -> float:
"""Gets the current price for a stock ticker."""
prices = {"AAPL": 180.50, "GOOG": 140.20}
return prices.get(ticker.upper(), 0.0)
Stellen LLMs Daten zur Verfügung, hauptsächlich zur Bereitstellung von Informationen ohne wesentliche Berechnungen oder Nebenwirkungen:
@mcp.resource("config://app-version")
def get_app_version() -> str:
"""Returns the application version."""
return "v2.1.0"
@mcp.resource("db://users/{user_id}/email")
async def get_user_email(user_id: str) -> str:
"""Retrieves the email address for a given user ID."""
emails = {"123": "alice@example.com", "456": "bob@example.com"}
return emails.get(user_id, "not_found@example.com")
Definieren wiederverwendbare Vorlagen oder Interaktionsmuster:
from fastmcp.prompts.base import UserMessage, AssistantMessage
@mcp.prompt()
def ask_review(code_snippet: str) -> str:
"""Generates a standard code review request."""
return f"Please review the following code snippet for potential bugs and style issues:\n```python\n{code_snippet}\n```"
@mcp.prompt()
def debug_session_start(error_message: str) -> list[Message]:
"""Initiates a debugging help session."""
return [
UserMessage(f"I encountered an error:\n{error_message}"),
AssistantMessage("Okay, I can help with that. Can you provide the full traceback and tell me what you were trying to do?")
]
Erstellen eines FastMCP-Servers, der als Vermittler fungiert und Anfragen an einen anderen MCP-Endpunkt weiterleitet:
import asyncio
from fastmcp import FastMCP, Client
from fastmcp.client.transports import PythonStdioTransport
proxy_client = Client(
transport=PythonStdioTransport('path/to/original_stdio_server.py'),
)
proxy = FastMCP.from_client(proxy_client, name="Stdio-to-SSE Proxy")
if __name__ == "__main__":
proxy.run(transport='sse')
Erstellen großer MCP-Anwendungen durch Erstellung modularer FastMCP-Server und deren "Mounten" auf einem übergeordneten Server:
from fastmcp import FastMCP
weather_mcp = FastMCP("Weather Service")
@weather_mcp.tool()
def get_forecast(city: str):
return f"Sunny in {city}"
news_mcp = FastMCP("News Service")
@news_mcp.tool()
def fetch_headlines():
return ["Big news!", "Other news"]
mcp = FastMCP("Composite")
mcp.mount("weather", weather_mcp)
mcp.mount("news", news_mcp)
Automatische Generierung von FastMCP-Servern aus bestehenden Web-APIs:
from fastapi import FastAPI
from fastmcp import FastMCP
fastapi_app = FastAPI(title="My Existing API")
@fastapi_app.get("/status")
def get_status():
return {"status": "running"}
mcp_server = FastMCP.from_fastapi(fastapi_app)
Interaktion mit jedem MCP-Server:
from fastmcp import Client
async with Client("path/to/server") as client:
result = await client.call_tool("weather", {"location": "San Francisco"})
print(result)
res = await client.read_resource("db://users/123/profile")
print(res)
fastmcp dev your_server_file.py
fastmcp install your_server_file.py
if __name__ == "__main__":
mcp.run()
Das Projekt enthält mehrere Beispieldateien:
simple_echo.py: Grundlegende Tools, Ressourcen und Promptscomplex_inputs.py: Verwendung von Pydantic-Modellen als Tool-Eingabenmount_example.py: Mounten mehrerer FastMCP-Serversampling.py: Verwendung von LLM-Vervollständigung in einem MCP-Serverscreenshot.py: Tool zur Rückgabe von Image-Objektentext_me.py: Tool zur Interaktion mit einer externen APImemory.py: Komplexes Beispiel mit DatenbankinteraktionFastMCP begrüßt Beiträge aus der Community:
git clone https://github.com/jlowin/fastmcp.git && cd fastmcp
uv venv && uv sync
uv run pytest -vv
Verwendung von ruff und pre-commit:
pre-commit install
pre-commit run --all-files
FastMCP schließt die Lücke zwischen der Implementierung des MCP-Protokolls und der tatsächlichen Anwendungsentwicklung und ermöglicht es Entwicklern: