SIXTA Connect
Database Reliability Engineer-grade SQL analysis inside any MCP client
Documentation
Connect Pro is live · Free tier + 14-day trial · MySQL & PostgreSQL · In your editor and your CI/CD
Ship DBA reviewed SQL
The database engineer you'd call at 11pm, on demand.
No DBA on your team, or one who's far too busy to ask? SIXTA Connect reviews your queries, plans, and migrations two ways: in your editor while you write, and in your CI/CD pipeline before a risky change merges. It tells you what's wrong, how bad it is, and gives you a safer version to run. Or tells you it's clean. No tickets, no waiting.
Get your free key
One free key, no password. Add it to your editor or your pipeline in about 30 seconds.
Connect your editor
Add one URL, sign in once, and ask about any SQL. Thirteen analysis tools at your cursor, in Claude, Cursor, VS Code, Windsurf, or Codex.
claude mcp add --transport http sixta https://connect.sixta.ai/mcp
Add to your editor →
One-click sign-in, no key to copy. What the 13 tools do →
Gate your pipeline
The same analysis on every pull or merge request: a review comment, inline findings, and a build that fails on danger. GitHub and GitLab.
- uses: sixta-systems/sixta-ci@v1 with: engine_version: "16"
Set up CI/CD →
Django, Alembic, Spring Boot (Flyway, Liquibase), and plain .sql migrations. Why gate in CI →
Two front doors, one free key, the same verdicts.
You know the moment your cursor hovers over Run and you think, "this probably won't lock the whole table"? That's where SIXTA sits. Paste it first.
0%
unsafe migrations approved with SIXTA connected: 0 of 75 graded runs, every model tier.
100%
critical-issue recall with SIXTA on the recommended model tiers, every run.
129
cases across MySQL and PostgreSQL, graded blind by a three-model panel, averaged over repeated runs.
How we measure, including what SIXTA adds over a model answering alone, is on the benchmarks page.
Ask it what you'd ask a DBA
“Is this migration safe?”
The exact lock, what it blocks, and a safe rollout for your engine and version.
“Why is this query slow?”
The anti-pattern or plan problem, with a ready-to-run, self-checked rewrite.
“Can I drop this index?”
Which indexes are dead weight, with the exact DROP and what it saves.
Paste any SQL artifact. It picks the right tool.
A slow query
The index it needs, plus a self-verified rewrite.
An EXPLAIN plan
Full scans, spilling sorts, bad estimates.
A migration
Lock level and the safe online path, version-aware.
A slow query log
Ranked by total time: where your DB time goes.
A deadlock dump
The lock cycle, the victim, the ordering fix.
Schema DDL
Redundant indexes to drop, with the statements.
An ORM trace
N+1 patterns with the eager-load fix.
SQL to review
GRANT ALL, SECURITY DEFINER, CVV storage.
Your AI assistant knows SQL. It doesn't know your database.
Let your assistant draft SQL freely. SIXTA sits between the model and your database, putting every query, plan, and migration it suggests through the same deterministic checks a DBA would. SIXTA runs with frontier models, not against them: the model brings the language, SIXTA brings the database judgment. On Pro, that judgment is grounded in your real tables, indexes, and replication lag.
Every report signs its work.
If we can't prove it, we won't call it safe.
Every migration you run bets your reputation on what it does in production. SIXTA is built to be the part of your stack that keeps its promise: named findings, a severity, the stakes in plain numbers, and exactly what to change. Deterministic, grounded in the plan, and honest when it doesn't know. You don't get vibes. You get a report.
And every report is written to be learned from: what was checked, what was ruled out, why. Turn SIXTA off tomorrow and your team keeps everything it taught them.
In your editor in three steps
- 1. Add the SIXTA URL to your editor.
- 2. Sign in once when it pops up. One click with Google, or an email link.
- 3. Ask about any SQL. It calls SIXTA on its own.
Add this one URL as a remote MCP server. Your editor opens a sign-in once (one click with Google or GitHub, or an email link), then you're connected. Nothing to copy and paste.
Cursor
One click. Cursor opens its add-server dialog pre-filled, then you sign in:
Or add https://connect.sixta.ai/mcp by hand as an MCP server (just the url, no headers).
Claude Code
Claude web / Desktop
Settings → Connectors → Add custom connector → paste the URL → sign in.
VS Code / Windsurf
Add https://connect.sixta.ai/mcp as an MCP server (just the url, no headers). The sign-in opens automatically.
Once connected, just ask in plain language ("is this migration safe?", "why is this slow?"); your model picks the right SIXTA tool. See all 13 tools and when to reach for each →
Prefer an API key? (clients without the sign-in popup, or CI)
Create a free key and paste it into the connector config. Works in any MCP client.
Claude Code
claude mcp add --transport http sixta https://connect.sixta.ai/mcp --header "Authorization: Bearer "
Cursor: ~/.cursor/mcp.json
{ "mcpServers": { "sixta": { "url": "https://connect.sixta.ai/mcp", "headers": { "Authorization": "Bearer " } } } }
VS Code (Copilot): .vscode/mcp.json
{ "servers": { "sixta": { "type": "http", "url": "https://connect.sixta.ai/mcp", "headers": { "Authorization": "Bearer " } } } }
Windsurf: ~/.codeium/windsurf/mcp_config.json
{ "mcpServers": { "sixta": { "serverUrl": "https://connect.sixta.ai/mcp", "headers": { "Authorization": "Bearer " } } } }
Codex CLI: ~/.codex/config.toml
experimental_use_rmcp_client = true
[mcp_servers.sixta] url = "https://connect.sixta.ai/mcp" bearer_token_env_var = "SIXTA_KEY" # then in your shell: export SIXTA_KEY=
Claude web / Desktop (add a custom connector)
The connector UI can't send headers, so the key goes in the URL:
Your key goes in the config above. Get a free key → if you don't have one yet.
In your CI/CD pipeline
The same analysis, on every pull or merge request. Block a risky migration before it merges: SIXTA reviews every changed migration and .sql file, comments the findings, and gates the build on the verdict. No MCP client, no parsing prose.
GitHub: install the GitHub App, link it, done. Plain .sql migrations (Flyway, Prisma, and friends) get the full report comment and a SIXTA review check by sixta-connect[bot] with nothing else to configure. Django, Alembic, and Spring Boot render in CI, so they add the workflow:
GitLab: a merge-request comment, inline findings on the diff (Code Quality), and a pipeline gate.
include:
- component: gitlab.com/sixta-systems/sixta-ci/sixta-review@0.8 inputs: engine_version: "16"
Works on Django, Alembic, Flyway, and Liquibase migrations, plain .sql files (Prisma and friends), and native SQL inside Java code (@Query, JdbcTemplate, MyBatis mappers); Django and Alembic projects add a setup input. Identical migrations on a re-run are served from cache and don't count against your quota. The full CI/CD setup walks through both paths step by step; the CI gate explained covers what it checks and why. Find us on the GitHub Marketplace and the GitLab CI/CD Catalog, or get a free key →
Safe to try, safe to trust
Start free, grow into it. The free tier works from the SQL you paste: no database credentials, no access to your systems. Connect Pro is the next step, a read-only connection that grounds verdicts in your live database on demand, in your editor and CI. The full SIXTA platform is the step after that: an autonomous DBRE that watches continuously and acts.
Nothing stored. What you paste is analyzed in memory and never persisted. The Pro connection is read-only and collects derived statistics only: schema names, sizes, index metadata, replication lag. No rows, no column values, no query text, ever. See the data-handling statement.
Deterministic verdicts. The same artifact gives the same answer every time, from version-aware rules. The model relays the findings, it doesn't invent them.
Self-checked fixes. Every rewrite is re-analyzed against the same rules before it reaches you, and flagged if it isn't clean.
We built SIXTA Connect so you don't have to tiptoe around SQL. The goal: turn the developer who inherited the database by accident into the one their team trusts with the scary stuff.
Ready for a DBA that watches your live systems?
Anything can tell you what locks a table. Free tells you what's dangerous in any database. Connect Pro tells you what's dangerous in yours: your real table sizes, your indexes, your replication lag, read-only and on demand. The full SIXTA platform is the step after: an autonomous DBRE that joins your team, learns your environment on the job, plugs into your live databases and observability, investigates incidents on its own, and posts root cause and a fix to Slack for your approval. From $40/db/mo.
See the SIXTA platform →
Free tier: best-effort, no SLA; limits may change. Connect Pro is live: verdicts grounded in your live database, priced per connected writer, with a 14-day free trial (pricing). The AI synthesis in sixta_diagnose runs on a limited daily budget; when it's exhausted, SIXTA falls back to its deterministic analysis and the other tools are unaffected. Benchmark figures are from our own 129-case suite, averaged across runs; method on the Benchmarks page.