MCP (Model Context Protocol): Der vollständige Leitfaden für Entwickler

Das Model Context Protocol (MCP) ist ein offener Standard, der von Anthropic entwickelt wurde und definiert, wie AI-Modelle mit externen Tools, Datenquellen und Diensten kommunizieren. Man kann es sich als das "USB-C der AI" vorstellen - ein universeller Anschluss, der es jedem AI-Agenten ermöglicht, über eine standardisierte Schnittstelle mit jedem Tool zu kommunizieren.

Seit seinem Launch hat MCP 97 Millionen monatliche SDK-Downloads überschritten und wurde von allen großen AI-Anbietern übernommen: Anthropic, OpenAI, Google, Microsoft und Amazon. In diesem Leitfaden werden wir alles erkunden, was du wissen musst, um mit MCP zu arbeiten.

Warum MCP existiert

Vor MCP musste jede AI-Anwendung benutzerdefinierte Integrationen für jedes Tool erstellen, das sie nutzen wollte. Soll deine AI Dateien lesen? Schreibe benutzerdefinierten Code. Eine Datenbank abfragen? Noch mehr benutzerdefinierter Code. Auf Slack posten? Noch eine weitere Integration.

Das erzeugte ein N×M-Problem: N AI-Anwendungen benötigten jeweils M benutzerdefinierte Integrationen, was zu doppeltem Aufwand und fragmentierten Ökosystemen führte.

MCP löst dies mit einem einzigen Protokoll, das jeder AI-Client verwenden kann, um mit jedem MCP-Server zu kommunizieren:

Grundkonzepte

MCP hat drei fundamentale Primitive:

1. Tools

Tools sind Funktionen, die die AI aufrufen kann. Sie repräsentieren Aktionen wie "erstelle eine Datei", "frage eine Datenbank ab" oder "sende eine Nachricht". Jedes Tool hat einen Namen, eine Beschreibung und ein JSON Schema für seine Parameter.

{
  name: "create_issue",
  description: "Create a new GitHub issue",
  inputSchema: {
    type: "object",
    properties: {
      title: { type: "string", description: "Issue title" },
      body: { type: "string", description: "Issue body" },
      repo: { type: "string", description: "Repository name" }
    },
    required: ["title", "repo"]
  }
}

2. Ressourcen (Resources)

Ressourcen sind Daten, die die AI lesen kann. Sie repräsentieren Dateien, Datenbankeinträge, API-Antworten oder jede andere Datenquelle. Ressourcen werden durch URIs identifiziert.

{
  uri: "file:///Users/dev/project/README.md",
  name: "Project README",
  mimeType: "text/markdown"
}

3. Prompts

Prompts sind wiederverwendbare Vorlagen, die helfen, Interaktionen zu strukturieren. Sie können dynamische Parameter enthalten und sind nützlich für die Standardisierung gängiger Arbeitsabläufe.

{
  name: "code_review",
  description: "Review code changes for quality and security",
  arguments: [
    { name: "diff", description: "The code diff to review", required: true }
  ]
}

Architektur

MCP folgt einer Client-Server-Architektur:

• Host: Die AI-Anwendung (Claude Desktop, Cursor, deine eigene App)
• Client: Hält eine 1:1-Verbindung zu einem MCP-Server aufrecht
• Server: Stellt Tools, Ressourcen und Prompts dem Client zur Verfügung
• Transport: Die Kommunikation erfolgt über JSON-RPC 2.0 via stdio (lokal) oder Server-Sent Events (remote)

Einen MCP-Server bauen

Lass uns einen praktischen MCP-Server bauen, der mit einer in einer JSON-Datei gespeicherten Aufgabenliste interagiert.

Setup

mkdir mcp-todo-server && cd mcp-todo-server
npm init -y
npm install @modelcontextprotocol/sdk zod

Server-Implementierung

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

const TODO_FILE = "./todos.json";

function readTodos(): { id: number; text: string; done: boolean }[] {
  if (!fs.existsSync(TODO_FILE)) return [];
  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
}

function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
}

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

// Tool: Add a todo
server.tool(
  "add_todo",
  "Add a new todo item",
  { text: z.string().describe("The todo text") },
  async ({ text }) => {
    const todos = readTodos();
    const newTodo = { id: Date.now(), text, done: false };
    todos.push(newTodo);
    writeTodos(todos);
    return { content: [{ type: "text", text: `Added: "${text}"` }] };
  }
);

// Tool: List todos
server.tool(
  "list_todos",
  "List all todo items",
  {},
  async () => {
    const todos = readTodos();
    const list = todos
      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
      .join("\n");
    return { content: [{ type: "text", text: list || "No todos yet." }] };
  }
);

// Tool: Complete a todo
server.tool(
  "complete_todo",
  "Mark a todo as completed",
  { id: z.number().describe("The todo ID to complete") },
  async ({ id }) => {
    const todos = readTodos();
    const todo = todos.find((t) => t.id === id);
    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
    todo.done = true;
    writeTodos(todos);
    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
  }
);

// Resource: Current todos as a readable resource
server.resource(
  "todos://list",
  "Current todo list",
  async () => ({
    contents: [{
      uri: "todos://list",
      mimeType: "application/json",
      text: JSON.stringify(readTodos(), null, 2),
    }],
  })
);

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

Konfiguration

Um diesen Server mit Claude Desktop zu verwenden, füge ihn zu deiner Konfiguration hinzu:

{
  "mcpServers": {
    "todo": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
    }
  }
}

Einen MCP-Client bauen

Du kannst auch einen benutzerdefinierten Client erstellen, der sich mit jedem MCP-Server verbindet:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "npx",
  args: ["tsx", "./src/index.ts"],
});

const client = new Client({ name: "my-client", version: "1.0.0" });
await client.connect(transport);

// List available tools
const { tools } = await client.listTools();
console.log("Available tools:", tools.map((t) => t.name));

// Call a tool
const result = await client.callTool({
  name: "add_todo",
  arguments: { text: "Write MCP blog post" },
});
console.log(result);

Beliebte MCP-Server

Das MCP-Ökosystem ist schnell gewachsen. Hier sind einige der beliebtesten Server:

MCP vs A2A (Agent-to-Agent)

Während MCP die Agent-zu-Tool-Kommunikation behandelt, kümmert sich Googles A2A (Agent-to-Agent)-Protokoll um die Agent-zu-Agent-Kommunikation. Sie ergänzen sich:

• MCP: Wie ein AI-Agent Tools nutzt (vertikale Integration)
• A2A: Wie AI-Agenten miteinander zusammenarbeiten (horizontale Integration)

Best Practices

1. Halte Server fokussiert: Ein Server pro Domäne (GitHub-Server, Slack-Server, usw.). Baue keine monolithischen Server.
2. Validiere Eingaben mit Zod: Validiere Tool-Eingaben immer mit richtigen Schemas.
3. Behandle Fehler elegant: Gib aussagekräftige Fehlermeldungen zurück, keine Stack Traces.
4. Nutze Ressourcen für schreibgeschützte Daten: Wenn die AI nur Daten lesen muss, stelle sie als Ressource und nicht als Tool bereit.
5. Füge gute Beschreibungen hinzu: Gute Tool- und Parameterbeschreibungen helfen der AI zu verstehen, wann und wie jedes Tool zu verwenden ist.
6. Teste mit dem MCP Inspector: Nutze npx @modelcontextprotocol/inspector, um deinen Server interaktiv zu testen.

Erste Schritte

# Create a new MCP server from template
npx @modelcontextprotocol/create-server my-server

# Test with the MCP Inspector
npx @modelcontextprotocol/inspector npx tsx ./src/index.ts

Fazit

MCP ist 2026 zum De-facto-Standard für die AI-Tool-Nutzung geworden. Ob du benutzerdefinierte AI-Agenten baust, Claude Code erweiterst oder Integrationen für bestehende Plattformen erstellst - MCP zu verstehen ist essenziell. Das Protokoll ist einfach genug, um es an einem Nachmittag zu lernen, aber leistungsstark genug, um produktionsreife AI-Workflows zu erstellen.

Nächste Schritte:

• Erkunde die MCP-Spezifikation
• Durchstöbere bestehende MCP-Server zur Inspiration
• Baue deinen ersten Server mit dem TypeScript- oder Python-SDK
• Teste ihn mit Claude Desktop oder dem MCP Inspector