SQL-Sicherheits- & Kosten-Orakel

Das Urteil vor der Query.

Ein deterministischer Sicherheits- & Kosten-Check, den dein KI-Agent aufruft, bevor er SQL ausführt — mit stabilen Finding-IDs, auf die du deine CI hart gaten kannst.

deterministisch kein LLM im Loop verbindet sich nie mit deiner DB
analyze_sql
# dein Agent hat geschrieben:
DELETE FROM users;
● block
{
  "verdict": "block",
  "findings": [{
    "id": "destructive.delete_without_where",
    "severity": "block",
    "recommendation": "Add a WHERE clause, or confirm
                       a full-table delete is intended."
  }]
}
Im Loop mit Claude Code Cursor Postgres MCP GitHub CI

So funktioniert's

Deterministisch, sobald du fragst.

  1. 01

    Agent schreibt SQL

    Dein Agent ruft analyze_sql über /mcp auf, bevor er irgendetwas ausführt.

  2. 02

    Veto prüft es

    Deterministische Regeln laufen auf jedem Statement. Gibst du ein Schema an, bekommst du zusätzlich eine echte EXPLAIN-Kostenschätzung auf einem wegwerfbaren Scratch-Postgres; deine Produktiv-DB wird nie angefasst.

  3. 03

    Urteil kommt zurück

    Ein strukturiertes ok / warn / block-Urteil mit Finding-IDs, bevor die Query läuft.

Mach es verbindlich. Das Urteil ist deterministisch, sobald du fragst — aber ein Tool, das der Agent aufruft, ist beratend, bis du es einbindest. Lass deine CI bei einem block fehlschlagen (die Finding-IDs sind stabil) und weise deinen Agenten an, immer zuerst zu prüfen. Ein Proxy, der jedes Statement zwingend durch Veto schickt — nicht umgehbar, selbst von einem fehlerhaften Agenten — ist auf der Roadmap.

Urteile

Ein Vertrag. Drei Zustände.

● ok
SELECT … LIMIT 100

Sicher auszuführen. Geht ohne Reibung durch.

● warn
ALTER TABLE orders ALTER COLUMN id TYPE bigint

Risiko eines schweren Locks oder ein großer Sequential Scan. Du entscheidest.

● block
DELETE FROM users

Destruktiv ohne Schutz. Gestoppt, bevor es läuft.

Demo

Es hat die Migration geblockt. Du hast nie das Postmortem geschrieben.

Gleicher Input, gleiches Urteil — jedes Mal. Deterministische Findings mit stabilen IDs, auf die du deine CI gaten kannst.

Über MCP verbinden
analyze_sql · response
# DROP TABLE invoices;
● block
{
  "verdict": "block",
  "findings": [{
    "id": "destructive.drop",
    "severity": "block",
    "recommendation": "Confirm the object is unused;
                       consider renaming first as a
                       safer rollback path."
  }]
}

Warum Veto

Die langweilige, zuverlässige Schicht, auf die du setzt.

  • Deterministisch

    Gleiches Statement, gleiches Urteil — jedes Mal. Kein Model-Drift, voll reproduzierbar.

  • Kein LLM im Loop

    Regeln + Query-Planung, kein Prompt. Keine Tokens, keine Latenz, keine halluzinierten Freigaben.

  • Fasst nie deine DB an

    Kostenschätzungen laufen auf einem Scratch-Postgres via BEGIN … ROLLBACK. Die Produktion wird nie verbunden.

  • Gegen Golden Evals gegatet

    Stabile Finding-IDs und Golden Cases in der CI — ein Vertrag, dem du über die Zeit vertrauen kannst.

FAQ

Fragen, beantwortet.

Verbindet sich Veto mit meiner Datenbank? +

Nein. Veto verbindet sich nie mit deiner Produktiv-Datenbank. Kosten- und Plan-Schätzungen laufen auf einem wegwerfbaren Scratch-Postgres innerhalb einer Transaktion, die immer zurückgerollt wird.

Trifft ein LLM die Entscheidung? +

Nein. Das Urteil wird von deterministischen Regeln und Query-Plan-Analyse erzeugt — nicht von einem Modell. Gleicher Input liefert immer das gleiche Urteil.

Wie ruft mein Agent es auf? +

Verbinde dich über MCP unter /mcp und stelle das analyze_sql-Tool bereit. Dein Agent fragt ein Urteil an, bevor er irgendein Statement ausführt.

Ist Veto ein hartes Gate oder beratend? +

Beides — es kommt darauf an, wie du es einbindest, und das sagen wir lieber offen. Das Urteil ist deterministisch: gleiches SQL liefert immer dasselbe ok / warn / block, ohne LLM im Loop. Standardmäßig ruft dein Agent analyze_sql auf und entscheidet selbst, was er mit der Antwort macht — also ist es beratend, ein deterministisches Sicherheitsnetz, kein Interceptor im Datenpfad. Um es verbindlich zu machen: lass deine CI bei den stabilen Finding-IDs gaten (Build bei einem block fehlschlagen lassen) und weise deinen Agenten an, immer zuerst zu prüfen. Ein Proxy, der jedes Statement zwingend durch Veto schickt — nicht umgehbar, selbst von einem fehlerhaften Agenten — ist auf der Roadmap. Veto ist genau so verbindlich wie der Schritt, in den du es einbaust.

Was verlässt meine Maschine, und was speichert ihr? +

Dein SQL — und dein Schema-DDL, falls du es für die Kostenanalyse angibst — wird über TLS an den gehosteten Endpoint gesendet, im Speicher analysiert und verworfen. Wir speichern nur Analytics-Metadaten: das Urteil, welche Regel-IDs ausgelöst haben, ob ein Schema angegeben wurde und die Latenz. Niemals dein SQL, dein Schema oder deine Tabellennamen. Self-Hosting, das Egress vollständig eliminiert, ist auf der Roadmap.

Was deckt es ab? +

Destruktive Statements (ungescopte DELETE/UPDATE, DDL-Drops, in CTEs versteckte Anweisungen), Korrektheitsfallen (NULL-Vergleiche wie = NULL, NOT IN mit einer Subquery, LEFT JOINs, die still zu Inner Joins werden) und Kostenrisiken (große Sequential Scans, fehlende Indizes). Der Scope ist bewusst eng und zuverlässig statt breit und schwammig.

Blockt es fälschlich meine Routine-Migrationen? +

Nein. Die Regeln sind reines Postgres — jede Datenbank (Supabase, Neon, RDS, self-hosted) und jedes Migrations-Tool. Auf echten Migrationen getunt: Routine-DROP POLICY / DROP INDEX / DROP FUNCTION und lock-leichte ALTERs (RLS aktivieren, eine nullable Spalte hinzufügen) kommen als ok oder warn zurück — nur echter Datenverlust (DROP TABLE, TRUNCATE, ungeschütztes DELETE/UPDATE) blockt. Ein Schutzmechanismus, den du tatsächlich eingeschaltet lässt.

Was sind eigene Org-Richtlinien? +

Ein Pro-Feature, das Veto von einem Linter zu einer Governance-Schicht macht. Die eingebauten Regeln sind für alle gleich — sie wissen nicht, dass payments in deiner Datenbank heilig ist. Benutzerdefinierte Policies lassen dein Team eigene Regeln hinzufügen ("niemals DELETE aus payments", "kein TRUNCATE auf audit_*"), und Veto setzt sie zusätzlich zu den eingebauten durch. Policies sind deklarative Daten — validiert, nie ausgeführt — damit das Sicherheits-Tool nicht selbst zum Injection-Loch wird.

Wie richte ich eigene Org-Richtlinien ein? +

Sag es deinem Agenten in einfacher Sprache, und er erzeugt das deklarative JSON und ruft das Tool set_policies mit deinem Pro-Key auf. Richtlinien werden am Key gespeichert, sodass jeder spätere analyze_sql-Aufruf mit diesem Key sie automatisch durchsetzt — kein Web-Login, keine Konfiguration pro Aufruf.

Preise

Heute kostenlos. Mehr, wenn du es brauchst.

Free €0
  • Vollständiges deterministisches Urteil — jede Regel
  • Destruktiv-, Locking-, Korrektheits- & Kostenanalyse (CTE-fähig)
  • Verbindet sich nie mit deiner Datenbank
  • MCP-Endpoint mit stabilen Finding-IDs
  • 60 Requests / Min.
Pro €9.90/Mon.
  • Benutzerdefinierte Org-Policies — deine Regeln auf deinen Tabellen, zusätzlich zu den eingebauten durchgesetzt. z.B. no DELETE on payments.
  • 1200 Requests / Min. — 20× das Free-Limit
  • Direkter Support vom Maintainer
  • Früher Zugang & Mitsprache, was als Nächstes kommt

Auf der Roadmap, finanziert durch Pro: ein Audit- & Nutzungs-Dashboard, ein Proxy, der jedes Statement zwingend durch Veto schickt, ein Embed-SDK / Self-Hosting.

Pro abonnieren

Dein Agent wird Prod nicht droppen.

Richte deinen MCP-Client auf den Endpoint — kostenlos in Sekunden. Füge deinen Pro-Key für 1200 Req./Min. und benutzerdefinierte Org-Policies hinzu.

.mcp.json
{
  "mcpServers": {
    "veto": { "url": "https://vetosql.com/mcp" }
  }
}

Jeder MCP-Client — Claude Code, Cursor, … Free-Tier, kein Key, 60 Req./Min.

Noch keinen Key? Hol dir deinen Pro-Key →

Dein Key bleibt in deinem Browser — nichts wird gesendet oder gespeichert. Behalte das Wort Bearer und das Leerzeichen.

Claude Code · .mcp.json
{
  "mcpServers": {
    "veto": {
      "type": "http",
      "url": "https://vetosql.com/mcp",
      "headers": { "Authorization": "Bearer VETO-…" }
    }
  }
}
Cursor · ~/.cursor/mcp.json
{
  "mcpServers": {
    "veto": {
      "url": "https://vetosql.com/mcp",
      "headers": { "Authorization": "Bearer VETO-…" }
    }
  }
}
  1. Verbunden — lass deinen Agenten ein DROP TABLE test; mit analyze_sql prüfen → ein block bedeutet, dass Veto eingebunden ist. (funktioniert auch mit Free)
  2. Pro ist live — lass ihn set_policies aufrufen (block delete auf payments), dann ein DELETE FROM payments mit analyze_sql prüfen → ein policy.violation-Block beweist, dass dein Key Pro freigeschaltet hat. (Free-Keys können keine Policies setzen)
set_policies · Pro
# sag es deinem Agenten, in einfacher Sprache:
"never let anything DELETE from payments"
# it calls set_policies with your Pro key →
{
  "policies": [
    { "table": "payments", "operations": ["delete"],
      "action": "block" }
  ]
}

Am Key gespeichert — jeder spätere analyze_sql-Aufruf setzt sie durch. Kein Web-Login.

ausgeliefert mit Sicherheitsgurt