FastMCP - Python-Framework für den schnellen Aufbau von MCP-Servern und -Clients

Projektübersicht

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.

Warum FastMCP?

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:

• 🚀 Schnell: Hochentwickelte Schnittstellen bedeuten weniger Code und schnellere Entwicklung
• 🍀 Einfach: Aufbau von MCP-Servern mit minimalem Boilerplate-Code
• 🐍 Pythonisch: Fühlt sich für Python-Entwickler natürlich an
• 🔍 Vollständig: Bietet eine vollständige Implementierung der MCP-Kernspezifikation, die Server und Clients unterstützt

Kernfunktionsmerkmale

Basisfunktionen

• Erstellung von Servern mit intuitiven Dekoratoren, minimaler Boilerplate-Code
• Proxy für bestehende Server zur Änderung der Konfiguration oder des Übertragungswegs
• Kombination von Servern zu komplexen Anwendungen
• Generierung von Servern aus OpenAPI-Spezifikationen oder FastAPI-Objekten
• Programmgesteuerte Interaktion mit MCP-Servern
• Verbindung zu jedem MCP-Server über beliebige Übertragungsprotokolle
• Testen von Servern ohne manuellen Eingriff
• Nutzung von MCP-Kernfunktionen wie LLM-Sampling

Versionsentwicklung

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:

• Erweiterte Funktionen wie Proxy und Kombination von MCP-Servern
• Automatische Generierung von Servern aus OpenAPI-Spezifikationen oder FastAPI-Objekten
• Einführung von Client-Funktionen wie LLM-Sampling

Installationsmethoden

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

Schnellstartbeispiel

Grundlegendes Serverbeispiel

# 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

Erläuterung der Kernkonzepte

1. FastMCP-Instanz

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"])

2. Tools

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)

3. Ressourcen

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")

4. Prompts

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?")
    ]

Erweiterte Funktionen

1. Proxy-Server

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')

2. Serverkombination

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)        

3. Generierung von Servern aus APIs

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)

4. Client-Funktionen

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)

Ausführen von Servern

Entwicklungsmodus

fastmcp dev your_server_file.py

Produktionsinstallation

fastmcp install your_server_file.py

Direkte Ausführung

if __name__ == "__main__":
    mcp.run()

Beispielprojekte

Das Projekt enthält mehrere Beispieldateien:

• simple_echo.py: Grundlegende Tools, Ressourcen und Prompts
• complex_inputs.py: Verwendung von Pydantic-Modellen als Tool-Eingaben
• mount_example.py: Mounten mehrerer FastMCP-Server
• sampling.py: Verwendung von LLM-Vervollständigung in einem MCP-Server
• screenshot.py: Tool zur Rückgabe von Image-Objekten
• text_me.py: Tool zur Interaktion mit einer externen API
• memory.py: Komplexes Beispiel mit Datenbankinteraktion

Beitragshinweise

FastMCP begrüßt Beiträge aus der Community:

Umgebungsvoraussetzungen

• Python 3.10+
• uv-Paketmanager

Entwicklungseinrichtung

git clone https://github.com/jlowin/fastmcp.git && cd fastmcp
uv venv && uv sync

Tests

uv run pytest -vv

Codequalität

Verwendung von ruff und pre-commit:

pre-commit install
pre-commit run --all-files

Projektbedeutung

FastMCP schließt die Lücke zwischen der Implementierung des MCP-Protokolls und der tatsächlichen Anwendungsentwicklung und ermöglicht es Entwicklern:

1. Schnelle Prototypenerstellung und Bereitstellung von MCP-Servern
2. Einfache Integration bestehender APIs und Datenquellen
3. Aufbau modularer, erweiterbarer KI-Anwendungsarchitekturen
4. Konzentration auf die Geschäftslogik anstelle von Protokollimplementierungsdetails