Was ist ein MCP Server? (und wie du einen baust)

Was ein MCP Server ist

MCP (Model Context Protocol) ist ein offener Standard, der AI Agents über eine gemeinsame Schnittstelle mit externen Tools, Daten und Services verbindet. Ein MCP Server ist das Stück, das du (oder ein Anbieter) schreibst und das vor einer bestimmten Fähigkeit sitzt: einer Datenbank, einem Browser, einem Issue-Tracker, einem Filesystem, einer API. Er bewirbt, was er kann, und jeder MCP Client kann ihn entdecken und nutzen. Der Grund, warum sich MCP so schnell ausbreitete, ist, dass es ein N-mal-M-Problem löst: Vor MCP brauchte jedes Tool eine massgeschneiderte Integration für jeden Agenten; mit MCP wird ein Tool einmal integriert und funktioniert überall. Also gibt es heute einen MCP Server für fast alles, was ein Agent erreichen soll.

• Ein Server umhüllt eine Fähigkeit (eine Datenbank, einen Browser, eine API) und stellt sie Agents bereit.
• Er spricht das Model Context Protocol, sodass jeder MCP Client ihn ohne eigenen Klebe-Code nutzen kann.
• Schreib die Integration einmal; jede MCP-fähige App profitiert. Deshalb breitete sich die Unterstützung schnell aus.
• Siehe den Glossar-Eintrag zu MCP für die Kurzdefinition und Tool Calling dafür, wie Agents es aufrufen.

Wie er funktioniert: Host, Client und Server

MCP nutzt eine Client-Server-Architektur auf Basis von JSON-RPC 2.0, mit drei Beteiligten. Der Host ist die AI-Anwendung, die du nutzt, etwa Claude Code oder Cursor. Wenn der Host startet, erstellt er einen MCP Client pro konfiguriertem Server, und jeder Client hält seine eigene dedizierte, zustandsbehaftete Verbindung zu einem MCP Server. Der Server ist das Programm, das die Fähigkeit bereitstellt. Nachrichten fliessen als JSON-RPC-Requests, -Responses und -Notifications über einen Transport. Es gibt zwei gebräuchliche Transports: stdio, bei dem der Host den Server als lokalen Kindprozess spawnt und sie über Standardein- und -ausgabe reden, und Streamable HTTP, genutzt für entfernte, Cloud-gehostete Server. Ein Host kann viele Client-Server-Verbindungen gleichzeitig fahren, so erreicht ein Agent ein Filesystem, einen Browser und eine Datenbank in derselben Session.

• Host: die AI-App (Claude Code, Cursor, Claude Desktop), mit der der Nutzer interagiert.
• Client: einer pro Server, vom Host erstellt, der eine dedizierte Verbindung hält.
• Server: dein Programm, das eine Fähigkeit bereitstellt und JSON-RPC 2.0 spricht.
• Transport: stdio für lokale Server, Streamable HTTP für entfernte (SSE ist deprecated).

Was ein Server bereitstellt: Tools, Resources und Prompts

Ein MCP Server kann drei Arten von Primitive bereitstellen, und ein gegebener Server implementiert die, die für ihn Sinn ergeben. Tools sind Aktionen, die das Modell aufrufen kann, etwa "führe diese Query aus" oder "erstelle dieses Issue"; jedes Tool deklariert ein Input-Schema, damit der Agent weiss, wie er es aufruft. Resources sind read-only Daten, die der Agent abrufen kann, etwa der Inhalt einer Datei oder ein Datenbank-Record, adressiert per URI. Prompts sind wiederverwendbare Templates, die der Server anbietet, oft dem Nutzer als Slash Commands oder Quick Actions präsentiert. Tools sind bei Weitem am häufigsten, weil der Hauptwert von MCP ist, einen Agenten auf einem System handeln zu lassen, nicht es nur zu lesen.

• Tools: Aktionen, die der Agent aufrufen kann (eine DB abfragen, einen PR öffnen, einen Browser steuern). Jedes hat ein Input-Schema.
• Resources: read-only Daten, die der Agent per URI abrufen kann (Dateiinhalte, Records).
• Prompts: wiederverwendbare Templates, die der Server bietet, oft als Slash Commands gezeigt.
• Ein Server deklariert, welche Primitive er unterstützt; die meisten führen mit Tools.

Bau einen minimalen MCP Server

Der schnellste Weg, einen Server zu verstehen, ist, einen winzigen zu bauen. Das offizielle TypeScript SDK kommt als Paket @modelcontextprotocol/server und lässt dich einen funktionierenden stdio-Server in wenigen Zeilen aufstellen: Erstelle einen McpServer, registriere ein Tool mit einem Namen, einer Beschreibung und einem Zod-Input-Schema, dann verbinde ihn über einen StdioServerTransport. Das Beispiel unten stellt ein greet-Tool bereit. Speichere es, zeig deinen MCP Client auf den Befehl, der es ausführt (für Claude Code ist das claude mcp add --transport stdio), und der Agent kann greet aufrufen. Ein Python SDK (FastMCP) bietet dieselbe Form, falls du Python bevorzugst.

// server.ts - a minimal MCP server exposing one tool over stdio
import { McpServer } from '@modelcontextprotocol/server'
import { StdioServerTransport } from '@modelcontextprotocol/server/stdio'
import * as z from 'zod'

const server = new McpServer({ name: 'greeting-server', version: '1.0.0' })

// Register a tool: a name, a description, and a Zod input schema.
server.registerTool(
  'greet',
  {
    description: 'Greet someone by name',
    inputSchema: z.object({ name: z.string() }),
  },
  async ({ name }) => ({
    content: [{ type: 'text', text: `Hello, ${name}!` }],
  }),
)

// Connect over stdio: the host spawns this file and talks via stdin/stdout.
const transport = new StdioServerTransport()
await server.connect(transport)

Halte server.ts frei von console.log auf stdout: Ein stdio-Server nutzt stdout für das JSON-RPC-Protokoll, logge also stattdessen auf stderr. Von hier fügst du weitere Tools, Resources und Prompts genauso hinzu und wechselst zu Streamable HTTP, wenn du den Server entfernt hosten willst.

MCP Server vs eine reine API

Eine berechtigte Frage ist, warum ein Agent einen MCP Server braucht, wenn der zugrunde liegende Service schon eine REST-API hat. Der Unterschied ist Discovery und Selbstbeschreibung. Eine REST-API braucht einen Menschen, der ihre Doku liest und für jeden Client Integrations-Code schreibt; ein MCP Server bewirbt seine Tools, deren Schemas und Beschreibungen in einem Standard, den der Agent beim Verbinden liest, sodass der Agent automatisch lernt, wie er ihn nutzt, und derselbe Server über jeden MCP Client funktioniert. MCP ersetzt deine API nicht; es ist eine dünne, agentenfreundliche Schicht davor. Für interne Einzelfälle mag ein CLI, das der Agent aufrufen kann, einfacher sein, aber für alles, was viele Agents und Apps nutzen sollen, ist ein MCP Server die interoperable Wahl.

• Eine REST-API braucht pro Client Integrations-Code; ein MCP Server ist selbstbeschreibend und überall wiederverwendet.
• Der Agent liest Tool-Schemas und -Beschreibungen beim Verbinden, also weiss er, wie er sie aufruft.
• MCP sitzt als agentenfreundliche Schicht vor deiner API, es ersetzt sie nicht.
• Für einen privaten Einzelfall mag ein CLI einfacher sein; für geteilte Nutzung gewinnt ein Server.

Gängige Server, die du kennen solltest

Du musst selten einen Server von Grund auf bauen, weil das Ökosystem die gängigen Fälle schon abdeckt. Gute erste Verbindungen sind der Filesystem-Server (auf einen Ordner begrenzt, damit der Agent Projektdateien lesen und schreiben kann), der Playwright-Server (damit der Agent einen echten Browser steuern kann, um zu testen oder zu scrapen) und ein Datenbank-Server für deinen Stack. Darüber hinaus gibt es Server für Issue-Tracker, Design-Tools, Monitoring und die meisten grossen SaaS-Produkte. Verbinde aber bewusst: Jeder Server fügt seine Tool-Definitionen zum Agent-Kontext hinzu, also hat jeder laufende Kosten, und ein Server ist Drittanbieter-Code mit Zugriff auf deine Systeme, also prüfe ihn wie jede Abhängigkeit. Unser Guide MCP in Claude Code einrichten führt durch das sichere Hinzufügen, Scopen und Verifizieren von Servern.

• Filesystem-Server: Dateien in einem begrenzten Ordner lesen und schreiben.
• Playwright-Server: den Agenten einen echten Browser steuern lassen.
• Datenbank-Server: deine Daten direkt abfragen, statt Zeilen in den Chat zu kopieren.
• Verbinde wenige und prüfe jeden: Jeder Server kostet Kontext und ist Drittanbieter-Code.

Schritt für Schritt

1. 01

   Das SDK installieren

   In einem neuen Node.js-Projekt installiere das offizielle TypeScript SDK mit "npm install @modelcontextprotocol/server" (und zod für Input-Schemas). Ein Python SDK, FastMCP, ist verfügbar, falls du Python bevorzugst.

2. 02

   Den Server erstellen und ein Tool registrieren

   Erstelle einen McpServer mit Name und Version, rufe dann server.registerTool mit einem Tool-Namen, einer Beschreibung und einem Zod-inputSchema auf und gib aus dem async-Handler ein content-Array zurück.

3. 03

   Über einen Transport verbinden

   Für lokale Nutzung erstelle einen StdioServerTransport und await server.connect(transport). Der Host spawnt deine Datei und redet über stdin/stdout mit ihr, also logge auf stderr, nie auf stdout.

4. 04

   Den Server bei einem Client registrieren

   Zeig deinen MCP Client auf den Befehl, der den Server ausführt. In Claude Code: "claude mcp add --transport stdio <name> -- node server.js". Siehe unseren Guide MCP in Claude Code einrichten für Scopes und Verifikation.

5. 05

   Verifizieren und erweitern

   Bestätige, dass der Agent dein Tool sehen und aufrufen kann, dann füge weitere Tools, Resources und Prompts genauso hinzu. Wechsle zu Streamable HTTP, wenn du den Server entfernt hosten willst.

Häufige Fragen

Weiterlernen