Umfassendes Tutorial: FastAPI-APIs mit FastAPI-MCP in intelligente Werkzeuge verwandeln

FastAPI-MCP ist ein Framework, das FastAPI erweitert, um Ihre API-Endpunkte nahtlos als Model Context Protocol (MCP)-Werkzeuge bereitzustellen. Dieses Tutorial führt Sie von den Grundlagen bis zur fortgeschrittenen Nutzung von FastAPI-MCP und eignet sich sowohl für absolute Anfänger als auch für erfahrene FastAPI-Entwickler. Wir behandeln konzeptionelle Erklärungen, Komponentenaufschlüsselungen, Beispielcode und projektbasierte Illustrationen. Am Ende werden Sie wissen, wie Sie FastAPI-MCP einrichten, konfigurieren, mit Abhängigkeiten (Authentifizierung) sichern, in KI-Clients integrieren, bereitstellen und in realen Szenarien testen.

Einführung in FastAPI-MCP
Erste Schritte mit FastAPI-MCP
Verständnis von MCP-Werkzeugen und -Diensten
Strukturierung eines FastAPI-MCP-Projekts
Konfiguration und Anpassung
Dependency Injection und Sicherheit (Authentifizierung & Autorisierung)
Integration mit KI-Clients und -Werkzeugen
Bereitstellungsstrategien
Testen und Fehlerbehebung
Reale Beispiele und Anwendungsfälle
Zusammenfassung der Best Practices
Fazit
Referenzen

Einführung in FastAPI-MCP

FastAPI ist ein beliebtes Python-Webframework zum schnellen Erstellen von APIs mit automatischer OpenAPI-Dokumentation. MCP (Model Context Protocol) hingegen ist ein aufkommender offener Standard, der definiert, wie KI-Assistenten (wie GPT-4, Anthropic’s Claude usw.) mit Anwendungen und Werkzeugen kommunizieren. Stellen Sie sich MCP als einen „USB-C-Anschluss für KI-Anwendungen“ vor – eine universelle Schnittstelle, die es KI-Modellen ermöglicht, externe Werkzeuge oder Datenquellen standardisiert zu entdecken und zu nutzen. Mit MCP können KI-Modelle:

Entdecken, welche Werkzeuge (API-Operationen) verfügbar sind und was sie tun.
Verstehen, wie diese Werkzeuge aufgerufen werden (ihre Ein-/Ausgaben).
Daten abrufen oder Operationen über diese Werkzeuge auf einheitliche Weise ausführen.

FastAPI-MCP schließt die Lücke zwischen Ihren FastAPI-APIs und dem Ökosystem der KI-Werkzeuge. Einfach ausgedrückt, wird FastAPI-MCP Ihre bestehenden FastAPI-Endpunkte automatisch und mit minimalem Aufwand in MCP-kompatible Werkzeuge umwandeln. Das bedeutet, Sie können Ihre API für KI-Assistenten (wie Claude in der Cursor IDE, GPT in kompatiblen Clients usw.) verfügbar machen, sodass diese Ihre API-Operationen sicher und nahtlos aufrufen können.

Warum FastAPI-MCP verwenden?

FastAPI-MCP bietet einen FastAPI-nativen, konfigurationsfreien Ansatz zur KI-Integration. Sie müssen Ihre API nicht neu schreiben oder sich mit komplexen Plugin-Spezifikationen auseinandersetzen – FastAPI-MCP verwendet Ihre bestehende FastAPI-App und baut automatisch eine MCP-Schnittstelle darauf auf. Zu den Hauptmerkmalen gehören:

Native Abhängigkeitsintegration – Sie können MCP-Werkzeugaufrufe mit denselben Depends()-Abhängigkeiten (z. B. für die Authentifizierung) sichern, die Sie in FastAPI verwenden. Das bedeutet, dass vorhandene Authentifizierungs-/Autorisierungslogik für von KI initiierte Aufrufe wiederverwendet werden kann.
Schema- und Dokumentationserhaltung – Es bewahrt die Anfrage-/Antwortmodelle und die Dokumentation Ihrer Endpunkte, genau wie Ihre OpenAPI/Swagger-Dokumentation. KI-Agenten erhalten die gleichen Informationen über Parameter und Antworten wie menschliche Entwickler.
Keine/minimale Konfiguration – Zeigen Sie FastAPI-MCP einfach auf Ihre FastAPI-App und es funktioniert sofort. Keine manuelle Zuordnung oder spezielle Dekoratoren erforderlich.
FastAPI-First-Design – Es ist nicht nur ein Konverter von OpenAPI; es hakt sich direkt in das Routing- und Abhängigkeitssystem von FastAPI ein, um Effizienz und Genauigkeit zu gewährleisten.
Integrierte Authentifizierungsunterstützung – Es unterstützt das Hinzufügen von Authentifizierungsanforderungen (API-Schlüssel, OAuth2) für MCP-Endpunkte mithilfe von FastAPI-Abhängigkeiten oder Konfigurationen.
Flexible Bereitstellung – Sie können den MCP-Server auf derselben App (im selben Prozess) mounten oder als separaten Dienst bereitstellen; beide Modi werden unterstützt.
Effizienter ASGI-Transport – Standardmäßig werden MCP-Aufrufe prozessintern über ASGI abgewickelt (kein zusätzlicher HTTP-Hop), was die Kommunikation schnell macht und bei gemeinsamem Hosting nicht einmal eine Basis-URL erfordert.

Zusammenfassend lässt sich sagen, dass FastAPI-MCP es einfach macht, Ihre API in eine für KI zugängliche Schnittstelle zu verwandeln. Als Nächstes werden wir uns Schritt für Schritt mit der Einrichtung befassen.

Erste Schritte mit FastAPI-MCP

Beginnen wir von Grund auf und erstellen eine einfache FastAPI-App, um dann MCP darauf zu aktivieren. Dieser Abschnitt führt durch die Installation, die grundlegende Einrichtung und die Bestätigung, dass der MCP-Server läuft.

Installation

FastAPI-MCP ist ein Python-Paket. Sie können es über pip oder uv (ein schneller Python-Paketmanager, der von den Autoren empfohlen wird) installieren:

# Mit uv (falls installiert)
uv add fastapi-mcp

# Mit pip
pip install fastapi-mcp

Dadurch wird auch FastAPI (falls noch nicht vorhanden) als Abhängigkeit installiert. Stellen Sie sicher, dass Sie Python 3.10+ haben (FastAPI-MCP erfordert Python 3.10 oder neuer). Wahrscheinlich möchten Sie auch Uvicorn installieren, um die App auszuführen, sowie alle anderen FastAPI-Abhängigkeiten, die Sie verwenden möchten (wie pydantic usw.). Zum Beispiel:

pip install fastapi uvicorn

Jetzt sind Sie bereit, Ihre FastAPI-Anwendung zu erstellen und MCP zu integrieren.

Grundlegende Einrichtung und Implementierung

Schritt 1: Erstellen Sie eine FastAPI-App mit einem Endpunkt. Wenn Sie bereits eine FastAPI-App haben, können Sie diese verwenden; andernfalls erstellen wir eine minimale. Schreiben Sie in eine Datei (z. B. main.py):

from fastapi import FastAPI

app = FastAPI()

# Definieren Sie einen Beispiel-Endpunkt (Operation) wie gewohnt
@app.get("/items/{item_id}", operation_id="get_item")
async def read_item(item_id: int):
    """Retrieve an item by its ID"""
    return {"item_id": item_id, "name": f"Item {item_id}"}

Dies definiert einen einfachen GET-Endpunkt /items/{item_id}, der ein JSON mit der Artikel-ID und dem Namen zurückgibt. Wir haben ihm eine explizite operation_id="get_item" gegeben – dies ist der Name, der diesen Endpunkt als MCP-Werkzeug identifiziert (mehr dazu im nächsten Abschnitt). Wenn Sie keine operation_id angeben, generiert FastAPI automatisch eine, die jedoch tendenziell ausführlich ist (z. B. "read_item_items__item_id__get"), was weniger intuitiv ist.

Schritt 2: Mounten Sie FastAPI-MCP auf die App. Mit FastAPI-MCP ist die Umwandlung der obigen API in einen MCP-Server nur wenige Codezeilen entfernt. Weiter in main.py:

from fastapi_mcp import FastApiMCP

# ... (FastAPI-App und Endpunkte wie oben) ...

# Erstellen Sie eine MCP-Server-Instanz für unsere App
mcp = FastApiMCP(
    app,
    name="My API MCP",                  # Optionaler Name für den MCP-Dienst
    description="MCP server for my API" # Optionale Beschreibung
    # base_url="http://localhost:8000"  # Basis-URL, nicht erforderlich bei Verwendung des ASGI-Transports
)

# Mounten Sie den MCP-Server auf die FastAPI-App
mcp.mount()

Das ist alles! Durch den Aufruf von FastApiMCP(app) und mcp.mount() fügen wir unserer FastAPI-Anwendung einen voll funktionsfähigen MCP-Dienst hinzu. Wir haben einen menschenlesbaren Namen und eine Beschreibung für den MCP-Server angegeben (diese Metadaten helfen Clients, ihn zu identifizieren), und wir könnten bei Bedarf eine base_url angeben. Wenn auf derselben App gemountet, verwendet FastAPI-MCP direkte ASGI-Aufrufe, sodass base_url optional ist. (Wenn Sie den MCP getrennt von der Haupt-API bereitstellen, stellt eine base_url sicher, dass der MCP weiß, wohin er Anfragen senden soll – dieses Szenario besprechen wir später.)

Nach dem Mounten registriert FastAPI-MCP automatisch eine neue Route (standardmäßig unter dem Pfad /mcp) in Ihrer FastAPI-App. Dies ist der Endpunkt, mit dem sich MCP-Clients (KI-Agenten oder Werkzeuge) verbinden.

Schritt 3: Führen Sie die Anwendung aus. Starten Sie Ihre App mit Uvicorn (oder Ihrem bevorzugten ASGI-Server):

uvicorn main:app --reload --host 0.0.0.0 --port 8000

Dies startet die FastAPI-App (mit unserer Route /items/{item_id}) und auch den MCP-Server am Endpunkt /mcp.

Schritt 4: Testen Sie den MCP-Endpunkt. Öffnen Sie einen Browser (oder verwenden Sie curl) und gehen Sie zu http://127.0.0.1:8000/mcp. Sie werden keine typische JSON-Antwort sehen; stattdessen, da MCP Server-Sent Events (SSE) zur Kommunikation verwendet, hält Ihr Browser möglicherweise die Verbindung offen und zeigt einen Ereignisstrom an. Zum Beispiel könnten Sie so etwas sehen:

event: endpoint
data: /mcp/messages/?session_id=abcdef123456...

Das ist normal – es zeigt an, dass der MCP-Server läuft und bereit ist. Im Wesentlichen baut der MCP-Endpunkt sofort eine Sitzung für Clients über SSE auf. (Wenn Sie rohe SSE-Daten wie oben sehen, ist das zu erwarten, da Browser SSE-Streams nicht nativ rendern.)

Sie können auch überprüfen, ob Ihre ursprüngliche API noch funktioniert: Versuchen Sie http://127.0.0.1:8000/items/42 – es sollte wie gewohnt {"item_id": 42, "name": "Item 42"} zurückgeben. Die normale Funktionalität der FastAPI-App bleibt unverändert; der MCP-Server ist ein Add-on, das neben Ihrer API läuft.

An diesem Punkt haben Sie mit minimalem Setup einen MCP-fähigen FastAPI-Dienst. Die Fähigkeiten Ihrer API (in diesem Fall der einzelne Endpunkt /items/{item_id}) sind nun für jeden MCP-kompatiblen KI-Agenten auffindbar und aufrufbar. In den nächsten Abschnitten werden wir untersuchen, was genau bereitgestellt wurde, wie man es anpasst und wie ein KI-Client es verwenden würde.

Verständnis von MCP-Werkzeugen und -Diensten

Nachdem unser MCP-Server läuft, wollen wir klären, was FastAPI-MCP erstellt hat. Im Hintergrund behandelt FastAPI-MCP jede API-Operation als Werkzeug im Sinne von MCP, und die Sammlung von Werkzeugen, die am Endpunkt /mcp bereitgestellt werden, als Dienst (MCP-Serverdienst). Hier ist eine Aufschlüsselung der Komponenten:

MCP-Server (Dienst): Dies ist der Dienst, den wir unter /mcp gemountet haben. Er fungiert als Schnittstelle für KI-Clients. Wenn sich ein KI-Agent mit /mcp verbindet (normalerweise über SSE), kann er abfragen, welche Werkzeuge verfügbar sind, und sie aufrufen. Der MCP-Server kümmert sich um die Auflistung Ihrer Endpunkte und das Routing von Aufrufen zu ihnen.
MCP-Werkzeuge: Dies sind die einzelnen Operationen (Endpunkte) aus Ihrer FastAPI-App, die bereitgestellt werden. Jede FastAPI-Pfadoperation wird zu einem Werkzeug mit einem Namen, einer Beschreibung, einem Schema für Eingabeparameter und einem Ausgabeschema. Standardmäßig benennt FastAPI-MCP jedes Werkzeug nach der operation_id des Endpunkts. In unserem Beispiel hat der Endpunkt /items/{item_id} die operation_id="get_item", sodass ein KI-Client ein Werkzeug namens "get_item" sieht – er weiß, dass dieses Werkzeug eine item_id: int erwartet und ein Artikelobjekt zurückgibt.

Werkzeugerkennung und Dokumentation

Ein leistungsstarker Aspekt von FastAPI-MCP ist, dass es automatisch alle Ihre FastAPI-Endpunkte erkennt und deren Metadaten für KI bereitstellt. Dazu gehören: der Pfad, die HTTP-Methode, die erwarteten Eingabeparameter (mit Typen/Einschränkungen) und das Antwortmodell oder -schema. Im Wesentlichen spiegelt es wider, was in Ihrer OpenAPI-Dokumentation steht. Wenn Sie beispielsweise Pydantic-Modelle für Anfragen oder Antworten definiert haben, werden diese Schemata in die Werkzeugbeschreibung aufgenommen.

Das bedeutet, ein KI-Agent kann den MCP-Server abfragen (normalerweise durch eine anfängliche "Werkzeuge auflisten"-Anfrage) und eine Liste von Werkzeugnamen und -beschreibungen erhalten. Die Beschreibung jedes Werkzeugs enthält, was es tut und wie es verwendet wird. FastAPI-MCP verwendet den Docstring und jede Beschreibung, die Sie in der FastAPI-Route angegeben haben, als Teil der Werkzeugbeschreibung. Wenn Sie also Ihren Endpunkt dokumentiert haben (wie wir es mit einem Docstring für read_item getan haben), sieht die KI das. Eine gut dokumentierte API hilft der KI, Werkzeuge korrekt auszuwählen und zu verwenden.

Operation IDs und Werkzeugbenennung: Wie erwähnt, leiten sich Werkzeugnamen von der operation_id ab. Wenn Sie keine festlegen, generiert FastAPI automatisch einen Namen. Diese automatisch generierten Namen funktionieren, sind aber oft lang und nicht benutzerfreundlich. Für KI-Agenten ist es vorteilhaft, beschreibende, prägnante Namen zu haben – daher ist es eine Best Practice, für jeden Endpunkt eine operation_id festzulegen, die aussagekräftig ist. Zum Beispiel get_user_info für einen Endpunkt, der Benutzerinformationen abruft (anstelle eines Standardnamens wie read_user_users__user_id__get). Klare Werkzeugnamen erleichtern es einer KI zu entscheiden, welches Werkzeug für eine bestimmte Aufgabe verwendet werden soll.

Wenn Sie bereits eine bestehende FastAPI-App ohne operation_ids haben, können Sie diese hinzufügen, ohne die Funktionalität zu ändern (sie beeinflussen nur Dokumentation/Spezifikationen). Stellen Sie zumindest sicher, dass die operation_id jedes Endpunkts in der gesamten App eindeutig ist.

Wie KI-Agenten MCP-Werkzeuge verwenden

Ein KI-Agent (Client), der mit Ihrem MCP-Server verbunden ist, wird typischerweise:

Verfügbare Werkzeuge auflisten – Der Client fordert die Liste der Werkzeuge vom MCP-Server an (dies ist oft ein automatischer Schritt beim Verbinden). Der MCP-Server antwortet mit den Namen und Beschreibungen aller enthaltenen Endpunkte/Werkzeuge. Der Agent weiß nun, was er tun kann (z. B. sieht er ein Werkzeug get_item, das einen Artikel nach ID abruft).
Ein Werkzeug auswählen und aufrufen – Wenn die KI entscheidet, eine Aktion durchzuführen (z. B. „Artikel 42 abrufen“), ruft sie das entsprechende MCP-Werkzeug auf. Im Hintergrund bedeutet dies, eine Anfrage über das MCP-Protokoll zu senden (die FastAPI-MCP in einen Aufruf Ihres FastAPI-Endpunkts übersetzt). Die Eingabeparameter (wie item_id=42) werden übergeben, und FastAPI-MCP ruft die Funktion read_item genau wie bei einem regulären API-Aufruf auf und gibt das Ergebnis an den KI-Client zurück.
Das Ergebnis empfangen – Die KI erhält die Antwort des Endpunkts (hier {"item_id": 42, "name": "Item 42"}) über den MCP-Kanal und kann sie in ihrer Konversation oder Berechnung verwenden. Das Protokoll stellt sicher, dass die Antwort strukturiert ist (gemäß dem JSON-Schema Ihres Endpunkts).

All dies geschieht sicher und in Echtzeit. Aus Entwicklersicht ändert sich Ihr FastAPI-Endpunktcode überhaupt nicht – FastAPI-MCP übernimmt die Umwandlung des Werkzeugaufrufs der KI in einen normalen Funktionsaufruf an Ihren Endpunkt und das Streamen der Antwort zurück.

Wichtig: MCP verwendet standardmäßig SSE-Streaming für Antworten, da einige Werkzeugausgaben groß sein oder gestreamt werden könnten. FastAPI-MCP übernimmt dies für Sie. Wenn sich ein Client über SSE verbindet, werden Ergebnisse als Ereignisse gesendet. Wenn ein Client SSE nicht verarbeiten kann, könnte er einen Proxy verwenden (später besprochen). In jedem Fall müssen Sie sich als API-Entwickler normalerweise keine Gedanken über die Streaming-Details machen – implementieren Sie Ihren Endpunkt normal (geben Sie Daten zurück oder verwenden Sie StreamingResponse, wenn Sie bereits streamen). FastAPI-MCP passt es an die Anforderungen von MCP an.

Strukturierung eines FastAPI-MCP-Projekts

Egal, ob Sie FastAPI-MCP zu einem bestehenden Projekt hinzufügen oder ein neues starten, Sie sollten Ihren Code wartbar organisieren. In kleinen Demos ist alles in einer Datei in Ordnung, aber für größere Projekte sollten Sie die folgende Struktur in Betracht ziehen:

myproject/
├── app.py          # FastAPI-App und Definitionen der API-Routen
├── mcp_app.py      # (Optional) Separate FastAPI-App für MCP bei separater Bereitstellung
├── routes/         # Paket für Routenmodule, wenn Sie Ihre Endpunkte aufteilen
│   ├── __init__.py
│   └── items.py    # z.B. definiert /items Endpunkte
├── models/         # Datenmodelle (Pydantic-Modelle usw.)
├── auth/           # Auth-Hilfsprogramme (falls vorhanden)
└── ... (andere Module)

Setup mit einer einzigen App: Wenn Sie planen, den MCP auf derselben Anwendungsinstanz wie Ihre API bereitzustellen (was am einfachsten ist), können Sie ihn in Ihren Hauptanwendungscode integrieren. Zum Beispiel instanziieren Sie in app.py, nachdem Sie alle Ihre Routen definiert haben, FastApiMCP(app) und rufen mcp.mount() auf. Es ist oft ratsam, den MCP zu erstellen, nachdem alle Ihre Routen hinzugefügt wurden, damit er jeden Endpunkt erfasst. Auf diese Weise müssen Sie den MCP nicht „aktualisieren“, wenn neue Routen hinzugefügt werden (mehr zum Aktualisieren gleich).

Setup mit separater App (Microservice-Stil): In einigen Fällen möchten Sie den MCP-Server möglicherweise als separaten Dienst von der Haupt-API ausführen. FastAPI-MCP unterstützt dies, indem es Ihnen erlaubt, den MCP auf einer anderen FastAPI-App zu mounten. Zum Beispiel:

# Datei: api_app.py
from fastapi import FastAPI
api_app = FastAPI()
# ... definieren Sie alle Ihre API-Endpunkte auf api_app ...

# Datei: mcp_app.py
from fastapi import FastAPI
from fastapi_mcp import FastApiMCP
from api_app import api_app  # importieren Sie die andere FastAPI-App

mcp_app = FastAPI()                 # separate App nur für MCP
mcp = FastApiMCP(api_app)           # erstellen Sie MCP aus der API-App
mcp.mount(mcp_app)                  # mounten Sie MCP-Routen auf die separate App

Hier haben wir zwei FastAPI-Instanzen: api_app (mit unseren regulären Endpunkten) und mcp_app (die nur die MCP-Schnittstelle bereitstellt). Wir übergeben api_app an FastApiMCP und mounten es auf mcp_app. Wir würden diese beiden Apps dann separat ausführen (z. B. uvicorn api_app:api_app auf einem Host/Port und uvicorn mcp_app:mcp_app auf einem anderen). Der MCP-Server ruft intern die andere App auf. In diesem Szenario, da es sich um separate Prozesse handelt, sollten Sie die base_url in FastApiMCP so einstellen, dass sie auf den API-Host zeigt (oder einen benutzerdefinierten HTTP-Client bereitstellen), damit der MCP weiß, wie er die API-App erreichen kann. Alternativ können Sie sie im selben Prozess ausführen, indem Sie eine App in die andere mounten, aber das ist weniger üblich.

Welches Setup wählen? Für viele Fälle ist das Mounten von MCP auf derselben App (vielleicht unter dem Pfad /mcp) völlig in Ordnung und einfacher. Es hält alles in einem Dienst zur Bereitstellung zusammen. Eine separate Bereitstellung könnte jedoch nützlich sein, wenn:

Sie die MCP-Schnittstelle unabhängig skalieren oder sichern möchten. Wenn der MCP-Dienst beispielsweise für die interne Nutzung durch KI-Agenten vorgesehen ist, könnten Sie ihn in einem internen Netzwerk getrennt von der Haupt-API hosten.
Sie den MCP-Server auf einem anderen Port oder einer anderen Domain ausführen möchten (möglicherweise aufgrund von SSE- oder Client-Anforderungen).
Ihre API sehr leistungsempfindlich ist und Sie den Overhead von MCP lieber isolieren möchten (obwohl MCP leichtgewichtig ist).

Die Flexibilität von FastAPI-MCP bedeutet, dass Sie damit beginnen können, es zusammen zu mounten (zur Entwicklungserleichterung) und es später herauszulösen, ohne Ihren Endpunktcode zu ändern – passen Sie einfach an, wie Sie den MCP-Server erstellen und mounten.

Tipps zur Projektstruktur: Halten Sie Ihre FastAPI-App modular (verwenden Sie Router, separate Dateien für Logik), da FastAPI-MCP nur das endgültige FastAPI-App-Objekt benötigt. Wenn Sie neue Routen hinzufügen, nachdem MCP eingerichtet wurde (z. B. dynamisch oder in einer interaktiven Umgebung), müssen Sie den MCP-Server aktualisieren, um sie zu übernehmen (über mcp.setup_server(), das die Endpunkte neu scannt). In einer typischen statischen App stellen Sie einfach sicher, dass alle Routen definiert sind, bevor Sie MCP mounten. Wenn Sie es jemals vergessen und Ihre neuen Werkzeuge nicht erscheinen, können Sie mcp.setup_server() aufrufen oder die MCP-Instanz neu erstellen.

Konfiguration und Anpassung

FastAPI-MCP funktioniert standardmäßig ohne Konfiguration, bietet jedoch mehrere Optionen zur Anpassung des Verhaltens des MCP-Servers und der bereitgestellten Werkzeuge. Hier besprechen wir, wie man Server-Metadaten konfiguriert, die Werkzeugdokumentation verbessert und filtert, welche Endpunkte bereitgestellt werden.

Server-Metadaten (Name & Beschreibung)

Beim Erstellen von FastApiMCP können Sie einen name und eine description für Ihren MCP-Dienst übergeben. Diese helfen Clients, Ihren Dienst zu identifizieren. Zum Beispiel:

mcp = FastApiMCP(app,
                 name="Inventory API MCP",
                 description="MCP interface for my Inventory API")

Im MCP-Protokoll kann der Server einen Namen/eine Beschreibung präsentieren, die Clients möglicherweise in einer Benutzeroberfläche anzeigen. Es ist optional, wird aber empfohlen, insbesondere wenn Sie mehrere MCP-Dienste betreiben. Standardmäßig kann ein generischer Name verwendet werden, wenn keiner festgelegt ist. Das Festlegen einer klaren Beschreibung (z. B. „Endpunkte zur Verwaltung von Inventarartikeln“) kann KI-Agenten oder Entwicklern Hinweise auf den Zweck des Dienstes geben.

Werkzeugbeschreibungen und Antwortschemata

FastAPI-MCP verwendet automatisch Ihre FastAPI-Dokumentation (Pfadoperationsbeschreibungen, Pydantic-Schema-Dokumentationen usw.), um jedes Werkzeug zu beschreiben. Wenn Sie der KI noch umfangreichere Beschreibungen zur Verfügung stellen möchten, bietet FastAPI-MCP Flags, um mehr Schemadetails einzubeziehen:

describe_all_responses=True: Schließt die Dokumentation aller möglichen Antwortcodes und Schemata für den Endpunkt in die Werkzeugbeschreibung ein. Normalerweise konzentriert sich eine Werkzeugbeschreibung möglicherweise auf die Haupt-Erfolgsantwort; hiermit werden auch mehrere Antwortmodelle (z. B. Fehlerantworten) beschrieben.
describe_full_response_schema=True: Schließt das vollständige JSON-Schema des Antwortmodells in die Werkzeugbeschreibung ein. Dies kann für KI-Agenten sehr nützlich sein, um die Struktur der Ausgabe vollständig zu verstehen. Wenn Ihr Endpunkt beispielsweise ein verschachteltes JSON zurückgibt, kennt die KI die genauen erwarteten Felder und Typen.

Sie können diese beim Instanziieren von FastApiMCP aktivieren:

mcp = FastApiMCP(app,
                 describe_all_responses=True,
                 describe_full_response_schema=True)

Beachten Sie, dass extrem ausführliche Beschreibungen einem KI-Modell helfen können oder auch nicht – es könnte für die Präzision vorteilhaft sein, aber einige Clients könnten sehr lange Beschreibungen kürzen. Verwenden Sie diese Flags nach Bedarf, insbesondere wenn Ihre Endpunkte komplexe Ausgaben haben, über die die KI informiert sein sollte.

Filtern von Endpunkten (Selektive Bereitstellung)

In vielen Fällen möchten Sie möglicherweise nicht jeden API-Endpunkt für KI-Agenten verfügbar machen. Zum Beispiel könnte eine Anwendung interne oder Admin-Endpunkte haben, die für eine KI nicht sicher zu verwenden sind oder einfach nicht relevant sind. FastAPI-MCP ermöglicht es Ihnen, Endpunkte anhand ihrer Operations-IDs oder Tags ein- oder auszuschließen.

Sie haben vier optionale Hauptparameter zum Filtern von Werkzeugen:

include_operations: Eine Liste von Operations-IDs, die eingeschlossen werden sollen. Nur diese werden zu MCP-Werkzeugen (alle anderen werden ignoriert).
exclude_operations: Eine Liste von Operations-IDs, die ausgeschlossen werden sollen (alles andere wird eingeschlossen).
include_tags: Schließt nur Endpunkte ein, die eines dieser FastAPI-Tags haben. Wenn Sie Ihre Routen nach Tags organisieren (z. B. tags=["public"]), könnten Sie nur die „öffentlichen“ verfügbar machen.
exclude_tags: Schließt Endpunkte aus, die eines dieser Tags haben.

Hinweis: Sie können das Ein- und Ausschließen desselben Typs nicht mischen – zum Beispiel können Sie nicht gleichzeitig include_operations und exclude_operations verwenden. Sie können jedoch Operationsfilter mit Tag-Filtern kombinieren. Die Logik beim Kombinieren ist eine gierige Vereinigung: Endpunkte, die einem Einschlusskriterium entsprechen, werden eingeschlossen, dann werden alle entfernt, die einem Ausschlusskriterium entsprechen.

Beispiele:

Nur bestimmte Endpunkte verfügbar machen:
```
mcp = FastApiMCP(app, include_operations=["get_item", "list_items"])
```
Dies würde nur die Werkzeuge namens get_item und list_items verfügbar machen (und keine anderen Endpunkte).
Einen gefährlichen Endpunkt ausschließen:
```
mcp = FastApiMCP(app, exclude_operations=["delete_item"])
```
Dies macht alle Endpunkte verfügbar, außer dem mit der operation_id „delete_item“. Nützlich, wenn Sie bestimmte Operationen (wie Löschen oder sensible Aktionen) für die KI-Nutzung blockieren möchten.
Nach Tags: Angenommen, Sie markieren bestimmte Routen als admin oder internal. Dann:
```
mcp = FastApiMCP(app, exclude_tags=["admin", "internal"])
```
würde alles verfügbar machen, außer Endpunkten, die mit diesen Tags markiert sind (um sicherzustellen, dass interne APIs nicht für KI verfügbar sind).
Kombiniert: Wenn Sie nur bestimmte Tags einschließen, aber auch eine bestimmte Operation innerhalb dieser ausschließen möchten, könnten Sie Folgendes tun:
```
mcp = FastApiMCP(app, include_tags=["public"], exclude_operations=["reset_database"])
```
Dies würde alle Endpunkte nehmen, die mit "public" getaggt sind, und sie verfügbar machen, außer einem, dessen operation_id "reset_database" ist, selbst wenn er dieses Tag hätte.

Mithilfe von Filtern können Sie die Angriffsfläche Ihrer API, die für KI zugänglich ist, feinabstimmen. Eine gängige Strategie besteht darin, nur schreibgeschützte oder sichere Operationen verfügbar zu machen und alles auszuschließen, was Daten ändert oder kritische Aktionen durchführt (insbesondere wenn Ihr MCP-Server von nicht vertrauenswürdigen KI-Agenten aufgerufen werden könnte). Dies führt zu Sicherheitsüberlegungen, die wir als Nächstes behandeln werden.

Aktualisieren von Werkzeugen bei Änderungen

Wenn Ihre Anwendung langlebig ist und Sie dynamisch Routen hinzufügen (vielleicht durch das Mounten neuer Router zur Laufzeit oder andere Plugin-Systeme), denken Sie daran, dass die Liste der Werkzeuge von FastAPI-MCP erstellt wird, wenn Sie mcp.mount() (oder setup_server()) aufrufen. Später hinzugefügte neue Endpunkte erscheinen nicht automatisch, bis Sie sie aktualisieren. Sie haben zwei Möglichkeiten, damit umzugehen:

Definieren Sie zuerst alle Routen, dann erstellen Sie den MCP-Server. Beim normalen Start ordnen Sie einfach Ihren Code so an, dass Sie das Hinzufügen von Routen zu app abschließen, bevor Sie FastApiMCP(app) und mount() aufrufen. Dies ist der einfachste Ansatz und vermeidet Probleme.
Manuell aktualisieren, falls erforderlich. Wenn Sie eine Route nach dem Mounten von MCP hinzufügen müssen, rufen Sie anschließend mcp.setup_server() auf, um den neuen Endpunkt neu zu scannen und zu registrieren. Alternativ könnten Sie FastApiMCP neu initialisieren (aber setup_server() ist einfacher). Die FAQ weist auf diese Anforderung hin: Nach der Erstellung hinzugefügte Endpunkte werden erst nach erneuter Registrierung der Werkzeuge gesehen.

In der Entwicklung vergisst man das leicht – wenn Sie ein erwartetes Werkzeug nicht sehen, überprüfen Sie, ob der MCP zu früh erstellt wurde. Die Protokoll- oder SSE-Ausgabe könnte auch warnen, dass keine Werkzeuge gefunden wurden, wenn das passiert.

Dependency Injection und Sicherheit (Authentifizierung & Autorisierung)

Die Sicherung Ihrer API beim Zugriff durch KI ist entscheidend. FastAPI-MCP ermöglicht es Ihnen, das Dependency-Injection-System von FastAPI zu nutzen, um Authentifizierung oder andere Prüfungen bei MCP-Aufrufen zu erzwingen, genau wie bei normalen API-Aufrufen. Mit anderen Worten, Sie können OAuth2, API-Schlüssel-Authentifizierung, Berechtigungsprüfungen usw. auf die MCP-Schnittstelle anwenden, sodass nur autorisierter Zugriff erlaubt ist.

Verwendung von FastAPI-Abhängigkeiten für die Authentifizierung

FastAPI-Endpunkte verwenden oft Abhängigkeiten (über Depends(), Security() usw.) zur Authentifizierung. Zum Beispiel könnten Sie haben:

from fastapi import Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

@app.get("/users/me")
async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = verify_token_and_get_user(token)
    if not user:
        raise HTTPException(status_code=401, detail="Invalid or expired token")
    return {"username": user.username}

Wenn Sie einen solchen Endpunkt über MCP verfügbar machen, müsste ein KI-Client den Authorization-Header (mit einem Bearer-Token) bereitstellen, um ihn zu verwenden. FastAPI-MCP wird alle Abhängigkeiten des ursprünglichen Endpunkts berücksichtigen. Das bedeutet, wenn die Abhängigkeit eine HTTPException auslöst (z. B. 401), führt der MCP-Aufruf ebenfalls zu einem Fehler (und die KI erhält einen Fehlschlag).

Allerdings können nicht alle KI-Clients problemlos Authentifizierungstoken bereitstellen. Viele aktuelle MCP-Clients sind IDEs oder Agenten, die möglicherweise nichts über Ihre Authentifizierung wissen. Um dies zu handhaben, bietet FastAPI-MCP ein auth_config oder ein einfacheres dependencies-Argument, das die Authentifizierung auf der MCP-Ebene erzwingen und die Token-Weitergabe erleichtern kann.

Grundlegende API-Schlüssel- oder Token-Authentifizierung

Der einfachste Weg, den MCP-Server zu sichern, besteht darin, einen API-Schlüssel für alle Werkzeugaufrufe zu verlangen. Sie können dies tun, indem Sie FastApiMCP eine Abhängigkeit hinzufügen, die einen Header überprüft. Zum Beispiel mit einem API-Schlüssel-Header:

from fastapi import Security, HTTPException
from fastapi.security import APIKeyHeader

api_key_header = APIKeyHeader(name="X-API-Key")

async def verify_api_key(key: str = Security(api_key_header)):
    if key != "mysecret123":
        raise HTTPException(status_code=403, detail="Invalid API Key")
    return True

mcp = FastApiMCP(app,
    # stellt sicher, dass jede MCP-Anfrage von verify_api_key abhängt
    auth_config=AuthConfig(dependencies=[Depends(verify_api_key)])
)
mcp.mount()

Jetzt erfordert jeder Aufruf eines Werkzeugs über die MCP-Schnittstelle den Header X-API-Key: mysecret123. Wenn der Header fehlt oder falsch ist, wird die MCP-Anfrage mit 403 Forbidden abgelehnt. Im Wesentlichen fügt dies eine globale Abhängigkeit zum MCP-Server selbst hinzu.

Hinweis: In älteren Beispielen oder einfacherer Verwendung sehen Sie möglicherweise FastApiMCP(app, mcp_dependencies=[Depends(verify_api_key)]), was den gleichen Effekt erzielt. Der neueste Ansatz verpackt es in AuthConfig für erweiterte Optionen. In jedem Fall ist das Konzept dasselbe: FastAPI-MCP kann eine Abhängigkeit verwenden, um die Werkzeuge zu schützen.

Für ein API-Schlüsselschema muss der KI-Client diesen Header senden. Wenn Sie ein Werkzeug wie mcp-remote oder einen benutzerdefinierten Client verwenden, können Sie es so konfigurieren, dass es bei jeder Anfrage Header einschließt. Zum Beispiel mit mcp-remote (einem Node-basierten Proxy-Client) kann man einen Header wie folgt übergeben:

"mcpServers": {
  "myapi": {
    "command": "npx",
    "args": ["mcp-remote", "http://localhost:8000/mcp", "--header", "X-API-Key:mysecret123"]
  }
}

Dies stellt sicher, dass der Header bei jedem Aufruf angehängt wird und die Abhängigkeit erfüllt ist.

OAuth2-Authentifizierung

FastAPI-MCP unterstützt auch den vollständigen OAuth2 Authorization Code Flow, wie in der MCP-Spezifikation (2025-03-26) festgelegt. Dies ist komplexer, ermöglicht aber eine benutzergesteuerte OAuth-Anmeldung, wenn der Client dies unterstützt. In der Praxis unterstützen viele MCP-Clients derzeit nicht vollständig die interaktiven OAuth-Flows, sodass die Verwendung eines API-Tokens oder API-Schlüssels (wie oben) möglicherweise einfacher ist. Wenn Sie OAuth2 benötigen, können Sie AuthConfig mit OAuth-Einstellungen wie Aussteller, Autorisierungs-URL, Token-URL usw. konfigurieren. Zum Beispiel:

mcp = FastApiMCP(app, auth_config=AuthConfig(
    issuer="https://auth.example.com/",
    authorize_url="https://auth.example.com/authorize",
    oauth_metadata_url="https://auth.example.com/.well-known/oauth-authorization-server"
))

Dies würde dem MCP-Client die OAuth-Details mitteilen. Die Idee ist, dass der KI-Agent (oder der Benutzer, der ihn steuert) ein Token über OAuth erhalten könnte, um die Werkzeuge zu verwenden. In der Praxis, bis die KI-Client-Tools aufholen, könnten Sie sich auf Token-Passthrough oder API-Schlüssel verlassen.

Tipp: Sie können Ansätze kombinieren: Erlauben Sie beispielsweise einfaches Token-Passthrough und haben Sie zusätzlich eine Authentifizierungsabhängigkeit, die auf ein gültiges Token prüft. Die offizielle Dokumentation legt nahe, dass FastAPI-MCP einen Authorization: Bearer <token>-Header vom Client einfach an die FastAPI-Endpunkte weiterleitet. Wenn Ihre Endpunkte also bereits ein Bearer-Token über Depends(oauth2_scheme) erwarten, funktioniert es, solange der Client es bereitstellt. Die Verwendung von mcp-remote --header Authorization:Bearer <token> ist eine Möglichkeit, dies sicherzustellen.

Andere Verwendungen von Dependency Injection

Abgesehen von der Authentifizierung könnten Ihre Endpunkte Abhängigkeiten für andere Dinge verwenden (Datenbanksitzung usw.). Die gute Nachricht ist, dass all diese weiterhin normal funktionieren. FastAPI-MCP ruft Ihren Endpunkt über die FastAPI-App auf, sodass Abhängigkeiten wie db: Session = Depends(get_db) wie gewohnt ausgeführt werden. Es gibt keinen Unterschied zwischen einem von KI ausgelösten Aufruf und einem regulären HTTP-Aufruf hinsichtlich der Ausführung Ihres Endpunktcodes – dieselbe Dependency Injection und derselbe Kontext gelten.

Eine Sache zu beachten: Wenn eine Abhängigkeit einen bestimmten Kontext erwartet (wie ein Anfrageobjekt oder spezielle Header), stellen Sie sicher, dass der MCP-Client diese bereitstellt oder dass Ihre Abhängigkeit damit umgehen kann, wenn sie fehlen. Zum Beispiel könnten Abhängigkeiten, die auf Request angewiesen sind, sich unter MCP anders verhalten, da die „Anfrage“ der MCP-Aufruf ist. Aber in den meisten Fällen ist das kein Problem.

Sicherheits-Best-Practices: Wenn Sie Ihre API über MCP für KI verfügbar machen, beachten Sie diese Richtlinien (ähnlich der normalen API-Sicherheit, aber unter Berücksichtigung der Unvorhersehbarkeit von KI-Agenten):

Nur sichere Endpunkte verfügbar machen: Bevorzugen Sie schreibgeschützte oder idempotente Operationen. Seien Sie sehr vorsichtig, wenn Sie etwas verfügbar machen, das Daten ändert oder irreversible Aktionen durchführt. Wenn Sie dies tun, stellen Sie sicher, dass eine Authentifizierung erforderlich ist und vielleicht sogar ein Genehmigungsschritt außerhalb von MCP.
Authentifizierung für sensible Operationen verlangen: Verlassen Sie sich nicht auf Unklarheit. Wenn ein Endpunkt sensible Daten zurückgibt, schützen Sie ihn mit ordnungsgemäßer Authentifizierung, auch wenn Sie denken, „nur die KI“ weiß davon. MCP-Listings könnten für jeden Client mit Zugriff zugänglich sein. Verwenden Sie API-Schlüssel oder OAuth nach Bedarf.
Eingaben streng validieren: Ihre Endpunkte sollten dies bereits tun (mit Pydantic-Modellen, Typ-Hinweisen). Dies ist besonders wichtig, wenn der Aufrufer eine KI ist, die Fehler machen könnte. Robuste Validierung verhindert, dass die KI versehentlich ungültige Daten übergibt oder etwas Unbeabsichtigtes durchführt.
Ausgaben bei Bedarf bereinigen: Wenn bestimmte Daten teilweise maskiert oder vor der Rückgabe verarbeitet werden sollen (aus Datenschutz- oder Sicherheitsgründen), stellen Sie sicher, dass Ihr Endpunkt dies tut. Gehen Sie nicht davon aus, dass die KI die Vertraulichkeit handhabt – es ist besser, wenn die Daten, die Ihren Server verlassen, sicher sind.
Nutzung überwachen: Führen Sie Protokolle darüber, wann Werkzeuge aufgerufen werden und mit welchen Parametern. Die Überwachung, wie die KI Ihre API verwendet, kann helfen, Missbrauch oder notwendige Verbesserungen zu identifizieren. Sie könnten Muster erkennen, wie z. B. dass eine KI einen Endpunkt zu häufig oder mit seltsamen Parametern aufruft, was auf ein Missverständnis hindeuten könnte, das Sie durch Anpassen von Beschreibungen oder Hinzufügen von Einschränkungen beheben können.

Durch die Verwendung des robusten Dependency-Injection- und Sicherheitsmodells von FastAPI ermöglicht Ihnen FastAPI-MCP, all diese Maßnahmen für den KI-Zugriff genauso durchzusetzen wie für den menschlichen Zugriff.

Integration mit KI-Clients und -Werkzeugen

Sobald Ihr FastAPI-MCP-Server eingerichtet und angemessen gesichert ist, besteht der nächste Schritt darin, ihn tatsächlich mit einem KI-Client zu verwenden. Es gibt verschiedene Möglichkeiten, wie KI-Systeme sich mit Ihrem MCP-Dienst verbinden können:

Direkte SSE-Verbindung: Viele KI-IDEs oder Agenten-Frameworks unterstützen MCP nativ über SSE.
Proxy oder Bridge (mcp-remote): Ein kleiner Proxy, der SSE und erweiterte Funktionen handhabt, hilfreich, wenn der Client SSE nicht unterstützt oder Sie Authentifizierung einschleusen müssen.
Inspektor- oder Testwerkzeuge: Nützlich für manuelles Testen und Debuggen Ihrer MCP-Schnittstelle.
Benutzerdefinierte Integration (LangChain oder benutzerdefinierter Code): Sie können auch Code schreiben, um sich mit einem MCP-Server zu verbinden, obwohl Bibliotheken dafür noch im Entstehen sind.

Lassen Sie uns die gängigen Methoden untersuchen.

Verbindung über Server-Sent Events (Direkt)

MCP-Server (wie FastAPI-MCP) verwenden grundlegend Server-Sent Events zur Kommunikation. Werkzeuge wie Cursor IDE, Claude Desktop, Windsurf, VSCode-Erweiterungen und andere haben begonnen, MCP zu unterstützen, indem sie Ihnen erlauben, einen MCP-Endpunkt zu konfigurieren.

Zum Beispiel können Sie in Cursor (KI-Coding-Assistent-IDE) Ihren MCP-Server in den Einstellungen hinzufügen. Dies könnte das Bearbeiten einer Konfigurationsdatei mcp.json beinhalten, um Ihren Server einzuschließen. Laut einer Anleitung würden Sie etwa Folgendes hinzufügen:

{
  "mcpServers": {
    "fastapi-mcp": {
      "url": "http://localhost:8000/mcp"
    }
  }
}

Hier ist "fastapi-mcp" nur ein Label, das Sie vergeben, und die url zeigt auf Ihren laufenden FastAPI-MCP-Endpunkt. In Cursor würden Sie zu Einstellungen → MCP → Neuen MCP-Server hinzufügen gehen und die URL eingeben. Nach der Konfiguration verbindet sich der Client (oft sofort oder wenn Sie einen KI-Chat öffnen) mit Ihrem MCP-Server.

Was passiert als Nächstes? Typischerweise listet die IDE oder der Client nun neue „Werkzeuge“ oder Fähigkeiten auf. Im Fall von Cursor könnten Sie in der Agentenoberfläche sehen, dass die Werkzeuge Ihrer API (wie get_item) für die KI zur Verfügung stehen. Das KI-Modell (mit etwas System-Prompt-Engineering) wird über diese Werkzeuge informiert. Jetzt können Sie die KI bitten, sie zu verwenden. Zum Beispiel könnten Sie auffordern: „Verwende das get_item-Werkzeug, um Artikel 42 abzurufen.“ Die KI ruft über die MCP-Integration das Werkzeug auf und gibt das Ergebnis in ihrer Antwort zurück.

Zur Veranschaulichung könnte man nach der Einrichtung einfach die KI fragen (im Agenten-Tab von Cursor): „Rufe den Endpunkt /items/42 für mich auf.“ Die KI würde erkennen, dass dies dem get_item-Werkzeug entspricht, es ausführen und wahrscheinlich mit den Daten antworten. Das ist unglaublich mächtig – die KI fungiert effektiv als Vermittler zu Ihrer API und ermöglicht konversationelle oder autonome Interaktionen mit Ihrem Dienst.

Die meisten modernen MCP-fähigen Clients verwenden SSE, daher ist eine direkte Verbindung oft am einfachsten. Stellen Sie sicher, dass Ihre MCP-Server-URL für den Client zugänglich ist (wenn Sie beide lokal ausführen, ist localhost in Ordnung; wenn die KI remote ist, müssten Sie eine URL bereitstellen, die die KI erreichen kann).

Verwendung eines MCP-Proxys (für Authentifizierung oder inkompatible Clients)

Nicht alle KI-Clients unterstützen SSE oder benutzerdefinierte Header. Zum Beispiel unterstützte Anthropic’s Claude Desktop (in früheren Versionen) SSE für MCP nicht nativ, und einige Werkzeuge erlauben es Ihnen möglicherweise nicht, benutzerdefinierte Authentifizierungsheader einfach hinzuzufügen. In diesen Fällen ist die empfohlene Lösung die Verwendung von mcp-remote (in einigen Dokumentationen auch als mcp-proxy bezeichnet). Dies ist ein npm-Paket, das im Wesentlichen als Brücke fungiert: Es verbindet sich auf der einen Seite über SSE mit Ihrem MCP-Server und bietet auf der anderen Seite eine lokale stdio- oder WebSocket-Schnittstelle, die der KI-Client verwenden kann.

Zum Beispiel könnten Sie einen MCP-Client-Eintrag wie folgt konfigurieren:

{
  "mcpServers": {
    "myapi-via-proxy": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://localhost:8000/mcp",
        "8080"
      ]
    }
  }
}

Dies würde dem System mitteilen, npx mcp-remote http://localhost:8000/mcp 8080 auszuführen. Dieser Befehl verbindet sich mit Ihrem MCP-Endpunkt und öffnet einen lokalen Port 8080, den die KI verwenden kann. Die KI würde sich dann tatsächlich mit dem Proxy verbinden (der sich möglicherweise als MCP-Server ohne SSE-Einschränkungen präsentiert). Der Proxy leitet Anfragen an Ihren echten FastAPI-MCP-Dienst weiter und leitet Antworten zurück.

Sie können auch Header über mcp-remote weitergeben, wie zuvor gezeigt, mit --header "Authorization:Bearer XYZ" oder Ähnlichem, was für die Authentifizierung sehr praktisch ist. Im Wesentlichen kann mcp-remote diese Header bei jedem Aufruf für Sie einfügen, sodass der Client nichts davon wissen muss.

Verwenden Sie mcp-remote, wenn:

Ihr Client das Bereitstellen der erforderlichen Authentifizierungsheader nicht unterstützt oder SSE nicht unterstützt.
Sie die KI in einer Umgebung ausführen möchten, in der eine lokale Portverbindung einfacher ist als SSE (in einigen Fällen aus Firewall- oder Kompatibilitätsgründen).
Sie den Datenverkehr debuggen oder protokollieren müssen – das Ausführen eines Proxys kann Ihnen ermöglichen, die hin- und hergehenden Anfragen zu sehen.

mcp-remote ist ein Node-Tool, daher benötigen Sie Node.js in der Umgebung, in der der KI-Client ausgeführt wird. Der Overhead ist normalerweise gering.

MCP Inspector (Manuelles Testen)

Bevor Sie überhaupt eine KI einbeziehen, möchten Sie vielleicht Ihren MCP-Server manuell testen, um zu sehen, welche Werkzeuge er bereitstellt und sicherzustellen, dass sie funktionieren. Der MCP Inspector ist ein Befehlszeilen-Dienstprogramm für diesen Zweck, bereitgestellt vom Model Context Protocol-Projekt. Sie können es auch mit npx ausführen:

npx @modelcontextprotocol/inspector

Dies startet eine interaktive Eingabeaufforderung (wahrscheinlich in einem Browser), in der Sie Ihre MCP-Server-URL eingeben und sie inspizieren können. Schritte zur Verwendung:

Stellen Sie sicher, dass Ihr FastAPI-MCP-Server läuft.
Führen Sie den Inspektor aus (npx @modelcontextprotocol/inspector).
Wenn Sie dazu aufgefordert werden, geben Sie die MCP-Endpunkt-URL ein (z. B. http://localhost:8000/mcp).
Der Inspektor listet die verfügbaren Werkzeuge auf. Sie können ein Werkzeug auswählen und Parameter eingeben, um den Aufruf zu testen, und dann auf "Werkzeug ausführen" klicken.
Sie sehen die Antwort und können bestätigen, dass alles korrekt verbunden ist.

Dies ist im Wesentlichen wie eine Swagger-UI, aber für MCP. Es ist sehr hilfreich, um zu bestätigen, dass Ihre Endpunkte wie erwartet erscheinen und dass die Authentifizierung funktioniert (wenn Sie Authentifizierung eingerichtet haben, müssen Sie möglicherweise Header im Inspektor angeben – er hat auch Optionen zum Hinzufügen von Headern).

Integration über Code (LangChain oder Benutzerdefiniert)

Was ist, wenn Sie Ihren eigenen KI-Agenten in Python erstellen möchten, der den MCP-Server verwendet? Während Sie direkt einen HTTP-Client verwenden könnten, um sich mit /mcp zu verbinden und SSE zu handhaben, ist das etwas Low-Level. Es entstehen Bibliotheken zur Unterstützung. Zum Beispiel erwähnt das fastapi-mcp GitHub-Repository einen MCP-Client und Werkzeuge zum Komponieren von Servern. Es gibt auch ein Projekt namens FastMCP (jlowin/fastmcp), das MCP-Clients erstellen und sogar mehrere MCP-Server komponieren kann.

Derzeit sind dies fortgeschrittene Themen, aber ein Beispielansatz könnte sein:

Verwenden Sie Python's httpx oder requests, um eine GET-Anfrage an /mcp mit stream=True zu initiieren, um SSE-Ereignisse zu handhaben.
Parsen Sie das anfängliche "endpoint"-Ereignis, um die Sitzung oder den Kontrollendpunkt zu erhalten (oft beinhaltet das Protokoll eine anfängliche Nachricht mit einer messages-URL).
Senden Sie einen Befehl zum Auflisten von Werkzeugen (die MCP-Spezifikation definiert eine Nachricht dafür) und parsen Sie die Antwort.
Rufen Sie ein bestimmtes Werkzeug auf, indem Sie die entsprechende JSON-Payload als Ereignis oder Anfrage senden.

Dies geht über den Rahmen dieses Tutorials hinaus, aber seien Sie sich bewusst, dass Sie, da MCP ein offener Standard ist (es gibt eine offizielle Spezifikation und SDKs), auf dieser Ebene integrieren könnten, wenn nötig. Zum Beispiel könnte eine LangChain-Integration den MCP-Server ähnlich behandeln wie OpenAI Function Calling oder Werkzeuge – man bräuchte einen Adapter, um einen LangChain-„Werkzeug“-Aufruf in einen MCP-Werkzeugaufruf zu übersetzen. Wir könnten bald erstklassige Bibliotheken für die MCP-Integration in Python sehen, da das Ökosystem wächst.

Vorerst ist die Verwendung vorhandener KI-Clients oder des Inspektors der einfachste Weg, mit Ihrem MCP-Server zu arbeiten.

Bereitstellungsstrategien

Die Bereitstellung einer FastAPI-MCP-Anwendung ähnelt sehr der Bereitstellung jeder FastAPI-App. Da es sich nur um eine ASGI-Anwendung handelt, können Sie Uvicorn, Hypercorn oder Gunicorn (mit Uvicorn-Workern) verwenden, um sie auszuführen, und sie bei Bedarf mit Docker containerisieren. Beachten Sie jedoch SSE- und Netzwerküberlegungen:

Bereitstellung in derselben App: Wenn Sie MCP auf derselben FastAPI-App mounten, stellen Sie einen Dienst bereit. Stellen Sie sicher, dass die Umgebung SSE unterstützen kann (die meisten ASGI-Server tun dies – Uvicorn standardmäßig). Wenn Sie hinter einem Reverse-Proxy (wie Nginx) arbeiten, konfigurieren Sie ihn so, dass er SSE-Streams nicht puffert und Keep-Alive-Verbindungen zulässt.
Separate Bereitstellung: Wenn Sie API und MCP in separate Dienste aufteilen, stellen Sie zwei Apps bereit. Stellen Sie sicher, dass der MCP-Dienst weiß, wie er den API-Dienst erreichen kann (über base_url oder internes Netzwerk). Zum Beispiel könnten Sie Ihre Haupt-API unter api.example.com und den MCP unter mcp.example.com bereitstellen, wobei die http_client-Basis-URL des MCP auf https://api.example.com gesetzt ist. Sie könnten auch über eine interne Adresse kommunizieren, wenn sie am selben Ort bereitgestellt werden.

Beispiel (Separate Bereitstellung mit Docker Compose): Sie könnten zwei Container haben, einen für die API und einen für MCP. Der MCP-Container könnte eine Umgebungsvariable für die API-URL haben. Die Verwendung von FastApiMCP(app, http_client=httpx.AsyncClient(base_url=os.getenv("API_URL"))) würde Aufrufe an den API-Dienst leiten. Auf diese Weise benötigt der MCP-Container den API-Code nicht importiert – er könnte sogar einen völlig anderen Dienst aufrufen, solange er eine kompatible OpenAPI hat (obwohl Sie normalerweise einfach dieselbe FastAPI-App importieren würden, wie wir zuvor gezeigt haben).

Skalierung: Wenn Ihre API stark ausgelastet ist und Sie nur eine moderate Nutzung von MCP erwarten (oder umgekehrt), können Sie sie unabhängig voneinander skalieren. Führen Sie beispielsweise mehrere Replikate der API hinter einem Load Balancer aus, und vielleicht werden nur eine oder zwei MCP-Serverinstanzen für die KI-Nutzung benötigt. Da MCP Streaming verwendet, setzen Sie möglicherweise keinen Load Balancer vor den MCP (um SSE nicht zu unterbrechen) oder verwenden eine Sticky-Connection-Strategie.

HTTPS und Netzwerk: Wenn der KI-Client von einem externen Dienst (z. B. einer Online-IDE oder einem in der Cloud laufenden Agenten) verbunden wird, müssen Sie Ihren MCP-Endpunkt über HTTPS bereitstellen (aus Sicherheitsgründen und weil viele Clients dies möglicherweise erfordern). Dies bedeutet normalerweise, ihn hinter einen SSL-terminierenden Proxy zu setzen oder einen Cloud-Dienst zu verwenden. Daran ist nichts MCP-spezifisch – behandeln Sie es wie das Bereitstellen eines API-Endpunkts. Verwenden Sie ordnungsgemäßes TLS, Domainnamen usw. Wenn Ihr MCP nur für den internen Gebrauch bestimmt ist, stellen Sie ihn möglicherweise überhaupt nicht öffentlich bereit.

Aktualisierung und Updates: Wenn Sie Ihre API mit neuen Endpunkten aktualisieren, denken Sie daran, den MCP-Dienst neu bereitzustellen oder zu aktualisieren, damit er die neuen Endpunkte kennt. Wenn der MCP-Dienst langlebig ist, könnte ein Rolling Restart oder der Aufruf von setup_server() (vielleicht ausgelöst durch ein Bereitstellungsskript) verwendet werden, um Änderungen zu übernehmen.

Zusammenfassend lässt sich sagen, stellen Sie FastAPI-MCP wie einen FastAPI-Microservice bereit. Der Hauptunterschied besteht darin, sicherzustellen, dass SSE durchgängig funktioniert und zu planen, ob es Teil Ihrer Haupt-App oder ein eigenständiger Dienst ist. Die offiziellen Dokumente enthalten ein einfaches Beispiel, das separate Uvicorn-Prozesse auf verschiedenen Ports zeigt, aber Sie können dies an jede Infrastruktur anpassen.

Testen und Fehlerbehebung

Das Testen eines FastAPI-MCP-Setups umfasst sowohl die Überprüfung des traditionellen API-Verhaltens als auch der neuen MCP-Schnittstelle. Hier sind einige Strategien:

Testen der API-Endpunkte

Schreiben Sie zunächst weiterhin Tests für Ihre FastAPI-Endpunkte wie gewohnt (mit TestClient von FastAPI oder HTTP-Aufrufen). FastAPI-MCP ändert die Logik Ihrer Endpunkte nicht, daher bleiben Unit-Tests und Integrationstests für sie gültig. Sicherzustellen, dass jeder Endpunkt bei gegebenen Eingaben erwartete Daten zurückgibt, stellt indirekt auch sicher, dass die MCP-Ausgabe korrekt ist.

Testen der MCP-Schnittstelle

Um speziell die MCP-Schicht zu testen, können Sie einen MCP-Client simulieren. Wie erwähnt, ist das MCP Inspector-Werkzeug hervorragend für manuelle Tests geeignet – es ist wie ein interaktiver Testclient. Verwenden Sie es während der Entwicklung, um sicherzustellen, dass alle Ihre Werkzeuge aufgelistet sind und funktionieren:

Führen Sie Ihre App aus, verbinden Sie den Inspektor, listen Sie Werkzeuge auf. Wenn etwas vorhanden sein sollte und nicht da ist, überprüfen Sie die Operations-IDs und ob Sie mount() nach der Definition dieser Routen aufgerufen haben.
Verwenden Sie den Inspektor, um jedes Werkzeug mit gültigen und ungültigen Eingaben aufzurufen. Testen Sie beispielsweise einen fehlenden erforderlichen Parameter und sehen Sie, dass ein Validierungsfehler zurückgegeben wird (genau wie Ihre API über die Validierung von FastAPI). Der Inspektor zeigt die Fehlerantwort an.

Für automatisierte Tests könnten Sie einen kleinen Test schreiben, der den SSE-Client oder WebSockets von Python verwendet, um sich mit /mcp zu verbinden. Python hat keine integrierte SSE-Unterstützung, aber Sie könnten httpx mit einem Event-Stream-Parser verwenden. Dies kann jedoch kompliziert werden. Ein anderer Ansatz besteht darin, einen Befehl wie npx @modelcontextprotocol/inspector oder mcp-remote in einer Testumgebung auszuführen, um sicherzustellen, dass die Verbindung funktioniert (obwohl dies aus dem reinen Python-Testen herausführt).

Wenn Ihre Endpunkte einfach sind, ist eine pragmatische Prüfung zu sehen, ob GET http://localhost:8000/mcp einen 200-Statuscode zurückgibt und einen Ereignisstrom liefert (Sie könnten das erste Ereignis parsen). Zum Beispiel:

from fastapi.testclient import TestClient

client = TestClient(app)
response = client.get("/mcp", stream=True)
assert response.status_code == 200
chunks = []
for chunk in response.iter_content(chunk_size=None):
    chunks.append(chunk.decode())
    if b"event: " in chunk:
        break
stream_output = "".join(chunks)
assert "event: endpoint" in stream_output or "event: tool_list" in stream_output

Das ist etwas hemdsärmelig, prüft aber, ob der MCP-Endpunkt ein Ereignis erzeugt. Ein gründlicherer Test würde einen MCP-Client mocken und den Befehl zum Auflisten der Werkzeuge ausführen.

Tipps zur Fehlerbehebung

„Keine MCP-Werkzeuge verfügbar“: Wenn der KI-Client sagt, er habe keine Werkzeuge gefunden, hat der MCP-Server wahrscheinlich keine Endpunkte registriert. Stellen Sie sicher, dass FastApiMCP(app) aufgerufen wurde, nachdem die Routen eingerichtet wurden (oder rufen Sie setup_server() auf, um zu aktualisieren). Stellen Sie außerdem sicher, dass Sie nicht versehentlich alles durch Einschluss-/Ausschluss-Einstellungen herausgefiltert haben.
Authentifizierungsprobleme: Wenn Sie den MCP mit Authentifizierung schützen und der KI-Client keine Verbindung herstellen kann, überprüfen Sie, ob der Client den Header oder das Token sendet. Sie könnten mit curl und dem Header testen, ob Sie einen 200 OK bei /mcp erhalten. Beispiel: curl -N http://localhost:8000/mcp -H "X-API-Key: mysecret123" (das -N dient dazu, die Ausgabe nicht zu puffern, damit Sie SSE sehen). Wenn dies funktioniert, liegt das Problem in der Client-Konfiguration.
SSE-Verbindung schließt sich sofort: Dies könnte passieren, wenn beim Verbinden ein Fehler auftritt. Überprüfen Sie Ihre Serverprotokolle; wenn Ihre Authentifizierungsabhängigkeit aufgrund eines fehlenden Tokens einen Fehler ausgelöst hat, könnte die Verbindung abbrechen. Oder wenn während der Werkzeugauflistung eine Ausnahme ausgelöst wird. Protokolle geben normalerweise die Ursache an.
Werkzeugaufruf funktioniert nicht: Wenn eine KI sagt, sie habe versucht, ein Werkzeug zu verwenden, aber einen Fehler erhalten, behandeln Sie es wie einen API-Aufruffehler. Zum Beispiel könnte die KI einen String angeben, wo eine Ganzzahl erwartet wird, was zu einem 422-Validierungsfehler führt. Diese Fehler werden über MCP als Ereignisse zurückgesendet – überprüfen Sie Protokolle oder verwenden Sie den Inspektor, um den Aufruf zu replizieren. Möglicherweise müssen Sie Ihre Beschreibungen anpassen, damit die KI die richtigen Typen kennt.
Leistung: Wenn Aufrufe langsam sind, denken Sie daran, dass bei SSE die Verbindung offen bleibt. Stellen Sie sicher, dass Sie nichts tun, was den Request-Body auf eine Weise liest, die blockiert. Normalerweise kein Problem, aber wenn Sie Streaming-Antworten verwenden, stellen Sie sicher, dass Sie Daten ordnungsgemäß liefern. Für hohen Durchsatz sollten Sie horizontale Skalierung in Betracht ziehen.
MCP-Spezifikations-Inkompatibilitäten: Da sich MCP weiterentwickelt, kann es geringfügige Versionsunterschiede zwischen Clients und Server geben. FastAPI-MCP zielt darauf ab, mit der Spezifikation auf dem neuesten Stand zu sein. Wenn Sie auf eine Inkompatibilität mit einem bestimmten Client stoßen, überprüfen Sie die FastAPI-MCP-Versionshinweise. Eine Problemumgehung kann oft die Verwendung von mcp-remote sein, da es dazu neigt, die Kommunikation zu normalisieren.

Durch methodisches Testen sowohl der API als auch der MCP-Schnittstelle können Sie sich auf Ihre Bereitstellung verlassen. Es ist ratsam, mit dem tatsächlichen KI-Client zu testen, den Sie voraussichtlich verwenden werden (z. B. wenn Ihr Ziel Cursor-IDE-Benutzer sind, testen Sie mit Cursor; wenn es Claude Desktop ist, testen Sie über Claude mit mcp-remote).

Reale Beispiele und Anwendungsfälle

FastAPI-MCP eröffnet viele Möglichkeiten zur Integration von APIs mit KI. Hier sind einige Szenarien zur Veranschaulichung praktischer Anwendungen:

KI-gestützter Dokumentationsassistent: Stellen Sie Ihre öffentlichen API-Endpunkte über MCP bereit, damit ein KI-Assistent Benutzern helfen kann, die API zu erkunden. Zum Beispiel könnte ein Benutzer fragen: „Wie erstelle ich mit dieser API einen neuen Benutzer?“ und die KI (mit Zugriff auf die MCP-Werkzeuge) könnte den create_user-Endpunkt finden und sogar Beispielaufrufe ausführen. Dies bietet ein interaktives Dokumentationserlebnis, das von KI unterstützt wird.
Interner Entwicklerassistent: Innerhalb eines Unternehmens könnten Entwickler einen KI-Agenten (in VSCode oder Slack) haben, der über MCP mit internen Microservices verbunden ist. Sie könnten Daten abfragen (schreibgeschützt) oder Routineoperationen durchführen, indem sie die KI in natürlicher Sprache anweisen. Zum Beispiel: „KI, hol mir die neuesten Fehlerprotokolle vom Überwachungsdienst“ – die KI ruft die entsprechende interne API auf und gibt die Ergebnisse zurück. Dies kann die Produktivität steigern, indem einfache Abfragen an die KI ausgelagert werden.
Systemübergreifende Automatisierung: Stellen Sie sich eine KI vor, die Aufgaben orchestriert, die mehrere Systeme umfassen – z. B. ein KI-Workflow, der ein Support-Ticket entgegennimmt, Benutzerinformationen von einem Dienst und Produktinformationen von einem anderen nachschlägt und dann einen Eintrag in einer Datenbank erstellt. Wenn jeder dieser Dienste eine MCP-Schnittstelle hat, kann die KI nahtlos zwischen ihnen wechseln, indem sie standardisierte Aufrufe verwendet, ohne benutzerdefinierten Integrationscode für jedes System. MCP bietet den Klebstoff für systemübergreifende Automatisierung durch KI.
Natürlichsprachliche API für Endbenutzer: Sie könnten sogar bestimmte Werkzeuge über einen KI-Chatbot für Endbenutzer verfügbar machen. Zum Beispiel könnte eine Einzelhandelswebsite einen Chatbot haben, bei dem der Benutzer fragt: „Wo ist meine Bestellung mit der ID 12345?“ Der Backend-KI-Agent verwendet MCP, um die Bestellverfolgungs-API (get_order_status) aufzurufen und antwortet dem Benutzer dann mit den Informationen. FastAPI-MCP ermöglicht in diesem Fall der KI, dieselbe API zu verwenden, die die mobile App oder Website möglicherweise verwendet, jedoch durch natürlichsprachliche Interaktion.
Prototyp eines KI-Plugins: Wenn Sie erwägen, ein OpenAI-Plugin für Ihre API zu erstellen, erreicht die Implementierung von FastAPI-MCP ein ähnliches Ziel, jedoch mit einem offenen Standard, der mit mehreren KI-Anbietern funktionieren kann. Zum Beispiel stimmen sich Anthropic, OpenAI und andere auf MCP ab. Sie profitieren von einer einzigen Implementierung, die über viele KI-Clients hinweg funktioniert.

Dies sind nur einige Ideen. Die wichtigste Erkenntnis ist, dass FastAPI-MCP es Ihrer API ermöglicht, mit minimalem Aufwand problemlos in KI-Workflows integriert zu werden. Sie konzentrieren sich auf das Schreiben der API-Logik; FastAPI-MCP macht sie KI-konsumierbar.

Zusammenfassung der Best Practices

Um den Erfolg bei der Verwendung von FastAPI-MCP sicherzustellen, beachten Sie die folgenden Best Practices (einige haben wir bereits angesprochen):

Geben Sie Werkzeugen klare Namen: Legen Sie immer operation_id mit einem beschreibenden Namen für jeden Endpunkt fest. Dies hilft KI (und Menschen), zu verstehen, was das Werkzeug tut (z. B. update_user_password vs. ein vager Standardname). Verwenden Sie konventionsgemäß lower_case oder lowerCamelCase und passen Sie Namen an Aktionen an.
Dokumentieren Sie Ihre Endpunkte gut: Je mehr Details in Ihrer FastAPI-Dokumentation (Beschreibungen, Beispiele, Docstrings von Antwortmodellen), desto mehr Kontext hat die KI. Fügen Sie nach Möglichkeit Beispielwerte für Parameter hinzu. FastAPI-MCP übernimmt diese Beschreibungen in die MCP-Werkzeuginformationen.
Validieren und bereinigen Sie gründlich: Erwarten Sie, dass die KI Ihre Werkzeuge manchmal mit falschen Parametern oder auf unbeabsichtigte Weise aufruft. Stellen Sie sicher, dass Ihre FastAPI-Validatoren (Pydantic-Modelle, Typüberprüfungen) vorhanden sind, um diese abzufangen und korrekte Fehler zurückzugeben. Stellen Sie außerdem sicher, dass Antworten nicht versehentlich Daten preisgeben – z. B. wenn Ihr Modell ein Feld enthält, das ausgeblendet werden soll, verwenden Sie response_model_exclude oder Ähnliches.
Beginnen Sie restriktiv, öffnen Sie dann vorsichtig: Besonders am Anfang könnte es ratsam sein, einen begrenzten Satz von Endpunkten für KI verfügbar zu machen, bis Sie sehen, wie sie diese verwendet. Sie können nur wenige sichere schreibgeschützte Operationen einschließen und die Lage testen. Im Laufe der Zeit können Sie bei Bedarf mehr verfügbar machen. Dies begrenzt das Risiko.
Überwachen Sie die KI-Nutzung: Aktivieren Sie die Protokollierung für MCP-Aufrufe. Sie könnten Middleware hinzufügen oder einfach die Serverprotokolle beobachten (die Anfragen an /mcp und möglicherweise zugrunde liegende Endpunkte anzeigen). Durch die Überwachung können Sie feststellen, ob die KI Schwierigkeiten hat (z. B. einen Endpunkt wiederholt ohne Erfolg aufruft) und dann entweder Ihre Anweisungen oder das Design des Endpunkts verbessern. Es hilft auch, Missbrauch zu erkennen.
Bleiben Sie über Änderungen der MCP-Spezifikation auf dem Laufenden: MCP entwickelt sich weiter (der angegebene Link zur Spezifikation zeigt eine Datumsversion). FastAPI-MCP wird wahrscheinlich aktualisiert, um neuen Versionen zu entsprechen. Behalten Sie das FastAPI-MCP GitHub im Auge für Releases und aktualisieren Sie Ihr Paket regelmäßig, um Verbesserungen und Fehlerbehebungen zu erhalten.

Indem Sie diese Praktiken befolgen, stellen Sie sicher, dass die Integration von KI die Integrität oder Sicherheit Ihrer API nicht beeinträchtigt und dass die KI die Funktionalität Ihrer API optimal nutzen kann.

Fazit

FastAPI-MCP bietet eine leistungsstarke und dennoch einfache Möglichkeit, jede FastAPI-Anwendung in einen KI-fähigen Dienst zu verwandeln. In diesem Tutorial haben wir mit grundlegenden Konzepten begonnen und uns zu fortgeschrittenen Themen vorgearbeitet. Lassen Sie uns die Reise kurz zusammenfassen:

Wir haben gelernt, was MCP ist – ein Standardprotokoll für die Kommunikation zwischen KI und Werkzeugen, vergleichbar damit, der KI einen universellen Anschluss zur Nutzung externer APIs zu geben. FastAPI-MCP implementiert dies für FastAPI und erfordert nur wenige Codezeilen zur Einrichtung.
Wir sind einen Schnellstart durchgegangen – Installation des Pakets, Mounten auf einer FastAPI-App und Überprüfung, ob der MCP-Endpunkt live ist. Mit minimalem Code wurden unsere API-Endpunkte zu auffindbaren MCP-Werkzeugen.
Wir haben die Projektstruktur besprochen – wie man sie in einer einzigen App integriert oder zur Flexibilität in API- und MCP-Dienste aufteilt. Eine frühzeitige Planung Ihrer Bereitstellung hilft, späteres Refactoring zu vermeiden.
Wir haben die Anpassung untersucht – Benennung von Werkzeugen über operation_id, Hinzufügen detaillierter Schemainformationen und Filtern, welche Endpunkte zur Kontrolle bereitgestellt werden.
Wir haben uns mit Sicherheit durch Dependency Injection befasst – Verwendung von Depends(), um Authentifizierungstoken oder API-Schlüssel für MCP-Aufrufe zu verlangen, und sogar die Aktivierung von OAuth-Flows für fortgeschrittene Szenarien. Wir haben betont, die vorhandenen Sicherheitsdienstprogramme von FastAPI zu verwenden, um die MCP-Schnittstelle sicher zu halten.
Wir haben die Integration mit KI-Clients durchgeführt – gezeigt, wie eine KI-IDE über SSE oder über einen mcp-remote-Proxy eine Verbindung herstellen kann. Wir haben gesehen, dass eine KI dann API-Funktionen in natürlicher Sprache aufrufen kann, wodurch Ihre App effektiv Teil des Werkzeugkastens der KI wird.
Wir haben die Bereitstellung behandelt – hervorgehoben, dass Sie FastAPI-MCP-Apps ähnlich wie jede FastAPI-App bereitstellen, unter Beachtung von SSE und möglicherweise separater Skalierung. Containerisierung und Cloud-Bereitstellung funktionieren nahtlos und ermöglichen die reale Nutzung Ihres MCP-Dienstes.
Wir haben Testen und Fehlerbehebung behandelt – Verwendung von Werkzeugen wie MCP Inspector zur Validierung Ihres Setups und Hinweis auf häufige Fallstricke (wie das Vergessen, die Werkzeugliste zu aktualisieren oder Authentifizierungs-Inkompatibilitäten).
Wir haben uns reale Anwendungsfälle angesehen – von Dokumentationsassistenten bis hin zur systemübergreifenden Automatisierung, um die Vielseitigkeit der Bereitstellung einer API für KI zu veranschaulichen.
Schließlich haben wir Best Practices zusammengefasst, um einen reibungslosen und sicheren Betrieb zu gewährleisten, wenn Menschen und KI beginnen, Ihre API gemeinsam zu nutzen.

Indem Sie dieser Anleitung folgen, sollten Sie gut gerüstet sein, um FastAPI-MCP in Ihren Projekten zu implementieren. Sie können reichhaltige, KI-integrierte Anwendungen erstellen, die die Leistungsfähigkeit großer Sprachmodelle nutzen, um auf intelligente Weise mit Ihren FastAPI-Diensten zu interagieren. Da das MCP-Ökosystem wächst (mit mehr Clients und Servern, die entstehen), sind Sie bereits auf dem neuesten Stand mit einer API, die die Sprache der KI spricht.

Nächste Schritte: Experimentieren Sie mit Ihrem eigenen API + MCP-Setup. Versuchen Sie, verschiedene KI-Clients damit zu verbinden (Cursor, VSCode usw.) und sehen Sie, wie die KI Ihre Werkzeuge verwendet. Treten Sie der FastAPI-MCP-Community (dem „MCParty“ Slack) bei, wenn Sie Fragen oder Ideen haben – als Open-Source-Projekt sind Beiträge und Feedback willkommen. Viel Spaß beim Codieren und willkommen zur nächsten Generation KI-gestützter Anwendungen!

Referenzen

Tipp: Das fastapi-mcp-Repo und die MCP-Spezifikation entwickeln sich schnell weiter – überprüfen Sie diese Quellen regelmäßig, um auf dem neuesten Stand zu bleiben.

Hat Ihnen dieser Beitrag gefallen? Fanden Sie ihn aufschlussreich? Hinterlassen Sie gerne unten einen Kommentar, um Ihre Gedanken zu teilen oder Fragen zu stellen. Ein GitHub-Konto ist erforderlich, um an der Diskussion teilzunehmen.