flowki@club:~$ Gerade gestartet · sei von Anfang an dabei

// quickstart + katalog / model context protocol

MCP-Server-Starter (Deutsch)

Model-Context-Protocol-Server sind der Schlüssel, um KI-Assistenten eigene Tools zu geben — aber ein guter deutscher Einstieg fehlte bisher. Hier ist er: ein Quickstart mit lauffähigem Code und ein kuratierter Katalog nützlicher Server.

Quickstart (Markdown) Server-Katalog (Markdown)

Ein praktischer Quickstart für das Model Context Protocol mit TypeScript

Was ist MCP?

Das Model Context Protocol (MCP) ist ein offener Standard von Anthropic, der LLMs wie Claude Zugriff auf externe Tools und Datenquellen ermöglicht. Statt alles in den Prompt zu packen, stellt ein MCP-Server strukturierte Schnittstellen bereit — der LLM kann dann gezielt Tools aufrufen, Ressourcen abfragen oder Prompts nutzen.

Voraussetzungen

Projekt-Setup

# Neues Projekt anlegen
mkdir mein-mcp-server
cd mein-mcp-server

# package.json initialisieren
npm init -y

# MCP SDK installieren
npm install @modelcontextprotocol/sdk

# TypeScript + Dev-Dependencies
npm install -D typescript @types/node tsx

# TypeScript-Config
npx tsc --init

Wichtig für tsconfig.json: Setze "module": "NodeNext" und "moduleResolution": "NodeNext" für moderne ESM-Kompatibilität.

Dein erster Server: Ein einfaches Rechner-Tool

Erstelle src/server.ts:

#!/usr/bin/env node
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

// Server-Instanz erstellen
const server = new Server(
  {
    name: "mein-rechner",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {}, // Wir bieten Tools an
    },
  }
);

// Handler: Liste aller verfügbaren Tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "addiere",
        description: "Addiert zwei Zahlen",
        inputSchema: {
          type: "object",
          properties: {
            a: { type: "number", description: "Erste Zahl" },
            b: { type: "number", description: "Zweite Zahl" },
          },
          required: ["a", "b"],
        },
      },
    ],
  };
});

// Handler: Tool-Ausführung
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  if (name === "addiere") {
    const { a, b } = args as { a: number; b: number };

    // Einfache Validierung
    if (typeof a !== "number" || typeof b !== "number") {
      throw new Error("a und b müssen Zahlen sein");
    }

    const ergebnis = a + b;

    return {
      content: [
        {
          type: "text",
          text: `${a} + ${b} = ${ergebnis}`,
        },
      ],
    };
  }

  throw new Error(`Unbekanntes Tool: ${name}`);
});

// Server über stdio starten
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);

  // Wichtig: Error-Logs nur nach stderr, nie nach stdout!
  console.error("MCP-Server läuft auf stdio");
}

main().catch((error) => {
  console.error("Server-Fehler:", error);
  process.exit(1);
});

Was passiert hier?

  1. Server-Instanz: Name + Version + Capabilities (wir bieten tools an)
  2. ListToolsRequestSchema: Der Client fragt: "Welche Tools hast du?" → Wir antworten mit Schema
  3. CallToolRequestSchema: Der Client sagt: "Führe Tool X mit Argumenten Y aus" → Wir liefern Ergebnis
  4. stdio-Transport: Kommunikation über stdin/stdout (Standard für lokale Server)

Server testen

1. Build-Script in package.json ergänzen

{
  "scripts": {
    "build": "tsc",
    "dev": "tsx src/server.ts"
  }
}

2. Server lokal testen (ohne Client)

npm run dev

Du solltest sehen: MCP-Server läuft auf stdio (auf stderr). Der Prozess wartet jetzt auf JSON-RPC-Nachrichten auf stdin.

Manueller Test (optional):

In einer zweiten Shell kannst du eine JSON-RPC-Nachricht schicken:

echo '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | npm run dev

Du solltest die Tool-Liste als JSON zurückbekommen.

3. Anbindung an Claude Desktop / Claude Code

Erstelle oder bearbeite die MCP-Client-Config:

Claude Desktop:

Claude Code:

Config-Beispiel:

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

Wichtig:

4. Im Client testen

Öffne Claude Desktop/Code und schreibe:

"Addiere 42 und 27 mit dem verfügbaren Tool"

Claude sollte das addiere-Tool nutzen und dir 42 + 27 = 69 ausgeben.

Error-Handling-Basics

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  try {
    // ... deine Tool-Logik ...
  } catch (error) {
    // Fehler strukturiert zurückgeben
    return {
      content: [
        {
          type: "text",
          text: `Fehler bei Tool-Ausführung: ${error instanceof Error ? error.message : String(error)}`,
        },
      ],
      isError: true,
    };
  }
});

Logging-Regel: Nutze console.error() für Debug-Logs — niemals console.log(), weil stdout für JSON-RPC-Nachrichten reserviert ist.

Typische Stolperfallen

1. stdout vs. stderr

Problem: Server schreibt Debug-Logs nach stdout → JSON-RPC-Stream wird korrumpiert → Client bricht ab.

Lösung: Alle Logs nach console.error(), nie console.log().

2. stdio vs. SSE

stdio (Standard Input/Output):

SSE (Server-Sent Events):

Nicht mischen! Wenn du HTTP willst, nutze SSE-Transport + separaten HTTP-Server.

3. Async-Initialisierung

Wenn dein Server beim Start externe Ressourcen laden muss (Datenbank, API-Keys):

async function main() {
  // ERST Ressourcen laden
  await ladeKonfiguration();

  // DANN Transport starten
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

Nie server.connect() vor async-Init aufrufen — sonst bekommst du Race Conditions.

4. JSON-Schema-Validierung

Der inputSchema wird vom Client NUR zur UI-Generierung genutzt — keine automatische Validierung. Du musst im CallToolRequestSchema-Handler selbst prüfen:

if (typeof args.a !== "number") {
  throw new Error("Parameter 'a' muss eine Zahl sein");
}

Nächste Schritte

Weiterführende Ressourcen:

Die nützlichsten Model-Context-Protocol-Server — kuratiert von der FlowKI-Community

Das Model Context Protocol (MCP) erweitert Claude (und andere LLMs) um direkten Zugriff auf Dateisysteme, Datenbanken, APIs und Tools. Dieser Katalog listet die 30 relevantesten Server für deutsche Entwickler — von offiziellen Referenz-Implementierungen bis zu bewährten Community-Tools.

Wichtig: Wir hosten keine Server selbst, sondern verlinken die Originale. Installation und Nutzung erfolgen auf eigene Verantwortung.

Wie du MCP-Server nutzt

MCP-Server werden in claude_desktop_config.json (Claude Desktop) oder .claude/settings.json (Claude Code) registriert. Grundstruktur:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/pfad/zum/projekt"]
    }
  }
}

Nach Neustart von Claude stehen dir die Server-Tools zur Verfügung. Details findest du im MCP-Quickstart.

Offizielle Referenz-Server

Die Kerntruppe — von Anthropic entwickelt, öffentlich, produktionsreif.

Server Wofür Quelle
filesystem Lese- und Schreibzugriff auf lokale Dateien und Verzeichnisse. Claude kann Dateien lesen, schreiben, umbenennen, löschen und Verzeichnisse durchsuchen. GitHub
everything Windows-Dateisuche via Everything Search Engine (lokal, extrem schnell). Findet Dateien in Sekundenbruchteilen über deinen gesamten PC. GitHub
git Git-Repository-Operationen über lokale Repos. Status prüfen, Commits lesen, Branches wechseln, Diffs anzeigen — ohne Terminal. GitHub
fetch HTTP-Anfragen an beliebige APIs (GET, POST, PUT, DELETE). REST-APIs aufrufen, Daten fetchen, Webhooks testen — wie curl, aber intelligenter. GitHub
memory Einfacher In-Memory-Key-Value-Store für Entwicklung und Testing. Temporäre Daten während einer Session speichern — ideal für Prototypen. GitHub
time Zeitzonenkonvertierung, Datumsberechnungen und Weltzeiten. Timestamps umrechnen, Zeitdifferenzen berechnen — ohne Math.floor-Chaos. GitHub

Datenbanken

Direkter DB-Zugriff — lies Schemas, führe Queries aus, analysiere Daten.

Server Wofür Verfügbarkeit
postgres PostgreSQL-Datenbankzugriff (read-only empfohlen für Sicherheit). SQL-Queries ausführen, Schema inspizieren, Daten abfragen — ohne pgAdmin. Community (siehe awesome-mcp-servers)
sqlite SQLite-Datenbankzugriff (lokal, ideal für Entwicklung). Lokale SQLite-DBs abfragen, Schema lesen — perfekt für Prototypen und Analysen. Community (siehe awesome-mcp-servers)
mongodb MongoDB-Datenbankzugriff. Collections abfragen, Aggregation-Pipelines testen, Dokumente durchsuchen — NoSQL direkt in Claude. Community (siehe awesome-mcp-servers)

Web & Browser

Seiten scrapen, Screenshots machen, HTTP-Aufrufe — Claude als Browser-Bot.

Server Wofür Verfügbarkeit
puppeteer Browser-Automatisierung via Puppeteer (Screenshots, Scraping, Testing). Webseiten scrapen, Screenshots machen, Formulare ausfüllen — Headless-Chrome-Power. Community (siehe awesome-mcp-servers)
playwright Browser-Automatisierung via Playwright (wie Puppeteer, aber Multi-Browser). Tests schreiben, Cross-Browser-Screenshots, E2E-Flows automatisieren — mit Firefox, Chrome, Safari. Community (siehe awesome-mcp-servers)

Suche & Recherche

Echte Web-Suche und spezialisierte Suchmaschinen — Claude mit Google-Augen.

Server Wofür Verfügbarkeit
brave-search Web-Suche über Brave Search API. Aktuelle Web-Suchergebnisse direkt in Claude (braucht API-Key) — Privacy-First-Alternative zu Google. Community (siehe awesome-mcp-servers)
exa Semantische Suche über Exa AI (Neural Search Engine). Intelligentere Suche als Google — findet Inhalte nach Bedeutung, nicht nur Keywords. Community (siehe awesome-mcp-servers)
google-maps Google Maps API-Zugriff (Orte, Routen, Geocoding). Adressen geocoden, Entfernungen berechnen, Orte suchen — Maps in Claude. Community (siehe awesome-mcp-servers)

Cloud & APIs

AWS, GCP, Azure — Cloud-Infrastruktur direkt ansprechbar.

Server Wofür Verfügbarkeit
aws-kb-retrieval Amazon Bedrock Knowledge Base Retrieval. Wissen aus AWS Knowledge Bases abrufen — ideal für Enterprise-RAG-Setups. Community (siehe awesome-mcp-servers)
gdrive Google Drive-Zugriff (Dateien lesen, suchen, Metadaten). Drive-Dateien durchsuchen, Inhalte lesen — ohne Browser. Community (siehe awesome-mcp-servers)
google-cloud-vertex-ai Google Cloud Vertex AI-Integration. Vertex AI-Modelle nutzen, Prompts ausführen — Multi-Cloud-LLM-Setup. Community (siehe awesome-mcp-servers)

Dev-Tools & Code

GitHub, GitLab, Docker — DevOps-Workflows automatisieren.

Server Wofür Verfügbarkeit
github GitHub-API-Zugriff (Issues, PRs, Repos, Discussions). Issues erstellen/lesen, Pull Requests verwalten, Repo-Infos abrufen — GitHub ohne Browser. Community (siehe awesome-mcp-servers)
gitlab GitLab-API-Zugriff (Issues, Merge Requests, Pipelines). GitLab-Projekte verwalten, CI/CD-Status prüfen — Self-Hosted-DevOps-Zentrale. Community (siehe awesome-mcp-servers)
docker Docker-Container- und Image-Verwaltung. Container starten/stoppen, Logs lesen, Images bauen — Docker-CLI in Claude. Community (siehe awesome-mcp-servers)
kubernetes Kubernetes-Cluster-Management (Pods, Services, Deployments). kubectl-Operationen ausführen, Cluster-Status prüfen — K8s ohne Terminal. Community (siehe awesome-mcp-servers)
terraform Terraform-Plan und Apply-Operationen. Infra-as-Code verwalten, State-Dateien inspizieren — IaC-Workflows automatisieren. Community (siehe awesome-mcp-servers)

Produktivität & SaaS

Slack, Notion, Linear — Arbeits-Tools direkt in Claude.

Server Wofür Verfügbarkeit
slack Slack-Workspace-Zugriff (Nachrichten senden, Channels lesen). Slack-Messages posten, Channel-Historie lesen — Team-Chat automatisieren. Community (siehe awesome-mcp-servers)
notion Notion-Workspace-Zugriff (Pages lesen, Datenbanken abfragen). Notion-Datenbanken durchsuchen, Pages lesen/schreiben — Second-Brain-Autopilot. Community (siehe awesome-mcp-servers)
linear Linear-Projekt-Management (Issues, Projects, Teams). Linear-Issues erstellen/lesen, Projektstatus prüfen — Dev-Workflow in Claude. Community (siehe awesome-mcp-servers)
jira Jira-Integration (Issues, Sprints, Boards). Jira-Tickets verwalten, Sprint-Status prüfen — Agile-Workflows ohne Browser. Community (siehe awesome-mcp-servers)
discord Discord-Server-Zugriff (Nachrichten senden, Channels lesen). Discord-Messages posten, Channel-Historie lesen — Community-Management automatisieren. Community (siehe awesome-mcp-servers)
obsidian Obsidian-Vault-Zugriff (Notes lesen, Metadaten, Backlinks). Obsidian-Notes durchsuchen, Graph-Zusammenhänge analysieren — Zettelkasten in Claude. Community (siehe awesome-mcp-servers)

Monitoring & Observability

Fehler-Tracking und Logging — Production-Debugging mit Claude.

Server Wofür Verfügbarkeit
sentry Sentry.io-Integration (Error-Tracking, Issues abrufen). Sentry-Issues lesen, Fehlerberichte analysieren — Bug-Hunting automatisiert. Community (siehe awesome-mcp-servers)

Spezialisierte Tools

Nischen-Anwendungen mit echtem Impact.

Server Wofür Verfügbarkeit
sequential-thinking Strukturierte Denkprozesse für komplexe Probleme. Claude zu sequentiellem Denken anleiten (experimentell) — bessere Reasoning-Qualität. Community (siehe awesome-mcp-servers)
crypto Kryptowährungsdaten (Preise, Charts, Wallets). Crypto-Preise abfragen, Wallet-Balances prüfen — Blockchain-Daten in Echtzeit. Community (siehe awesome-mcp-servers)
email E-Mail-Zugriff (IMAP/SMTP, Gmail API). E-Mails lesen/senden, Postfach durchsuchen — Mail-Automation ohne Zapier. Community (siehe awesome-mcp-servers)

Vollständige Community-Liste

Die obigen 30 Server decken die wichtigsten Anwendungsfälle ab. Für hunderte weitere Server (z.B. Todoist, Trello, Airtable, Stripe, Shopify, WordPress, und viele mehr):

→ awesome-mcp-servers
Kuratierte Community-Liste mit 300+ Servern, sortiert nach Kategorien. Regelmäßig aktualisiert.

Sicherheitshinweise

Vorsicht bei Schreibzugriff

Server mit write-Rechten (filesystem, git, Datenbanken) können destruktive Operationen ausführen. Nutze sie nur in Verzeichnissen, die du kontrollierst.

API-Keys schützen

Viele Server brauchen Credentials (GitHub-Token, API-Keys). Nutze Umgebungsvariablen, nie hardcoded im Config:

{
  "env": {
    "GITHUB_TOKEN": "dein-token-hier"
  }
}

Read-Only bevorzugen

Für Produktiv-Datenbanken: erstelle read-only-User für den MCP-Server. Nie den Admin-User verwenden.

Audit vor Installation

Community-Server sind Open Source, aber nicht alle gleich gut gepflegt. Prüfe vor Installation:

Mehr Sicherheitstipps: MCP-Server absichern

Installation

Die meisten Server werden via npm installiert:

# Global installieren (einmalig)
npm install -g @modelcontextprotocol/server-filesystem

# Oder direkt via npx (keine Installation nötig)
npx -y @modelcontextprotocol/server-filesystem /pfad/zum/projekt

Details zur Config findest du im jeweiligen Repo-README.

Eigene Server bauen?

MCP-Server sind einfacher zu entwickeln als gedacht. Mit dem offiziellen Template bist du in 30 Minuten live:

→ MCP-Quickstart-Guide
TypeScript- und Python-Templates, Step-by-Step-Anleitung, Best Practices.

Quellen & Attribution

Hinweis: Diese Liste ist eine Momentaufnahme (Stand: Januar 2026). Neue Server kommen laufend hinzu — prüfe die offiziellen Quellen für aktuelle Ergänzungen.

Weitere Ressourcen:

// weiter geht's in der community

Fragen, Feedback, eigene Ergänzungen?

Dieses Freebie ist ein Startpunkt, kein Endpunkt. Im deutschsprachigen FlowKI-Club-Discord besprichst du deine Fälle mit anderen KI-Praktikern, bekommst Updates zu den Sammlungen zuerst und kannst eigene Beiträge einbringen.

Zur FlowKI-Community →