MCP ist überall. Jede KI-Tool-Ankündigung Anfang 2026 erwähnt es. Jeder Artikel über den 'modernen KI-Stack" listet es auf. Aber wenn du Leute fragst, was MCP eigentlich ist, bekommst du entweder eine Doktorarbeit oder einen Marketing-Pitch.

Hier die Ein-Satz-Version: MCP ist ein USB-Anschluss für KI-Agenten.

Das ist die ganze Erklärung. OK gut, hier kommt der Rest. 😼

Die Welt vor dem Standard

Stell dir dein Setup Ende 2024 vor. Du baust einen KI-Agenten — ein Programm, das ein Large Language Model (LLM — das Gehirn hinter ChatGPT, Claude, Gemini) nutzt, um eigenständig Entscheidungen zu treffen und Aktionen auszuführen. Dein Agent muss eine PostgreSQL-Datenbank abfragen, im Web suchen, GitHub-Issues verwalten und lokale Dateien lesen.

Für jedes einzelne Tool schreibst du eigenen Integrations-Code:

# Jedes Tool braucht seinen eigenen Kleber-Code
from custom_postgres import query_db
from custom_github import create_issue
from custom_search import web_search
from custom_files import read_file

# Jede Integration hat andere:
# - Authentifizierungsmethoden
# - Antwortformate
# - Fehlerbehandlung
# - Verbindungsverwaltung

Jeder KI-Anbieter hat sein eigenes Integrationssystem gebaut. Claude hatte 'tool use". OpenAI hatte 'function calling". LangChain hatte 'tools". Alle machten das Gleiche — nur auf inkompatible Weise. Eine Integration für den einen bauen hieß, sie für den anderen komplett neu zu schreiben.

Das war die Ära von seriellen Ports, Parallelports und proprietären Ladekabeln in der KI-Welt. Erinnerst du dich? Bevor USB kam, hatte jedes Gerät sein eigenes Kabel. Reinstes Chaos. 😹

Die Lücke, die gefüllt werden musste

Das Problem war nicht, dass Integrationen schwer waren. Das Problem war, dass sie jedes verdammte Mal schwer waren. Ein neues Tool kommt raus — du schreibst weitere 200 Zeilen Custom-Integration. Multiplizier das mit jedem KI-Client auf dem Markt. Die Rechnung ist brutal.

Jemand musste einen Universalstecker definieren.

MCP betritt die Bühne

Anthopic hat MCP (Model Context Protocol) Ende 2024 als offenen Standard eingeführt — ein universeller Anschlussstandard für KI-Tools, wie USB, aber für Daten. Bis März 2026 ist es zum Standardweg geworden, wie KI-Agenten sich mit der Außenwelt verbinden.

So sieht die Anbindung von vier Tools mit MCP aus:

{
  "mcpServers": {
    "postgres": { "command": "npx", "args": ["-y", "@mcp/server-postgres", "..."] },
    "github": { "command": "npx", "args": ["-y", "@mcp/server-github"] },
    "search": { "command": "npx", "args": ["-y", "@mcp/server-brave-search"] },
    "files": { "command": "npx", "args": ["-y", "@mcp/server-filesystem", "/home"] }
  }
}

Vier Tools. Vier Zeilen Config. Kein Custom-Code. Jeder Server spricht dasselbe Protokoll — ein Regelwerk, das festlegt, wie Programme miteinander kommunizieren — und jeder Client versteht es.

Die Architektur: drei Akteure, null Magie

MCP hat genau drei bewegliche Teile:

┌──────────────────┐
│       HOST       │  (Claude Code, Cursor, deine App)
│                  │
│  ┌────────────┐  │
│  │   CLIENT   │──── MCP Protocol ──── SERVER (Postgres, GitHub)
│  └────────────┘  │
│                  │
│  ┌────────────┐  │
│  │   CLIENT   │──── MCP Protocol ──── SERVER (Search, Files)
│  └────────────┘  │
└──────────────────┘

Host — die KI-Anwendung, mit der du interagierst. Claude Code, Claude Desktop, Cursor, Windsurf oder deine eigene App.

Client — lebt innerhalb des Hosts. Verwaltet die Verbindung zu einem Server. Ein Host kann viele Clients betreiben, die gleichzeitig mit vielen Servern verbunden sind.

Server — stellt Tools und Daten bereit. Läuft als separater Prozess — ein eigenständiges Programm — entweder auf deinem Rechner oder auf einem Remote-Server.

Kein Orchestrierungs-Layer. Keine Message Queue. Kein Service Mesh. Einfach ein Client, der über ein Standardprotokoll mit einem Server spricht. Das ist das Ganze. 😸

Was durch die Leitung fließt

MCP-Server können drei Arten von Dingen bereitstellen:

1. Tools — Aktionen, die die KI ausführen kann

Tools sind Funktionen — in sich geschlossene Operationen — die die KI aufrufen kann. Wie 'eine SQL-Abfrage ausführen" oder 'ein GitHub-Issue erstellen".

{
  "name": "query",
  "description": "Run a read-only SQL query against the database",
  "inputSchema": {
    "type": "object",
    "properties": {
      "sql": { "type": "string", "description": "The SQL query to execute" }
    },
    "required": ["sql"]
  }
}

Wenn der Server startet, sagt er dem Client: 'Hier sind die Tools, die ich anbiete, hier ist, was jedes tut, hier sind die Parameter." Das KI-Modell liest diese Beschreibungen und entscheidet, wann es sie einsetzt — genauso wie du entscheidest, welche App du auf deinem Handy öffnest.

2. Resources — Daten, die die KI lesen kann

Resources sind Datenstücke, die der Server bereitstellt. Dateiinhalte, ein Datenbankschema (die Struktur deiner Tabellen), eine Konfiguration.

Der Unterschied ist wichtig: Tools tun Dinge, Resources liefern Kontext. Die KI liest Resources, um die Umgebung zu verstehen, bevor sie handelt. Stell es dir vor wie Speisekarte lesen, bevor du bestellst.

3. Prompts — Startvorlagen

Vorgefertigte Templates, die der Server anbietet, wie 'analysiere diese Tabelle" oder 'überprüfe diesen Pull Request". Praktische Abkürzungen, die wissen, wie man die Tools des Servers effektiv einsetzt.

Die meisten Leute ignorieren Prompts und reden einfach normal mit ihrer KI. Völlig in Ordnung. Sie sind optional.

Eine echte Anfrage Schritt für Schritt

Schauen wir uns an, was passiert, wenn du 'Zeig mir alle User, die sich heute registriert haben" in Claude Code tippst, während ein Postgres MCP-Server verbunden ist:

1. DU tippst: "Zeig mir alle User, die sich heute registriert haben"

2. CLAUDE sieht, dass die Postgres MCP-Tools verfügbar sind
   (query, list_tables, describe_table)

3. CLAUDE ruft zuerst 'describe_table' auf, um die
   Struktur der Users-Tabelle zu verstehen

4. CLIENT sendet an SERVER:
   { "method": "tools/call",
     "params": { "name": "describe_table",
                 "arguments": { "table": "users" } } }

5. SERVER fragt PostgreSQL ab, gibt das Schema zurück

6. CLAUDE schreibt eine SQL-Abfrage basierend auf dem Schema:
   SELECT * FROM users WHERE created_at >= CURRENT_DATE

7. CLIENT sendet die Abfrage an SERVER, SERVER führt sie aus

8. CLAUDE formatiert die Ergebnisse und zeigt sie dir

Das Ganze dauert 1-2 Sekunden. Du hast auf Deutsch gefragt, die KI hat das SQL herausgefunden, der MCP-Server hat es ausgeführt, und du hast Ergebnisse bekommen. Kein manuelles Query-Schreiben. Das ist der Moment, wo es bei den meisten Leuten Klick macht. 😻

Die Transportschicht — wie die Bits reisen

MCP arbeitet über zwei Transportmethoden:

STDIO (lokale Server) — der Server läuft als Kindprozess auf deinem Rechner. Die Kommunikation läuft über stdin/stdout — die gleichen Text-Pipes, die dein Terminal benutzt. Das ist das häufigste Setup:

{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "env": { "DB_URL": "..." }
    }
  }
}

Einfach, schnell, kein Netzwerk involviert.

Streamable HTTP (Remote-Server) — für Server auf anderen Maschinen. Cloud-gehostet, teamweit geteilt oder Drittanbieter-Dienste:

{
  "mcpServers": {
    "remote-server": {
      "url": "https://mcp.example.com/sse",
      "headers": { "Authorization": "Bearer your-token" }
    }
  }
}

Anfragen gehen als regulärer HTTP POST raus. Antworten werden in Echtzeit zurückgestreamt. So funktionieren Enterprise-Deployments — zentralisierte Server, an die sich mehrere Entwickler anschließen.

Bau deinen eigenen in 20 Zeilen

Hier ist der einfachste funktionierende MCP-Server, den du mit dem offiziellen TypeScript SDK schreiben kannst:

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

const server = new McpServer({
  name: "my-tool",
  version: "1.0.0"
});

server.tool(
  "hello",
  "Says hello to someone",
  { name: { type: "string", description: "Person to greet" } },
  async ({ name }) => ({
    content: [{ type: "text", text: `Hello, ${name}!` }]
  })
);

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

Installier das SDK (npm install @modelcontextprotocol/sdk), definier deine Tools, verbinde den Transport. Das SDK kümmert sich um die Protokollverhandlung — den Handshake, bei dem Client und Server klären, was beide unterstützen — Message-Parsing und Fehlerbehandlung.

Ein praktisches Beispiel — Wetter-API

server.tool(
  "get_weather",
  "Get current weather for a city",
  {
    city: { type: "string", description: "City name" },
    units: { type: "string", description: "celsius or fahrenheit", default: "celsius" }
  },
  async ({ city, units }) => {
    const response = await fetch(
      `https://wttr.in/${encodeURIComponent(city)}?format=j1`
    );
    const data = await response.json();
    const current = data.current_condition[0];
    const temp = units === "fahrenheit"
      ? current.temp_F + "°F"
      : current.temp_C + "°C";
    return {
      content: [{ type: "text", text: `${city}: ${temp}, ${current.weatherDesc[0].value}` }]
    };
  }
);

Jetzt kann dein KI-Agent das Wetter checken. Wichtiger noch — sieh das Muster: Daten von irgendeiner API holen (Application Programming Interface — die Art, wie Programme miteinander reden), in ein MCP-Tool verpacken, und jeder MCP-kompatible Client auf dem Planeten kann es nutzen.

Der Capability-Handshake

Wenn ein Client sich zum ersten Mal mit einem Server verbindet, verhandeln sie:

Client: "Ich unterstütze Tools, Resources und Prompts. Was hast du?"
Server: "Ich biete 3 Tools und 2 Resources. Hier sind sie."
Client: "Verstanden. Bereit."

Das bedeutet: Clients müssen nicht im Voraus wissen, was ein Server bietet. Server können Features hinzufügen oder entfernen, ohne etwas kaputtzumachen. Verschiedene Clients können denselben Server unterschiedlich nutzen. Elegante Evolution statt brüchiger Kopplung.

Was nicht perfekt ist

Tun wir nicht so, als wäre das fehlerfrei. Stand März 2026:

Security ist dein Problem. Ein MCP-Server kann alles tun, wozu du ihm die Berechtigung gibst. Ein bösartiger Server könnte Daten über Tool-Calls abgreifen. Es gibt kein eingebautes Sandboxing — keine automatische Isolation vom Rest deines Systems. Du vertraust jedem Server so, wie du jedem npm-Paket vertraust, das du installierst. Denk mal kurz darüber nach.

Discovery ist chaotisch. Den richtigen MCP-Server für deinen Anwendungsfall zu finden bedeutet, durch Registries wie mcpservers.org oder glama.ai/mcp/servers zu stöbern. Es gibt noch keinen zentralisierten, verifizierten Marktplatz. Die Qualität schwankt extrem.

Debugging ist zäh. Wenn ein Tool-Call fehlschlägt, wandern die Fehlermeldungen oft durch mehrere Schichten — Client, Protokoll, Server, zugrundeliegende API — und kommen am anderen Ende als Brei raus. Wird besser, aber immer noch schmerzhaft.

Performance-Overhead existiert. Jeder Tool-Call ist ein JSON-RPC Round Trip — eine Request-Response-Nachricht im JSON-Format. Bei lokalen STDIO-Servern ist das vernachlässigbar. Bei Remote-Servern über HTTP summiert sich die Latenz, wenn die KI mehrere Calls verkettet.

Was das für dich bedeutet

Wenn du KI-Coding-Tools wie Claude Code oder Cursor benutzt: MCP bedeutet, dass deine KI ständig neue Fähigkeiten bekommt, ohne Software-Updates. Ein neuer MCP-Server für Jira taucht auf? Installieren, und deine KI verwaltet deine Tickets. Ein neuer Server für AWS? Deine KI verwaltet deine Infrastruktur. Du wartest nicht darauf, dass der Tool-Anbieter Integrationen baut — die Community baut sie.

Wenn du Tools oder APIs baust: MCP bedeutet, du schreibst eine Integration und sie funktioniert mit Claude, Cursor, Windsurf, Cline und jedem zukünftigen MCP-kompatiblen Client. Ein Server, Dutzende Clients. Das ist die USB-Rechnung.

Wenn du Gründer bist: Einen MCP-Server für dein Produkt zu bauen wird zum Muss, wie eine REST-API vor 10 Jahren. Wenn dein Developer-Tool keinen MCP-Server hat, werden deine Nutzer fragen, warum.

Das Ökosystem im März 2026

  • Offizielle Server von Anthropic: PostgreSQL, GitHub, Filesystem, Brave Search, Puppeteer, Google Maps, Slack und mehr — siehe das MCP-Servers-Repository
  • Enterprise-Server von AWS, Cloudflare, Sentry
  • Community-Server für Docker, Kubernetes, Notion, Linear, Figma, Stripe — Hunderte und es werden mehr
  • Die 2026-Roadmap fokussiert sich auf Agent-zu-Agent-Kommunikation, horizontale Skalierung und einen .well-known-Discovery-Mechanismus, damit Server sich automatisch bekanntmachen können

USB hat das proprietäre Ladekabel gekillt. MCP killt Custom-Integrationen.

MCP ist das Wichtigste, was KI-Tooling passiert ist, seit Context Windows — das Arbeitsgedächtnis der KI — lang genug wurden, um eine echte Codebase reinzupassen. Es ist nicht sexy. Es ist ein JSON-RPC-Protokoll über stdio. Aber USB war auch nicht sexy, und es hat jeden proprietären Stecker auf seinem Weg erledigt.

Das Klügste, was du jetzt tun kannst: Hör auf, Spezifikationsdokumente zu lesen. Installier einen Postgres MCP-Server, verbinde ihn mit Claude Code und stell ihm Fragen über deine Datenbank. Du wirst MCP in 30 Sekunden verstehen.

Die Spezifikation ist für die Leute, die das Protokoll bauen. Du benutzt es. 😹