Model Context Protocol (MCP): Bedeutung für APIs verstehen

Kurz gesagt

Das Model Context Protocol (MCP) ist ein Standard zur Verbindung von KI-Assistenten mit externen Datenquellen und APIs. Es ermöglicht Claude Desktop, Cursor und anderen KI-Tools den sicheren Zugriff auf Ihre API. Die moderne PetstoreAPI implementiert MCP, sodass KI-Assistenten über natürliche Sprache nach Haustieren suchen, Bestellungen aufgeben und den Bestand verwalten können.

Einleitung

Sie fragen Claude Desktop: „Zeig mir verfügbare Katzen unter 300 $.“ Claude antwortet: „Ich habe keinen Zugriff auf Tierhandelsdaten.“ Sie müssten dann von Ihrer API kopieren/einfügen, was Ihren Arbeitsablauf unterbricht.

Mit MCP (Model Context Protocol) kann Claude direkt auf Ihre API zugreifen. Sie stellen dieselbe Frage, und Claude fragt die PetstoreAPI ab, filtert die Ergebnisse und zeigt Ihnen verfügbare Katzen unter 300 $.

Die moderne PetstoreAPI implementiert MCP und ermöglicht es KI-Assistenten, über natürliche Sprache mit dem Tierhandel zu interagieren.

Wenn Sie APIs für die KI-Integration entwickeln, hilft Ihnen Apidog beim Testen von MCP-Implementierungen und der Validierung von KI-Assistenteninteraktionen.

Was ist MCP?

MCP ist ein von Anthropic entwickeltes Protokoll zur Verbindung von KI-Assistenten mit externen Ressourcen.

Das Problem, das MCP löst

KI-Assistenten sind leistungsstark, aber isoliert. Sie können nicht:

• Auf die internen APIs Ihres Unternehmens zugreifen
• Ihre Datenbank abfragen
• Dateien aus Ihrem Dateisystem lesen
• Mit externen Diensten interagieren

MCP bietet eine standardisierte Methode, mit der KI-Assistenten sicher auf diese Ressourcen zugreifen können.

MCP-Komponenten

1. MCP-Server – Stellt Ressourcen und Tools für KI-Assistenten bereit

2. MCP-Client – KI-Assistent (Claude Desktop, Cursor usw.)

3. Ressourcen – Daten, die die KI lesen kann (Dateien, Datenbankeinträge, API-Antworten)

4. Tools – Aktionen, die die KI ausführen kann (Bestellung erstellen, Haustier aktualisieren, Bestand suchen)

MCP-Architektur

AI Assistant (Claude Desktop)
    ↓ MCP Protocol
MCP Server (PetstoreAPI MCP Server)
    ↓ Internal APIs
PetstoreAPI Backend
    ↓
Database

Wie MCP funktioniert

1. Server-Registrierung

Konfigurieren Sie Claude Desktop, um eine Verbindung zum MCP-Server herzustellen:

{
  "mcpServers": {
    "petstore": {
      "command": "node",
      "args": ["/path/to/petstore-mcp-server.js"],
      "env": {
        "PETSTORE_API_KEY": "your-api-key"
      }
    }
  }
}

2. Tool-Erkennung

KI-Assistent fragt: „Welche Tools sind verfügbar?“

MCP-Server antwortet:

{
  "tools": [
    {
      "name": "search_pets",
      "description": "Nach Haustieren nach Art, Status und Preis suchen",
      "inputSchema": {
        "type": "object",
        "properties": {
          "species": {"type": "string", "enum": ["CAT", "DOG"]},
          "maxPrice": {"type": "number"},
          "status": {"type": "string", "enum": ["AVAILABLE", "ADOPTED"]}
        }
      }
    },
    {
      "name": "create_order",
      "description": "Eine Bestellung für ein Haustier aufgeben",
      "inputSchema": {
        "type": "object",
        "properties": {
          "petId": {"type": "string"},
          "userId": {"type": "string"}
        },
        "required": ["petId", "userId"]
      }
    }
  ]
}

3. Tool-Ausführung

Benutzer fragt: „Zeig mir verfügbare Katzen unter 300 $“

KI-Assistent ruft auf:

{
  "tool": "search_pets",
  "arguments": {
    "species": "CAT",
    "status": "AVAILABLE",
    "maxPrice": 300
  }
}

MCP-Server führt aus:

async function search_pets({ species, status, maxPrice }) {
  const response = await fetch(
    `https://petstoreapi.com/v1/pets?species=${species}&status=${status}&maxPrice=${maxPrice}`
  );
  return await response.json();
}

Gibt Ergebnisse an die KI zurück, die diese für den Benutzer formatiert.

MCP vs. traditionelle APIs

Beispielvergleich

Traditionelle API:

curl -H "Authorization: Bearer token" \
  "https://petstoreapi.com/v1/pets?species=CAT&maxPrice=300"

MCP:

Benutzer: „Zeig mir verfügbare Katzen unter 300 $“
KI: [Ruft das search_pets-Tool auf, formatiert die Ergebnisse]
„Hier sind 5 verfügbare Katzen unter 300 $:
1. Fluffy – 250 $
2. Whiskers – 280 $
...“

Wie die moderne PetstoreAPI MCP implementiert

Die moderne PetstoreAPI stellt einen MCP-Server bereit.

Verfügbare Tools

1. search_pets – Haustiere nach Kriterien suchen 2. get_pet – Haustierdetails abrufen 3. create_order – Eine Bestellung aufgeben 4. get_inventory – Bestand prüfen 5. update_pet_status – Haustierverfügbarkeit aktualisieren

Beispiel: Suchen und Bestellen

Benutzer: „Finde mir einen Hund unter 500 $ und gib eine Bestellung auf“

KI-Arbeitsablauf:

1. Ruft search_pets({species: "DOG", maxPrice: 500}) auf
2. Zeigt dem Benutzer die Ergebnisse
3. Benutzer bestätigt: „Bestelle den Labrador“
4. Ruft create_order({petId: "019b4132", userId: "user-456"}) auf
5. Bestätigt die aufgegebene Bestellung

MCP-Server-Code

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new Server({
  name: 'petstore-mcp',
  version: '1.0.0'
}, {
  capabilities: {
    tools: {}
  }
});

server.setRequestHandler('tools/list', async () => ({
  tools: [
    {
      name: 'search_pets',
      description: 'Search for pets',
      inputSchema: {
        type: 'object',
        properties: {
          species: { type: 'string' },
          maxPrice: { type: 'number' }
        }
      }
    }
  ]
}));

server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;

  if (name === 'search_pets') {
    const response = await fetch(
      `https://petstoreapi.com/v1/pets?${new URLSearchParams(args)}`
    );
    return { content: [{ type: 'text', text: JSON.stringify(await response.json()) }] };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);

MCP mit Apidog testen

Apidog hilft beim Testen von MCP-Implementierungen:

1. Testen, ob die zugrundeliegenden APIs korrekt funktionieren
2. Validieren, ob Tool-Schemata mit API-Verträgen übereinstimmen
3. Fehlerbehandlung testen
4. Authentifizierungsabläufe überprüfen

Warum MCP wichtig ist

1. KI-native APIs

APIs werden über natürliche Sprache zugänglich. Nicht-technische Benutzer können über KI-Assistenten mit Ihrer API interagieren.

2. Standardisierung

MCP entwickelt sich zum Standard für die KI-API-Integration. Einmal unterstützen, mit allen MCP-Clients arbeiten.

3. Sicherheit

MCP-Server übernehmen die Authentifizierung. KI-Assistenten benötigen keinen direkten API-Zugriff.

4. Komponierbarkeit

KI-Assistenten können mehrere MCP-Server kombinieren und so Workflows über Dienste hinweg erstellen.

Fazit

MCP überbrückt die Lücke zwischen KI-Assistenten und APIs. Die moderne PetstoreAPI implementiert MCP, sodass Claude Desktop und andere KI-Tools über natürliche Sprache mit dem Tierhandel interagieren können.

Wichtige Erkenntnisse:

• MCP verbindet KI-Assistenten mit APIs
• Tools definieren, was die KI tun kann
• Natürliche Sprache ersetzt API-Aufrufe
• Moderne PetstoreAPI zeigt die MCP-Implementierung

FAQ

Welche KI-Assistenten unterstützen MCP?

Claude Desktop, Cursor und andere von Anthropic betriebene Tools. Die Unterstützung wächst.

Ist MCP sicher?

Ja. MCP-Server übernehmen die Authentifizierung. KI-Assistenten sehen keine API-Schlüssel.

Kann ich MCP mit bestehenden APIs verwenden?

Ja. Erstellen Sie einen MCP-Server, der Ihre bestehende API umschließt.

Ersetzt MCP REST-APIs?

Nein. MCP ist für den Zugriff von KI-Assistenten vorgesehen. REST-APIs bleiben für den direkten programmatischen Zugriff bestehen.

Wie teste ich MCP-Tools?

Verwenden Sie Apidog, um die zugrundeliegenden APIs zu testen, und testen Sie dann die MCP-Tools mit Claude Desktop.