"MCP-Server bauen: Schritt-für-Schritt Anleitung 2026"

## Was ist das Model Context Protocol (MCP)?

Das Model Context Protocol — kurz MCP — ist ein offener Standard von Anthropic, der es KI-Modellen wie Claude ermöglicht, auf externe Datenquellen und Tools zuzugreifen. Stell dir MCP als USB-Anschluss für KI vor: Du steckst eine Datenquelle an, und Claude kann damit arbeiten.

MCP löst ein fundamentales Problem: KI-Modelle wissen nur das, was in ihrem Trainingsdatensatz steckt. Mit MCP gibst du Claude Zugriff auf deine eigenen Datenbanken, APIs, Dateisysteme und Tools — in Echtzeit.

• Echtzeit-Daten: Claude greift auf aktuelle Unternehmensdaten zu, nicht auf veraltete Trainingsdaten.
• Eigene Tools: Du definierst, welche Aktionen Claude ausführen kann — von Datenbankabfragen bis API-Calls.
• Sicherheit: Du kontrollierst exakt, welche Daten Claude sehen darf und welche nicht.
• Interoperabilität: MCP ist ein offener Standard — ein Server funktioniert mit Claude Code, Claude Desktop und anderen MCP-kompatiblen Clients.

MCP-Architektur verstehen

Bevor du einen MCP-Server baust, musst du die Architektur verstehen. MCP folgt einem Client-Server-Modell:

Voraussetzungen

Bevor du loslegst, stelle sicher, dass du Folgendes hast:

• Node.js 18+ installiert (empfohlen: Node.js 22 LTS)
• Claude Code installiert und eingerichtet
• TypeScript-Grundkenntnisse (hilfreich, aber nicht zwingend)
• Ein Code-Editor (VS Code, Cursor oder direkt Claude Code im Terminal)

Schritt 1: Projekt aufsetzen

Erstelle ein neues Verzeichnis und initialisiere das Projekt:

```bash mkdir mein-mcp-server cd mein-mcp-server npm init -y npm install @modelcontextprotocol/sdk zod npm install -D typescript @types/node ```

Erstelle eine `tsconfig.json`:

```json { "compilerOptions": { "target": "ES2022", "module": "Node16", "moduleResolution": "Node16", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "declaration": true }, "include": ["src/**/*"] } ```

Passe die `package.json` an:

```json { "type": "module", "scripts": { "build": "tsc", "start": "node dist/index.js" } } ```

Schritt 2: Grundstruktur des MCP-Servers

Erstelle `src/index.ts` — das Herzstück deines Servers:

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

// Server erstellen const server = new McpServer({ name: "mein-mcp-server", version: "1.0.0", capabilities: { tools: {}, resources: {}, }, });

// Transport starten const transport = new StdioServerTransport(); await server.connect(transport); console.error("MCP Server läuft."); ```

Das ist bereits ein funktionierender MCP-Server — er tut nur noch nichts. Das ändern wir jetzt.

Schritt 3: Ein Tool definieren

Tools sind Funktionen, die Claude aufrufen kann. Hier ein Beispiel für ein Tool, das den aktuellen Zeitstempel zurückgibt:

```typescript server.tool( "aktuelle-zeit", "Gibt das aktuelle Datum und die Uhrzeit zurück", {}, async () => { const jetzt = new Date().toLocaleString("de-DE", { timeZone: "Europe/Berlin", }); return { content: [ { type: "text", text: `Aktuelle Zeit: ${jetzt}`, }, ], }; } ); ```

Und ein komplexeres Tool mit Parametern — eine Wortanzahl-Analyse:

```typescript server.tool( "woerter-zaehlen", "Zählt die Wörter in einem Text und gibt Statistiken zurück", { text: z.string().describe("Der zu analysierende Text"), detail: z .boolean() .optional() .describe("Detaillierte Analyse mit Zeichenanzahl"), }, async ({ text, detail }) => { const woerter = text.split(/\s+/).filter(Boolean).length; const zeichen = text.length; const saetze = text.split(/[.!?]+/).filter(Boolean).length;

let ergebnis = `Wörter: ${woerter}`; if (detail) { ergebnis += `\nZeichen: ${zeichen}\nSätze: ${saetze}\nDurchschnittliche Wortlänge: ${(zeichen / woerter).toFixed(1)} Zeichen`; }

return { content: [{ type: "text", text: ergebnis }], }; } ); ```

• Name: Eindeutig, beschreibend, mit Bindestrichen getrennt.
• Beschreibung: Klar formuliert — Claude entscheidet anhand der Beschreibung, wann das Tool eingesetzt wird.
• Parameter: Validiert mit Zod-Schemas. Nutze `.describe()` für jedes Feld.
• Rückgabe: Immer ein Array von Content-Objekten mit `type` und `text`.

Schritt 4: Eine Resource definieren

Resources sind Datenquellen, die Claude lesen kann. Hier ein Beispiel für eine statische Resource:

```typescript server.resource( "firmen-richtlinien", "policy://ki-nutzung", async (uri) => { return { contents: [ { uri: uri.href, mimeType: "text/plain", text: `KI-Nutzungsrichtlinien der Firma XY: 1. Keine personenbezogenen Daten in externe KI-Tools eingeben. 2. Claude Code darf für Code-Generierung verwendet werden. 3. Alle KI-generierten Texte müssen vor Veröffentlichung geprüft werden. 4. Bei Unsicherheit: Rücksprache mit dem KI-Team.`, }, ], }; } ); ```

Und eine dynamische Resource, die Dateien aus einem Verzeichnis liest:

```typescript import { readdir, readFile } from "fs/promises"; import { join } from "path";

server.resource( "projekt-notizen", "notes://liste", async (uri) => { const notizVerzeichnis = "./notizen"; const dateien = await readdir(notizVerzeichnis); const notizen = await Promise.all( dateien .filter((d) => d.endsWith(".md")) .map(async (d) => { const inhalt = await readFile(join(notizVerzeichnis, d), "utf-8"); return `## ${d}\n${inhalt}`; }) );

return { contents: [ { uri: uri.href, mimeType: "text/plain", text: notizen.join("\n\n---\n\n"), }, ], }; } ); ```

Schritt 5: Bauen und testen

Kompiliere den Server:

```bash npm run build ```

Füge den Server zu deiner Claude-Code-Konfiguration hinzu. In deiner `.claude/settings.json` oder projektspezifisch in `.mcp.json`:

```json { "mcpServers": { "mein-server": { "command": "node", "args": ["/absoluter/pfad/zu/mein-mcp-server/dist/index.js"] } } } ```

Starte Claude Code neu. Du siehst jetzt deine Tools in der Tool-Liste, und Claude kann sie verwenden.

Du kannst den Server auch direkt testen:

```bash echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | node dist/index.js ```

Schritt 6: Praxisbeispiel — Datenbank-Anbindung

Hier ein realistischeres Beispiel: Ein MCP-Server, der eine SQLite-Datenbank abfragt.

```typescript import Database from "better-sqlite3";

const db = new Database("./daten.db");

server.tool( "kunden-suchen", "Sucht Kunden in der Datenbank nach Name oder E-Mail", { suchbegriff: z.string().describe("Name oder E-Mail des Kunden"), limit: z.number().optional().default(10).describe("Maximale Ergebnisse"), }, async ({ suchbegriff, limit }) => { const ergebnisse = db .prepare( `SELECT name, email, firma FROM kunden WHERE name LIKE ? OR email LIKE ? LIMIT ?` ) .all(`%${suchbegriff}%`, `%${suchbegriff}%`, limit);

if (ergebnisse.length === 0) { return { content: [{ type: "text", text: "Keine Kunden gefunden." }], }; }

const text = ergebnisse .map((k: any) => `- ${k.name} (${k.email}) — ${k.firma}`) .join("\n");

return { content: [{ type: "text", text: `Gefundene Kunden:\n${text}` }], }; } ); ```

Use Cases: Wofür MCP-Server in der Praxis eingesetzt werden

MCP-Server sind extrem vielseitig. Hier die häufigsten Einsatzgebiete:

• CRM-Integration: Claude durchsucht Kundendaten, erstellt Zusammenfassungen, schlägt nächste Schritte vor.
• ERP-Anbindung: Bestandsdaten, Bestellstatus, Lieferketten-Infos direkt in Claude verfügbar.
• Wiki/Confluence: Internes Wissen wird für Claude durchsuchbar.

• Git-Integration: Commit-Historien analysieren, PRs zusammenfassen, Changelogs generieren.
• CI/CD-Monitoring: Build-Status abfragen, Fehler-Logs analysieren.
• Datenbank-Queries: Produktionsdaten sicher abfragen, ohne direkten DB-Zugang.

• E-Mail-Versand: Claude erstellt und versendet E-Mails über deinen Server.
• Ticket-Erstellung: Claude erstellt Jira-, Linear- oder GitHub-Issues.
• Kalender-Management: Termine finden, erstellen, verschieben.

• Dokumenten-Suche: Claude durchsucht interne Dokumente und gibt relevante Stellen zurück.
• FAQ-Bot: Claude beantwortet Fragen auf Basis interner Wissensdatenbanken.
• Onboarding-Assistent: Neue Mitarbeitende stellen Fragen, Claude antwortet mit internem Wissen.

Fortgeschrittene Themen

Robuste MCP-Server brauchen gute Fehlerbehandlung:

```typescript server.tool( "api-abfrage", "Fragt eine externe API ab", { endpoint: z.string().url() }, async ({ endpoint }) => { try { const response = await fetch(endpoint); if (!response.ok) { return { content: [ { type: "text", text: `Fehler: HTTP ${response.status} — ${response.statusText}`, }, ], isError: true, }; } const daten = await response.json(); return { content: [ { type: "text", text: JSON.stringify(daten, null, 2) }, ], }; } catch (error) { return { content: [ { type: "text", text: `Verbindungsfehler: ${error instanceof Error ? error.message : "Unbekannt"}`, }, ], isError: true, }; } } ); ```

• Umgebungsvariablen: API-Keys und Zugangsdaten gehören in `.env`, niemals in den Code.
• Input-Validierung: Zod-Schemas validieren alle Eingaben automatisch.
• Rate Limiting: Begrenze die Anzahl der Aufrufe pro Zeiteinheit.
• Logging: Logge alle Tool-Aufrufe für Audit-Zwecke (über `console.error`, da `stdout` für MCP reserviert ist).

MCP-Server laufen lokal — aber du kannst sie auch auf einem Server betreiben:

• Docker: Verpacke den Server als Container für einheitliche Umgebungen.
• SSE-Transport: Für Remote-Server nutze Server-Sent Events statt stdio.
• Systemd/PM2: Für dauerhafte Ausführung auf Linux-Servern.

Häufige Fehler beim MCP-Server-Bau

• stdout verwenden: MCP kommuniziert über stdout. Nutze `console.error` für Logs, niemals `console.log`.
• Fehlende Beschreibungen: Ohne gute Tool-Beschreibungen weiß Claude nicht, wann es das Tool nutzen soll.
• Zu große Responses: Claude hat ein Context Window. Paginiere oder limitiere Ergebnisse.
• Keine Fehlerbehandlung: Ein crashender Server unterbricht den gesamten Workflow.

Weiterlernen: MCP und Claude Code meistern

Einen MCP-Server zu bauen ist erst der Anfang. Um das volle Potenzial zu nutzen, brauchst du ein solides Verständnis von Claude Code und Context Engineering.

In unseren [Kursen](/de/kurse) lernst du: - Wie du Claude Code professionell einsetzt - Wie du CLAUDE.md Dateien schreibst, die Claude präzise steuern - Wie du MCP-Server für deine konkreten Use Cases baust

Schau dir auch unsere [Bundles](/de/bundles) an, wenn du Claude Code und MCP gemeinsam lernen willst.

Fazit

MCP-Server sind die Brücke zwischen KI und deinen Daten. Das Model Context Protocol macht Claude Code zum mächtigsten Entwickler-Tool auf dem Markt — weil du damit nicht nur Code generieren lässt, sondern Claude in deine gesamte Infrastruktur integrierst.

Der Einstieg ist einfacher als du denkst. Mit den Beispielen aus diesem Tutorial hast du in unter einer Stunde deinen ersten MCP-Server laufen.

Bereit für den nächsten Schritt? Nutze den [Kurs-Finder](/de/kurs-finder), um den passenden Claude-Code-Kurs für dein Level zu finden.