Sixta Connect
Connect Pro is live · Free tier + 14-day trial · MySQL & PostgreSQL · In your editor and your CI/CD

Ship SQL like you have a DBA

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.
75% → 100%

critical-issue recall: weakest model alone → recommended tiers with SIXTA.

~7% → 0%

unsafe migrations approved: worst bare-model baseline → connected, every tier, every run.

~14 → 0

flatly wrong answers per run: budget model alone → recommended tiers with SIXTA.

Best and worst cases across model tiers; the full per-model table is on the benchmarks page. 129 cases, graded blind, averaged across runs.

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.

AI sounds confident about SQL. Your database isn't impressed.

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. A very fast junior dev, with a very strict reviewer.

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.

In your editor in three steps

  1. 1. Add the SIXTA URL to your editor.
  2. 2. Sign in once when it pops up. One click with Google, or an email link.
  3. 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.

https://connect.sixta.ai/mcp

Cursor

One click. Cursor opens its add-server dialog pre-filled, then you sign in:

Add SIXTA to Cursor

Or add https://connect.sixta.ai/mcp by hand as an MCP server (just the url, no headers).

Claude Code

claude mcp add --transport http sixta https://connect.sixta.ai/mcp

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 <your-key>"

Cursor: ~/.cursor/mcp.json

{
  "mcpServers": {
    "sixta": { "url": "https://connect.sixta.ai/mcp", "headers": { "Authorization": "Bearer <your-key>" } }
  }
}

VS Code (Copilot): .vscode/mcp.json

{
  "servers": {
    "sixta": { "type": "http", "url": "https://connect.sixta.ai/mcp", "headers": { "Authorization": "Bearer <your-key>" } }
  }
}

Windsurf: ~/.codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "sixta": { "serverUrl": "https://connect.sixta.ai/mcp", "headers": { "Authorization": "Bearer <your-key>" } }
  }
}

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=<your-key>

Claude web / Desktop (add a custom connector)

The connector UI can't send headers, so the key goes in the URL:

https://connect.sixta.ai/mcp/<your-key>

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:

- uses: sixta-systems/sixta-ci@v1
  with:
    engine_version: "16"

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. 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?

You start by pasting SQL, free. Connect Pro is the next step, reading your database on demand. The full SIXTA platform is the last: an autonomous DBRE that joins your team, 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.