MCP-Praxis-Tutorial: Cursor direkt mit Datenbank und API verbinden – vollständige Konfigurationsanleitung

Letzten Mittwochnachmittag arbeitete ich an einer Datenanalyse-Funktion und musste herausfinden, wie viele neue Nutzer im Dezember in der Datenbank dazukamen. Früher hätte ich DataGrip geöffnet, eine SQL-Abfrage geschrieben, ausgeführt, das Ergebnis kopiert und wieder in den Code eingefügt. Für diese eine einfache Abfrage bin ich dreimal zwischen Fenstern hin und her gewechselt – zwei Minuten verschwendet.

Dann dachte ich: Ich nutze Cursor jeden Tag zum Programmieren, die KI schreibt mir Funktionen und behebt Bugs – warum kann sie nicht direkt die Datenbank abfragen?

Nach der MCP-Einrichtung frage ich einfach in Cursor: „Wie viele neue Nutzer gab es im Dezember?“ – und die KI liefert sofort die Antwort. Kein Fensterwechsel, kein SQL schreiben, die Effizienz verdoppelt sich.

Als ich zum ersten Mal von MCP hörte, war ich erst eine Weile ratlos. Server, Client, Protocol – klingt alles sehr technisch, aber die Tutorials online sind entweder zu theoretisch (lange Architekturdiagramme) oder zu oberflächlich (Hello World und fertig). Zwei Tage Trial-and-Error brauchte ich, bis die Konfiguration saß.

Dieser Artikel erklärt MCP deshalb ganz pragmatisch: Schritt für Schritt einrichten, damit die KI direkt Datenbanken abfragen und APIs aufrufen kann. 15 Minuten Setup – sofort nutzbar.

Was ist MCP und warum brauchen Sie es?

MCP in einfachen Worten

MCP steht für Model Context Protocol (Modell-Kontext-Protokoll). Klingt akademisch – gemeint ist im Grunde ein „Werkzeuggürtel“ für die KI.

Früher war die KI wie ein sehr kluger Berater: Sie stellten Fragen, bekamen Ratschläge und Code – aber ausführen konnte sie nichts. Sie mussten alles selbst umsetzen.

Mit MCP wird die KI zum echten Assistenten: Sie gibt nicht nur Tipps, sondern erledigt Aufgaben selbst – Datenbankabfragen, API-Aufrufe, Dateien lesen.

Klassisch vs. MCP

Beispiel: Sie wollen wissen, welches Produkt im letzten Monat den höchsten Umsatz hatte.

Klassisch (ohne MCP):

1. Sie: Bitte die KI, eine SQL-Abfrage zu schreiben
2. KI: liefert SQL-Code
3. Sie: SQL kopieren, zum DB-Client wechseln
4. Sie: SQL einfügen und ausführen
5. Sie: Ergebnis kopieren
6. Sie: zurück zu Cursor, Ergebnis einfügen
7. KI: analysiert weiter

Ständiges Hin- und Herwechseln zwischen drei Fenstern – umständlich.

Mit MCP:

1. Sie: „Welches Produkt hatte im letzten Monat den höchsten Umsatz?“
2. KI: fragt die Datenbank ab und liefert die Antwort direkt

Ein Schritt. Mindestens fünfmal schneller.

Kernkonzepte (in 3 Minuten)

Die MCP-Architektur ist simpel – drei Rollen:

MCP Client (das KI-Gehirn, das Tools nutzt)
Ihr KI-Tool, z. B. Cursor oder Claude Desktop. Es versteht Ihre Anfrage und entscheidet, ob ein Tool nötig ist.

MCP Server (der Dienst, der Tools bereitstellt)
Ein von Ihnen konfigurierter Dienst mit einer konkreten Fähigkeit – z. B. Datenbank-MCP-Server für Abfragen, API-MCP-Server für Schnittstellen.

Tools (die konkreten Fähigkeiten)
Jeder MCP Server stellt bestimmte Funktionen bereit – z. B. „Tabellenstruktur abfragen“, „SELECT ausführen“, „Zeilen zählen“.

Analogie: Die KI ist der Arbeiter (Client), der MCP Server ist der Werkzeugkasten mit Schraubenschlüssel und Hammer (Tools). Sie sagen „Nagel einschlagen“ – die KI greift zum Hammer.

Mit diesen drei Begriffen ist klar, was die Konfiguration bewirkt.

Praxis 1 – SQLite-Datenbank anbinden

Warum mit SQLite starten?

SQLite ist maximal einfach: kein DB-Server, kein Port-Setup – eine Datei ist die ganze Datenbank. Ideal zum Üben.

Sobald der Ablauf sitzt, funktioniert PostgreSQL oder MySQL nach demselben Muster.

Alibaba Cloud - Top-Wahl für Entwickler, exklusiv 15 % Rabatt auf Lighthouse-Server

15 % Rabatt sichern →Anzeige

Vorbereitung: Testdatenbank anlegen

Zuerst Testdaten, damit Abfragen greifbar sind. Datei test.db erstellen:

-- Nutzertabelle anlegen
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT UNIQUE,
    created_at TEXT DEFAULT CURRENT_TIMESTAMP
);

-- Bestelltabelle anlegen
CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    user_id INTEGER,
    product_name TEXT,
    amount REAL,
    order_date TEXT DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

-- Testnutzer einfügen
INSERT INTO users (name, email) VALUES
    ('Anna', '[email protected]'),
    ('Ben', '[email protected]'),
    ('Clara', '[email protected]');

-- Testbestellungen einfügen
INSERT INTO orders (user_id, product_name, amount) VALUES
    (1, 'MacBook Pro', 12999.00),
    (1, 'AirPods', 1299.00),
    (2, 'iPhone 15', 5999.00),
    (3, 'iPad Air', 4799.00),
    (3, 'Apple Watch', 2999.00);

Die SQL-Statements können Sie mit jedem SQLite-Tool (DB Browser, Kommandozeile usw.) ausführen – oder per Python:

import sqlite3

conn = sqlite3.connect('test.db')
cursor = conn.cursor()

# Obige SQL-Statements ausführen
# ...

conn.commit()
conn.close()

MCP Server konfigurieren (der Kern)

Der wichtigste Teil. Die MCP-Konfiguration liegt an zwei Orten – je nach Bedarf:

Global (für alle Projekte):

• Windows: C:\Users\IhrBenutzername\.cursor\mcp.json
• Mac/Linux: ~/.cursor/mcp.json

Projektbezogen (nur im aktuellen Projekt):

• .cursor/mcp.json im Projektroot

Empfehlung: zuerst projektbezogen üben, dann bei Bedarf global übernehmen.

Datei .cursor/mcp.json anlegen:

{
  "mcpServers": {
    "sqlite": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sqlite",
        "--db-path",
        "D:/path/to/your/test.db"
      ]
    }
  }
}

Wichtige Punkte (hier hängen viele fest):

1. mcpServers: fester Feldname – nicht ändern
2. "sqlite": beliebiger Name für diesen Server – die KI sieht ihn
3. command: "npx": MCP Server direkt per npx starten, ohne manuelle Installation
4. args: Parameter für den Befehl
   • -y: Installation automatisch bestätigen
   • @modelcontextprotocol/server-sqlite: offizielles SQLite-MCP-Server-Paket
   • --db-path: Pfad zur Datenbankdatei (muss absolut sein!)

Windows-Hinweis: Schrägstriche / oder doppelte Backslashes \\ – kein einfacher Backslash:

• ✅ D:/projects/test.db
• ✅ D:\\projects\\test.db
• ❌ D:\projects\test.db (führt zu Fehlern)

Cursor neu starten und prüfen

Nach dem Speichern Cursor vollständig beenden und neu starten – nicht nur das Fenster schließen, die Anwendung wirklich beenden.

Danach in den Cursor-Einstellungen prüfen:

1. Einstellungen öffnen (Strg+,)
2. Nach „MCP“ suchen
3. Der konfigurierte SQLite-Server sollte sichtbar sein

Oder direkt: eine datenbankbezogene Frage stellen und schauen, ob MCP aufgerufen wird.

Live-Demo

Nach erfolgreicher Konfiguration funktioniert es so:

Abfrage 1: Tabellen auflisten

Sie: Welche Tabellen gibt es in der Datenbank?
KI: [MCP-Aufruf] Zwei Tabellen: users und orders

Abfrage 2: Nutzer zählen

Sie: Wie viele Nutzer gibt es insgesamt?
KI: [SELECT COUNT(*) FROM users] Insgesamt 3 Nutzer

Abfrage 3: Bestellungen eines Nutzers

Sie: Was hat Anna gekauft?
KI: [Join-Abfrage] Anna hat gekauft:
- MacBook Pro (12.999 €)
- AirPods (1.299 €)
Gesamt: 14.298 €

Abfrage 4: Aggregation

Sie: Welcher Nutzer hat am meisten ausgegeben?
KI: [GROUP BY-Abfrage] Anna mit insgesamt 14.298 €

Kein SQL schreiben – die KI erledigt es. Das ist die Stärke von MCP.

Häufige Probleme

Problem 1: MCP Server startet nicht
Symptom: KI antwortet, ruft aber keine Datenbank auf
Lösung:

• JSON-Syntax prüfen (keine überflüssigen Kommas)
• Cursor wirklich vollständig neu gestartet?
• Ausgabe-Log in Cursor durchsuchen, nach „MCP“-Fehlern filtern

Problem 2: Datenbankdatei nicht gefunden
Symptom: Fehler „cannot open database file“
Lösung:

• Absoluter Pfad, kein relativer
• Windows: Schrägstrich-Richtung prüfen
• Datei existiert? (ls oder dir)

Problem 3: Berechtigungsfehler
Symptom: Permission denied
Lösung:

• Lese-/Schreibrechte der Datei prüfen
• Windows: Rechtsklick → Eigenschaften → Sicherheit, Lesezugriff für aktuellen Nutzer

Debug-Tipp: In Cursor „Ausgabe“ öffnen (View → Output), Kanal „MCP“ wählen – detaillierte Fehlerlogs.

Praxis 2 – PostgreSQL anbinden

Fortgeschritten: Produktions-Datenbank

SQLite eignet sich zum Lernen und für kleine Projekte. Im Alltag nutzen Sie eher PostgreSQL oder MySQL – das Prinzip bleibt gleich, nur die Parameter ändern sich.

Im Folgenden PostgreSQL; MySQL ist analog.

Unterschied: Verbindungsdaten und Umgebungsvariablen

PostgreSQL ist Client/Server – Verbindungsdaten sind nötig. Passwörter niemals direkt in die Konfiguration schreiben – ein häufiger Sicherheitsfehler.

Richtig: Umgebungsvariablen.

.env im Projektroot anlegen (in .gitignore eintragen):

POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_DATABASE=myapp
POSTGRES_USER=readonly_user
POSTGRES_PASSWORD=your_secure_password

Dann .cursor/mcp.json:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "--stdio"
      ],
      "env": {
        "POSTGRES_HOST": "${POSTGRES_HOST}",
        "POSTGRES_PORT": "${POSTGRES_PORT}",
        "POSTGRES_DATABASE": "${POSTGRES_DATABASE}",
        "POSTGRES_USER": "${POSTGRES_USER}",
        "POSTGRES_PASSWORD": "${POSTGRES_PASSWORD}"
      }
    }
  }
}

Wichtig:

• --stdio: Kommunikation über Standard-Ein-/Ausgabe (lokal)
• env: Umgebungsvariablen – Cursor liest die .env des Projekts

Sicherheit (sehr wichtig)

Datenbankzugriff für die KI erfordert strikte Vorsicht:

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

Jetzt starten →Anzeige

1. Nur-Lese-Account

Keine Schreibrechte! Versteht die KI Ihre Anfrage falsch und führt DELETE oder UPDATE aus, ist der Schaden groß.

Nur-Lese-Nutzer anlegen:

-- Nur-Lese-Nutzer anlegen
CREATE USER readonly_user WITH PASSWORD 'secure_password';

-- Nur SELECT erlauben
GRANT CONNECT ON DATABASE myapp TO readonly_user;
GRANT USAGE ON SCHEMA public TO readonly_user;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO readonly_user;

-- Auch für künftig neue Tabellen nur SELECT
ALTER DEFAULT PRIVILEGES IN SCHEMA public
GRANT SELECT ON TABLES TO readonly_user;

2. Zugriff einschränken

Sensible Tabellen (Passwörter, Zahlungsdaten) von der KI fernhalten:

-- Zugriff auf sensible Tabellen entziehen
REVOKE SELECT ON TABLE user_passwords FROM readonly_user;
REVOKE SELECT ON TABLE payment_info FROM readonly_user;

3. In Produktion: Read Replica

Wenn Sie MCP in Produktion nutzen (erstmal abraten), mindestens an eine Read Replica – nicht an die Primary. Komplexe KI-Abfragen belasten dann nicht den Live-Betrieb.

Live-Demo

Nach dem Setup geht mehr als mit SQLite:

Komplexe Abfrage: Multi-Table-JOIN

Sie: Durchschnittsgehalt pro Abteilung
KI: [komplexe Abfrage]
SELECT d.name, AVG(e.salary) as avg_salary
FROM departments d
JOIN employees e ON d.id = e.department_id
GROUP BY d.name
ORDER BY avg_salary DESC;

Ergebnis:
- Technik: durchschnittlich 15.000 €
- Produkt: durchschnittlich 12.000 €
- Operations: durchschnittlich 10.000 €

Performance: Ausführungsplan

Sie: Warum ist diese Abfrage so langsam?
KI: [EXPLAIN] Kein Index genutzt – Index auf user_id empfohlen

Analyse: Report

Sie: Neue Nutzer pro Tag der letzten 7 Tage
KI: [Zeitfenster-Abfrage]
2024-01-10: 45
2024-01-11: 52
...

Häufige Probleme

Problem 1: Verbindungs-Timeout
Symptom: timeout connecting to database
Lösung:

• DB läuft? (pg_isready)
• Firewall erlaubt Verbindung?
• host und port korrekt?

Problem 2: Authentifizierung fehlgeschlagen
Symptom: authentication failed
Lösung:

• Benutzername/Passwort prüfen
• pg_hba.conf erlaubt Verbindung?
• Mit psql manuell testen

Problem 3: Unzureichende Rechte
Symptom: permission denied for table xxx
Lösung:

• Kann auch gut sein – Nur-Lese-Rechte greifen
• Falls Tabelle nötig: GRANT mit Admin-Account ausführen

Praxis 3 – API-Aufrufe

Anwendungsfall: externe Dienste

Datenbanken decken interne Daten ab – manchmal brauchen Sie externe APIs:

• GitHub: Stars, Issues
• interne Microservice-APIs
• Wetter, Wechselkurse in Echtzeit

Mit MCP kann die KI auch diese Schnittstellen aufrufen.

HTTP-MCP-Server konfigurieren

API-Aufrufe unterscheiden sich: oft kein separates MCP-Paket, sondern HTTP-Konfiguration.

Beispiel GitHub API in .cursor/mcp.json:

{
  "mcpServers": {
    "github-api": {
      "url": "https://api.github.com",
      "headers": {
        "Accept": "application/vnd.github.v3+json",
        "User-Agent": "Cursor-MCP-Client"
      }
    }
  }
}

Bei Authentifizierung (private Repos) Token hinzufügen:

{
  "mcpServers": {
    "github-api": {
      "url": "https://api.github.com",
      "headers": {
        "Accept": "application/vnd.github.v3+json",
        "Authorization": "Bearer ${GITHUB_TOKEN}",
        "User-Agent": "Cursor-MCP-Client"
      }
    }
  }
}

Token in .env:

GITHUB_TOKEN=ghp_your_personal_access_token_here

GitHub Token erstellen:

1. GitHub → Settings → Developer settings
2. Personal access tokens → Tokens (classic)
3. Generate new token → Berechtigungen wählen (repo, user usw.)
4. Token kopieren (nur einmal sichtbar – sicher speichern)

Live-Demo

Repository-Infos

Sie: Wie viele Stars hat facebook/react?
KI: [GET /repos/facebook/react]
React hat derzeit 218.345 Stars und 79.234 Forks

Neueste Issues

Sie: Welche offenen Issues gibt es bei facebook/react?
KI: [GET /repos/facebook/react/issues?state=open&per_page=5]
Die letzten 5 Issues:
1. [Bug] useEffect läuft im Strict Mode doppelt
2. [Feature] Neue Suspense-API
3. [Question] Optimierung großer Listen
...

Commit-Frequenz

Sie: Wie viele Commits bei facebook/react in der letzten Woche?
KI: [GET /repos/facebook/react/commits?since=...]
43 Commits in 7 Tagen, Hauptbeitragende: ...

Eigene API konfigurieren

Interne APIs analog. Beispiel Nutzerdienst:

{
  "mcpServers": {
    "user-service": {
      "url": "https://api.yourcompany.com/user-service",
      "headers": {
        "Authorization": "Bearer ${INTERNAL_API_KEY}",
        "Content-Type": "application/json"
      }
    }
  }
}

Dann z. B.:

Sie: Bestellhistorie für Nutzer-ID 12345
KI: [interne API] Nutzer 12345: 8 Bestellungen in 30 Tagen, Gesamt 3.200 €

Hinweise

API-Rate-Limits
Viele APIs begrenzen Aufrufe. GitHub Free: 60/Stunde. Mit Token: 5.000/Stunde.

Lösungen:

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

Preise ansehen →Anzeige

• Authentifizierungs-Token nutzen
• KI bitten: „API sparsam nutzen, Ergebnisse wiederverwenden“

Sicherheit
API-Zugriff für die KI = Zugriff auf externe Dienste:

• Nur-Lese-Token
• Token regelmäßig rotieren
• API-Logs überwachen

Fortgeschrittene Tipps und Best Practices

Mehrere MCP Server parallel

In einem Projekt können mehrere Server gleichzeitig laufen – die KI wählt passende Tools.

Beispielkonfiguration:

{
  "mcpServers": {
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "D:/projects/myapp/data.db"]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "--stdio"],
      "env": {
        "POSTGRES_HOST": "${POSTGRES_HOST}",
        "POSTGRES_PORT": "${POSTGRES_PORT}",
        "POSTGRES_DATABASE": "${POSTGRES_DATABASE}",
        "POSTGRES_USER": "${POSTGRES_USER}",
        "POSTGRES_PASSWORD": "${POSTGRES_PASSWORD}"
      }
    },
    "github-api": {
      "url": "https://api.github.com",
      "headers": {
        "Authorization": "Bearer ${GITHUB_TOKEN}",
        "Accept": "application/vnd.github.v3+json"
      }
    }
  }
}

Dann z. B.:

Sie: Wie viele Nutzer in der lokalen SQLite-DB und wie viele Stars auf GitHub?
KI: [sqlite MCP] Lokal 245 Nutzer
    [github-api MCP] Repository 1,2k Stars

Die KI wählt das Tool passend zur Frage.

Projekt vs. global

Projekt (.cursor/mcp.json):

• projektspezifische DB und APIs
• Vorteil: getrennte Konfiguration, versionierbar (ohne Secrets)
• Nachteil: pro Projekt einmal einrichten

Global (~/.cursor/mcp.json):

• allgemeine Tools (Dateisystem, APIs)
• Vorteil: einmal konfigurieren, überall nutzen
• Nachteil: unübersichtlicher, schlechter für Teams

Empfehlung:

• DB, projektspezifische APIs → Projekt
• GitHub, Wetter → global
• Nach dem Setup: Projekt-Konfig als Dokumentation fürs Team

Performance

Jeder MCP-Aufruf führt echte Abfragen/API-Requests aus – bei häufiger Nutzung spürbar.

1. KI-Ergebnisse wiederverwenden

Sie: Nutzerliste abfragen (Ergebnis merken, brauche ich gleich wieder)
KI: [Abfrage] 245 Nutzer...

Sie: Wie viele davon sind VIP?
KI: [ohne neue Abfrage, aus vorherigem Ergebnis]

2. Abfragekomplexität begrenzen
Bei extrem verschachteltem SQL eingreifen und manuell optimieren.

3. Indizes
Intelligente KI-Abfragen helfen nicht, wenn die DB langsam ist – Indizes setzen.

Debugging

1. MCP-Log
Cursor: View → Output, Kanal „MCP“:

• Server-Start
• Tool-Aufrufe mit Parametern und Rückgaben
• Fehler-Stack

2. Konfiguration testen

Sie: Datenbankverbindung testen – welche Tabellen gibt es?

3. Manuell verifizieren
Schlägt die KI fehl: SQL oder Verbindung manuell prüfen – Problem in Abfrage oder Berechtigung?

Häufige Fehlercodes

• ENOENT: Datei/Pfad existiert nicht
• ECONNREFUSED: Verbindung abgelehnt (DB nicht gestartet, falscher Port)
• EACCES: unzureichende Rechte
• ERR_MODULE_NOT_FOUND: MCP-Paket fehlt (npx prüfen)
• ETIMEDOUT: Timeout (Netzwerk oder langsame Abfrage)

Fazit

Seit MCP nutze ich Cursor anders.

Früher: drei Fenster, unterbrochener Flow. Heute: eine Frage, sofort Antwort – der Fokus bleibt im Code.

Kern in drei Punkten:

1. Konzept: MCP gibt der KI Werkzeuge – sie handelt, nicht nur rät
2. Setup: SQLite zum Üben, PostgreSQL für Produktion, API für Erweiterungen
3. Sicherheit: Nur-Lese, Umgebungsvariablen, keine Primary in Produktion

15 Minuten für ein SQLite-MCP – der Unterschied ist nicht 10 oder 20 Prozent, sondern eine andere Arbeitsweise.

MCP entwickelt sich schnell; die Community liefert ständig neue Server. Auf GitHub gibt es Listen – vielleicht finden Sie passende Tools.

Fragen? In den Kommentaren – ich antworte.