mcp model-context-protocol ai-coding developer-tools ai-agents

Zehn MCP-Server, die Entwicklern in Prioritätsreihenfolge zuerst installiert werden sollten

Ein sortiertes Starter-Set für MCP-Server für KI-Code-Assistenten, von Context7 und GitHub über Postgres bis hin zu Speichermöglichkeiten, inklusive Installationskonfigurationen und Hinweisen zu Berechtigungen.

Verlag: REACTAPP.TOPAuf dieser Website hinzugefügt 28. Okt. 202616 Min. Lesezeit3781 Wörter

Quellen: Stop Installing Random MCP Servers. Start With These 10.

Zu Beginn wirkten MCP-Server wie Magie. Schon nach einigen Monaten gab es Server für GitHub, Postgres, Browserautomatisierung, Speicherverwaltung, Dokumentation und Scraping – sowie einen Server für fast jedes andere Entwicklerwerkzeug. Der erste Impuls ist, sie alle zu installieren und von einem unaufhaltsamen Assistenten zu erwarten.

Reale Projekte funktionieren jedoch nicht so. Ein Agent, dem zu viele Werkzeuge gegeben werden, wird standardmäßig nicht besser – er kann sogar langsamer, verwirrter und riskanter werden. Erfolg bringt es, dem Assistenten zum richtigen Zeitpunkt den richtigen Kontext zur Verfügung zu stellen; die Anzahl der Server spielt dabei kaum eine Rolle.

Im Folgenden finden Entwickler eine Priorisierungsliste für einen Assistenten, der ihr Projekt versteht, aktuelle Dokumentationen liest, Code überprüft, Browserprobleme behebt, mit GitHub arbeitet, Datenbanken abfragt und bei der Veröffentlichung von Software hilft.

Was MCP ist

MCP steht für Model Context Protocol. Kurz gesagt ist es eine Standardmethode, um KI-Assistenten mit externen Tools, Daten und Systemen zu verbinden.

Ohne dieses Protokoll ist ein Assistent hauptsächlich von dem abhängig, was in das Chat-Fenster eingegeben wird. Er kann Code erklären, Lösungen vorschlagen und Beispiele schreiben, kann aber in der Regel nicht auf die wichtigsten Elemente zugreifen: Projektdateien, GitHub-Issues, das Datenbankschema, Browser-Logs, aktuelle Dokumentation oder den Zustand der neuesten Bereitstellung.

Ein MCP-Server dient als Brücke zwischen dem Assistenten und einem bestimmten Tool. Einige Beispiele:

Der GitHub-Server ermöglicht es dem Assistenten, mit Repositorien, Pull-Requests, Issues und Workflows zu arbeiten.
Der Dateisystem-Server erlaubt das Lesen und Bearbeiten lokaler Dateien innerhalb eines kontrollierten Verzeichnisses.
Der Playwright-Server öffnet einen echten Browser und simuliert Benutzerabläufe.

Der Postgres-Server überprüft die Datenbank-Schemata und führt sichere Abfragen aus.

Sobald diese Einrichtungen vorhanden sind, hört der Assistent auf zu raten. Er kann überprüfen, inspizieren und verifizieren und arbeitet dabei mit dem tatsächlichen Kontext und nicht mit isolierten Auszügen.

Doch es gibt einen Haken: Diese Server greifen auf reale Systeme zu, wodurch eine nachlässige Konfiguration echte Risiken birgt. Ein Dateisystemserver kann Dateien lesen, ein GitHub-Server erreicht Repositorien, ein Datenbankserver kann Daten abfragen und ein Browserserver kann mit Seiten interagieren. Ziel ist es, nur das zu installieren, was den Arbeitsablauf verbessert, und die kleinstmöglichen Berechtigungen zu gewähren, die ausreichen, um die Aufgabe zu erledigen.

Die Reihenfolge der Installation

Eine saubere Einrichtung für einen Entwickler im Jahr 2026 würde nicht mit zehn Servern beginnen. Sie würde mit fünf beginnen.

Context7 kommt zuerst, da veraltete Dokumentation zu den Hauptgründen dafür gehört, dass generierter Code nicht funktioniert. Danach folgt GitHub MCP, da viel der eigentlichen Entwicklungsarbeit um Repositorien, Issues, Pull Requests und CI herum stattfindet. Filesystem MCP ist an dritter Stelle, da ein Assistent nicht bei einer Codebasis helfen kann, die er nicht sehen kann. Playwright MCP und Chrome DevTools MCP vervollständigen die fünf, da Frontend-Code in einem echten Browser getestet werden sollte und nicht nur anhand von Quelldateien erfasst werden kann.

Je nach Projekt können weitere Server hinzugefügt werden:

Git MCP für bessere Workflows zum lokalen Versionskontrolle.
Postgres MCP, wenn die Anwendung stark auf PostgreSQL angewiesen ist.
Firecrawl MCP für Live-Web-Recherche oder Scraping.
Sequential Thinking MCP, wenn eine Aufgabe komplex ist und sorgfältige Planung erfordert.
Memory MCP, wenn dasselbe Projekt monatelang läuft und derselbe Kontext immer wieder auftritt.

Das ergibt diese Rangliste:

Context7
GitHub MCP Server
Filesystem MCP
Playwright MCP
Chrome DevTools MCP
Git MCP
Postgres MCP oder Postgres MCP Pro
Firecrawl MCP
Sequential Thinking MCP
Memory MCP

Die Reihenfolge folgt den tatsächlichen Gewohnheiten von Entwicklern: Dokumentation, anschließend Projektkontext, dann Browser-Prüfungen, danach Versionskontrolle, Datenbanken, Recherche, Planung und schließlich das Gedächtnis.

1. Context7

Die meisten Fehlschläge bei der KI-Programmierung bedeuten nicht, dass das Modell nicht programmieren kann. Sie treten auf, weil es mit veralteten Informationen arbeitet. Wenn man ein Next.js-Beispiel anfordert, erzeugt es ein altes Routing-Muster. Bei einer Anfrage nach LangChain werden verschiedene Versionen miteinander vermischt. Bei einer Anfrage nach einem Supabase-Auth-Flow wird plausibel aussehender Code für eine geänderte API erstellt.

Context7 stellt dem Assistenten aktuelle, versionsspezifische Dokumentation zur Verfügung. Anstatt sich ausschließlich auf Trainingsdaten zu verlassen, zieht der Assistent vor dem Schreiben von Code aktuelle Dokumente in den Kontext hinzu. Ein normaler Assistent könnte antworten: „So konfiguriert man Middleware in Next.js“, während ein Assistent mit Context7 für die aktuelle Version von Next.js antworten kann. Dieser Unterschied ist wichtig.

Betrachten Sie ein SaaS-Dashboard, das mit Next.js, Supabase, Stripe sowie einer modernen UI-Bibliothek erstellt wird. Jedes dieser Komponenten entwickelt sich im Laufe der Zeit weiter, und mit veralteter Dokumentation kann man mehr Zeit damit verbringen, generierten Code zu debuggen, als man eigentlich zum Schreiben desselben benötigen würde. Context7 macht aktuelle Dokumentationen zu einem integralen Bestandteil des Arbeitsablaufs.

Nehmen wir beispielsweise das Hinzufügen eines Authentifizierungs-Middlewares zu einem Next.js 15-Projekt. Ohne Context7 könnte der Assistent seine Antworten auf dem Verhalten älterer Middlewares basieren lassen, wodurch der Code zunächst ordentlich aussieht, bis die Anwendung beim Ausführen fehlschlägt. Mit Context7 kann man nach der korrekten Middleware-Einrichtung unter Verwendung der neuesten Next.js-Dokumentation fragen, wodurch das Ergebnis viel eher mit dem aktuellen Framework übereinstimmt.

Hier ist der Config-Eintrag:

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"],
      "description": "Fresh, version-specific documentation for AI coding assistants"
    }
  }
}

Context7 kommt zum Einsatz, wenn eine Aufgabe auf einem Framework, einer Bibliothek, einem SDK oder einer API beruht, die häufig ändern, darunter Frontend-Frameworks, KI-SDKs, Cloud-Dienste, Authentifizierungs-Bibliotheken, Vektordatenbanken, ORMs sowie aktuelle Python- oder JavaScript-Tools.

Es kann sich gut mit öffentlichen, beliebten Bibliotheken umgehen. Private interne Pakete sind eine andere Sache: Der Assistent versteht sie nicht, es sei denn, ihre Dokumentation stammt aus einer indizierten oder vernetzten Quelle.

2. GitHub MCP-Server

Ein Assistent, der nur ein eingefügtes Datei bearbeiten kann, ist nur für kleine Aufgaben geeignet. Einer, der Repositorien, Pull Requests, Issues sowie Workflow-Fehler lesen kann, hilft bei echten Aufgaben – deshalb hat dieser Server eine so hohe Bewertung.

Durch GitHub MCP kann der Assistent direkt mit GitHub kommunizieren. Das Überprüfen von Pull Requests, das Zusammenfassen von Problemen, das Lesen von Code, das Überprüfen von CI-Fehlern, das Erstellen von Branches sowie das Verfolgen der Projektgeschichte sind alle möglich.

Nehmen wir an, nach dem Deployment gestern tritt ein Fehler im Zahlungssystem auf. Ohne Server durchsucht man manuell GitHub, prüft die kürzlich integrierten Pull Requests, liest die geänderten Dateien sowie die CI-Logs und kopiert anschließend relevante Teile in den Assistenten. Mit diesem kann man den Assistenten bitten, die gestrigen Integrationsvorgänge zu finden, die das Zahlungssystem betroffen haben, risikoreiche Änderungen zusammenzufassen und zu überprüfen, ob die damit verbundenen Workflows erfolgreich waren.

Die Konfigurationseinstellung:

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_GITHUB_PAT"
      },
      "description": "GitHub repositories, pull requests, issues, actions, and code search"
    }
  }
}

Nutzen Sie es, wenn Ihr Team Code, Issues, Pull Requests, Reviews, CI/CD oder Release-Management auf GitHub verwaltet. Es ist besonders nützlich, wenn ein großer Teil des technischen Kontexts außerhalb des Codes selbst liegt.

Geben Sie dem Assistenten standardmäßig keinen vollständigen Zugriff auf GitHub. Beginnen Sie dort, wo möglich, mit nur lesenden Rechten, verwenden Sie begrenzte Token und aktivieren Sie Schreibfunktionen nur dann, wenn sie wirklich benötigt werden.

3. Filesystem MCP

Das klingt langweilig. Es durchsucht nicht das Internet, öffnet keine DevTools und verwaltet keine Pull Requests. Es gewährt dem Assistenten einfach kontrollierten Zugriff auf lokale Dateien und Ordnern, und genau diese einfache Fähigkeit bildet die Grundlage dafür, dass künstliche Intelligenz beim Programmieren nützlich ist.

Ohne Zugriff auf Dateien ist der Assistent blind und kann nur über das nachdenken, was Sie einfügen. Das ist für kleine Auszüge in Ordnung, bricht aber in einer echten Anwendung zusammen, die Konfigurationsdateien, Routen, Dienste, Komponenten, Tests, Beispiele für Umgebungen, Hilfsfunktionen sowie versteckte Abhängigkeiten zwischen Modulen enthält. Der Dateisystemserver ermöglicht es dem Assistenten, diese gesamte Struktur zu überprüfen.

Stellen Sie sich ein Projekt mit schlechter Dokumentation vor. Die README-Datei ist veraltet, die Authentifizierungslogik ist über Middleware, API-Routen und Hilfsfunktionen verteilt, und der vorherige Entwickler ist gegangen. Ohne den Server fügen Sie die Dateien nacheinander in den Chat ein und hoffen, dass der Assistent sie zusammenfügt. Mit dem Server können Sie fragen, wie die Authentifizierung von der Anmeldung bis zu den geschützten Routen funktioniert, und die Antwort stammt aus der echten Codebasis.

Config-Eintrag:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/your/project"
      ],
      "description": "Controlled local file access for project inspection and editing"
    }
  }
}

Es eignet sich für die lokale Entwicklung, Refactoring, Fehlerbehebung, Einarbeitung, Dokumentationsarbeit und die Erkundung von Projekten. Es passt auch gut zu Git MCP, da das Dateisystem zeigt, was derzeit vorhanden ist, und Git zeigt an, was sich geändert hat.

Exponieren Sie niemals den gesamten Rechner. Beschränken Sie den Zugriff auf den Projektordner, den der Assistent benötigt, und halten Sie Verzeichnisse mit Geheimnissen, persönlichen Dateien, SSH-Schlüsseln oder unverwandten Projekten fern.

4. Playwright MCP

Frontend-Fehler sind ärgerlich, weil der Code zwar korrekt aussehen kann, aber dennoch im Browser fehlerhaft funktioniert. Ein Anmeldeformular kann ordnungsgemäß dargestellt werden, aber bei Absenden fehlschlagen, ein Modal kann hinter seinem Überlagerungsrahmen erscheinen, eine Bestellschaltfläche kann aufgrund einer einzigen falschen Zustandsvariable deaktiviert bleiben, und ein Dropdown kann mit der Maus funktionieren, aber mit der Tastatur nicht.

Ein Assistent, der nur den Quellcode liest, muss raten, was im Browser geschieht, und Playwright MCP verringert dieses Raten. Er ermöglicht es dem Assistenten, einen Browser zu öffnen, darin zu navigieren, zu klicken, Formulare auszufüllen und das Verhalten zu überprüfen. Für Frontend- und Full-Stack-Arbeiten ist das ein großer Fortschritt, da der Assistent nicht nur Code generieren, sondern auch Benutzerflüsse testen kann.

Nehmen wir an, Sie bitten ihn, eine Zahlungsseite zu erstellen. Er bearbeitet den React-Komponenten, fügt Formularvalidierungen hinzu und gibt an, die Arbeit sei abgeschlossen. Die eigentliche Frage ist jedoch, ob die Zahlung funktioniert. Mit Playwright MCP können Sie ihm sagen, er solle localhost:3000 öffnen, ein Produkt in den Warenkorb legen, zur Zahlungsseite gehen, das Formular mit Testdaten ausfüllen, absenden und bestätigen, dass die Bestätigungsseite angezeigt wird. Nun überprüft er das Verhalten in einem echten Browser.

Konfigurations-Eintrag:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"],
      "description": "Browser automation and UI testing with Playwright"
    }
  }
}

Zu den wichtigen Anwendungsbereichen gehören End-to-End-Tests, Frontend-Überprüfungen, QA-Prüfungen, die Wiederherstellung von Fehlern, Formulare, Anmeldevorgänge, Bestellprozesse und Onboarding-Flüsse sowie interne Dashboards. Am wichtigsten ist, dass der Nutzerweg korrekt funktioniert, während der jeweilige Codeausschnitt sekundär ist.

Browserautomatisierung kann langsam sein und viele Ressourcen verbrauchen, weshalb sie für wichtige Arbeitsabläufe verwendet werden sollte und bei kleinen UI-Anpassungen weggelassen werden kann.

5. Chrome DevTools MCP

Playwright MCP hilft dem Assistenten dabei, den Browser zu nutzen, während Chrome DevTools MCP ihm dabei hilft, den Browser zu verstehen. Der Unterschied ist erheblich. Wenn eine Seite langsam lädt, kann Playwright mit ihr interagieren, während DevTools die Leistungsdaten auswerten kann. Wenn eine API-Anfrage fehlschlägt, sieht Playwright möglicherweise nur eine Fehlermeldung, während DevTools die Netzwerkanfrage untersuchen kann. Wenn die Seite einen Laufzeitfehler auslöst, zeigt DevTools den Konsoleintrag an.

Deshalb zählt es zu den nützlichsten Servern für die Frontend-Debugging, da es laufzeitbezogene Informationen liefert. Anstatt zu vermuten, dass ein großes Bild das Problem sein könnte, kann der Assistent die Seite überprüfen und melden, dass die größte Inhaltserfassung verzögert wird, weil ein Bild spät lädt und nicht im Voraus geladen wurde. Das ist ein anderes Niveau an Hilfe.

Stellen Sie sich eine Landingpage mit schlechter Leistung vor. Ein einfacher Assistent gibt allgemeine Ratschläge wie die Optimierung von Bildern, das Kürzen von JavaScript und das Lazy Loading. Das mag zutreffen, ist aber nicht spezifisch. Mit DevTools MCP können Sie ihn bitten, die Seite zu öffnen, die Leistungsprotokolle zu lesen, herauszufinden, was den LCP beeinträchtigt, und den kleinstmöglichen Fix vorzuschlagen – also basierend auf den Daten im Browser und nicht auf allgemeinen Vorgaben.

Konfigurations-Eintrag:

{
  "mcpServers": {
    "chrome-devtools": {
      "command": "npx",
      "args": ["chrome-devtools-mcp@latest"],
      "description": "Chrome DevTools debugging, performance analysis, console, and network inspection"
    }
  }
}

Verwenden Sie es zur Fehlersuche im Frontend, zur Leistungsanalyse, zur Überprüfung von Konsolefehlern, zur Netzwerkanalyse, bei Layoutproblemen, zum Verständnis des Laufzeitverhaltens sowie zur Überprüfung des Browsers. Frontend-Entwickler, Full-Stack-Entwickler sowie Teams, die benutzerorientierte Webanwendungen veröffentlichen, profitieren am meisten davon.

Es ist leistungsstark, ersetzt aber keine regulären Testverfahren. Betrachten Sie es als Hilfsmittel zur Fehlersuche und lesen Sie seine Ausgaben nicht als Garantie dafür, dass die gesamte Anwendung bereit für die Produktion ist.

6. Git MCP

GitHub MCP umfasst die Workflow-Verwaltung in Repositorien auf GitHub, während Git MCP das lokale Repository abdeckt. Diese Trennung ist wichtig, denn viele Aufgaben finden bereits vor dem Push statt. Möglicherweise möchten Sie einen lokalen Diff überprüfen, herausfinden, was durch eine Refaktorierung geändert wurde, Branches vergleichen, die Commit-Geschichte einsehen oder eine ordentliche Commit-Nachricht vorbereiten.

Git MCP liefert dem Assistenten einen lokalen Git-Kontext, wodurch Änderungen leichter überprüft werden können, da er den Diff sieht und nicht nur die endgültigen Dateien.

Nach drei Stunden des Refaktorisierens eines Services enthält der Arbeitsbaum Änderungen in vielen Dateien. Einige gehören zum Refaktorieren, einige sind temporäre Debug-Änderungen, und wieder andere sollten nicht in derselben Commit-Operation zusammengefasst werden. Mit Git MCP können Sie den Assistenten bitten, die eingestellten Änderungen zu überprüfen, sie nach Zweck zu gruppieren, die riskanten zu markieren und eine klare Commit-Nachricht zu erstellen. Das ist besser, als ihn zu bitten, einen eingefügten Diff zusammenzufassen.

Konfigurations-Eintrag:

{
  "mcpServers": {
    "git": {
      "command": "uvx",
      "args": [
        "mcp-server-git",
        "--repository",
        "/path/to/your/repo"
      ],
      "description": "Local Git repository inspection, diffs, history, and commit support"
    }
  }
}

Verwenden Sie es vor Commit-Vorgängen, während von Refaktorierungen, beim Vergleichen von Branches, bei der Überprüfung lokaler Änderungen sowie wenn Sie herausfinden möchten, wann ein Fehler aufgetreten ist. Es wird noch nützlicher, wenn es mit Filesystem MCP kombiniert wird: Das Dateisystem erklärt das aktuelle Projekt und Git erläutert, wie sich das Projekt verändert hat.

Seien Sie vorsichtig bei Schreibvorgängen. Beginnen Sie mit Inspektionen, Zusammenfassungen, Diff-Vergleichen und Entwürfen für Commit-Nachrichten.

7. Postgres MCP und Postgres MCP Pro

Viele Fehler im Backend befinden sich in der Datenbankschicht. Der Handler scheint in Ordnung zu sein, die API gibt einen vagen Fehler an und die Logs liefern nur wenig Informationen – erst nach einiger Zeit entdeckt man einen fehlenden Index, eine fehlerhafte Verknüpfung, einen Null-Wert, eine Inkonsistenz bei Migrationsdateien oder eine Abfrage, die erst in der Produktionsumgebung Probleme verursacht.

Ein Postgres-Server liefert Kontext zur Datenbank. Je nach Konfiguration kann der Assistent Schemata und Tabellen betrachten, sichere Abfragen ausführen, Abfragepläne lesen und Optimierungen vorschlagen.

Sagen wir, ein API-Endpunkt benötigt in der Produktion vier Sekunden, obwohl der Code normal aussieht und die ORM-Anfrage einfach erscheint. Mit dem Server können Sie den Assistenten bitten, die Anfrage des Endpunkts zu überprüfen, zu erklären, warum sie langsam ist, und den sichersten Index zu empfehlen. Er kann nun auch über die Datenbankschicht nachdenken und nicht nur über den Anwendungscode.

Konfigurations-Eintrag:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://YOUR_USER:YOUR_PASSWORD@YOUR_HOST:5432/YOUR_DATABASE"
      },
      "description": "PostgreSQL schema inspection and natural language SQL queries"
    }
  }
}

Andere Konfigurationen verwenden Postgres MCP Pro oder open-source-Implementierungen von Postgres. Hier ist eine solche Alternative:

{
  "mcpServers": {
    "postgres-pro": {
      "command": "uvx",
      "args": ["postgres-mcp"],
      "env": {
        "DATABASE_URI": "postgresql://YOUR_USER:YOUR_PASSWORD@YOUR_HOST:5432/YOUR_DATABASE"
      },
      "description": "PostgreSQL development, query analysis, and optimization"
    }
  }
}

Verwenden Sie es für die Debugging-Arbeit im Backend, SQL-Analysen, die Erkundung von Schemata, Analysen, die Optimierung von Abfragen sowie für datenbankintensive Anwendungen. Am meisten profitieren SaaS-Produkte, Dashboards, Marktplätze, CRM-Systeme, interne Tools und Berichtssysteme.

Fangen Sie niemals mit Schreibzugriff auf das Produktivsystem an. Beginnen Sie mit nur-Lese-Zugriffsrechten. Beschränken Sie auf Produktivsystemen die Berechtigungen sorgfältig und prüfen Sie jede Abfrage, bevor eine zerstörerische Operation durchgeführt werden darf.

8. Firecrawl MCP

Nützlicher Kontext befindet sich nicht immer im Repository. Der Assistent könnte eine Dokumentationsseite, ein Changelog, die Preisseite eines Wettbewerbers, eine öffentliche API-Dokumentation, einen Support-Artikel oder eine Veröffentlichungsnotiz aus dem öffentlichen Internet benötigen.

Firecrawl MCP ermöglicht es dem Assistenten, im Live-Web zu suchen, Daten abzurufen und strukturierte Informationen zu extrahieren. Das ist hilfreich, da viele Entwicklertätigkeiten aktuelle externe Informationen erfordern: das Vergleichen von Preisseiten, das Überprüfen, ob sich eine API geändert hat, das Herunterladen von Dokumentationen von einer Website oder das Sammeln von Daten von Seiten ohne saubere API. Es ist nicht der erste Server, den man für tägliche Programmierarbeit installiert, doch er wird äußerst nützlich, sobald ein Arbeitsablauf auf Recherchen angewiesen ist.

Nehmen wir an, ein Manager bittet um einen Preisvergleich Ihres Produkts mit drei Konkurrenten. Ohne diesen Server öffnen Sie mehrere Tabs, kopieren den Text manuell, räumen unübersichtliche Seiten auf und erstellen die Tabelle selbst. Mit ihm bitten Sie den Assistenten, diese Preisseiten aufzusuchen, Planbezeichnungen, Monatspreise, Limits sowie Unternehmensfunktionen zu extrahieren und eine Vergleichstabelle zurückzugeben. Dies ist ein praktisches Beispiel dafür, wie der Web-Zugriff zu einem Bestandteil der Entwicklungsarbeit wird.

Konfigurations-Eintrag:

{
  "mcpServers": {
    "firecrawl": {
      "command": "npx",
      "args": ["-y", "firecrawl-mcp"],
      "env": {
        "FIRECRAWL_API_KEY": "YOUR_FIRECRAWL_API_KEY"
      },
      "description": "Live web search, scraping, structured extraction, and page interaction"
    }
  }
}

Verwenden Sie es für Dokumentationsrecherchen, Wettbewerbsanalyse, Marktanalyse, Überwachung von Changelogs, Audits von API-Dokumentationen sowie zum Abrufen strukturierter Daten von Webseiten.

Behalten Sie sich an robots.txt, die Nutzungsbedingungen der Website, Authentifizierungsregeln und Geschwindigkeitsbeschränkungen und nutzen Sie kein Scraping, um Zugangsbeschränkungen zu umgehen.

9. Sequential Thinking MCP

Manche Fehler entstehen dadurch, dass ein Assistent zu schnell vorgeht. Er springt sofort zu einer Lösung, bearbeitet zu viele Dateien, befasst sich nur mit Symptomen und übersieht die eigentliche Ursache, schlägt einen Umstieg ohne Rückrollungsplan vor und antwortet selbstsicher, bevor er die Einschränkungen verstanden hat.

Sequential Thinking MCP fördert eine strukturiertere Problemlösung. Es hilft dem Assistenten, ein Problem in Schritte zu unterteilen, Annahmen zu überprüfen, verschiedene Ansätze zu vergleichen und sorgfältig zu überlegen, bevor er handelt.

Stellen Sie sich vor, Sie möchten eine monolithische API in kleinere Dienste migrieren. Ein schwacher Assistent könnte sofort eine Ordnerstruktur vorschlagen und mit der Erstellung von Code beginnen. Ein besserer Assistent verlangsamt sich und stellt zunächst einige Fragen:

Welches Modul soll zuerst verschoben werden?
Welche Datenbanktabellen werden gemeinsam genutzt?
Welche Endpunkte bergen das größte Risiko?
Welche Tests müssen vor dem Deployment bestanden werden?
Wie sieht der Rollback-Plan aus?

Dieser Server hilft dabei, einen solchen strukturierten Ansatz zu verfolgen.

Konfigurations-Eintrag:

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"],
      "description": "Structured reasoning and step-by-step planning for complex development tasks"
    }
  }
}

Verwenden Sie es für Architekturentscheidungen, Migrationsplanung, gründliches Debuggen, Analyse von Vorfällen, mehrstufige Refaktorisierungen sowie für alle Aufgaben, bei denen Fehler teuer zu stehen kommen.

Es ist nicht für jede Aufgabe geeignet. Bei einfachen Arbeiten verursacht es zusätzlichen Aufwand, daher verwenden Sie es, wenn die Qualität der Planung wichtiger ist als die Geschwindigkeit.

10. Memory MCP

Jeder, der mit KI-Assistenten arbeitet, hat immer wieder denselben Projektkontext bearbeitet:

Das Projekt ist mehrfach genutzt (multi-tenant).
Jede Datenbankabfrage muss tenant_id enthalten.
Der generierte API-Client darf nicht geändert werden.
Die Staging-Datenbank wird jeden Sonntag zurückgesetzt.
Alle Admin-Wege benötigen rollenbasierte Berechtigungen.

Neben der Langweiligkeit führt diese Wiederholung zu Fehlern, da ein Assistent, der sich an eine Projektregel erinnert, Code erstellen kann, der gegen die Architektur verstößt. Memory MCP bietet dem Assistenten eine dauerhafte Speicherung über verschiedene Sitzungen hinweg. Er kann stabile Projektinformationen, Konventionen, Entscheidungen und Beziehungen in einem lokalen Speichersystem aufbewahren, was hilft, wenn dasselbe Projekt wochen- oder monatelang läuft.

Man denke an ein B2B-SaaS-Produkt, bei dem jede Anfrage durch tenant_id eingegrenzt werden muss. Wenn der Assistent diese Regel vergisst, könnte er einen Sicherheitsfehler verursachen. Mit Memory MCP kann die Regel einmalig gespeichert werden, indem dem Assistenten mitgeteilt wird, dass es sich um ein Multi-Tenant-Projekt handelt und jede Anfrage tenant_id enthalten muss, sofern nicht anders dokumentiert. In späteren Sitzungen holt sich der Assistent diesen Kontext ab, und niemand muss ihn wiederholen.

Konfigurations-Eintrag:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"],
      "description": "Persistent project memory using a knowledge graph"
    }
  }
}

Es eignet sich für langfristige Projekte, Einzelarbeit, kleine Teams, architekturstarkes Software sowie Codebasen mit vielen Konventionen, die niemand aufgeschrieben hat.

Das Gedächtnis wird schädlich, wenn es falsche oder veraltete Informationen speichert. Halten Sie Geheimnisse daraus raus, vermeiden Sie vorübergehende Annahmen und lassen Sie es nicht zu einem „Müllschrank“ werden. Ein gutes Gedächtnis hilft, während ein schlechtes in die Irre führt.

Eine Starter-Datei mcp.json

Eine praktische Starter-Konfiguration umfasst die ersten fünf Server:

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"],
      "description": "Fresh, version-specific documentation for coding agents"
    },
    "github": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_GITHUB_PAT"
      },
      "description": "GitHub repositories, pull requests, issues, actions, and code search"
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/your/project"
      ],
      "description": "Controlled local file access"
    },
    "playwright": {
      "command": "npx",
      "args": ["@playwright/mcp@latest"],
      "description": "Browser automation and UI testing"
    },
    "chrome-devtools": {
      "command": "npx",
      "args": ["chrome-devtools-mcp@latest"],
      "description": "Chrome DevTools debugging and performance analysis"
    }
  }
}

Ersetzen Sie die Platzhalter durch den tatsächlichen Projektpfad und die Anmeldeinformationen. Im Folgenden sind beispielsweise die Werte aufgelistet, die ersetzt werden müssen:

/path/to/your/project
YOUR_GITHUB_PAT
YOUR_USER
YOUR_PASSWORD
YOUR_HOST
YOUR_DATABASE
YOUR_FIRECRAWL_API_KEY

Der häufigste Fehler

Der größte Fehler besteht darin, zu viele Server zu schnell zu installieren. Das wirkt produktiv und sieht beeindruckend aus, führt aber oft zu einem schlechteren Assistenten. Der Assistent hat mehr Werkzeuge zur Auswahl, das Berechtigungsmodell wird schwieriger zu überprüfen, die Gefahr des Lecks sensibler Daten steigt, der Workflow wird unübersichtlich, und wenn etwas kaputtgeht, wird das Debuggen der KI-Einrichtung schwieriger als das Debuggen der Anwendung.

Eine gute Einrichtung wirkt langweilig und offensichtlich. Der Assistent weiß bereits, wann Dokumente benötigt werden, wann Dateien gelesen, wann auf GitHub geschaut, wann der Browser gestartet und wann auf die Datenbank zugegriffen werden muss.

Was man daraus lernen kann

MCP verändert die Funktionsweise von Assistenten, indem sie in die Systeme und Kontexte integriert werden, mit denen Entwickler täglich arbeiten. Der Vorteil ergibt sich nicht aus der größten Anzahl an Servern, sondern daraus, genau zu wissen, wo jeder Server im Arbeitsablauf seinen Platz hat.

Eine sinnvolle Reihenfolge der Erstellung ist zunächst die Bereitstellung neuer Dokumente, damit der generierte Code nicht veraltet. Danach kommt der Zugriff auf das Repository, der dem Assistenten Probleme, Pull Requests sowie die Historie zur Verfügung stellt. Anschließend folgt ein kontrollierter lokaler Zugriff auf die Codebasis, gefolgt von einem Browser und DevTools, damit der Assistent testen und debuggen kann, was Endbenutzer tatsächlich sehen.

Datenbanken, Web-Recherche, strukturiertes Planen sowie das Speichern von Informationen sollten erst dann genutzt werden, wenn jeweils ein echtes Bedürfnis besteht. Das ist die Grenze zwischen einem Assistenten, der nur Code vorschlägt, und einem, der dabei hilft, zu entwickeln, zu testen, zu debuggen und fertige Lösungen bereitzustellen.

Was MCP ist

Die Reihenfolge der Installation

1. Context7

2. GitHub MCP-Server

3. Filesystem MCP

4. Playwright MCP

5. Chrome DevTools MCP

6. Git MCP

7. Postgres MCP und Postgres MCP Pro

8. Firecrawl MCP

9. Sequential Thinking MCP

10. Memory MCP

Eine Starter-Datei mcp.json

Der häufigste Fehler

Was man daraus lernen kann

Verwandte Artikel