Du nutzt KI zum Coden. Du stellst ihr Fragen, kippst Fehlermeldungen rein, lässt sie vielleicht mal eine Funktion schreiben. Sie antwortet basierend auf dem, was sie weiß — also auf dem, was sie beim Training gelernt hat, eingefroren in der Zeit wie ein Mammut im Eis. Sie kann nicht in deine Datenbank schauen. Sie kann dein GitHub nicht öffnen. Sie kann nicht googeln, ob die Library, die du gleich installieren willst, seit 2023 verwaist ist. Deine KI lebt in einer Box. 😼

Die Box ist das Problem. Eine KI, die deine tatsächliche Infrastruktur nicht anfassen kann, ist nur eine sehr eloquente Quietscheente.

Das änderte sich im November 2024, als Anthropic MCP (Model Context Protocol) veröffentlichte — ein Standardprotokoll, mit dem KI-Tools sich mit externen Diensten verbinden können. Stell dir das wie USB-Anschlüsse für deine KI vor: Du stöpselst einen "Server" ein (ein kleines Hintergrundprogramm), und plötzlich kann dein KI-Agent Datenbanken abfragen, GitHub Issues verwalten, im Web suchen oder einen Browser steuern. Stand März 2026 listet die offizielle MCP-Server-Registry tausende dieser Plugins. Die meisten sind Demos. Einige sind kaputt. Fünf davon sind tatsächlich relevant für den Alltag.

Ich gehe jeden einzelnen mit dir durch, inklusive Copy-Paste-Anleitung, die in unter fünf Minuten erledigt ist.

Bevor du loslegst: wo die MCP-Configs liegen

MCP-Server funktionieren mit jedem MCP-kompatiblen Client — Claude Code, Claude Desktop, Cursor, Windsurf, Cline. Ich verwende Claude Code als Beispiel, aber das Config-Format ist überall quasi identisch.

Deine Config-Datei liegt hier:

# Claude Code (projektbezogen)
.mcp.json

# Claude Code (global)
~/.claude.json

# Claude Desktop
~/Library/Application Support/Claude/claude_desktop_config.json  # macOS
~/.config/Claude/claude_desktop_config.json                       # Linux

Jeder Server folgt dem gleichen Muster:

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "@package/server-name"],
      "env": {
        "API_KEY": "dein-key-hier"
      }
    }
  }
}

npx führt ein Node.js-Paket aus, ohne es global zu installieren. Das -y-Flag überspringt die Bestätigungsabfrage. Das ist die komplette Zeremonie. Jetzt zum guten Zeug.

1. PostgreSQL — mit deiner Datenbank auf Deutsch reden

Was es tut: Deine KI liest dein Datenbankschema (die Struktur — Tabellen, Spalten, Typen), führt SQL-Abfragen aus (die Sprache, die Datenbanken sprechen) und liefert echte Ergebnisse zurück. Schluss mit dem Copy-Paste-Wahnsinn aus dem Terminal in den Chat.

Warum dich das interessiert: Die Hälfte der Entwicklungsarbeit besteht aus "Datenbank checken, Daten verstehen, Query schreiben." Dieser Server macht daraus ein Gespräch.

Config:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-postgres",
        "postgresql://user:pass@localhost:5432/mydb"
      ]
    }
  }
}

Du sagst: "Zeig mir alle Nutzer, die sich diese Woche registriert haben, aber nie etwas gekauft haben." Claude führt echtes SQL gegen deine Datenbank aus. Echte Daten kommen zurück. Du sagst: "Erstell einen Index, um das zu beschleunigen." Claude analysiert den Execution Plan und baut den richtigen Index.

Der Server stellt drei Tools bereit: query (nur lesende SQL-Abfragen), list_tables und describe_table.

Sicherheit: Leg einen Read-only-Datenbankbenutzer an. Gib niemals deine Admin-Credentials an ein automatisiertes Tool:

CREATE USER mcp_readonly WITH PASSWORD 'sicheres_passwort';
GRANT CONNECT ON DATABASE mydb TO mcp_readonly;
GRANT USAGE ON SCHEMA public TO mcp_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO mcp_readonly;

Fazit: Der erste Server, den ich bei jedem Projekt installiere. Spart täglich 30+ Minuten Copy-Paste-Archäologie. 😸

2. GitHub — Repos ohne Browser

Was es tut: Volle GitHub-Integration — Issues, Pull Requests (PRs — vorgeschlagene Codeänderungen), Code-Suche, Dateioperationen. Alles über deinen KI-Agenten.

Warum dich das interessiert: Ständiges Hin-und-Her-Wechseln zwischen Terminal, Chat und GitHub killt den Fokus. Dieser Server hält dich an einem Ort.

Config:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_dein_token_hier"
      }
    }
  }
}

Du brauchst ein Personal Access Token — hol dir eins auf github.com/settings/tokens. Benötigte Scopes: repo, read:org, read:user.

Jetzt kannst du sagen: "Erstell ein Issue für den Login-Timeout-Bug mit dem Stack Trace, den ich dir gerade gezeigt habe." Oder: "Review PR #47 und kommentiere Sicherheitsprobleme." Claude liest den Diff, analysiert den Code und postet echte Review-Kommentare auf GitHub.

Wichtige Tools: create_issue, list_pull_requests, search_code, create_branch, get_file_contents. Über ein Dutzend insgesamt.

Profitipp: Kombinier das mit dem Postgres-Server. "Check die Error-Logs in der Datenbank, finde den relevanten Code auf GitHub, erstell ein Issue mit beidem." Ein Prompt. Drei Tools. Null Browser-Tabs. 😹

Fazit: Der zweite Server, den ich installiere. GitHubs Web-UI ist okay zum Stöbern. Zum Arbeiten ist das hier schneller.

3. Filesystem — kontrollierter Dateizugriff mit Leitplanken

Was es tut: Gibt deinem KI-Agenten Zugriff auf Lesen, Schreiben, Suchen und Verwalten von Dateien — aber nur in Verzeichnissen, die du explizit freigibst. Er kann nicht zu deinen SSH-Keys oder .env-Dateien wandern.

Config:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-filesystem",
        "/home/user/projects",
        "/home/user/documents"
      ]
    }
  }
}

Liste mehrere Verzeichnisse auf — der Server beschränkt den Zugriff auf genau diese Pfade. Path-Traversal-Versuche (Tricks wie ../../etc/passwd) werden blockiert.

Tools: read_file, write_file, create_directory, list_directory, move_file, search_files, read_multiple_files.

Wer braucht das: Hauptsächlich Claude Desktop-Nutzer. Claude Code hat bereits eingebauten Dateisystemzugriff, daher ist dieser Server dort überflüssig. Aber für Claude Desktop — wo die KI sonst überhaupt keine Dateien anfassen kann — ist er essenziell. Das Directory-Sandboxing (Zugriffsbeschränkung auf bestimmte Ordner) ist ein echtes Sicherheitsfeature.

Fazit: Überspring es, wenn du Claude Code nutzt. Installier es sofort, wenn du Claude Desktop nutzt.

4. Brave Search — Echtzeit-Webdaten

Was es tut: Websuche über die Brave Search API. Deine KI sucht live, statt aus Trainingsdaten zu raten.

Warum dich das interessiert: "Was kostet ein Hetzner CAX11 aktuell?" "Wird diese Library noch gepflegt?" "Welche Next.js-Version ist die neueste?" Diese Fragen brauchen Live-Antworten. Trainingsdaten wissen nicht, was letzten Dienstag passiert ist.

Config:

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA_dein_key_hier"
      }
    }
  }
}

Hol dir einen kostenlosen API-Key auf brave.com/search/api. Free Tier: 2.000 Abfragen/Monat, 1 Request/Sekunde. Für einen Solo-Entwickler mehr als genug. Der bezahlte Tarif startet bei 5$/Monat für 20.000 Abfragen, falls du das freie Kontingent durchbrennst.

Zwei Tools: brave_web_search (allgemeine Websuche mit Paginierung) und brave_local_search (lokale Unternehmenssuche).

Clevere Nutzung: Validier die Architekturvorschläge deiner KI, bevor du dich commitest. "Such nach bekannten Problemen mit Prisma 6.x und PostgreSQL 17" ist ein prima Sanity Check, bevor du drei Tage tief in einer Implementierung steckst.

Fazit: Schließt die größte Lücke bei KI-gestütztem Coding — die Unfähigkeit zu prüfen, was jetzt gerade stimmt. 😼

5. Puppeteer — Browser-Automatisierung per Gespräch

Was es tut: Steuert einen Headless Browser (ein Chromium-Browser, der unsichtbar im Hintergrund läuft, ohne sichtbares Fenster). Deine KI navigiert Seiten, macht Screenshots, klickt Buttons, füllt Formulare aus, extrahiert Inhalte von JavaScript-gerenderten Seiten.

Config:

{
  "mcpServers": {
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Keine API-Keys. Keine Konfiguration. Puppeteer lädt Chromium automatisch herunter.

Tools: puppeteer_navigate, puppeteer_screenshot, puppeteer_click, puppeteer_fill, puppeteer_evaluate (JavaScript auf der Seite ausführen).

Sag: "Geh auf localhost:3000, mach einen Screenshot der Login-Seite, sag mir ob sie korrekt rendert." Dann: "Füll Test-Credentials ein und schick das Formular ab." Claude navigiert, füllt Felder aus, klickt auf Absenden, screenshottet das Ergebnis.

Ich nutze das für visuelles Regressionstesting — "Navigier zu jeder Route und mach einen Screenshot" gibt mir einen visuellen Snapshot, den Claude mit dem erwarteten Layout abgleichen kann. Kein Playwright-Setup, kein Test-Framework. Einfach "geh die Seite angucken."

Achtung: Das startet einen echten Browser. Jede Instanz frisst 200-500 MB RAM. Lass das nicht auf einem RAM-knappen Laptop durchlaufen. Der Server räumt automatisch auf, wenn du deinen MCP-Client schließt.

Fazit: Der Server mit dem meisten Spaßfaktor auf dieser Liste. Browser-Automatisierung per natürlicher Sprache ist ernsthaft befriedigend. Unverzichtbar für Frontend-Arbeit und Web Scraping. 😸

Die komplette Config — kopieren und einfügen

Alle fünf Server in einer Datei:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://mcp_readonly:password@localhost:5432/mydb"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
               "/home/user/projects"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA_xxx"
      }
    },
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Ersetze die Platzhalter durch deine echten Credentials. Speicher die Datei als .mcp.json im Projekt-Root oder als ~/.claude.json für globalen Zugriff.

Mehr finden (und wissen, wann Schluss ist)

Die offizielle Registry liegt auf github.com/modelcontextprotocol/servers. mcpservers.org listet Community-Server. Stöber ruhig, wenn du neugierig bist.

Aber widersteh dem Drang, 15 Server "auf Vorrat" zu installieren. Jeder davon ist ein laufender Prozess. Jeder erhöht die Startzeit. Jeder ist eine Angriffsfläche — ein potenzieller Einstiegspunkt für Sicherheitsprobleme. 80% der Entwickler brauchen zwei oder drei Server, maximal.

Du bist jetzt gefährlich

Du hast mit einer KI angefangen, die in einer Textbox gelebt hat. Jetzt hast du eine, die deine Datenbank abfragt, dein GitHub verwaltet, live im Web sucht und einen Browser steuert. Das Protokoll darunter — JSON-RPC (ein simples Nachrichtenformat) über stdio (Standard-Ein-/Ausgabe, so reden Programme miteinander) — ist langweilig. Langweilige Protokolle, die funktionieren, sind genau das, was wir gebraucht haben.

Diese fünf Server decken 90% dessen ab, was ein Solo-Entwickler braucht. Alles andere im MCP-Verzeichnis ist entweder Nischen-Tooling für spezifische Use Cases oder eine Demo, die in dem Moment zerbricht, in dem du dich tatsächlich darauf verlässt. Fang mit Postgres und GitHub an. Nimm Brave Search dazu, wenn du Live-Daten brauchst. Häng Puppeteer dran, wenn du dich fühlen willst wie im Jahr 2030.

Die Box ist offen. Deine KI hat jetzt Hände. Versuch, sie nichts Wichtiges fallen zu lassen. 😹