API zu MCP Server umwandeln

Haben Sie sich jemals gewünscht, Ihre API könnte mit KI-Agenten wie Claude oder Cursor chatten und Ihre Endpunkte in intelligente, konversationelle Tools verwandeln? Nun, schnallen Sie sich an, denn wir tauchen ein in die Frage, wie Sie Ihre API mithilfe von Stainless und einer OpenAPI-Spezifikation in einen MCP-Server verwandeln können. Dieser konversationelle Leitfaden führt Sie durch den Prozess, von der Einrichtung bis zur Bereitstellung, mit einem Test, um die Funktionsfähigkeit zu beweisen. Wir werden das Model Context Protocol (MCP) verwenden, um Ihre API KI-freundlich zu gestalten, und das alles auf eine unterhaltsame, zugängliche Weise. Legen wir los!

💡

Möchten Sie ein großartiges API-Test-Tool, das wunderschöne API-Dokumentation generiert?

Möchten Sie eine integrierte All-in-One-Plattform für Ihr Entwicklerteam, um mit maximaler Produktivität zusammenzuarbeiten?

Apidog erfüllt all Ihre Anforderungen und ersetzt Postman zu einem viel günstigeren Preis!

button

Was ist ein MCP-Server und warum sollte es Sie interessieren?

Das Model Context Protocol (MCP) ist wie ein universeller Händedruck für KI-Systeme. Es ist ein JSON-RPC-basierter Standard, der es KI-Clients (wie Claude Desktop, Cursor oder VS Code Copilot) ermöglicht, mit Ihrer API über natürliche Sprache oder programmierbare Prompts zu interagieren. Ein MCP-Server fungiert als Brücke, indem er die Endpunkte Ihrer API in Tools übersetzt, die KI-Agenten verstehen und verwenden können.

Warum Ihre API in einen MCP-Server verwandeln? Es ist ein Game Changer:

KI-gestützte Interaktion: Lassen Sie KI-Agenten Ihre API mit einfachen Prompts wie „Benutzerdaten abrufen“ oder „Neue Bestellung erstellen“ aufrufen.
Einfache Automatisierung: Stainless automatisiert den Prozess und generiert einen MCP-Server aus Ihrer OpenAPI-Spezifikation mit minimalem Programmieraufwand.
Skalierbarkeit: Machen Sie Ihre API mehreren KI-Clients zugänglich, von lokalen Entwicklungstools bis hin zu produktionsreifen Anwendungen.
Entwicklerfreundlich: Sie müssen Ihre API nicht neu schreiben – fügen Sie einfach eine MCP-Schicht hinzu und lassen Sie die KI die Schwerarbeit erledigen.

Egal, ob Sie eine Zahlungsplattform, eine Inhalts-API oder einen benutzerdefinierten Dienst entwickeln, die Umwandlung Ihrer API in einen MCP-Server macht sie intelligenter und zugänglicher.

Wie fügt sich Stainless ein?

Stainless ist der beste Freund eines Entwicklers, wenn es darum geht, SDKs und jetzt auch MCP-Server aus OpenAPI-Spezifikationen zu erstellen. Die experimentelle MCP-Server-Generierungsfunktion nimmt Ihre OpenAPI-Definition und spuckt ein TypeScript-Unterpaket aus, das als MCP-Server einsatzbereit ist. Das bedeutet, dass die Endpunkte Ihrer API zu KI-zugänglichen Tools werden, ohne dass Sie ins Schwitzen kommen. Mal sehen, wie das geht!

Ihre API mit Stainless in einen MCP-Server verwandeln

Voraussetzungen

Bevor wir eintauchen, stellen Sie sicher, dass Sie Folgendes haben:

OpenAPI-Spezifikation: Eine gültige OpenAPI (Swagger)-Datei für Ihre API (z. B. openapi.yaml oder openapi.json).
Stainless-Konto: Melden Sie sich unter stainless.com an, um ein Projekt zu erstellen.
Apidog-Konto: Zum Testen Ihrer OpenAPI-Spezifikation (besuchen Sie https://apidog.com/).
Node.js 20+: Für lokale Tests und den Betrieb des MCP-Servers (nodejs.org/en/download).
npm: Wird mit Node.js für die Paketverwaltung geliefert.
MCP-kompatibler Client: Claude Desktop, Cursor oder VS Code Copilot zum Testen.
API-Schlüssel: Wenn Ihre API eine Authentifizierung erfordert, halten Sie einen API-Schlüssel bereit.

Schritt 1: Testen Ihrer OpenAPI-Spezifikation mit Apidog

Bevor oder sogar nachdem Sie Ihre OpenAPI-Spezifikation in einen MCP-Server umgewandelt haben, wäre es großartig, sie zu testen. Und genau hier kommt Apidog ins Spiel! Die intuitive Plattform von Apidog ermöglicht es Ihnen, Ihre OpenAPI-Spezifikation zu importieren und zu testen, um sicherzustellen, dass die Endpunkte Ihrer API für die MCP-Integration bereit sind. So geht's:

Besuchen Sie Apidog und registrieren Sie sich oder melden Sie sich an:

Klicken Sie auf Anmelden (oben rechts), wenn Sie ein Konto haben, oder auf Registrieren, um eines gemäß den Anweisungen zu erstellen.

button

2. Erstellen Sie ein neues Projekt und importieren Sie Ihre OpenAPI-Spezifikation:

Nach der Anmeldung klicken Sie auf dem Dashboard auf Projekt erstellen.
Klicken Sie auf der Projekt-Erstellungsseite auf Importieren.
Geben Sie die URL Ihrer OpenAPI-Datei ein (z. B. https://my-api.com/openapi.yaml) oder klicken Sie auf oder eine Datei hochladen, um Ihre lokale openapi.yaml oder openapi.json auszuwählen.

Apidog parst die Datei und generiert eine neue API in Ihrem Konto (dies kann bei komplexen Spezifikationen einige Minuten dauern).

3. API-Einstellungen konfigurieren:

Nach einem erfolgreichen Import werden Sie zur Einstellungsseite weitergeleitet. Passen Sie den Namen, die Beschreibung und die Authentifizierungsanforderungen Ihrer API an (z. B. API-Schlüssel oder OAuth).

4. Endpunkte hinzufügen und testen:

Verwenden Sie die Oberfläche von Apidog, um Endpunkte und Dokumentation hinzuzufügen oder zu bearbeiten.
Testen Sie Ihre Endpunkte direkt in Apidog, um zu überprüfen, ob sie wie erwartet funktionieren, bevor Sie Ihren MCP-Server generieren.

Das Testen mit Apidog stellt sicher, dass Ihre OpenAPI-Spezifikation solide ist, was den Stainless MCP-Generierungsprozess reibungsloser und Ihren MCP-Server zuverlässiger macht.

Schritt 2: Ein Stainless-Projekt mit TypeScript einrichten

Ein Stainless-Projekt erstellen:

Melden Sie sich bei stainless.com an und erstellen Sie ein neues Projekt.
Laden Sie Ihre OpenAPI-Spezifikation (YAML oder JSON) hoch, um die Endpunkte Ihrer API zu definieren.
Wählen Sie TypeScript als Zielsprache (die MCP-Server-Generierung erfordert TypeScript, obwohl ältere node-Ziele unterstützt werden).

MCP-Server-Generierung aktivieren:

Wählen Sie im Abschnitt SDKs hinzufügen Ihres Projekts MCP-Server aus, um die Generierung zu aktivieren.
Dadurch wird ein Unterpaket unter packages/mcp-server in Ihrem Projekt erstellt.

Schritt 3: MCP-Server-Generierung konfigurieren

Konfigurieren Sie in den Stainless-Projekteinstellungen die MCP-Server-Optionen. Erstellen oder bearbeiten Sie eine Konfigurationsdatei (z. B. stainless.yaml) mit:

targets:
  typescript:
    package_name: my-org-name
    production_repo: null
    publish:
      npm: false
    options:
      mcp_server:
        package_name: my-org-name-mcp
        enable_all_resources: true

package_name: Benennen Sie Ihr MCP-Server-Paket (standardmäßig Ihr SDK-Name mit -mcp).
enable_all_resources: true: Macht standardmäßig alle API-Endpunkte als MCP-Tools zugänglich.

Dies weist Stainless an, ein MCP-Server-Unterpaket zu generieren, das die Endpunkte Ihrer API als KI-zugängliche Tools implementiert.

Schritt 4: Endpunkt-Exposition und Tool-Beschreibungen anpassen

Standardmäßig werden alle Endpunkte in Ihrer OpenAPI-Spezifikation zu MCP-Tools. Zum Anpassen:

Spezifische Endpunkte auswählen:

Setzen Sie enable_all_resources: false und aktivieren Sie spezifische Ressourcen oder Methoden:

resources:
  users:
    mcp: true
    methods:
      create:
        mcp: true
  orders:
    methods:
      create:
        mcp: true
        endpoint: post /v1/orders

2. Tool-Metadaten feinabstimmen:

Passen Sie Tool-Namen und -Beschreibungen für eine bessere KI-Interaktion an:

resources:
  users:
    methods:
      create:
        mcp:
          tool_name: create_user
          description: Creates a new user profile with name and email.

Dies stellt sicher, dass Ihr MCP-Server nur die gewünschten Endpunkte mit klaren, KI-freundlichen Beschreibungen bereitstellt.

Schritt 5: Große APIs mit Tool-Filterung und dynamischen Tools handhaben

Bei APIs mit vielen Endpunkten (>50) kann das Bereitstellen jedes einzelnen als separates Tool das Kontextfenster einer KI überfordern. Verwenden Sie diese Strategien:

Tool-Filterung:

Filtern Sie Tools zur Laufzeit nach Ressource, Operationstyp (z. B. Lesen/Schreiben) oder benutzerdefinierten Tags:

npx -y my-org-mcp --resource=users

2. Modus für dynamische Tools:

Aktivieren Sie dynamische Tools, um drei Meta-Tools freizulegen: list_api_endpoints, get_api_endpoint_schema und invoke_api_endpoint. Dies vereinfacht die Interaktion für große APIs:

npx -y my-org-mcp --tools=dynamic

Dynamische Tools ermöglichen es der KI, Endpunkte dynamisch zu entdecken und aufzurufen, wodurch die Kontextüberlastung reduziert wird.

Schritt 6: Ihren MCP-Server erstellen und veröffentlichen

Den MCP-Server erstellen:

Stainless generiert den MCP-Server in packages/mcp-server, wenn Sie Ihr SDK erstellen.
Führen Sie den Build-Befehl in Ihrem Stainless-Projekt aus (überprüfen Sie die README.md Ihres Projekts für Details).

Auf npm veröffentlichen:

Konfigurieren Sie ein Produktions-Repository in Ihren Stainless-Einstellungen.
Veröffentlichen Sie den MCP-Server als separates npm-Paket (z. B. my-org-name-mcp):

npm publish

Schritt 7: Installation und Konfiguration für MCP-Clients

Nach der Veröffentlichung installieren Sie Ihr MCP-Server-Paket lokal oder remote zur Verwendung mit KI-Clients. Für Claude Desktop:

Das Paket installieren:

Wenn Sie lokal testen, navigieren Sie zu packages/mcp-server und folgen Sie den Anweisungen in der README.md.
Für die Remote-Nutzung installieren Sie über npm:

npm install my-org-name-mcp

2. Claude Desktop konfigurieren:

Öffnen Sie claude_desktop_config.json (macOS: ~/Library/Application Support/Claude, Windows: %APPDATA%\Claude).

Hinzufügen:

{
  "mcpServers": {
    "my_org_api": {
      "command": "npx",
      "args": ["-y", "my-org-mcp"],
      "env": {
        "MY_API_KEY": "123e4567-e89b-12d3-a456-426614174000"
      }
    }
  }
}

Ersetzen Sie my-org-mcp durch Ihren Paketnamen und MY_API_KEY durch Ihren API-Schlüssel.
Speichern und starten Sie Claude Desktop neu.

3. Andere Clients:

Für Cursor oder VS Code Copilot fügen Sie dieselbe Konfiguration zu deren jeweiligen Einstellungen hinzu (z. B. settings.json für VS Code oder das Tools- und Integrationspanel von Cursor).

Schritt 8: Ihren MCP-Server testen

Lassen Sie uns Ihren MCP-Server testen! Versuchen Sie in Claude Desktop (oder einem anderen MCP-Client) diesen Prompt:

alex@example.com

Wenn Ihre API einen POST /users-Endpunkt hat (wie in Ihrer OpenAPI-Spezifikation definiert), übersetzt der MCP-Server diesen Prompt in einen API-Aufruf, erstellt einen Benutzer und gibt eine Antwort zurück wie:

User created: { "name": "Alex", "email": "alex@example.com", "id": "123" }

Dies bestätigt, dass Ihr MCP-Server funktioniert und für KI-gesteuerte Interaktionen bereit ist.

Tipps zur Fehlerbehebung

Build-Fehler? Stellen Sie sicher, dass Ihre OpenAPI-Spezifikation gültig ist und TypeScript in Ihrem Stainless-Projekt aktiviert ist.
Client verbindet sich nicht? Überprüfen Sie den Paketnamen und den API-Schlüssel in Ihrer MCP-Konfiguration und starten Sie den Client neu.
Prompt funktioniert nicht? Überprüfen Sie Ihre Endpunktkonfigurationen und stellen Sie sicher, dass die angeforderte Aktion einem freigegebenen Tool entspricht.
Kontextüberlastung? Aktivieren Sie den Modus für dynamische Tools oder filtern Sie Ressourcen für große APIs.

Best Practices für MCP-Server

Tools fokussiert halten: Stellen Sie nur die Endpunkte bereit, die Ihre KI benötigt, um eine Kontextüberladung zu vermeiden.
Klare Beschreibungen: Schreiben Sie LLM-freundliche Tool-Beschreibungen, um die Prompt-Genauigkeit zu verbessern.
Dynamische Tools für große APIs verwenden: Vereinfachen Sie große APIs mit Meta-Tools, um Kontextplatz zu sparen.
Sichere Authentifizierung: Verwenden Sie Umgebungsvariablen oder OAuth für API-Schlüssel in der Produktion.
Zuerst lokal testen: Verwenden Sie die Anweisungen in der README.md, um vor der Veröffentlichung auf npm zu testen.

Fazit

Und das war's! Sie haben gerade gelernt, wie Sie Ihre API mithilfe von Stainless in einen MCP-Server verwandeln und Ihre OpenAPI-Spezifikation in ein KI-fähiges Kraftpaket umwandeln. Von der Konfiguration der Endpunkte bis zum Testen mit einem Benutzererstellungs-Prompt macht dieser Leitfaden es einfach, Ihre API mit KI-Agenten wie Claude oder Cursor zu verbinden. Egal, ob Sie ein kleines Projekt verbessern oder eine Produktions-API skalieren, der MCP-Server ist Ihr Schlüssel zu intelligenteren, konversationellen Integrationen.

Bereit, es auszuprobieren? Schnappen Sie sich Ihre OpenAPI-Spezifikation, starten Sie Stainless und lassen Sie Ihre API in der KI-Welt glänzen.

💡

button