MCP-Server automatisch erstellen: aus OpenAPI und FastAPI

Inhalt

Wenn Sie bereits eine API haben, müssen Sie einen MCP-Server nicht von Hand schreiben. FastMCP erzeugt ihn für Sie: FastMCP.from_openapi() baut einen MCP-Server aus einer OpenAPI-Spezifikation, FastMCP.from_fastapi() macht dasselbe für eine FastAPI-Anwendung. Dieser Beitrag zeigt beides und erklärt, wie Sie steuern, welche Endpunkte zu MCP-Tools und welche zu Resources werden.

In unserem Beitrag über MCP-Server mit FastMCP haben wir beschrieben, was MCP-Server sind, warum sie für das aktuelle KI-Ökosystem wichtig sind, welche Ressourcen sie bereitstellen können und wie man einen von Grund auf baut.

Mit den heutigen Werkzeugen ist das einfach. Einen Haken gibt es trotzdem: Im Kern stellt ein MCP-Server nur eine standardisierte, für LLMs optimierte API bereit. (Das soll den Wert nicht kleinreden. MCP ist ein dringend nötiger Standard mit vielen Vorteilen. Am Ende ist es aber eben eine API.) In Ihren Anwendungen gibt es sehr wahrscheinlich schon APIs, und mit MCP legen Sie eine weitere API um die bestehenden herum.

Auch hier legen wir einen MCP-Server um Ihre bestehende API, erzeugen ihn aber automatisch aus Ihrer OpenAPI-Spezifikation oder FastAPI-Anwendung. So stehen Ihre vorhandenen Endpunkte im MCP-Ökosystem und damit fast jedem LLM-Client zur Verfügung. (Wenn Sie mit Python-SDKs statt mit HTTP-APIs arbeiten, verfolgt langchain-autotools (auf Englisch) einen ähnlichen Ansatz und macht aus SDK-Methoden LLM-Tools.)

MCP-Server automatisch aus einer OpenAPI-Spezifikation erstellen

Hat Ihre API eine OpenAPI-Spezifikation, kann FastMCP daraus direkt einen MCP-Server erzeugen. Die Funktion kam mit FastMCP 2.0.0 und verbindet Ihre bestehende API mit MCP-Clients, ohne dass Sie für jeden Endpunkt eine Tool-Definition schreiben.

Im einfachsten Fall brauchen Sie für einen MCP-Server aus Ihrer OpenAPI-Spezifikation nur ein paar Zeilen Code:

1import httpx
2from fastmcp import FastMCP
3
4api_client = httpx.AsyncClient(base_url="https://api.my-api-url.com")
5
6# OpenAPI-Spezifikation laden
7spec = {...}  # Ihre OpenAPI-Spezifikation als Python-Dict
8
9# MCP-Server aus der OpenAPI-Spezifikation erzeugen
10mcp = FastMCP.from_openapi(openapi_spec=spec, client=api_client)
11
12if __name__ == "__main__":
13    mcp.run()

Mehr ist nicht nötig. FastMCP analysiert Ihre OpenAPI-Spezifikation, erzeugt die passenden MCP-Komponenten und leitet MCP-Anfragen an die dahinterliegende API weiter.

Konfigurationsoptionen für OpenAPI

Bei FastMCP.from_openapi können Sie Timeouts für Requests und das Route-Mapping konfigurieren.

Timeout konfigurieren

1# 5 Sekunden Timeout für alle Requests
2mcp = FastMCP.from_openapi(
3    openapi_spec=spec,
4    client=api_client,
5    timeout=5.0
6)

Dieser Timeout gilt für alle Requests von Tools, Resources und Resource Templates.

Standard-Mapping der Routen

FastMCP muss jede API-Route einer MCP-Komponente zuordnen. Wie in unserem vorigen Beitrag beschrieben, liefern MCP-Server Daten über zwei Hauptkomponenten aus: Resources und Tools. Resources sind lesende Endpunkte, Tools führen Aktionen aus.

FastMCP schätzt anhand von Regeln ein, welche Komponente jede Route werden soll:

OpenAPI-Route	Beispiel	MCP-Komponente
GET ohne Path-Parameter	GET /stats	Resource
GET mit Path-Parametern	GET /users/{id}	Resource Template
POST, PUT, PATCH, DELETE usw.	POST /users	Tool

• Lesende Endpunkte werden zu Resources.
• Lesende Endpunkte mit Parametern werden zu Resource Templates.
• Endpunkte, die etwas verändern, werden zu Tools.

Eigene Route Maps

Das Standard-Mapping passt für die meisten APIs, aber nicht für alle. Ein GET-Endpunkt kann ein Tool sein (etwa einer, der eine Datenbankabfrage ausführt), und ein POST-Endpunkt in manchen Fällen eine Resource.

Um das Mapping zu ändern, definieren Sie RouteMap-Objekte mit den HTTP-Methoden, einem URL-Muster und dem Routentyp (RouteType.TOOL oder RouteType.RESOURCE) und übergeben sie an FastMCP.from_openapi:

1from fastmcp.server.openapi import RouteMap, RouteType
2
3custom_maps = [
4    RouteMap(methods=["GET"],
5             pattern=r"^/database/.*",
6             route_type=RouteType.TOOL),
7    RouteMap(methods=["POST"],
8              pattern=r"^/user/profile/status",
9              route_type=RouteType.RESOURCE),
10]
11
12mcp = FastMCP.from_openapi(
13    openapi_spec=spec,
14    client=api_client,
15    route_maps=custom_maps
16)
17
18mcp.run()

FastMCP wendet Ihre eigenen Route Maps zuerst an, vor den Standardregeln.

So funktioniert die OpenAPI-Integration von FastMCP

Im Hintergrund macht die OpenAPI-Integration von FastMCP Folgendes:

1. Sie liest Ihre OpenAPI-Spezifikation und holt daraus Routen und Schemas.
2. Sie ordnet jede Route anhand der Mapping-Regeln einer Resource, einem Resource Template oder einem Tool zu.
3. Wenn ein MCP-Client mit dem Server arbeitet,
   • baut FastMCP anhand der OpenAPI-Definition einen HTTP-Request,
   • schickt ihn über den httpx-Client, den Sie übergeben haben, und
   • übersetzt die HTTP-Antwort in das passende MCP-Format.

Umgang mit Parametern

FastMCP kümmert sich auch um Query- und Path-Parameter.

Query-Parameter

Standardmäßig übernimmt FastMCP nur Query-Parameter mit nicht leerem Wert. Parameter mit None oder einem leeren String ("") fallen weg, damit Ihre API keine leeren Parameter bekommt:

1await client.call_tool("search_products", {
2    "category": "electronics",  # wird übernommen
3    "min_price": 100,           # wird übernommen
4    "max_price": None,          # fällt weg
5    "brand": "",                # fällt weg
6})

Der resultierende HTTP-Request enthält nur category=electronics&min_price=100.

Path-Parameter

Bei Path-Parametern prüft FastMCP, ob jeder erforderliche Parameter vorhanden und nicht null ist, denn ein Path-Parameter lässt sich nicht einfach aus der URL weglassen.

1# Das funktioniert
2await client.call_tool("get_product", {"product_id": 123})
3
4# Das löst ValueError aus: "Missing required path parameters: {'product_id'}"
5await client.call_tool("get_product", {"product_id": None})

Die erzeugten MCP-Komponenten kontrollieren

Um zu sehen, welche Komponenten FastMCP aus Ihrer Spezifikation erzeugt hat, legen Sie folgende Funktion an und rufen sie mit asyncio.run(check_mcp(mcp)) auf. Sie gibt alle Tools, Resources und Resource Templates des MCP-Servers aus:

1async def check_mcp(mcp: FastMCP):
2    tools = await mcp.get_tools()
3    resources = await mcp.get_resources()
4    templates = await mcp.get_resource_templates()
5
6    print(f"{len(tools)} Tool(s): {', '.join([t.name for t in tools.values()])}")
7    print(f"{len(resources)} Resource(s): {', '.join([r.name for r in resources.values()])}")
8    print(f"{len(templates)} Resource Template(s): {', '.join([t.name for t in templates.values()])}")
9
10    return mcp

MCP-Server automatisch aus einer FastAPI-Anwendung erstellen

Laufen Ihre Backend-Dienste auf FastAPI, kann FastMCP sie direkt als MCP-Server bereitstellen. Auch diese Integration kam mit FastMCP 2.0.0 und braucht kaum Änderungen am Code.

Angenommen, wir haben folgende FastAPI-Anwendung:

1from fastapi import FastAPI
2
3# Eine bestehende FastAPI-App
4app = FastAPI()
5
6@app.get("/items")
7def list_items():
8    return [{"id": 1, "name": "Item 1"}, {"id": 2, "name": "Item 2"}]
9
10@app.get("/items/{item_id}")
11def get_item(item_id: int):
12    return {"id": item_id, "name": f"Item {item_id}"}
13
14@app.post("/items")
15def create_item(name: str):
16    return {"id": 3, "name": name}

Um daraus einen MCP-Server zu machen, rufen Sie FastMCP.from_fastapi(app) auf und starten den Server:

1mcp = FastMCP.from_fastapi(app=app)
2mcp.run()

Konfigurationsoptionen für FastAPI

Wie bei der OpenAPI-Integration können Sie auch für Ihre FastAPI-Anwendung Timeouts und Route-Mapping konfigurieren.

Timeout konfigurieren

1mcp = FastMCP.from_fastapi(
2    app=app,
3    timeout=5.0
4)

Eigene Route Maps für FastAPI

Eigene Route Maps funktionieren bei FastAPI genauso wie bei OpenAPI: Mit einer Liste von RouteMap-Objekten legen Sie fest, wie FastMCP Ihre FastAPI-Routen auf MCP-Komponenten abbildet.

1custom_maps = [
2    RouteMap(methods=["GET"],
3             pattern=r"^/items/.*",
4             route_type=RouteType.TOOL),
5    RouteMap(methods=["POST"],
6              pattern=r"^/items",
7              route_type=RouteType.RESOURCE),
8]
9mcp = FastMCP.from_fastapi(
10    app=app,
11    route_maps=custom_maps
12)

Mehr braucht es nicht. Wie FastMCP mit Query- und Path-Parametern umgeht, steht im Abschnitt Umgang mit Parametern, wie Sie die erzeugten Komponenten auflisten, im Abschnitt Die erzeugten MCP-Komponenten kontrollieren.

Sobald Ihre API als MCP-Server verfügbar ist, stehen dieselben Funktionen von FastMCP zur Verfügung wie bei einem handgeschriebenen Server. Mit LLM Sampling in FastMCP (auf Englisch) kann der Server zum Beispiel das LLM des Clients aufrufen. Und in unserem Beitrag zum MCP-Server für BigQuery zeigen wir, wie KI-Agenten damit auf ein Data Warehouse zugreifen.

Sie möchten bestehende Unternehmens-APIs als MCP-Server für KI-Agenten bereitstellen und dabei entscheiden, welche Endpunkte wirklich als Tool taugen? Dabei unterstützt Sie unser Team für KI-Beratung. Sprechen Sie uns an.

Sie möchten zuverlässige KI-Agenten-Systeme bauen?

Wir haben auf Basis aktueller Forschung einen ausführlichen Leitfaden (auf Englisch) erstellt, wie Sie robuste KI-Agenten-Systeme bauen, die auch im produktiven Betrieb funktionieren. Der Leitfaden behandelt:

• die 14 systematischen Fehlerquellen in Multi-Agenten-Systemen
• belegte Best Practices für das Design von Agenten
• strukturierte Kommunikationsprotokolle und Prüfmechanismen

Weiterlesen

• MCP-Server mit FastMCP erstellen
• Bessere KI-Systeme mit automatischer Prompt-Optimierung (auf Englisch)
• Zuverlässige KI-Agenten bauen: Best Practices
• KI-Agenten für Unternehmen mit dem Microsoft Agent Framework
• Text-to-SQL mit semantischer Schicht: NVIDIA Auto Ontology im Praxistest

Über den Autor

Andreas Nigg

Mitgründer, Pondhouse Data

Andreas entwickelt seit mehr als acht Jahren Datenanwendungen. Bei Pondhouse Data konzipiert und baut er KI-Systeme und integriert sie in komplexe, gewachsene Unternehmensumgebungen.

Sprechen Sie mit Andreas über Ihr ProjektAuf LinkedIn folgen