1~
2Das **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.
3~
4Seit 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.
5~
6## Warum MCP existiert
7~
8Vor 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.
9~
10Das erzeugte ein **N×M-Problem**: N AI-Anwendungen benötigten jeweils M benutzerdefinierte Integrationen, was zu doppeltem Aufwand und fragmentierten Ökosystemen führte.
11~
12```mermaid
13graph TD
14    subgraph "Before MCP (N×M)"
15        A1[AI App 1] --> T1[GitHub Integration]
16        A1 --> T2[Slack Integration]
17        A1 --> T3[DB Integration]
18        A2[AI App 2] --> T4[GitHub Integration]
19        A2 --> T5[Slack Integration]
20        A2 --> T6[DB Integration]
21    end
22```
23~
24MCP löst dies mit einem **einzigen Protokoll**, das jeder AI-Client verwenden kann, um mit jedem MCP-Server zu kommunizieren:
25~
26```mermaid
27graph TD
28    subgraph "With MCP (N+M)"
29        A1[AI App 1] --> MCP[MCP Protocol]
30        A2[AI App 2] --> MCP
31        MCP --> S1[GitHub Server]
32        MCP --> S2[Slack Server]
33        MCP --> S3[DB Server]
34    end
35```
36~
37## Grundkonzepte
38~
39MCP hat drei fundamentale Primitive:
40~
41### 1. Tools
42Tools 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.
43~
44```typescript
45{
46  name: "create_issue",
47  description: "Create a new GitHub issue",
48  inputSchema: {
49    type: "object",
50    properties: {
51      title: { type: "string", description: "Issue title" },
52      body: { type: "string", description: "Issue body" },
53      repo: { type: "string", description: "Repository name" }
54    },
55    required: ["title", "repo"]
56  }
57}
58```
59~
60### 2. Ressourcen (Resources)
61Ressourcen sind Daten, die die AI lesen kann. Sie repräsentieren Dateien, Datenbankeinträge, API-Antworten oder jede andere Datenquelle. Ressourcen werden durch URIs identifiziert.
62~
63```typescript
64{
65  uri: "file:///Users/dev/project/README.md",
66  name: "Project README",
67  mimeType: "text/markdown"
68}
69```
70~
71### 3. Prompts
72Prompts 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.
73~
74```typescript
75{
76  name: "code_review",
77  description: "Review code changes for quality and security",
78  arguments: [
79    { name: "diff", description: "The code diff to review", required: true }
80  ]
81}
82```
83~
84## Architektur
85~
86MCP folgt einer Client-Server-Architektur:
87~
88```mermaid
89graph LR
90    subgraph "Host Application"
91        Client[MCP Client]
92    end
93~
94    subgraph "MCP Server"
95        Server[Server Process]
96        Server --> Tools[Tools]
97        Server --> Resources[Resources]
98        Server --> Prompts[Prompts]
99    end
100~
101    Client -- "JSON-RPC 2.0\n(stdio or SSE)" --> Server
102```
103~
104- **Host**: Die AI-Anwendung (Claude Desktop, Cursor, deine eigene App)
105- **Client**: Hält eine 1:1-Verbindung zu einem MCP-Server aufrecht
106- **Server**: Stellt Tools, Ressourcen und Prompts dem Client zur Verfügung
107- **Transport**: Die Kommunikation erfolgt über JSON-RPC 2.0 via stdio (lokal) oder Server-Sent Events (remote)
108~
109## Einen MCP-Server bauen
110~
111Lass uns einen praktischen MCP-Server bauen, der mit einer in einer JSON-Datei gespeicherten Aufgabenliste interagiert.
112~
113### Setup
114~
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120~
121### Server-Implementierung
122~
123```typescript
124// src/index.ts
125import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
126import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
127import { z } from "zod";
128import fs from "fs";
129~
130const TODO_FILE = "./todos.json";
131~
132function readTodos(): { id: number; text: string; done: boolean }[] {
133  if (!fs.existsSync(TODO_FILE)) return [];
134  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
135}
136~
137function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
138  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
139}
140~
141const server = new McpServer({
142  name: "todo-server",
143  version: "1.0.0",
144});
145~
146// Tool: Add a todo
147server.tool(
148  "add_todo",
149  "Add a new todo item",
150  { text: z.string().describe("The todo text") },
151  async ({ text }) => {
152    const todos = readTodos();
153    const newTodo = { id: Date.now(), text, done: false };
154    todos.push(newTodo);
155    writeTodos(todos);
156    return { content: [{ type: "text", text: `Added: "${text}"` }] };
157  }
158);
159~
160// Tool: List todos
161server.tool(
162  "list_todos",
163  "List all todo items",
164  {},
165  async () => {
166    const todos = readTodos();
167    const list = todos
168      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
169      .join("\n");
170    return { content: [{ type: "text", text: list || "No todos yet." }] };
171  }
172);
173~
174// Tool: Complete a todo
175server.tool(
176  "complete_todo",
177  "Mark a todo as completed",
178  { id: z.number().describe("The todo ID to complete") },
179  async ({ id }) => {
180    const todos = readTodos();
181    const todo = todos.find((t) => t.id === id);
182    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
183    todo.done = true;
184    writeTodos(todos);
185    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
186  }
187);
188~
189// Resource: Current todos as a readable resource
190server.resource(
191  "todos://list",
192  "Current todo list",
193  async () => ({
194    contents: [{
195      uri: "todos://list",
196      mimeType: "application/json",
197      text: JSON.stringify(readTodos(), null, 2),
198    }],
199  })
200);
201~
202// Start the server
203const transport = new StdioServerTransport();
204await server.connect(transport);
205```
206~
207### Konfiguration
208~
209Um diesen Server mit Claude Desktop zu verwenden, füge ihn zu deiner Konfiguration hinzu:
210~
211```json
212{
213  "mcpServers": {
214    "todo": {
215      "command": "npx",
216      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
217    }
218  }
219}
220```
221~
222## Einen MCP-Client bauen
223~
224Du kannst auch einen benutzerdefinierten Client erstellen, der sich mit jedem MCP-Server verbindet:
225~
226```typescript
227import { Client } from "@modelcontextprotocol/sdk/client/index.js";
228import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
229~
230const transport = new StdioClientTransport({
231  command: "npx",
232  args: ["tsx", "./src/index.ts"],
233});
234~
235const client = new Client({ name: "my-client", version: "1.0.0" });
236await client.connect(transport);
237~
238// List available tools
239const { tools } = await client.listTools();
240console.log("Available tools:", tools.map((t) => t.name));
241~
242// Call a tool
243const result = await client.callTool({
244  name: "add_todo",
245  arguments: { text: "Write MCP blog post" },
246});
247console.log(result);
248```
249~
250## Beliebte MCP-Server
251~
252Das MCP-Ökosystem ist schnell gewachsen. Hier sind einige der beliebtesten Server:
253~
254| Server | Beschreibung | Anwendungsfall |
255|--------|-------------|----------------|
256| **GitHub** | Issues erstellen, PRs, Repos verwalten | Entwicklungs-Workflows |
257| **Slack** | Nachrichten senden, Kanäle verwalten | Teamkommunikation |
258| **PostgreSQL** | Datenbanken abfragen und verwalten | Datenzugriff |
259| **Filesystem** | Dateien lesen, schreiben und durchsuchen | Lokale Entwicklung |
260| **Puppeteer** | Browser-Automatisierung und Scraping | Web-Tests |
261| **Sentry** | Fehlerüberwachung und Debugging | Produktionsunterstützung |
262| **Supabase** | Datenbank, Auth, Speicher | Backend-Operationen |
263~
264## MCP vs A2A (Agent-to-Agent)
265~
266Wä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:
267~
268```mermaid
269graph TD
270    Agent1[Agent 1] -- "A2A Protocol" --> Agent2[Agent 2]
271    Agent1 -- "MCP Protocol" --> Tool1[GitHub MCP Server]
272    Agent2 -- "MCP Protocol" --> Tool2[Database MCP Server]
273```
274~
275- **MCP**: Wie ein AI-Agent Tools nutzt (vertikale Integration)
276- **A2A**: Wie AI-Agenten miteinander zusammenarbeiten (horizontale Integration)
277~
278## Best Practices
279~
2801. **Halte Server fokussiert**: Ein Server pro Domäne (GitHub-Server, Slack-Server, usw.). Baue keine monolithischen Server.
2812. **Validiere Eingaben mit Zod**: Validiere Tool-Eingaben immer mit richtigen Schemas.
2823. **Behandle Fehler elegant**: Gib aussagekräftige Fehlermeldungen zurück, keine Stack Traces.
2834. **Nutze Ressourcen für schreibgeschützte Daten**: Wenn die AI nur Daten lesen muss, stelle sie als Ressource und nicht als Tool bereit.
2845. **Füge gute Beschreibungen hinzu**: Gute Tool- und Parameterbeschreibungen helfen der AI zu verstehen, wann und wie jedes Tool zu verwenden ist.
2856. **Teste mit dem MCP Inspector**: Nutze `npx @modelcontextprotocol/inspector`, um deinen Server interaktiv zu testen.
286~
287## Erste Schritte
288~
289```bash
290# Create a new MCP server from template
291npx @modelcontextprotocol/create-server my-server
292~
293# Test with the MCP Inspector
294npx @modelcontextprotocol/inspector npx tsx ./src/index.ts
295```
296~
297## Fazit
298~
299MCP 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.
300~
301**Nächste Schritte:**
302- Erkunde die [MCP-Spezifikation](https://spec.modelcontextprotocol.io/)
303- Durchstöbere [bestehende MCP-Server](https://github.com/modelcontextprotocol/servers) zur Inspiration
304- Baue deinen ersten Server mit dem TypeScript- oder Python-SDK
305- Teste ihn mit Claude Desktop oder dem MCP Inspector
306~