Blueprints für Agenten: Warum MCP das Ende der isolierten KI einläutet

1. Das Problem: Agenten im Silo

KI-Agenten generieren eleganten Code, scheitern aber an der Realität. Wer heute KI-Apps baut, schreibt 50% der Zeit Glue-Code: fragile Adapter für Datenbanken, Filesysteme und proprietäre APIs.

Das Ergebnis sind ineffiziente Agenten, die halluzinieren, weil ihnen der Live-Zugriff auf Kontext fehlt. Wir brauchen keine weiteren Bastellösungen, sondern eine Architektur, die Kontext als festen Bestandteil begreift.

2. Die Lösung: MCP als Context-Bus

Anthropic liefert mit dem Model Context Protocol (MCP) diesen Standard. Es trennt die Architektur strikt in drei Rollen:

1. Host: Die KI-Umgebung (z. B. Claude Desktop, Cursor, IDE).
2. Client: Der Vermittler, der die Verbindung hält.
3. Server: Dein Service, der Ressourcen und Tools bereitstellt.

Statt für jedes LLM einen eigenen Connector zu bauen, stellst du einen MCP-Server bereit. Deine Daten bleiben lokal oder in deiner Cloud, das Modell greift nur bei Bedarf darauf zu. Die Integration wird vom Entwicklungsprojekt zur reinen Konfiguration.

3. Von RAG zu Action: Skills statt .md-Dateien

RAG war der erste Schritt (Wissen/Lesen). MCP ist der zweite Schritt (Handeln/Schreiben).

• RAG (Markdown): "Wie deploye ich?" (Passiv / Statisch)
• MCP (Tool): "Prüfe den Deployment-Status." (Aktiv / Dynamisch)

Ein MCP-Server liefert Tools, die Seiteneffekte erzeugen: APIs abfragen, Files manipulieren, Prozesse starten. Dein Agent wird vom Chatbot zur funktionalen Komponente deiner Software-Architektur.

4. Anatomie einer Capability (JSON-Schema)

Damit die KI ein Werkzeug nutzen kann, braucht es eine strikte Definition via JSON-Schema.

{
"mcpServers": {
  "my-saas-tool": {
    "command": "node",
    "args": ["./build/index.js"],
    "env": {
      "API_KEY": "sk-..."
    }
  }
}
}

Ein MCP-Tool besteht aus drei Säulen:

1. Identität: Eindeutiger Name der Funktion.
2. Instruktion: Wann soll das Tool genutzt werden? (Context Awareness).
3. Struktur: Welche Parameter (Datentypen, Pflichtfelder) sind nötig?

Validierung ist Pflicht: Bevor dein Server Code ausführt, wird der Input gegen das Schema geprüft. Das verhindert, dass Halluzinationen deine Datenbank korrumpieren oder falsche Parameter APIs crashen lassen.

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// Beispiel CRM API (ersetze mit deiner Implementierung)
const crmApi = {
create: async (data: { title: string; priority: string; email: string }) => {
  // Hier würde die echte API-Integration stehen
  return Math.floor(Math.random() * 10000); // Mock Ticket-ID
}
};

// 1. Server initialisieren
const server = new McpServer({
name: "saas-control-server",
version: "1.0.0",
});

// 2. Einen Skill (Tool) registrieren
server.tool(
"create_support_ticket", // Identität
"Erstellt ein Ticket im CRM, wenn ein User ein Bug meldet.", // Instruktion
{
  title: z.string(),
  priority: z.enum(["low", "high", "critical"]), // Struktur & Validierung
  user_email: z.string().email(),
},
async ({ title, priority, user_email }) => { // 3. Execution (Hier passiert die Magie)
  const ticketId = await crmApi.create({ title, priority, email: user_email });

  return {
    content: [{ type: "text", text: `Ticket #${ticketId} erstellt.` }],
  };
}
);

// Der "USB-Stecker": Startet den Server via Stdio
const transport = new StdioServerTransport();
await server.connect(transport);

5. Machine Experience (MX) > User Experience (UX)

SaaS-Anbieter müssen umdenken. Agenten brauchen keine bunten Dashboards, sie brauchen saubere, maschinenlesbare Endpunkte.

Dein Produkt wird zum "Skill" im Gürtel des Agenten. Wer interoperabel ist, wird Teil des Workflows. Wer isoliert bleibt, wird ignoriert. Die Monetarisierung verschiebt sich perspektivisch vom Login zur erfolgreich ausgeführten Aktion.

6. Sicherheit: Governance für autonome Systeme

Sobald Agenten Schreibrechte haben, brauchst du einen digitalen Türsteher.

• Granulare Scopes: Kein Root-Zugriff. Der Agent erhält nur Zugriff auf spezifische Ressourcen.
• Human-in-the-Loop: Kritische Aktionen (z. B. "Lösche Tabelle", "Sende E-Mail") erfordern explizite menschliche Bestätigung.
• Logging: Jede KI-Aktion muss nachvollziehbar sein, um Prompt-Injections oder Fehlentscheidungen zu debuggen.

7. Fazit: Wer das Protokoll beherrscht, führt

MCP beendet das Zeitalter des manuellen Kontext-Schubsens. Du wechselst vom Vermittler zum Architekten.

Natürlich bleibt ein Restrisiko: Ob sich MCP als der globale Standard durchsetzt oder ob Giganten wie Google und OpenAI versuchen werden, eigene, geschlossene Ökosysteme zu erzwingen, ist noch offen. Doch selbst wenn sich das spezifische Protokoll ändern sollte – das Mindset der entkoppelten, agenten-basierten Architektur ist gekommen, um zu bleiben.

Entwickler, die heute MCP-Server bauen, setzen den Standard für morgen. Deine IDE und dein SaaS werden zum Cockpit. Komplexität wird durch klare Regeln beherrschbar. Bau keine Silos mehr, bau Blueprints.

Ressourcen

Damit du direkt loslegen kannst, hier die wichtigsten Links aus dem Anthropic-Ökosystem:

• Die Bibel: modelcontextprotocol.io – Die offizielle Dokumentation und Spezifikation.
• Die SDKs: TypeScript SDK und Python SDK auf GitHub.
• Inspiration: Glama MCP List – Eine kuratierte Liste von Open-Source Servern (Postgres, Slack, Google Drive etc.).
• Inspiration 2: GitHub Liste mit MCP-Servern
• Debugging: MCP Inspector – Das offizielle Tool, um deine Server zu testen, bevor du sie in Claude integrierst.

Häufige Fragen zu MCP