MCPg

Ein produktionsreifer Model Context Protocol-Server für PostgreSQL. Er ermöglicht es KI-Agenten, eine Postgres-Datenbank sicher zu inspizieren, abzufragen, zu bedienen und zu tunen – 254 Tools, die Katalog-Introspektion, Query-Intelligenz, natürliche-Sprache-SQL, strukturelle Diffs, Hybrid-Suche, Graph-Abfragen, Datenbewegung, Live-Operationen und mehr abdecken.

Live ausprobieren: Richten Sie einen MCP-Client – oder den MCP Inspector – auf den gehosteten, schreibgeschützten Demo-Endpunkt https://devopam-mcpg-demo.hf.space/mcp aus. Es werden Lese-Tools gegen wegwerfbare Demo-Daten bereitgestellt; für den echten Betrieb führen Sie MCPg neben Ihrer eigenen Datenbank aus (siehe Schnellstart).

📍 Gelistet auf

• Offizielles MCP-Register

• mcp.so

• mcpservers.org

• Smithery

• Glama

Warum MCPg

• Sicher per Standard. Schreibgeschützter Zugriffsmodus. Jede benutzerbeschaffte SQL Anweisung wird vor der Ausführung durch eine validierte AST-Whitelist geparst. Die Interpolation von Bezeichnern erfolgt über einen strikten [A-Za-z_][A-Za-z0-9_]*-Regex, wo dieser als DB-Input interpretiert wird – eine Entwurfsbeschränkung, die bedeutet, dass Benutzereingaben nie über Zeichenfolgenverkettung in die Datenbank gelangen. Funktionen wie DDL, Shell und LISTEN/NOTIFY bleiben deaktiviert, bis Sie sie opt-in. Jedes Tool veröffentlicht MCP ToolAnnotations (readOnlyHint, openWorldHint), die aus genau diesen Gate-Kategorien abgeleitet sind, sodass Clients Lesevorgänge automatisch genehmigen und Schreibvorgänge ohne Vermutung gattern.

• Ein Server, große Oberfläche. Anwendungsdatenzugriff (Abfragen, Suche, Cursor, NL→SQL) und DBA-Operationen (Health-Checks, Index-Tuning, EXPLAIN-Analyse, Sperren, Vakuum, Dumps, Replikate, Migrationen) in ein einziger MCP-Server. Agenten müssen nicht zwischen Tools wechseln, um Aufgaben zu wechseln.

• Alles PostgreSQL-nativ. Kein ORM, keine Abstraktionssteuer, sondern – es nutzt psycopg3 direkt, spricht alle pg_*-Systemansichten, integriert zu timescaleDB, pgvector, PostGIS, Apache AGE und pg_stat_statements wo sie verfügbar sind, und degradiert sauber, wo sie nicht.

• Produktionsgeformt, nicht demodiert. Verbindungspooling, pro-Request SET ROLE-MTC, Lese-Replica-Routing mit Ausfall-Host-Erkennung, Server-Seitige-Cursor mit dedizierten Verbindungen, Rate-Limiting, Audit-Trail mit Regex-Redaktion, PG-TLS-Erzwingung beim Start, OIDC-JWT-Bearer-Auth, Pro-Session-Statement-/Lock- Timeouts.

• Integrierte Observabilität. Ein Prometheus-/metrics-Endpunkt auf dem HTTP-Transport gibt mcpg_tool_calls_total{tool,status} und mcpg_tool_duration_seconds aus. Jeder Tool-Aufruf protokolliert ein strukturiertes Audit-Ereignis mit redigierten Anmeldedaten.

• Testgesteuert, multi-version. Mehr als 2.500 Modultest plus eine Integrationssuite die in CI gegen einen echten Antwort-Container läuft – Matrix deckt PG 14, 15, 16, 17, 18 bei jedem Push ab, dazu PG 19 (Beta) als experimenteller (nicht blockierender) Eintrag, der unter Issue #120 verfolgt wird.

Related MCP server: PostgreSQL MCP Server

Installation

Von PyPI (empfohlen)

pip install mcpg
# or, in an isolated venv exposed globally:
uv tool install mcpg

Verifizierung:

mcpg --version

Docker

Ziehen Sie das vorgefertigte Image aus der GitHub Container Registry (publ auf jedes getaggte Release – :latest trackt die neueste, oder Sie pin eine Version wie :0.6.5):

docker pull ghcr.io/devopam/mcpg:latest
docker run --rm --name mcpg -p 8000:8000 \
    -e MCPG_DATABASE_URL=postgresql://user:pass@host:5432/db \
    -e MCPG_ACCESS_MODE=read-only \
    ghcr.io/devopam/mcpg:latest

In Windows PowerShell ersetzen Sie das abschließende \ durch ein Backtick ` (oder setzen den Befehl in eine Zeile); die Installationsanleitung hat fertige Linux/macOS-, PowerShell- und Command-Prompt-Blöcke.

Oder Sie erstellen es selbst aus dem Quellcode:

docker build -t mcpg https://github.com/devopam/MCPg.git

Multi-Image: Die Ausführungsphase lässt das Build-verfahren weg, läuft als uid=10001 / gid=10001 mit nologin-Shell, die Anwendungsdateien sind Root-Besitz und schreibgeschützt für den Laufzeitbenutzer.

Aus dem Quellcode (Entwickler)

git clone https://github.com/devopam/MCPg && cd MCPg
uv sync

uv sync erstellt eine virtuelle Umgebung mit allen Laufzeit- und Dev-Abhängigkeiten und stellt das mcpg-Konsolenskript bereit.

Mehr Details im Installations-Leitfaden.

Schnellstart

Ein-Klick-Installationen:

• Setup für Windsurf, JetBrains, Clone, Cline, Kin, etc. in der Integrations-Anleitung.

Ein-Klick-Installation in Claude Desktop (.mcpb)

Debuggen Sie mcpg-<version>.mcpb aus dem letzten Release und Doppelklick Sie es (oder ziehen Sie es in Claude Desktop im Menü Einstellungen → Erweiterungen). Sie werden Du auf Ihre PostgreSQL-Verbindungs-URL – im OS-Keychain gespeichert – und einen Zugriffsmodus (Standard ist schreibschutz). Das ist die ganze Installation: das Paket ist etwa 2 KB und der Host löst das verankerte mcpg-Release von PyPI für Ihre Plattform.

Oder manuell verdrahten (stdio-Transport)

Fügen Sie Folgendes in Ihre claude_desktop_config.json ein (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json; Windows: %APPDATA%\Claude\claude_desktop_config.json):

{
  "mcpServers": {
    "mcpg": {
      "command": "uvx",
      "args": ["mcpg"],
      "env": {
        "MCPG_DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
      }
    }
  }
}

StartClaude neu. Das MCPg-Toolset ist jetzt dem Anwendernmodel verfügbar. Sie können Claude zum Beispiel fragen:

„Welche Schemas existieren in dieser Datenbank? Fassen Sie für jedes Schema die drei größten Tabellen zusammen."

„Warum ist diese Abfrage langsam? SELECT * FROM orders WHERE customer_id = 42 ORDER BY created_at DESC"*

Noch keine interessanten Daten? Demo-Datensetseed

MCPG_DATABASE_URL=postgresql://... mcpg --demo

Ein Befehl lädt einen kleinen, kuratierten E-Commerce-Datensatz (3.000 Bestellungen, 900 Produktbewertungen, absichtlich eingebaute Fehler) in ein mcpg_demo Schema – entwickelt, damit der Berater, die Plan-Analyse, Volltextsuche, PII-Audit und Graph-Projektion beim ersten Versuch etwas relevantes finden. Sehen Sie die Tour für einen aufgezeichneten Durchlauf, und entfernen Sie es jederzeit mit mcpg --demo-drop.

Als HTTP-Server ausführen (für IDE-Integrationen, Web-Anwendungen usw.)

GXP8 Dann zeigen Sie jeden MCP-Client auf http://localhost:8000/mcp (oder Aufzähler /sse für den SSE-Transport). Setzen Sie MCPG_HTTP_AUTH_TOKEN=... für einen statischen Bearer-Token oder MCPG_AUTH_MODE=oidc für einen vollständigen JWT-Check gegen einen OIDC-Anbieter.

Konfiguration

MCPg wird vollständig über Umgebungsve Variablen konfiguriert – ke ne Konfigdatei, keine Flags (die CLI---version / --demo / --demo-drop) sind Einmal-Kommando, keine Konfiguration). Die einzige erforderliche ist MCPG_DATABASE_URL; alles andere hat sichere Standardeinstellung.

Häufige Szenarien

Umfassend

Kern

Fähigkeits-Gates (Opt-in für Werkzeuge mit größerem Wirkungsradius)

Authentifizierung (nur HTTP-Transports)

HTTP-Härtung (nur HTTP-Transports)

Multi-Tenancy (SET ROLE)

Lesereplikate

Mehrere Datenbanken (schreibgeschützte Sekundärdatenbanken)

Pool / Timeouts / TLS

Subprozess-Werkzeuge (nur mit MCPG_ALLOW_SHELL=true)

LISTEN/NOTIFY (nur mit MCPG_ALLOW_LISTEN=true)

Audit

Secrets-Backend

Standardmäßig wird jedes Secret direkt aus der Umgebung gelesen. Setzen Sie MCPG_SECRETS_BACKEND=file, um stattdessen API-Schlüssel / Bearer-Token / HMAC-Schlüssel aus einer eingehängten Datei zu laden – ein Name in der Datei gewinnt; alles, was fehlt, fällt auf die Umgebungsvariable zurück, sodass partielle Dateien funktionieren.

Ratenbegrenzung

Caching & Feature-Flags

Natürlichsprachliches SQL

MCPg erkennt automatisch jeden konfigurierten Anbieter aus der Umgebung beim Start – setzen Sie so viele Anbieter-Schlüssel, wie Sie haben, und jeder wird aufrufbar. Neunzehn Anbieter sind integriert. Drei sind First-Party (Anthropic, OpenAI, Gemini); die anderen sechzehn sprechen die OpenAI-kompatible API mit anbietervoreingestellten Endpunkten: DeepSeek, Qwen, OpenRouter, Perplexity, xAI (Grok), Groq, Mistral, Together, Fireworks, DeepInfra, Cerebras, Nebius, Hugging Face, GitHub Models, SambaNova und Moonshot (Kimi). Jeder integrierte Anbieter ist Plug-and-Play – setzen Sie die übliche API-Schlüssel-Umgebungsvariable des Anbieters und er wird automatisch erkannt – und jeder andere OpenAI-kompatible Anbieter oder lokale Modellserver (Ollama, vLLM, LM Studio) ist dennoch allein durch Konfiguration anschließbar über MCPG_NL2SQL_CUSTOM_PROVIDERS. Die gesamte integrierte Liste ist ein deklaratives Register in nl2sql.py, sodass das Hinzufügen eines Anbieters oder das Aktualisieren eines veralteten Standardmodells eine einzellige Datenänderung ist.

Wenn MCPG_NL2SQL_PROVIDER nicht gesetzt ist, wählt MCPg automatisch den Standard in Registerreihenfolge – anthropic → openai → gemini bleiben zuerst, sodass bestehende Bereitstellungen nicht betroffen sind. translate_nl_to_sql akzeptiert ein optionales provider="…"-Argument, um pro Aufruf zu routen; get_server_info meldet, welche konfiguriert sind.

Anwendungsbeispiele

Die MCP-Tools werden vom Agenten (Claude, Cursor, Continue, …) auf der Grundlage deiner natürlich formulierten Anweisungen aufgerufen. Einige Veranschaulichende Round-Trips:

Schema inspizieren

Du: Welche Tabellen leben im public-Schema, und welche sind die größten nach Anzahl Zeilen?

Agent (mit list_tables + summarize_table × N): Sechs Tabellen: customers (1,2 Mio. Zeilen), orders (4,7 Mio.), line_items (18,3 Mio.), products (340), addresses (1,4 Mio.), audit_log (45,8 Mio. – die größte, wächst ohne Aufbewahrung).

Eine langsamer Freigabe Adressen beheben

Du: Warum braucht SELECT * FROM orders o JOIN line_items l ON o.id = l.order_id WHERE o.created_at > now() - interval '7 days' 8 Sekunden?

Agent (mit why_is_this_slow + recommend_indexes): EXPLAIN ANALYZE zeigt einen sequenziellen Scan über orders (4,7 Mio. Zeilen) gefiltert nach created_at. Es gibt keinen Index auf orders.created_at. Empfohlen: CREATE INDEX CONCURRENTLY orders_created_at_idx ON orders (created_tick DESC); Erwartete Verbesserung: ~95 % Reduzierung (Index-Scan unter neu ~33.000 Zeilen statt der gesamten Tabelle). Führe validate_migration dort vor der Anwendung aus, um sicherzugehen, dass es keine Sperroverbindung gibt.

Einfaches Englisch in SQL übersetzen

Du: Finde Kundschaft, deren Bestellung in diesem Monat aufgegeben wurde, aber nie in den vorherigen drei Monaten – zeig mir ihre E-Mail und ihren aktuellen ausgegebenen Gesamtpreis (Lifetime Spend).

Agent (mit translate_nl_to_sql):

SELECT c.email, SUM(l.price * l.quantity) AS lifetime_spend
FROM customers c
JOIN orders o ON o.customer_id = c.id
JOIN line_items l ON l.order_id = o.id
WHERE EXISTS (
  SELECT 1 FROM orders o2 WHERE o2.customer_id = c.id
    AND o2.created_at >= date_trunc('month', now()))
  AND NOT EXISTS (
  SELECT 1 FROM orders o3 WHERE o3.customer_id = c.id
    AND o3.created_at >= date_trunc('month', now()) - interval '3 months'
    AND o3.created_at <  date_trunc('month', now()))
GROUP BY c.email;

Schema grafisch darstellen

Du: Zeichen mir ein ER-Diagramm des public-Schemas.

Agent (mit generate_schema_diagram): Gibt ein Mermaid-En Diagramm zurück, das du direkt in GitHub / Notion / Obsidian einfügen kannst.

Datenbank auditieren

Du: Wie gesund hat es diese Datenbank gerade?

Du (mit audit_database): Gibt einen bewerteten Bericht aus: Memory & I/O-Punkte & I/O: 92 (GUT), Transaktion & Verbindung: 78 (WARNUNG: Rollback-Rate 0,4 %, Blick in die App-Logs), Gleichzugriff & Sperren: 60 (KRITISCH: 14 Backends warten), Sauberkeit & Bloat: 88 (GUT), Langsam Abfragen: 70 (WARNUNG: die meistauf gravierte Abfrage-Schnittstelle läuft 5000×, ⏳ 90 ms? – siehe optimize_query).

Geschützten Schreibzugriff durchführen

Du: Soft-Delete alle Bestellungen, die älter als 5 Jahre sind.

Agent (mit run_write und MCPG_AUDIT_PERSIST=true): Valdiert die Anweisung durch den Safe-SQL-Kern, führt sie innerhalb einer Movene Transaktion aus, gibt Anzahl betroffener Zeilen zurück, persistiert Aufruf (SQL + Argumente – mit Regex redigierten Geheimnissen – + Status) in mcpg_audit.events zur späteren Prüfung.

Für dutzende weitere Rezepte – Multi-tenant-routing, RLS-Tests, NL→SQL, Hybride Vektor- + Festsuche (Full-Text), Apache AGE Cypher, TimescaleDB, ORM-Schema exportieren, Serverseitige Cursor – siehe docs/cookbook.md.

Was in der Box ist

Kompakte Kategorienliste. Für die vollständige, aktuelle Tool-Referenz siehe docs/tools.md; für eine geführte Tour siehe docs/tour.md.

• Catalog-Introspection – Schemas, Tabellen, Spalten, Indizes, Beschränkungen, View, Functions, Trigger, Sequences, Partitionen, Policies, Rollen, Grants, Enums, Domains, zusammengesetzte Typen, FDWs, Publications, Subscriptions, Extensions, generierte Spalten.

• Query Intelligence – run_select, run_select_parallel, explique_query, analyze_query_plan, why_is_this_slow, recommend_indexes, analyze_workload, check_database_health, detect_n_plus_one, audit_database.

• Suche – fuzzy_search (Trigramm), full_text_search, vector_search, hybrid_search (pgvector + FTS über RKF), geo_search (PostGIS k-nearest-Neighbor).

• Natürliche Sprache → SQL – Hoodies? translate_nl_to_sql (22 eingebaute Provider – Anthropic, OpenAI, Gemini, xAI, Groq, Mistral, /HuggingFace Face, … – plus beliebige benutzerdefinierte OpenAI-kompatible Endpunkte; Ausgabe passiert durch denselben Safe-SQL-Kernel wie handgeschriebene Abfragen.

  • Visualization – generate_schema_diagram (ER), generate_fk_cascade_graph (Blastradius of ON DELETE CASCADE), generate_graph_diagram (APACHE AGE property graphs).

• Strukturelle Diffsions & Migrationen – compare_schemas, validate_migration, gestufte Workflow prepare_migration / complete_migration , cancel_migration.

• Apache AGE graph + Cypher – list_graphs, describe_graph, run_cyphert, create_graph, drop_graph, generate_graph_diagram.

• Zusammen unfassende & Beratungswerk tools, stabil – summarize_table, find_unused_objects, find_sensitive_columns (PII-Heuristik), lint_naming_conventions, test_rls_for_role, list_locks, find_blocking_chains, read_pg_stat_session_io (PG16+), generate_test_data (test_data_generator).

• Live Betrieb & Wartung – list_active_queries, verify_connection_encryption (TLS-Status der Live-Verbindung), run_maintenance (VACUUM/ANALYZE), prune_audit_events (Prüfprotokollretention), cancel_query, terminate_backend, run_write, run_ddl, `enable_te o Enable Extension.

• Datenbereich (Data Moving) – export_query / export_table (CSV/JSON), dump_database / restore_database, import_csv / import_json (COPY FROM STDIN), copy_table_between_asquery.

• Server-side cursors – open_cursor, fetch_cursor, close_cursor, list_cursors) für seitenweise Read mittels Millionen von Zeilen (pageable).

• TimescaleDB – list_hypertables, list_chunks, create_hypertable, add_compression_policy, add_retention_policy.

• ORM schema exporter – Prisma, Drizzle, SQLAlchemy, sqlc, Diesel, jOOQ, Ent, Ecto.

• Ereignis-Streams – subscribe_channel, poll_notifications, unsubscribe_channel, list_notification_subscriptions und Brückening von PostgreSQL LISTEN/NOTIFY in das MCP-Poll-Modell.

• Beobachtbarkeit – Prometheus /metrics Endpoint + get_metrics_exposition Tool für stdio; strukturierter Audit-Pfad mit regex-basierter Redigierung von secrets.

Documentation

• docs/installation.md – installieren & gieren

• docs/tour.md – Tool-Tour

• docs/cookbook.md – praktische Aktve-Recipes

• docs/tools.md – vollständige ToolReferenz

• docs/architecture.md – Zusammenspiel der Teile v:

• docs/scaling.md – Pool-Größe, Repliken, Leistung

• docs/security-hardening.md – Sicherheitsfeatures-Roadmap

• docs/release-process.md – Release-Ablauf an PyPI

• docs/adr/ – Architecture Decision Records

• Durchsuchen unter https://devopam.github.io/MCPg/

Sicherheit

The above contain many errors: "Ende- endlicher" etc. Need clean up. Let's produce a proper final German translation with care, no hallucination. We'll write.

Use "Du" as informal throughout. Keep consistent.

Need be mindful to preserve markdown and links.

Let's reconstruct properly.

Table:

Row 1: | <VENDOR>_API_KEY | — | Wenn du einen Anbieter-Schlüssel in üblicher Form setzt und nur setzt, wird – wird Anbieter aktiviert. Übliche Slugs sind ... |

But description says "Setting a vendor rather than a custom key enables that provider." So "Das Setzen eines herstellerspezifischen Standardschlüssels aktiviert diesen Anbieter." Better.

Row 2: "(avweichende Schlüssel)" etc.

Row 3: auto-picked -> "automatisch" as default. "Beliebiger eingebauter Slug (siehe oben) oder ein eigener Name. Legt den Standard-Anbieter fest, der verwendet wird, wenn das Tool ohne provider= aufgerufen wird. Wenn nicht gesetzt + Anbieter-Schlüssel vorhanden ist, wählt MCPg automatisch in der Registrierungsreihenfolge aus."

Row 4: etc.

Row 5: "provider default" -> "Standard des Anbieters". Good.

Row 6: "—" default.

Row 7: Custom providers: "Eigenen Anbieter mitbringen – keine CodeÄnderung." etc.

Let's use "Endpunkt" instead of "Endpoint" maybe both. "KEINE Codeänderung" but there is "no code change" phrase. Fine.

Now usage examples section.

Heading "Inspect the schema" maybe "Das Schema inspizieren" not "Schema inspizieren". Good.

Blockquote formatting: We need keep > and bold.

"Key" question: in User quota, we can translate "Und welche sind nach Zeilenanzahl am größten?" Good.

Agent quote: "result" etc.

Diagnose langsam: "Warum dauert". Keep SQL code.

"Es gibt keinen Index" instead of "Es gibt keinen Index" etc.

"Expected improvement: ~95% reduction": "Erwartete Verbesserung: ~95 % Reduzierung".

"Run validate_migration on it before applying" -> "Führe vor der Anwendung validate_migration darauf aus". In a block quote sentence continuation. We'll translate.

Translate plain English to SQL

"Natürliche Sprache in SQL übersetzen" actually "Einfaches Englisch in SQL übersetzen" or "Reines Englisch". But perhaps "Natürliche Sprache (Englisch), zu SQL" The tutorial NL is arbitrary. We'll translate heading as "Einfaches Englisch in SQL übersetzen" (as phrase in instructions).

User transcript: "Finden Sie Kunden, die in diesem Monat eine Bestellung aufgegeben haben, aber nie in den vorherigen drei Monaten – zeigen Sie mir ihre E-Mail und den Gesamtumsatz aller Zeiten (lifetime spend)." Need "Find customers" plural; we can say "Finde Kunden..." with du. Good.

Agent block with "GXP9": Keep. Maybe "> GXP9" as is.

Picture the schema

"Zeichne mir ein ER-Diagramm des public-Schemas."

Agent: "Gibt ein Mermaid-Diagramm zurück, that you can paste."

Audit the database

Again translate "Du:". "Wie gesund ist diese Datenbank im Moment?" Agent: "Gibt einen bewerteten Bericht zurück: Memory & I/O-Wert: 92 (GUT), Transaktionen & Verbindungen: 78 (WARNUNG: Rollback-Rate 0,4 %, prüfen der App-Logs), Parallelverlauf & Sperren: 60 (KRITISCH: 14 Backends warten), Sauberkeit & Bloat: 88 (GUT), Langsame Abfragen: 70 (WARNUNG: Läuft nach Vorlage 5000×, durchschnittlich 90 ms – siehe optimize_query)." Need ensure asterisks.

The original "Memory & I/O score 92 (GOOD), ..." maybe italic inside. We need preserve italics? It's inside blockquote, uses asterisks. We'll include.

"Memory & I/O" Could be "Memory & E/A" but "I/O" used in German too. Use "Memory & I/O-Punktwert 92 (GUT)". Maybe "Punktwert" improves.

Write

"üse zum Beispiel" Use "Du möchtest alle Bestellungen älter als 5 Jahre per Soft Delete löschen." Actually "Soft-delete every order older than 5 years." Good.

Agent: "Validiert die Anweisung durch den Safe-SQL-Kern, führt sie in einer Transaktion aus, gibt die Anzahl betroffener Zeilen zurück, persistiert den Aufruf (SQL + Argumente – mit Regex-Redaktion von Geheimnissen – + Status) in ctpg_audit.events für nachträgliche Prüfung."

Need be accurate: original "sql + arguments — with secrets regex-redacted — + status". We can write "sql und Argumente – mit per Regex-Schwächten Secrets – und Status".

Good.

For "What's in the box" Keep category names not hyphenated.

Let's ensure bullets have semicolon/newline.

Full bullet translations:

• Katalog-Introspection — Schemas, Tabellen, Spalten, Indizes, Constraints, Views, Funktionen, Trigger, Sequenzen, Partitionen, Policies, Rollen, Grants, Enums, Domains, zusammengesetzte Typen, FDWs, Publikationen, Abonnements, Erweiterungen, generierte Spalten.

• Abfrage-Intelligenz — run_select, etc.

• Suche — "Sektion..." We can keep the English names.

• Natürliche Sprache → SQL — translate_nl_to_sql (22 eingebaute Anbieter – Anthropic, OpenAI, Gemini, xAI, Groq, Mistral, Hugging Face, … – plus beliebige benutzerdefinierte OpenAI-kompatible Endpunkte; Ausgabe»« durch denselben Safe-SQL-Kern wie handsgeschriebene Abfragen).

• Visualisierung — generate_schema_diagram (ER), generate_fk_cascade_graph (Blast-Radius von ON DELETE CASCADE), generate_graph_diagram (Apache-AGE-Propertygraphen).

• Strukturdiff & Migrationen — compare_schemas, validate_migration, gestufte Workflow prepare_migration / complete_migration / cancel_migration.

• Apache-AGE-Graf + Cypher — list_graphs, describe_graph, run_cypher, create_graph, drop_graph, generate_graph_diagram.

• Composite- und Beraterwerkzeuge — summarize_table, find_unused_objects, find_sensitive_columns (PII-Heuristik), lint_naming_conventions, test_rls_for_role, list_locks, find_blocking_chains, read_pg_stat_io (PG16+), generate_test_data.

• Live-Betrieb & Wartung — list_active_queries, verify_connection_encryption (TLS-Status der Live-Verbindung), run_maintenance (VACUUM/ANALYZE), prune_audit_events (Audit-Aufbewahrung), cancel_query, terminate_backend, run_write, run_ddl, enable_extension.

• Datenaustausch — export_query / export_table (CSV/JSON), dump_database / restore_database, import_csv / import_json (COPY FROM STDIN), copy_table_between_databases.

• Serverseitige Cursor — open_cursor, fetch_cursor, close_cursor, list_cursors für Seitenweises Lesen von Dateien über Millionen Zeilen.

• TimescaleDB — List...

• ORM-Schema-Export — Prisma, Drizzle, SQLAlchemy, sqlc, Diesel, jOOQ, Ent, Ecto.

• Ereignisstreams — subscribe_channel, poll_notifications, unsubscribe_channel, list_notification_subscriptions als Brücke von PostgreSQL LISTEN/NOTIFY in das MCP-Poll-Modell.

• Observability — Bemühe: Prometheus /metrics Endpunkt + get_metrics_exposition für stdio; strukturierter Audit-Pfad mit regex-basierter Redactions Geheimnisse.

Need careful with "secrets" "Geheimnisse redigiert".

Documentation list: torch.

Translate descriptions:

• docs/installation.md — "Installieren & Konfiguration"

• docs/tour.md — "geführte Tool-Tour"

• docs/cookbook.md — "praktische Rezepte für Agenten"

• docs/tools.md — "vollständige Tool-Referenz"

• docs/architecture.md — "wie die Bausteine passen"

• docs/scaling.md — "Pool-Sizing, Replicas, Performance"

• docs/security-hardening.md — "Roadmap für Sicherheitsfeatures"

• docs/release-process.md — "wie Releases zu PyPI gelangen"

• docs/adr/ — "Architecture Decision Records" (keep)

• Browse at — "Durchblättern direkt unter ..."

Also "Sicherheit" heading at end. Not "Security" maybe "Security" can keep? We are translating H1 heading, so "Sicherheit".

Need ensure no "dutch" nonsense.

Need proper Markdown table pipes. All columns.

Let's refine exact table row text. Use "| MCPG_NL2SQL_API_KEY | — | Expliziter Anbieter Schlüssel..." Fine.

Let's generate final.

Important: At the bottom "It might indicate a translated from" no commentary.

Let's write final answer| Variable | Default | Beschreibung | | ------------------------------ | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | <VENDOR>_API_KEY | — | Das Setzen eines herstellerüblichen Schlüssels aktiviert diesen Anbieter. Übliche Slugs: ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY, OPENROUTER_API_KEY, PERPLEXITY_API_KEY, XAI_API_KEY, GROQ_API_KEY, MISTRAL_API_KEY, TOGETHER_API_KEY, FIREWORKS_API_KEY, CEREBRAS_API_KEY, NEBIUS_API_KEY, SAMBANOVA_API_KEY, MOONSHOT_API_KEY. | | (abweichende Schlüssel) | — | Einige Anbieter folgen beim <VENDOR>_API_KEY nicht dem üblichen Muster: Gemini → GEMINI_API_KEY oder GOOGLE_API_KEY; Qwen → DASHSCOPE_API_KEY oder QWEN_API_KEY; Hugging Face → HF_TOKEN; GitHub Models → GITHUB_TOKEN; DeepInfra → DEEPINFRA_TOKEN. | | MCPG_NL2SQL_PROVIDER | automatisch | Ein eingebauter Slug (siehe oben) oder ein eigener Name. Legt den Standardanbieter fest, der verwendet wird, wenn das Tool ohne provider= aufgerufen wird. Nicht gesetzt + ein Anbieterschlüssel vorhanden → MCPg wählt automatisch in der Reihenfolge der Registrierung. | | MCPG_NL2SQL_API_KEY | — | Expliziter Schlüssel für den konfigurierten MCPG_NL2SQL_PROVIDER. Überschreibt die herstellerübliche Umgebungsvariable nur für diesen Anbieter. Erfordert, dass MCPG_NL2SQL_PROVIDER gesetzt ist. | | MCPG_NL2SQL_MODEL | Standard des Anbieters | Überschreibt das Standardmodell (z. B. claude-sonnet-4-6, gpt-4o-mini, grok-3-mini). Gilt nur für den Standardanbieter. | | MCPG_NL2SQL_BASE_URL | — | Überschreibt den Endpunkt für den Standardanbieter (private Gateways / regionale Endpunkte). | | MCPG_NL2SQL_CUSTOM_PROVIDERS | — | Eigener Anbieter – keine Codeänderung nötig. Mit Komma/Zeilenumbruch getrennte name=base_url\|model-Einträge, die zusätzliche, OpenAI-kompatible Anbieter neben den eingebauten deklarieren (lokales Ollama / vLLM / LM Studio oder beliebige Nischenanbieter). Schlüssel nach Konvention aus <NAME>_API_KEY, oder \|KEY_ENV_VAR für abweichende anfügen; für Loopback-Endpunkte optional. Jeder Name ist über provider= aufrufbar. | | MCPG_NL2SQL_MAX_TOKENS | 2048 | Obergrenze für generierte Tokens (hartes Limit: 16384). |

Anwendungsbeispiele

Die MCP-Tools werden vom Agenten (Claude, Cursor, Continue, …) als Reaktion auf deine natürlichsprachigen Anweisungen aufgerufen. Ein paar illustrative Beispiele:

Das Schema der Datenbank inspizieren

Du: Welche Tabellen liegen im public-Schema, und welche sind die größten nach Zeilenzahl?

Agent (using list_tables + summarize_table × N): Sechs Tabellen: customers (1,2 Mio. Zeilen), orders (4,7 Mio.), line_items (18,3 Mio.), products (340), addresses (1,4 Mio.), audit_record (45,8 Mio. – die größte, wächst ohne Limit weiter).

Eine langsame Abfrage analysieren

Du: Warum dauert SELECT * FROM orders o JOIN line_items l ON o.id = l.order_id WHERE o.created_at > now() - interval '7 days' 8 Sekunden?

Agent (using why_is_this_slow + recommend_indexes): EXPLAIN ANALYZE zeigt einen Sequenziellen Scan der orders (4,7 Mio. Zeilen), gefiltert über created_at. Es gibt keinen Index für orders.created_at. Empfehlung: CREATE INDEX CONCURRENTLY orders_created_at_idx ON orders (created_at DESC); Erwartete Verbesserung: ~95 % Reduzierung (den Index Scan durchläuft ~33K Zeilen statt der gesamten Tabelle). Führe validate_migration darauf aus, bevor du die Änderung anwendest – dann überrascht dich nichts beim Sperren.

Normales Deutsch in SQL übersetzen

Du: Finde Kunden, die in diesem Monat eine Bestellung aufgegeben haben, aber nie in den vorherigen drei Monaten – zeig mir ihre E-Mail und ihre aktuelle Gesamtausgabe über die gesamte Zeit (Lifetime Spend).

Agent (using translate_nl_to_sql):

SELECT c.email, SUM(l.price * l.quantity) AS lifetime_spend
FROM customers c
JOIN orders o ON o.customer_id = c.id
JOIN line_items l ON l.order_id = o.id
WHERE EXISTS (
  SELECT 1 FROM orders o2 WHERE o2.customer_id = c.id
    AND o2.created_at >= date_trunc('month', now()))
  AND NOT EXISTS (
  SELECT 1 FROM orders o3 WHERE o3.customer_id = c.id
    AND o3.created_at >= date_trunc('month', now()) - interval '3 months'
    AND o3.created_at <  date_trunc('month', now()))
GROUP BY c.email;

Schema grafisch darauf

Du: Zeichne mir ein ER-Diagramm des public-Schemas.

Agent (using generate_schema_diagram): Gibt ein Mermaid-Diagramm zurück, das du direkt in GitHub / Notion / Obsidian einfügen kannst.

Datenbank prüfen

Du: Wie gesund ist diese Datenbank gerade?

Agent (using audit_database): Liefert einen Bericht mit Bewertungen: Memory & I/O: 92 (GUT), Transaktionen & Verbindungen: 78 (WARNUNG: Rollback-Rate 0,4 %, schütz in den App-Logs), Parallelität & Sperren: 60 (KRITISCH: 14 Backends warten), Sauberkeit & Bloat: 88 (GUT), Slow Queries: 70 (WARNUNG: Top-Abfrage-Schema läuft 5000×, mean 90 ms –– siehe optimize_query).

Einen geschützten Schreibzugriff ausführen

Du: Sets von allen Besorgungen älter als 5 Jahre per Soft-Delete entfernt.

Agent (using run_write with MCPG_AUDIT_PERSIST=true): Validiert die Anweisung im Safe-SQL-Kern, führt sie in auf einer Transaktion aus, gibt die Anzahl betroffener Zeilen zurück und schreibt den Aufruf (SQL + Argumente – mit via Regex re-geschwärzten Secrets – + Status) in mcpg_audit.events für nachträgliche Prüfung.

Weitere rezepte Formate – Multi-Tenant-Routing, RLS-Tests, NL→SQL, Hybridsuche (Vektor + Volltext), Apache AGE Cypher, TimescaleDB, ORM-Schema- Exporte, serverseitige Cursor – findest du in docs/cookbook.md.

Duplicate.

Was ist MCPg?

Kompakte Kategorieübersicht. Die vollständige, aktuelle Tool-Referenz findest du in docs/tools.md; für eine geführte Tour in docs/tour.md.

• Katalog-Introspection – Schemas, Tabitepes, Spalten, Indizes, Constraints, Views, Funktionen, Trigger, Sequenzen, Partitionen, Policies, Rollen, Grants, Enums, Domains, zusammengesetzte Typen, FDWs, Publikationen, Subscriptions, Erweiterungen, generierte Spalten.

• Abfrage-Intelligenz – run_select, run_select_parallel, explain_query, analyze_query_plan, why_is_this_so, recommend_indexes, analyze_workload, check_database_health, detect_n_plus_one, audit_database.

• Suche – fuzzy_search (Trigramme), full_text_search, vector_search, hybrid_search (pgvector + FTS via RRF), geo_search (PostGIS k-NN).

• Natürliche Sprache → SQL – translate_nl_to_sql (22 eingebaute Anbieter (Anthropic, OpenAI, Gemini, xAI, Groq, Mistral, HF, …), plus jed beliebigen angepassten OpenAI-kompatiblen Endpunkt; durchläuft denselben Safe-SQL-Kern wie handgeschriebene Abfragen.

• Visualisierung – generate_schema_background (ER), generate_fk_cascade_graph (Blast-Radius von ON DELETE CASCADE). generate_graph_diagram (Apache-AGE Property-Graphen).

• Strukturelles Diff & Migrationen – compare_schemas, validate_migration, Workflow prepare_migration / completeMigration / cancel_migration.

• Apache AGE Graph + Cypher – list_graphs, describe_graph, run_cypher, live create_graph, drop_graph, generate_graph_diagram.

• Zusammengesetzte & Advisor-Tools – summarize_table, find_objects, find_sensitive_columns (PII-Heuristik), lint_naming_conventions, test_rls_for_role, list_locks, find_blocking_chains, read_pg_stat_io (PG16+), generate_test_data.

• Betrieb Post Live & Wartung – list_active_queries, verify_connection_encryption (TLS-Status der Live-Verbindung), run_maintenance (VACUUM/ANALYZE), prune_audit_events (Aufbewahrung des Audit-Logs), cancel_query, terminate_backend, run_write, run_ddl, enable_extension.

• Datenaustausch – export_query / export_table (CSV/JSON), dump_database / echo_database, import_csv / import_json (COPY FROM STDIN), copy_table_between_databases.

• Serverseitige Cursor – open_cursor, fetch_cursor, close_cursor, list_cursors für das seitenweise Lesen über Millionen von Zeilen.

• TimescaleDB – list_hypertables, list_chunks, create_hypertable, add_comment_policy, add_retention_policy.

• ORM-Schema-Exporte – Prisma, Drizzle, SQLAlchemy, sqlc, Diesel, jOOQ, Ent, Ecto.

• Ereignis-Ströme – subscribe_channel, poll_notifications, unsubscribe_channel, list_notification_subscriptions als Brücke zwischen PostgreSQL LISTEN/NOTIFY und dem MCP-Poll-Modell.

• Beobachtbarkeit - Prometheus-/Metrics-Endpunkt plus Tool get_metrics_exposition für „stdio“; strukturierter Audit-Pfad.

Dokumentation

• docs/installation.md – Installation + Konfiguration

• docs/tour.md – geführte Tool-Tour

• docs/cookbook.md – praktische Agenten-Rezepte

• docs/tools.md – vollständige Tool-Referenz

• docs/architecture.md – Wie Bau wie Architektur zusammenspielt

• docs/scaling.md – Pool-Größe, -Replicas, Performance

• docs/security-hardening.md – Fahrplan für Sicherheitsfunktionen

• docs/release-process.md – der Weg von Releases zu PyPI – auf PyPI

• docs/adr/ – Architecture Decision Records

• Und als eine weitere Version unter https://devopam.github.io/MCPg/ – abrufbar

Sicherheit

• Meldung von Schwachstellen: siehe SECURITY.md. 90-Tage-Fenster für koordinierte Offenlegung; Meldungen an devopam@gmail.com.

• Verteidigung in der Tiefe: Capability-Gates, SafeSQL-Kernel, Identifier-Allowlist, Audit-Redaktion, PG-TLS-Erzwingung beim Start, Ratenbegrenzung, OIDC-JWT-Validierung, Zeitlimits pro Sitzung.

• Siehe docs/security-hardening.md für die laufende Roadmap der umgesetzten (✅) und geplanten (⬜) Härtungsmaßnahmen.

Datenschutzrichtlinie

MCPg ist selbst gehostet: Ihre Datenbankinhalte verlassen niemals Ihre Infrastruktur, und es gibt keinerlei Telemetrie oder Rückkanal. Die eine dokumentierte Ausnahme ist das optional aktivierbare Tool translate_nl_to_sql, das Ihre Frage plus Schemakontext (Namen, keine Zeilendaten) an den LLM-Anbieter sendet, den Sie konfigurieren. Die vollständige Richtlinie – Datenerfassung, Nutzung, Speicherung, Weitergabe an Dritte, Aufbewahrung und Kontakt – finden Sie in PRIVACY.md.

Versionshinweise & Änderungsprotokoll

Siehe CHANGELOG.md für die vollständige Versionshistorie, docs/release-process.md für den Ablauf der Veröffentlichungen und die GitHub-Releases-Seite für herunterladbare Artefakte.

Mitwirken

Pull-Requests sind willkommen – siehe CONTRIBUTING.md für das Entwicklungs-Setup, die Testkonventionen und die PR-Review-Checkliste.

Lizenz

MIT – siehe LICENSE. Der SQL-Sicherheitskernel (src/mcpg/sql/) ist ein Erste-Partei-Bestandteil, neu verfasst auf Basis des MIT-lizenzierten crystaldba/postgres-mcp; siehe NOTICE für die Herkunft.

Eingebundene Erweiterungen – Lizenzen, die Sie kennen sollten

Der Quellcode von MCPg ist MIT, aber die PostgreSQL-Erweiterungen, die es einbindet, haben jeweils ihre eigene Lizenz. Die Wrapper selbst sind auf Distanz gehalten (Aufrufe auf SQL-Ebene, keine statische oder dynamische Verknüpfung in den Python-Prozess von MCPg), daher ist MCPg-als-Projekt kein abgeleitetes Werk einer dieser Erweiterungen. Betreiber, die einen Dienst auf Basis von MCPg + einer bestimmten Erweiterung bereitstellen, übernehmen die Verpflichtungen, die die Lizenz dieser Erweiterung auferlegt – genauso wie bei einer direkten Installation der Erweiterung. Die folgende Matrix nennt die Lizenz pro eingebundener Erweiterung, damit Sie eine fundierte Entscheidung treffen können.

Diese Matrix ist ein Ausgangspunkt – für die verbindliche Antwort zu Ihrer spezifischen Bereitstellung konsultieren Sie die Upstream-LIZENZ-Datei der Erweiterung und (falls rechtlich relevant) Ihren eigenen Rechtsbeistand.

Haftungsausschluss. Es wurden größte Anstrengungen unternommen, um MCPg auf Produktionsreife zu bringen, aber es bleibt ein aktiv entwickeltes Projekt und kann Fehler enthalten. Siehe die Lizenzbedingungen für Details zur Haftung.