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

> Source: <https://dev.to/donghyun_park_c71ad9463c6/an-erd-mcp-server-ai-agents-that-follow-your-naming-standard-5dee>
> Published: 2026-08-28 01:04:15+00:00

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](https://www.npmjs.com/package/sqemo-mcp) does, how the naming part works, and — in the same honest-comparison spirit as our [dbdiagram comparison](https://sqemo.com/blog/dbdiagram-alternative) — what it doesn't do yet.

[MCP (Model Context Protocol)](https://modelcontextprotocol.io) 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.

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

`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 `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_physical_name`

, `check_naming`

, `search_dictionary`

— more on these below, because they're the point.`lint_erd`

, `validate_erd`

, `diff_erds`

, `auto_layout`

.`propose_dictionary_word`

files a proposal into the team's 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](https://sqemo.com/blog/database-naming-conventions).

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](https://sqemo.com/docs/mcp) 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 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](https://sqemo.com/blog/dbml-vs-sql-ddl) — the `.erd.json`

model sits a layer above both, and the CLI derives either from it.

Honest limits, so you can decide with eyes open:

`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.`io.github.sqemo/sqemo`

); the web app itself is not open source.`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.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](https://app.sqemo.com) (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](https://sqemo.com/docs/ai-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](https://youtu.be/MqHWtiHfBI0), if reading is not your thing today.

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