Know the Impact
Before You Change Production
Schemity is database design software that turns your live database into a local architecture map. Review every schema change, yours or your AI agent's, with lint, dependency impact, and exact migration SQL before it is applied, then design the next one. No schema upload, no subscription.
2-week trial, all features unlocked, no credit card. See all platforms
PostgreSQL
Supabase
MySQL
MariaDB
SQL Server
SQLite
Understand your schema, see the impact of every change, design the next one.
From a Legacy Database to a Domain Map in Four Steps
You bring the database and the codebase. Your AI agent does the reading. Schemity gives you both the same schema, and keeps every change reviewable.
-
Connect the database
Schemity draws every table at once. Missing foreign keys are inferred from column names and drawn dashed.
-
Ask your agent to organize it
Open Claude Code, or any AI agent, in your codebase and ask it to group the tables by domain. It reads your code, and reads the schema from Schemity over MCP.
-
Review what it did
The agent groups tables into legends on your open diagram. Every step is in History, one undo away. Nothing is saved until you save.
-
Read the module dependencies
Turn the legends into context views in one click, then open the Context Map: each domain is a node, and each arrow counts the real foreign keys between them.
Read how context views give each domain its own view of one schema, and how inferred relations draw the foreign keys a database never declared. For the map itself, read the Context Map documentation or the deep dive on deriving a DDD context map from your foreign keys.
Whatever Your Agent Changes, You See It Before It Runs
An agent can edit the diagram, or write a schema migration in your codebase the way your ORM does. Either way, the change passes through the same checkpoints as your own.
-
The agent proposes
It edits the open diagram or writes a migration file in your codebase. Deletes ask you first, and it never holds database credentials.
-
You see it drawn
Schemity draws the change without running it: dropped tables in red, new ones in green, changed columns tinted. A rename written as DROP and ADD shows as exactly that.
-
You read the cost
Planned changes lists the migration in words. Impact shows what it does to real data: lost rows, failing statements, table rewrites, and dependent views.
-
Only you migrate
Nothing writes to the database until you click Migrate. On a Production connection, you type the database name first.
Your agent gets the same understanding you do. You keep the only key to the database.
See what impact analysis reports before a schema migration runs.
What Your Agent Can Use
Schemity is a local database MCP server with 16 tools. Reads are free and never change anything; drawings are throwaway; edits are staged for you to review.
Understand
- The schema: entities, fields, keys, and relations
- Context views and the dependencies between them, cycles included
- The data dictionary, descriptions included
- Schema lint findings
Measure
- Pending changes on a connected diagram
- Impact analysis: data loss, failing statements, rewrites, dependents
- Exact row counts, only when asked
- Migration files from Prisma, Alembic, or Flyway, never executed
Show
- Draw a migration file as a read-only change preview
- Draw a set of tables it wants to point at
- Open Schemity when it is not running
- Mark which diagram tab is active
Organize and propose
- Stage entities, fields, and relations
- Group entities into legends
- Route relations around the tables
- Check which relation lines overlap or cross
Works with Claude Code, Claude Desktop, Cursor, Codex, OpenCode, or any MCP host. The server listens only on your machine, and its token lives in your OS keychain. Read the setup guide.
Claude Code, one command (on macOS; the MCP panel gives the path for your platform):
claude mcp add --scope user schemity -- "/Applications/Schemity.app/Contents/MacOS/schemity" --mcpEverything the Agent Does, You Can Do Yourself
Smart defaults, drag-and-drop relationships, and a keyboard-first editor, so the diagram is yours to shape whether or not an agent is in the loop.
Smart Relationships
Create 1:N, 1:1, or N:N relationships with simple drag-and-drop. Auto junction table generation, auto FK naming - no manual wiring needed.
Import SQL/DBML
Import CREATE TABLE statements, a SQL dump file, or a DBML file. Schemity builds entities, fields, and relationships automatically - no database connection needed. Export back to DBML anytime.
Virtual & Inferred Relations
Document foreign keys the database never declared, drawn dashed and never written back.
Schema Lint
Twenty-six classes of schema problem, marked on the diagram itself.
Relations That Explain Themselves
A description written on the line says why the relation exists.
Check Constraints as Documentation
Fields with an IN constraint are underlined, with their allowed values one keystroke away.
Clear Unique Together
Composite unique constraints render as named, color-coded badges.
Flexible Routing
Route every line around the tables in one step, or shape one by hand with waypoints.
Data Dictionary Export
Export the documented schema as HTML, Markdown, or Excel.
Tabs and PostgreSQL Schemas
Open several diagrams at once, and model across schemas, not just public.
Why You Can Let an Agent Near Your Schema
Most database design software is a drawing canvas that lives in a browser. Schemity is a desktop app wired to the database it describes, and every property below holds whether the hands on the diagram are yours or an agent's.
It reads your database, and keeps up with it
Database design software in the browser takes your schema as text you paste in, so the diagram starts drifting the moment the next migration lands. Schemity opens a real connection, reverse engineers the schema, and re-syncs every time you open the diagram: entities keep the layout you gave them, dropped tables disappear, and new ones arrive ready to place.
The diagram is a file you own
Schemity writes plain JSON into a folder you choose, so a reorganization by your agent is reviewed in a pull request as a diff, like any other change: versioned, branched, and revertible.
You can only draw what a database would accept
Most canvases let you join any column to any column and pick a cardinality from a menu. In Schemity a foreign key targets the parent's primary key, cardinality follows that key's uniqueness, referential actions are set per relationship, and duplicate table names are refused - so a diagram that looks valid is valid.
Your agent gets Schemity, not your credentials
Most database MCP servers hand the agent a connection string and run whatever SQL it writes. Schemity is the governed path instead: a local server, no vendor cloud in the middle, and the schema goes only where your agent already sends your code, or nowhere at all with a local model. A migration it writes in your codebase is drawn here before you run it.
One purchase, and no meter on your model
Subscription tools price per seat and cap how many tables you may model, which quietly changes how you design. Schemity is a one-time purchase, with no limit on tables, diagrams, workspaces, or Context Views - and no reason to merge two entities to stay under a quota.
Nothing for us to leak
We store an auto-generated device ID and your country, for licensing and regional support, and nothing that identifies you. Payments go through LemonSqueezy, so a SOC 2 or ISO 27001 review finds almost nothing to review.
Coming from a specific tool? Read the honest comparison: ChartDB, dbdiagram.io, DbSchema, DrawSQL, or Lucidchart.
Explore a Real Schema in Your Browser
No install: pan and zoom a PostgreSQL schema in Schemity Lite, or download the desktop app for your platform.
A live ERD you can pan and zoom - a PostgreSQL schema in Schemity Lite, the browser version. The desktop app adds live database connections and Git-friendly JSON files stored on your own machine.
macOS
Windows
Linux
Browser
Give your agent the schema. Keep the key to the database.
One-time purchase. Two-week trial with every feature unlocked, no credit card, and your diagrams stay yours whether you buy or not.
Notes on Schema Design and ERD Perspectives
Working notes on context views, ERD best practices for software engineers, and the principles behind keeping an ERD in Git. The latest few posts.
