Einsteiger-Leitfaden zur Verwendung von FastMCP

Die Landschaft der Large Language Models (LLMs) entwickelt sich rasant weiter und geht über die einfache Texterstellung hinaus zu komplexen Interaktionen mit externen Systemen und Datenquellen. Um diese Interaktion zu erleichtern, ist ein standardisierter Ansatz erforderlich, eine gemeinsame Sprache für LLMs, um Informationen anzufordern und Aktionen auszulösen. Hier kommt das Model Context Protocol (MCP) ins Spiel, das als universeller Standard konzipiert wurde – oft verglichen mit "dem USB-C-Anschluss für KI" – und eine nahtlose Kommunikation zwischen LLMs und den Ressourcen ermöglicht, die sie benötigen.

Während MCP die Spezifikation bereitstellt, kann der Aufbau von Servern und Clients, die sich daran halten, einen erheblichen Boilerplate-Code und Protokollverwaltung erfordern. Hier glänzt FastMCP. FastMCP ist ein High-Level-, Pythonic-Framework, das entwickelt wurde, um die Erstellung von MCP-Servern und -Clients drastisch zu vereinfachen. Es kümmert sich um die zugrunde liegenden Komplexitäten des Protokolls, sodass sich Entwickler auf die Definition der wertvollen Tools, Datenressourcen und Interaktionsmuster konzentrieren können, die sie LLMs zur Verfügung stellen möchten.

💡

Want a great API Testing tool that generates beautiful API Documentation?

Want an integrated, All-in-One platform for your Developer Team to work together with maximum productivity?

Apidog delivers all your demans, and replaces Postman at a much more affordable price!

button

Was ist das Model Context Protocol (MCP)?

Bevor wir tiefer in FastMCP eintauchen, ist es wichtig, die Kernkonzepte von MCP selbst zu verstehen. MCP definiert eine standardisierte Methode für LLM-Anwendungen (Clients), um mit externen Systemen (Servern) zu interagieren. Ein MCP-Server kann mehrere Schlüsselkomponenten verfügbar machen:

Tools: Dies sind im Wesentlichen Funktionen, die ein LLM anfordern kann, dass der Server sie ausführt. Stellen Sie sich diese wie POST-Endpunkte in einer herkömmlichen API vor. Sie führen Aktionen aus, interagieren möglicherweise mit anderen Systemen (Datenbanken, APIs, Hardware) und geben Ergebnisse zurück. Ein Tool könnte beispielsweise eine E-Mail senden, eine Datenbank abfragen oder eine Berechnung durchführen.
Ressourcen: Diese machen Daten verfügbar, die ein LLM lesen oder abrufen kann. Ähnlich wie GET-Endpunkte stellen Ressourcen Informationen bereit, um den Kontext des LLM zu erweitern. Dies kann alles sein, von Konfigurationsdateien und Benutzerprofilen bis hin zu Echtzeit-Datenströmen.
Prompts: Dies sind wiederverwendbare Vorlagen zur Strukturierung von Interaktionen mit dem LLM. Sie helfen, die Konversation zu lenken und konsistente Ergebnisse für bestimmte Aufgaben sicherzustellen.
Kontext: Server können Kontextinformationen bereitstellen, einschließlich Anweisungen, wie am besten mit den verfügbaren Tools und Ressourcen interagiert werden kann.

MCP zielt darauf ab, ein robustes und sicheres Ökosystem zu schaffen, in dem LLMs zuverlässig auf externe Fähigkeiten zugreifen und diese nutzen können.

Warum FastMCP wählen?

Obwohl Sie die MCP-Spezifikation direkt mit SDKs auf niedrigerer Ebene implementieren könnten, bietet FastMCP überzeugende Vorteile, insbesondere für Python-Entwickler:

🚀 Schnelle Entwicklung: Seine High-Level-Schnittstelle reduziert den benötigten Code erheblich und beschleunigt den Entwicklungsprozess. Oft ist die Definition eines Tools oder einer Ressource so einfach wie das Dekorieren einer Standard-Python-Funktion.
🍀 Einfachheit: FastMCP abstrahiert die komplexen Details der Server-Einrichtung, der Protokollverarbeitung, der Inhaltstypen und des Fehlermanagements und minimiert Boilerplate.
🐍 Pythonic: Es wurde unter Berücksichtigung der Best Practices von Python entwickelt und fühlt sich für Entwickler, die mit der Sprache vertraut sind, natürlich und intuitiv an, wobei Funktionen wie Typ-Hinweise und Dekoratoren genutzt werden.
🔍 Vollständig: FastMCP zielt darauf ab, eine umfassende Implementierung der Kern-MCP-Spezifikation bereitzustellen und so die Kompatibilität und den Zugriff auf das volle Potenzial des Protokolls sicherzustellen.

FastMCP Version 1 war sehr erfolgreich und ist jetzt in das offizielle MCP Python SDK integriert. Version 2 baut auf dieser Grundlage auf und führt erweiterte Funktionen ein, die sich auf die Vereinfachung von Server-Interaktionen konzentrieren, wie z. B. flexible Clients, Server-Proxying und Kompositionsmuster.

Wie man FastMCP installiert

Die Einrichtung von FastMCP in Ihrer Python-Umgebung ist unkompliziert. Die empfohlene Methode verwendet uv, einen schnellen Python-Paket-Installer und -Resolver.

1. Verwendung von uv (Empfohlen):

Wenn Sie Abhängigkeiten für ein Projekt verwalten, fügen Sie FastMCP mit Folgendem hinzu:

uv add fastmcp

Alternativ können Sie es direkt in Ihrer Umgebung installieren:

uv pip install fastmcp

2. Verwendung von pip:

Wenn Sie pip bevorzugen, können Sie FastMCP mit Folgendem installieren:

pip install fastmcp

3. Überprüfen der Installation:

Nach der Installation können Sie überprüfen, ob FastMCP korrekt installiert ist, und seine Version zusammen mit der zugrunde liegenden MCP SDK-Version und Ihren Python-Umgebungsdetails überprüfen, indem Sie Folgendes ausführen:

fastmcp version

Sie sollten eine ähnliche Ausgabe wie diese sehen:

$ fastmcp version

FastMCP version:   0.4.2.dev41+ga077727.d20250410
MCP version:                                1.6.0
Python version:                            3.12.2
Platform:            macOS-15.3.1-arm64-arm-64bit
FastMCP root path:            ~/Developer/fastmcp

4. Installation für die Entwicklung:

Wenn Sie beabsichtigen, zum FastMCP-Projekt selbst beizutragen, sollten Sie eine Entwicklungsumgebung einrichten:

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

Dies klont das Repository, navigiert in das Verzeichnis und verwendet uv sync, um alle erforderlichen Abhängigkeiten, einschließlich Entwicklungstools, innerhalb einer virtuellen Umgebung zu installieren. Sie können dann Tests mit pytest ausführen.

Wie man FastMCP verwendet: Erstellen Ihres ersten Servers

Lassen Sie uns nun in die praktischen Aspekte der Verwendung von FastMCP eintauchen.

1. Erstellen einer grundlegenden Serverinstanz:

Der Kern jeder FastMCP-Anwendung ist die FastMCP-Klasse. Sie beginnen damit, eine Instanz dieser Klasse zu erstellen.

Erstellen Sie eine Datei mit dem Namen my_server.py:

# my_server.py
from fastmcp import FastMCP
import asyncio # Wir werden dies später für den Client benötigen

# Instanziieren Sie den Server und geben Sie ihm einen Namen
mcp = FastMCP(name="My First MCP Server")

print("FastMCP server object created.")

Der FastMCP-Konstruktor akzeptiert mehrere hilfreiche Argumente:

name (str, optional): Ein für Menschen lesbarer Name für Ihren Server (Standardwert: "FastMCP"). Nützlich für die Identifizierung in Protokollen oder Client-Anwendungen.
instructions (str, optional): Eine Beschreibung, die Clients anleitet, wie sie mit dem Server interagieren können, seinen Zweck erläutert oder wichtige Funktionen hervorhebt.
lifespan (callable, optional): Ein asynchroner Kontextmanager zur Behandlung der Server-Start- und -Shutdown-Logik (z. B. Initialisieren von Datenbankverbindungen).
tags (set[str], optional): Tags zur Kategorisierung des Servers selbst.
**settings: Sie können Schlüsselwortargumente, die ServerSettings entsprechen (z. B. port, host, log_level), direkt an den Konstruktor zur Konfiguration übergeben.

2. Hinzufügen von Komponenten:

Ein leerer Server ist nicht sehr nützlich. Lassen Sie uns die Kernkomponenten von MCP hinzufügen.

Hinzufügen eines Tools: Tools sind Funktionen, die dem Client verfügbar gemacht werden. Verwenden Sie den @mcp.tool()-Dekorator. FastMCP verwendet Python-Typ-Hinweise, um die erwarteten Eingabeparameter und den Rückgabetyp für den Client zu definieren.

# my_server.py (continued)
@mcp.tool()
def greet(name: str) -> str:
    """Gibt eine einfache Begrüßung zurück."""
    return f"Hallo, {name}!"

@mcp.tool()
def add(a: int, b: int) -> int:
    """Addiert zwei Zahlen."""
    return a + b

print("Tools 'greet' and 'add' added.")

Hinzufügen einer Ressource: Ressourcen machen Daten über eine URI verfügbar. Verwenden Sie den @mcp.resource()-Dekorator und geben Sie die URI-Zeichenfolge an.

# my_server.py (continued)
APP_CONFIG = {"theme": "dark", "version": "1.1", "feature_flags": ["new_dashboard"]}

@mcp.resource("data://config")
def get_config() -> dict:
    """Stellt die Anwendungskonfiguration bereit."""
    return APP_CONFIG

print("Resource 'data://config' added.")

Hinzufügen einer Ressourcenvorlage: Dies sind wie dynamische Ressourcen, bei denen Teile der URI als Parameter fungieren.

# my_server.py (continued)
USER_PROFILES = {
    101: {"name": "Alice", "status": "active"},
    102: {"name": "Bob", "status": "inactive"},
}

@mcp.resource("users://{user_id}/profile")
def get_user_profile(user_id: int) -> dict:
    """Ruft das Profil eines Benutzers anhand seiner ID ab."""
    # Das {user_id} aus der URI wird automatisch als Argument übergeben
    return USER_PROFILES.get(user_id, {"error": "User not found"})

print("Resource template 'users://{user_id}/profile' added.")

Hinzufügen eines Prompts: Prompts definieren wiederverwendbare Interaktionsmuster.

# my_server.py (continued)
@mcp.prompt("summarize")
async def summarize_prompt(text: str) -> list[dict]:
    """Generiert einen Prompt, um den bereitgestellten Text zusammenzufassen."""
    return [
        {"role": "system", "content": "Sie sind ein hilfreicher Assistent, der sich auf die Zusammenfassung versteht."},
        {"role": "user", "content": f"Bitte fassen Sie den folgenden Text zusammen:\n\n{text}"}
    ]

print("Prompt 'summarize' added.")

3. Testen des Servers (In-Process):

Bevor Sie den Server extern ausführen, können Sie seine Komponenten direkt innerhalb desselben Python-Skripts mit dem Client testen. Dies ist nützlich für schnelle Überprüfungen und Unit-Tests.

# my_server.py (continued)
from fastmcp import Client # Importieren Sie den Client

async def test_server_locally():
    print("\n--- Testing Server Locally ---")
    # Richten Sie den Client direkt auf das Serverobjekt aus
    client = Client(mcp)

    # Clients sind asynchron, also verwenden Sie einen async-Kontextmanager
    async with client:
        # Rufen Sie das Tool 'greet' auf
        greet_result = await client.call_tool("greet", {"name": "FastMCP User"})
        print(f"greet result: {greet_result}")

        # Rufen Sie das Tool 'add' auf
        add_result = await client.call_tool("add", {"a": 5, "b": 7})
        print(f"add result: {add_result}")

        # Lesen Sie die Ressource 'config'
        config_data = await client.read_resource("data://config")
        print(f"config resource: {config_data}")

        # Lesen Sie ein Benutzerprofil mit der Vorlage
        user_profile = await client.read_resource("users://101/profile")
        print(f"User 101 profile: {user_profile}")

        # Holen Sie sich die 'summarize'-Prompt-Struktur (führt hier nicht den LLM-Aufruf aus)
        prompt_messages = await client.get_prompt("summarize", {"text": "This is some text."})
        print(f"Summarize prompt structure: {prompt_messages}")

# Führen Sie die lokale Testfunktion aus
# asyncio.run(test_server_locally())
# Vorerst auskommentiert, wir konzentrieren uns als Nächstes auf das Ausführen des Servers

Beachten Sie die Verwendung von async und await. FastMCP-Clients arbeiten asynchron und erfordern eine async-Funktion und die Verwendung von async with client:, um den Lebenszyklus des Clients zu verwalten.

4. Ausführen des Servers:

Um Ihren MCP-Server für externe Clients (wie eine LLM-Anwendung) zugänglich zu machen, müssen Sie ihn ausführen. Es gibt zwei Hauptmöglichkeiten:

Standard-Python-Ausführung (empfohlen für Kompatibilität):
Fügen Sie den folgenden if __name__ == "__main__":-Block zu Ihrer Datei my_server.py hinzu. Dies ist die Standard-Python-Praxis, um ein Skript ausführbar zu machen.

# my_server.py (am Ende der Datei)

if __name__ == "__main__":
    print("\n--- Starting FastMCP Server via __main__ ---")
    # Dies startet den Server, normalerweise mit dem stdio-Transport standardmäßig
    mcp.run()

Um den Server auszuführen, führen Sie das Skript von Ihrem Terminal aus:

python my_server.py

Dieser Befehl startet den MCP-Server und lauscht auf Client-Verbindungen mit dem Standard-stdio-Transportmechanismus (Standardeingabe/ -ausgabe). Diese Methode stellt sicher, dass Ihr Server für verschiedene Clients, die die Ausführung eines Python-Skripts erwarten, konsistent ausgeführt wird.

Verwenden der FastMCP-CLI:
FastMCP bietet eine Befehlszeilenschnittstelle zum Ausführen von Servern, die mehr Flexibilität und Kontrolle bietet, insbesondere in Bezug auf Transportoptionen.

# Führen Sie den Server mit stdio aus (Standard)
fastmcp run my_server.py:mcp

# Führen Sie den Server mit Server-Sent Events (SSE) auf Port 8080 aus
fastmcp run my_server.py:mcp --transport sse --port 8080 --host 0.0.0.0

# Ausführen mit einem anderen Protokollierungsgrad
fastmcp run my_server.py:mcp --transport sse --log-level DEBUG

Wichtige Punkte zur CLI:

my_server.py:mcp: Gibt die Datei (my_server.py) und das FastMCP-Serverobjekt innerhalb dieser Datei (mcp) an. Wenn Sie :mcp weglassen, versucht FastMCP automatisch, ein Objekt mit dem Namen mcp, app oder server zu finden.
Der if __name__ == "__main__":-Block ist nicht erforderlich, wenn Sie fastmcp run verwenden; die CLI findet und führt das angegebene Serverobjekt direkt aus.
--transport: Wählt das Kommunikationsprotokoll aus (stdio, sse). SSE ist üblich für webbasierte Interaktionen.
--port, --host, --log-level: Konfigurieren Sie Transport- und Protokollierungseinstellungen.

5. Interagieren mit einem laufenden Server (Client):

Sobald Ihr Server ausgeführt wird (entweder über python my_server.py oder fastmcp run), können Sie ein separates Client-Skript erstellen, um mit ihm zu interagieren.

Erstellen Sie eine neue Datei, my_client.py:

# my_client.py
from fastmcp import Client
import asyncio

async def interact_with_server():
    print("--- Creating Client ---")

    # Option 1: Verbinden Sie sich mit einem Server, der über `python my_server.py` ausgeführt wird (verwendet stdio)
    # client = Client("my_server.py")

    # Option 2: Verbinden Sie sich mit einem Server, der über `fastmcp run ... --transport sse --port 8080` ausgeführt wird
    client = Client("http://localhost:8080") # Verwenden Sie die richtige URL/Port

    print(f"Client configured to connect to: {client.target}")

    try:
        async with client:
            print("--- Client Connected ---")
            # Rufen Sie das Tool 'greet' auf
            greet_result = await client.call_tool("greet", {"name": "Remote Client"})
            print(f"greet result: {greet_result}")

            # Lesen Sie die Ressource 'config'
            config_data = await client.read_resource("data://config")
            print(f"config resource: {config_data}")

            # Lesen Sie das Benutzerprofil 102
            profile_102 = await client.read_resource("users://102/profile")
            print(f"User 102 profile: {profile_102}")

    except Exception as e:
        print(f"An error occurred: {e}")
    finally:
        print("--- Client Interaction Finished ---")

if __name__ == "__main__":
    asyncio.run(interact_with_server())

Führen Sie dieses Client-Skript aus, während der Server in einem anderen Terminal ausgeführt wird:

python my_client.py

Der Client stellt eine Verbindung zum laufenden Server her (stellen Sie sicher, dass das Client(...)-Ziel mit der Art und Weise übereinstimmt, wie der Server ausgeführt wird – Dateipfad für stdio, URL für sse), führt die Toolaufrufe und Ressourcenlesevorgänge aus und gibt die Ergebnisse aus.

6. Serverkonfiguration (ServerSettings):

Sie können das Serververhalten mithilfe von ServerSettings optimieren. Einstellungen können in der folgenden Reihenfolge der Priorität angewendet werden:

Schlüsselwortargumente während der FastMCP-Initialisierung (höchste Priorität).
Umgebungsvariablen (mit dem Präfix FASTMCP_SERVER_, z. B. FASTMCP_SERVER_PORT=8888).
Werte, die aus einer .env-Datei im Arbeitsverzeichnis geladen werden.
Standardwerte (niedrigste Priorität).

Beispiel für die Konfiguration während der Initialisierung:

from fastmcp import FastMCP

mcp_configured = FastMCP(
    name="ConfiguredServer",
    port=8080,  # Legt den Standard-SSE-Port fest
    host="127.0.0.1", # Legt den Standard-SSE-Host fest
    log_level="DEBUG", # Legt den Protokollierungsgrad fest
    on_duplicate_tools="warn" # Warnen, wenn Tools mit demselben Namen registriert werden (Optionen: 'error', 'warn', 'ignore')
)

# Greifen Sie über das Attribut .settings auf die Einstellungen zu
print(f"Configured Port: {mcp_configured.settings.port}") # Ausgabe: 8080
print(f"Duplicate Tool Policy: {mcp_configured.settings.on_duplicate_tools}") # Ausgabe: warn

Zu den wichtigsten Konfigurationsoptionen gehören host, port, log_level und Richtlinien für die Behandlung doppelter Komponentennamen (on_duplicate_tools, on_duplicate_resources, on_duplicate_prompts).

Was Sie sonst noch mit FastMCP tun können

FastMCP unterstützt auch erweiterte Anwendungsfälle:

Komposition: Kombinieren Sie mehrere FastMCP-Server. main.mount("sub", sub_server) erstellt eine Live-Verbindung, während main.import_server(sub_server) Komponenten kopiert. Dies unterstützt die Modularität.
Proxying: Verwenden Sie FastMCP.from_client(client), um eine FastMCP-Serverinstanz zu erstellen, die als Proxy für einen anderen MCP-Server (lokal oder remote) fungiert. Dies ist nützlich, um Transporte zu überbrücken (z. B. einen Remote-SSE-Server über lokales stdio verfügbar zu machen) oder ein einheitliches Frontend hinzuzufügen.

Fazit

FastMCP senkt die Einstiegshürde für den Aufbau leistungsstarker, kontextsensitiver LLM-Anwendungen erheblich, indem es die Implementierung des Model Context Protocol vereinfacht. Sein Pythonic-Design, der Fokus auf die Reduzierung von Boilerplate und der umfassende Funktionsumfang machen es zu einer ausgezeichneten Wahl für Entwickler, die LLMs mit benutzerdefinierten Tools und Datenzugriff sicher und effizient ausstatten möchten.

Indem Sie die oben beschriebenen Schritte befolgen – FastMCP installieren, eine Serverinstanz erstellen, Tools und Ressourcen mithilfe einfacher Dekoratoren hinzufügen und den Server ausführen – können Sie schnell mit dem Erstellen Ihrer eigenen MCP-fähigen Anwendungen beginnen. Egal, ob Sie einfache Dienstprogramme oder komplexe, datenintensive Integrationen erstellen, FastMCP bietet die Grundlage für robuste und skalierbare LLM-Interaktionen.