An ERD MCP Server: AI Agents That Follow Your Naming Standard

AI agents already write database schemas. Ask Claude or Cursor for a feature and the migration file comes back with tables, columns, and foreign keys — named however the model's training data leans that day. user_id here, userId there, usr_no when it read one too many legacy dumps. The agent isn't wrong; it just has no idea your team writes cust_no, because your naming convention lives in a wiki the model has never seen.

That's the actual problem an ERD MCP server solves. Not "AI can draw diagrams now" — but that schema work done by agents can follow the same standard as schema work done by people. This post explains what sqemo-mcp does, how the naming part works, and — in the same honest-comparison spirit as our dbdiagram comparison — what it doesn't do yet.

What an MCP server is, in one paragraph

MCP (Model Context Protocol) is the open standard for giving AI agents tools. A server exposes typed operations — "list entities," "add an attribute," "export SQL" — and any MCP-capable client (Claude Code, Claude Desktop, Cursor, Codex, and a growing list) can call them. Instead of the agent hallucinating your schema from half-remembered context, it reads the real one and edits it through operations that enforce your rules.

What an agent can do with your ERD

sqemo-mcp exposes 36 tools over your ERD files. Grouped by what they're for:

• Read and edit the model. get_erd_overview, get_entity, upsert_entity, upsert_attribute, upsert_relationship, and their delete counterparts. The agent works on the same .erd.json file you edit in the app — one source of truth, not a parallel copy.
• Import and export. import_sql and export_sql in seven dialects (MySQL, PostgreSQL, Oracle, SQL Server, SQLite, H2, CUBRID), plus DBML both ways. Paste a raw pg_dump -s or mysqldump output and it parses. "Import this legacy dump and normalize the names against our word list" is a one-prompt task.
• Generate and check names. generate_physical_name, check_naming, search_dictionary — more on these below, because they're the point.
• Quality and hygiene. lint_erd, validate_erd, diff_erds, auto_layout.
• Propose, don't decree. When the agent needs a word that isn't in the team word list, propose_dictionary_word files a proposal into the team's approval queue instead of silently inventing an abbreviation. A human approves it; then it's standard.

Why the naming tools are the interesting part

Most schema tools treat names as free text, so an agent's naming is only as good as its prompt. Sqemo treats the physical name as computed: you register a word list (customer → cust, number → no) and naming rules once, and the physical column name is generated from the logical one — same input, same output, for humans and agents alike.

That changes what the agent is asked to do. It doesn't guess that your team abbreviates "customer" as cust — it says "Customer Number" and generate_physical_name returns cust_no, per your rules, deterministically. And because the correct name is computable, drift is detectable: check_naming and lint_erd flag any column that deviates from what the word list would generate. The agent's output is held to the same standard as a human's — mechanically, not by code-review vigilance. If you want the fuller argument for generating names from a word list, that's its own post.

Setup

Node.js 22+, no install — it runs via npx. For Claude Code, add to .mcp.json at your project root:

{
  "mcpServers": {
    "sqemo": { "command": "npx", "args": ["-y", "sqemo-mcp"] }
  }
}

Claude Desktop and most other clients take the same mcpServers JSON; the docs page has per-client paths. Local .erd.json files work fully offline with no account. To let an agent touch ERDs saved on the Sqemo server, sign in once with npx sqemo-mcp login — credentials are stored locally, and your password itself never is.

The same enforcement, without an agent

The package doubles as a plain CLI, which is how the standard reaches CI:

npx sqemo-mcp lint schema.erd.json   # exit code 1 on naming violations

Put that in a GitHub Action and a pull request that drifts from the word list fails the build — the same check the agent runs interactively, enforced mechanically on every merge. There's also export for generating SQL or DBML in a pipeline. If you're deciding what artifact should be the source of truth in the first place, we wrote about DBML vs SQL DDL — the .erd.json model sits a layer above both, and the CLI derives either from it.

What it doesn't do (yet)

Honest limits, so you can decide with eyes open:

• It's a local stdio server, not a hosted one. It runs on your machine via npx. There's no remote HTTPS endpoint yet, so clients that only support hosted MCP servers can't connect — remote MCP is on our roadmap, not shipped.
• The server code is open, the app isn't. The MCP server is on npm and the official MCP Registry (io.github.sqemo/sqemo); the web app itself is not open source.
• Three tools are paid. export_alter_sql (migration ALTER scripts from a baseline diff) and the two live-database tools, introspect_db and check_db_drift (checking the ERD against a real database), are Pro features ($9/mo). The other 33 tools, including everything above, work on the free plan.

Where this fits

If your schema work is entirely human and entirely solo, an MCP server is a nice-to-have. The moment either stops being true — an agent writes your migrations, or more than one person names columns — the question becomes how the standard gets enforced. Our answer: make the correct name computable, then let humans, CI, and agents all be checked against the same computation. Try it in the app (no signup), or point your agent at npx sqemo-mcp and ask it to import your schema. If you'd rather see the whole thing end to end first, the walkthrough goes from an empty project to standards-compliant DDL — including the case most tools get wrong, a post that replies to another post. It's also a three-and-a-half-minute video, if reading is not your thing today.

FAQ

What is an ERD MCP server?

An MCP (Model Context Protocol) server that exposes your entity-relationship diagram to AI agents as typed tools — list entities, add an attribute, import SQL, export DBML, check a name against the naming standard — so the agent reads and edits the real model instead of guessing the schema from context.

Which AI clients work with sqemo-mcp?

Any MCP-capable client that supports local stdio servers: Claude Code, Claude Desktop, Codex CLI, Cursor, and others. It runs via npx (Node.js 22 or later) with a one-line mcpServers entry; no separate install.

Is the Sqemo MCP server free?

Yes. 33 of its 36 tools, including import, export, naming generation, and lint, work on the free plan with no account for local .erd.json files. Three tools are Pro ($9/month): export_alter_sql, introspect_db, and check_db_drift.

Is it a hosted (remote) MCP server?

Not yet. sqemo-mcp is a local stdio server that runs on your machine via npx. Clients that only support hosted HTTPS MCP endpoints can't connect today; remote MCP is on the roadmap.

---

Originally published at sqemo.com. Sqemo is an ERD tool that enforces database naming conventions — free in the browser, no signup.