Cursor MCP – Vollständiges Tutorial: KI mit externen Tools verbinden

Beim Programmieren mit Cursor gibt es ein nerviges Problem: Jedes Mal, wenn die KI projektbezogene Aufgaben übernehmen soll, müssen Sie erneut Projektstruktur, Datenbankschema und API-Schnittstellen erklären – als würden Sie ständig Nachhilfe geben.

Die KI ist zwar leistungsfähig, „sieht“ aber weder Daten in der Datenbank noch Dateien im Dateisystem und kann APIs nicht direkt aufrufen. Informationen manuell kopieren und einfügen kostet Zeit.

MCP (Model Context Protocol) bietet dafür eine elegante Lösung. Kurz gesagt: MCP ist ein Standardprotokoll, mit dem KI externe Tools und Datenquellen anbinden kann. Nach der Konfiguration kann die KI selbstständig Datenbanken abfragen, Dateien lesen und APIs aufrufen.

Was ist MCP?

Eine einfache Analogie

Wenn ich MCP in einem Satz erklären müsste, würde ich sagen: MCP ist wie ein USB-C-Anschluss für die KI.

Früher hatte jedes Gerät seinen eigenen Ladeanschluss – iPhone mit Lightning, Android mit Micro-USB, Laptops wieder andere Standards. Umständlich. Dann kam USB-C: ein Anschluss für alles.

MCP folgt demselben Prinzip. Es ist ein offenes Protokoll von Anthropic und liefert eine Standard-Schnittstelle, über die KI externe Tools anbindet. Mit diesem Standard muss jede KI-Anwendung nicht mehr eigene Integrationslösungen von Grund auf entwickeln.

Warum braucht man MCP?

Vor MCP musste jede KI-Anwendung, die eine Datenbank anbinden wollte, eine eigene Lösung bauen. Cursor eine, Claude Desktop eine, andere Tools wieder andere. Entwickler bauten ständig neu, Wartungskosten stiegen, und die Tools waren untereinander inkompatibel.

MCP ändert das mit dem Prinzip „einmal schreiben, überall nutzen“. Entwickler bauen einen Datenbank-Connector nach MCP-Standard – und er funktioniert in allen MCP-fähigen KI-Anwendungen. Das spart Aufwand und vermeidet Doppelarbeit.

MCP vs. traditionelle Plugins

Vielleicht fragen Sie sich: Was unterscheidet das von klassischen Plugins und Erweiterungen?

Der Unterschied ist beträchtlich. Traditionelle Plugins erweitern Funktionen auf Anwendungsebene – wie ein Werbeblocker im Browser oder ein Theme in VS Code. MCP erweitert Fähigkeiten auf KI-Modellebene.

Der entscheidende Punkt: Die KI entscheidet selbst, wann ein Tool aufgerufen wird – ohne explizite Anweisung von Ihnen.

Sagen Sie zu Cursor: „Zeig mir die Bestellhistorie dieses Nutzers in der Datenbank.“ Mit konfiguriertem MCP versteht die KI automatisch, dass sie:

1. sich mit der Datenbank verbinden muss
2. in der Nutzertabelle die User-ID finden muss
3. in der Bestelltabelle die zugehörigen Bestellungen abfragen muss
4. die Ergebnisse für Sie aufbereiten muss

Sie müssen nicht sagen „Datenbank abfragen“ oder „SQL ausführen“. Die KI weiß selbst, was zu tun ist.

Kernarchitektur

Technisch ist die MCP-Architektur klar gegliedert:

• MCP Host: die KI-Anwendung, die Sie nutzen – z. B. Cursor oder Claude Desktop
• MCP Client: verwaltet die Verbindung zwischen Host und Server
• MCP Server: kapselt externe Dienste (Datenbank, API, Dateisystem usw.)
• Kommunikationsprotokoll: standardisierte JSON-RPC-Schnittstelle

Wie Bausteine: Jede Komponente hat ihre Aufgabe. Sie konfigurieren, welche MCP-Server genutzt werden – den Rest erledigt die KI.

Was kann MCP?

Nach den Grundlagen: konkrete Einsatzszenarien, die ich selbst getestet habe.

Datenbankzugriff

Das spart mir viel Zeit.

Nehmen Sie ein E-Commerce-Projekt mit Nutzer-, Produkt- und Bestelltabellen. Früher mussten Sie der KI zum Schreiben einer Abfrage für „Bestellungen eines Nutzers im letzten Monat“ erst:

1. die Tabellenstruktur kopieren
2. Beziehungen zwischen Tabellen erklären
3. die gewünschten Felder angeben

Mit konfiguriertem MySQL MCP Server reicht: „Zeig mir die Bestellungen von User-ID 123 im letzten Monat.“ Die KI:

• verbindet sich mit der Datenbank
• analysiert die Tabellenstruktur
• generiert präzises SQL
• führt die Abfrage aus
• formatiert das Ergebnis nach Bedarf

Das SQL basiert auf Ihrer echten Tabellenstruktur – nicht auf erfundenen Beispielen.

🔥 Verschwende keine Monate für ungenutzte Produkte! Teste deine SaaS-Nutzenversprechen mit Adsterra bei kleinem Budget ➡️

Jetzt testen →Anzeige

Dateisystem-Operationen

Damit räume ich Code am häufigsten auf.

Beispiel: Ein Projekt mit vielen Third-Party-Bibliotheken sammelt mit der Zeit ungenutzte import-Statements. Manuell zu prüfen ist mühsam.

Mit Dateisystem-MCP-Server kann ich Cursor sagen: „Scanne das gesamte Projekt, finde alle ungenutzten Imports und entferne sie.“ Die KI:

• durchläuft Projektverzeichnisse
• analysiert import-Statements pro Datei
• prüft, welche Imports ungenutzt sind
• bearbeitet die Dateien und entfernt sie

Besonders hilfreich beim Refactoring.

API-Integration

MCP unterstützt API-Integration umfassend – es gibt bereits viele MCP-Server für gängige Dienste.

GitHub MCP

Wer oft mit GitHub arbeitet, profitiert stark. Nach der Konfiguration können Sie der KI sagen:

• Issues eines Repos anzeigen: „Welche offenen Issues sind als Bug markiert?“
• Pull Request erstellen: „Erstelle einen PR für die Änderungen in diesem Branch“
• Branches verwalten: „Lege einen neuen Feature-Branch an“

Slack MCP

Für Team-Benachrichtigungen nutze ich das so:

• „Poste in #dev, dass die neue Version live ist“
• „Gab es kürzlich @-Erwähnungen für mich im Kanal?“

Google Workspace MCP

Deckt Gmail, Google Docs, Sheets, Drive und Calendar ab. Wer auf Google-Workspace setzt, spart damit viel Zeit.

Beispiele: „Fasse die Analyseergebnisse von gestern in Google Sheets zusammen“ oder „Zeig mir den Kalender für morgen“.

Browser-Automatisierung

Chrome DevTools MCP ist ein interessantes Tool.

Es ermöglicht direkte Browser-Interaktion. Die KI kann:

• eine Webseite öffnen
• die DOM-Struktur lesen
• JavaScript ausführen
• die Seitenperformance analysieren

Ich habe damit automatisierte Tests und Performance-Analysen gemacht – z. B.: „Öffne unsere Startseite, analysiere die Ladezeit des First Screen und zeig langsame Ressourcen.“

Web-Content-Extraktion

Der Fetch Server ist speziell für Web-Content-Extraktion gedacht.

Er wandelt Seiteninhalte in ein KI-freundliches Format um. Statt manuell zu kopieren, geben Sie einen Link: „Analysiere die Hauptargumente dieses Artikels.“ Die KI holt den Inhalt und wertet ihn aus.

MCP konfigurieren

Wenn Sie MCP grundlegend verstanden haben, folgt die konkrete Konfiguration.

Vorbereitung

Vor dem Start zwei Punkte klären:

1. Cursor-Version: Aktuelle Cursor-Version verwenden – MCP-Unterstützung ist relativ neu.
2. Transportart: Unterschied zwischen zwei Varianten kennen
   • stdio: Standard-Ein-/Ausgabe, Dienst läuft lokal, Cursor verwaltet automatisch, Einzelnutzer
   • SSE/HTTP: Netzwerkkommunikation, Remote-Deployment möglich, Mehrbenutzer-Sharing

In den meisten Fällen empfehle ich stdio – einfache Konfiguration, kein zusätzlicher Server.

Variante 1: Über die Cursor-Einstellungen (empfohlen)

Für die erste MCP-Konfiguration ist das der einfachste Weg.

Schritte:

1. Cursor öffnen
2. Einstellungen per Tastenkürzel öffnen
   • Windows/Linux: Ctrl+Shift+J
   • macOS: Cmd+Shift+J
3. Im linken Menü „Tools & Integrations“ wählen
4. Unten auf „New MCP Servers“ klicken
5. Cursor erstellt oder öffnet automatisch die mcp.json

Vorteil: visuelle Oberfläche und Echtzeit-Validierung. Bei Fehlern gibt es direkte Hinweise.

Variante 2: Konfigurationsdatei direkt bearbeiten

Wer lieber Dateien editiert, kann manuell anlegen.

Zwei Speicherorte:

• Projektebene: .cursor/mcp.json (nur für das aktuelle Projekt)
• Global: ~/.cursor/mcp.json (für alle Projekte)

Ich lege häufig genutzte Server (GitHub, Fetch) global ab, projektspezifische (Datenbankverbindung) im Projekt.

Struktur der Konfigurationsdatei

Grundaufbau:

{
  "mcpServers": {
    "server-name": {
      "command": "ausführungsbefehl",
      "args": ["argumentliste"],
      "env": {
        "UMGEBUNGSVARIABLE": "wert"
      }
    }
  }
}

• command: auszuführender Befehl, z. B. npx, node, python
• args: Argumente – meist MCP-Server-Paketname oder Skriptpfad
• env: Umgebungsvariablen für API-Token, DB-Passwörter usw.

Praxisbeispiel 1: GitHub MCP

GitHub MCP ist ein guter Einstieg – häufig im Einsatz.

Konfiguration:

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

Erklärung:

Vultr - Hochleistungs-NVMe-Cloud-Server mit 32 Standorten weltweit, Docker per Klick

Preise ansehen →Anzeige

• command: "npx": Node.js-Paketausführung ohne globale Installation
• args: ["-y", "@modelcontextprotocol/server-github"]:
  • -y bestätigt automatisch
  • @modelcontextprotocol/server-github ist das offizielle GitHub-MCP-Server-Paket
• env.GITHUB_PERSONAL_ACCESS_TOKEN: Ihr GitHub Personal Access Token

GitHub-Token erstellen:

1. GitHub öffnen, zu Settings gehen
2. Links „Developer settings“ wählen
3. „Personal access tokens“ → „Tokens (classic)“
4. „Generate new token“ klicken
5. Berechtigungen wählen (mindestens repo)
6. Token kopieren und in die Konfiguration einfügen

Hinweis: Der Token wird nur einmal angezeigt – sicher speichern.

Praxisbeispiel 2: Fetch Server

Noch einfacher – kein API-Token nötig.

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

Damit kann die KI Inhalte beliebiger Webseiten abrufen.

Praxisbeispiel 3: Datenbank-MCP

Etwas aufwendiger, weil Verbindungsdaten nötig sind.

Beispiel MySQL (Sie benötigen einen MySQL-MCP-Server – selbst gebaut oder aus der Community):

{
  "mcpServers": {
    "mysql": {
      "command": "node",
      "args": ["/path/to/mysql-mcp-server/index.js"],
      "env": {
        "DB_HOST": "localhost",
        "DB_USER": "root",
        "DB_PASSWORD": "your_password",
        "DB_NAME": "your_database"
      }
    }
  }
}

Wichtige Hinweise:

• /path/to/mysql-mcp-server/index.js durch den echten Pfad ersetzen
• DB-Passwort nicht hart codieren – Umgebungsvariablen nutzen
• Bei Remote-Datenbank DB_HOST anpassen

Vollständige Konfiguration mit mehreren MCP-Servern

In der Praxis konfigurieren Sie oft mehrere Server gleichzeitig:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    },
    "fetch": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch"]
    },
    "mysql": {
      "command": "node",
      "args": ["/Users/your-name/mcp-servers/mysql/index.js"],
      "env": {
        "DB_HOST": "localhost",
        "DB_USER": "root",
        "DB_PASSWORD": "your_password",
        "DB_NAME": "your_database"
      }
    }
  }
}

Konfiguration prüfen

Nach der Einrichtung sollten Sie testen, ob alles funktioniert.

Schritte:

1. Cursor neu starten: Konfigurationsänderungen greifen erst nach Neustart
2. MCP-Funktionen testen: im Cursor-Chat ausprobieren
   • GitHub: „Zeig mir meine GitHub-Repository-Liste“
   • Fetch: „Bitte den Hauptinhalt von https://example.com abrufen“
3. KI-Antwort beobachten: Bei Erfolg ruft die KI die MCP-Tools auf

Melden „Keine Berechtigung…“ oder „Verbindung fehlgeschlagen…“, stimmt etwas in der Konfiguration nicht.

Häufige Probleme beheben

Einige Fallstricke aus eigener Erfahrung:

Problem 1: Fehlerhaftes Konfigurationsformat

Symptom: Cursor startet mit Fehler oder MCP funktioniert nicht

Lösung:

• JSON-Syntax prüfen – Kommas, Anführungszeichen, Klammern
• JSON-Validator nutzen
• Kein überflüssiges Komma nach dem letzten Eintrag

Problem 2: Unzureichende Token-Berechtigungen

Symptom: Verbindung klappt, bestimmte Aktionen schlagen fehl

Lösung:

• Berechtigungsumfang des Tokens prüfen
• GitHub-Token mindestens mit repo
• Bei Bedarf weitere Rechte vergeben

Problem 3: Port belegt

Symptom: MCP-Server startet nicht

Lösung:

• Prüfen, ob ein anderer Prozess den Port nutzt
• Mit stdio tritt das selten auf
• Bei SSE anderen Port wählen

Problem 4: Umgebungsvariablen greifen nicht

Symptom: Variablen gesetzt, MCP-Server liest sie nicht

Lösung:

• Schreibweise der Variablennamen prüfen
• Sicherstellen, dass die Datei gespeichert wurde
• Unter Windows Pfadtrennzeichen: doppelte Backslashes oder Schrägstriche

Fortgeschrittene Tipps

Konfiguration ist der Anfang. Einige praktische Empfehlungen:

Passende Transportart wählen

stdio eignet sich für:

• lokale Entwicklung
• Einzelnutzer
• schnelle Einrichtung ohne Extra-Server

SSE/HTTP eignet sich für:

• gemeinsame MCP-Server im Team
• Remote-Datenbank oder -Dienste
• zentrale Verwaltung und Monitoring

Persönliche Tools (GitHub, Fetch) nutze ich per stdio, teamweite Datenbanken eher per SSE.

Railway - Moderne Deployment-Plattform, ohne DevOps-Aufwand, in Minuten live

Jetzt starten →Anzeige

Mehrere MCP-Server verwalten

Bei vielen Servern wird die Übersicht schwierig. Meine Struktur:

• Global: häufige, allgemeine Server (GitHub, Fetch, Slack)
• Projekt: projektspezifische Server (Datenbank, interne API)
• Bedarfsgesteuert: ungenutzte Server auskommentieren, um Ressourcen zu sparen

Sicherheitsempfehlungen

MCP-Konfiguration enthält sensible Daten – Sicherheit beachten:

Tokens nicht in Git committen:

• .cursor/mcp.json in .gitignore
• oder Umgebungsvariablen statt Hardcoding

Tokens regelmäßig erneuern:

• GitHub-Token mit Ablaufdatum setzen
• Passwörter und Tokens periodisch aktualisieren

Prinzip der minimalen Rechte:

• GitHub-Token nur mit nötigen Berechtigungen
• DB-Nutzer nur Lese-Rechte, wenn nur Abfragen nötig sind

Empfohlene MCP-Server

Nach eigener Erfahrung besonders nützlich:

Entwicklungstools:

• @modelcontextprotocol/server-github: GitHub-Integration
• @modelcontextprotocol/server-gitlab: GitLab-Integration

Datenbanken:

• PostgreSQL MCP Server
• MySQL MCP Server
• MongoDB MCP Server

Kollaboration:

• Google Workspace MCP Server (Gmail, Docs, Sheets usw.)
• Slack MCP Server

Datenbeschaffung:

• @modelcontextprotocol/server-fetch: Web-Scraping
• Firecrawl MCP Server: leistungsfähigeres Crawling

Browser-Automatisierung:

• Chrome DevTools MCP: Debugging und Automatisierung

Performance optimieren

Bei intensiver MCP-Nutzung können Performance-Themen auftreten:

Nur benötigte Server aktivieren:

• Ungenutzte Server entfernen oder auskommentieren
• Weniger Ressourcen beim Start

Netzwerklatenz beachten:

• Remote-Server verursachen Verzögerung
• Bei Cloud-Datenbank die Netzwerkqualität prüfen

Timeouts sinnvoll setzen:

• Manche MCP-Server unterstützen Timeout-Konfiguration
• Verhindert, dass eine Anfrage den gesamten Ablauf blockiert

Zusammenfassung

Kurz zusammengefasst:

Was ist MCP: Ein Standardprotokoll, mit dem KI externe Tools und Daten anbindet – wie USB-C für KI.

Was kann MCP:

• Datenbanken anbinden, SQL automatisch generieren und ausführen
• Dateisysteme bearbeiten, Dateien stapelweise verarbeiten
• GitHub, Slack, Google Workspace und mehr integrieren
• Browser automatisieren und Web-Inhalte extrahieren

Wie konfigurieren:

• Über Cursor-Einstellungen oder direkt mcp.json bearbeiten
• Konfiguration mit command, args und env
• Häufige Server: GitHub, Fetch, Datenbank-MCP

Mein Rat: Klein anfangen. Zuerst einen Fetch Server einrichten und MCP ausprobieren. Danach weitere Server nach Bedarf ergänzen.

Das MCP-Ökosystem wächst schnell – fast wöchentlich kommen neue Server dazu. Die Vision „einmal schreiben, überall nutzen“ wird Realität. Wechseln Sie später die KI-Anwendung, müssen Integrationen nicht neu gebaut werden – MCP-Server funktionieren direkt weiter.