# Thoth Blueprint: a visual database designer that keeps the schema on your machine

> Thoth Blueprint is a browser based schema editor with drag and drop tables, a DBML workflow, exports for SQL, JSON, SVG and PNG, and generated migrations for Laravel, TypeORM and Django. It stores diagrams locally, so the trade-off is local scope rather than a shared database of designs.

**AHS12/thoth-blueprint** — Design databases the way you think. Create unlimited schemas, import existing designs, visualize relationships, export to multiple formats, and generate framework migrations. Offline-first, local by default, with optional cloud or local AI.

- Repository: https://github.com/AHS12/thoth-blueprint
- Website: https://thoth-blueprint.vercel.app
- Stars: 625 · Forks: 53
- Language: TypeScript
- License: GPL-3.0
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/ahs12-thoth-blueprint

## Schema design that never leaves the browser

Thoth Blueprint is aimed at developers who think about a database as a picture before they think about it as DDL. The canvas holds tables, columns, and relationships that you build by dragging from a sidebar or right clicking the workspace, and every diagram you make is stored on your own computer rather than on a service account. The feature list describes the storage model plainly: all data is stored locally on your computer, ensuring complete privacy, and the app works on a diagram with or without an internet connection. The repository topics name IndexedDB and offline support, which fits a Progressive Web App you can install from the browser and keep on your desktop.

That offline-first posture is the defining constraint of the project. There is no mention of a hosted backend, a shared workspace, or a team account in the setup instructions, so a design lives inside one browser profile on one machine. A second laptop does not see it. The alternative approach is the hosted schema service, where designs live in a database owned by someone else and every teammate opens the same URL. Thoth Blueprint trades that shared surface for a model you can inspect, back up yourself, and run from a container you control.

## Importing SQL, DBML, or JSON instead of starting from a blank canvas

The interesting workflow is the reverse direction. Instead of drawing a schema from zero, you bring an existing design in and then keep working on it. Supported inputs are SQL, DBML, and JSON schema, so a design that already exists in a migration file, a DBML repository, or a hand written JSON description can be loaded and edited visually. The DBML path is the most developed one. There is a dedicated DBML editor with diagram sync, meaning a text change in the DBML view is reflected in the diagram and the other way around, and the export side can write DBML back out.

The dependency list backs this up: the package manifest includes @dbml/core alongside CodeMirror packages for SQL editing, which is what a bidirectional DBML text and diagram editor would need. The practical consequence is that you can treat DBML as a source format rather than a one way export. The limitation is equally visible. The project does not describe how an imported SQL file is mapped when the original contains dialect specific syntax, views, triggers, or stored procedures, so anyone planning to round trip a production schema should export and compare before trusting the result.

## Export targets and the migration generator for Laravel, TypeORM and Django

Export is where the design work pays off. The listed targets are SQL, DBML, JSON, SVG, and PNG, which covers three different jobs. SQL is the schema you hand to a database or fold into a migration. JSON is a portable description of the model. SVG and PNG exist for documents, tickets, and design reviews, so a diagram can leave the tool as an image rather than a file only engineers can read.

On top of that sits a framework migration generator that produces migration files for Laravel, TypeORM, and Django. That is the feature that makes the tool more than a drawing program, because a Laravel migration is a PHP class with an up and a down method, a TypeORM migration is a TypeScript class, and a Django migration is a Python module. The generated output has to fit three different conventions, and the documentation does not spell out how a generator handles data backfills, renames, or a table that already exists in the target database. Treat the first generated migration as a draft to read, not as a command to run blind.

An index manager sits beside the export layer. You can create, edit, search, and delete table indexes, including unique and composite indexes, which matters because an export that drops your composite keys silently would be a bad surprise.

## Building the app and serving it from nginx on port 8080

The prerequisites are Node.js 20 or newer and pnpm, with npm as an alternative. A clone, an install, and a dev server get you to a working editor:

```bash
   git clone https://github.com/AHS12/thoth-blueprint.git
   cd thoth-blueprint
```

```bash
   pnpm install
```

```bash
   pnpm dev
```

The dev script runs Vite. For a production build and a local preview of the built assets, the package manifest exposes the usual pair:

```bash
   pnpm build
```

```bash
   pnpm preview
```

A Docker route is documented as well, and the compose file is short enough to read in full. It builds the image from the local Dockerfile, maps host port 8080 to container port 80, and sets production mode:

```yaml
services:
  thothblueprint:
    build: .
    ports:
      - "8080:80"
    restart: unless-stopped
    environment:
      - NODE_ENV=production
```

The image itself is a two stage build on node:20-alpine that compiles the Vite bundle, then copies the output into an nginx:alpine stage with a custom nginx.conf. Once the compose stack is up, the application is served at http://localhost:8080. The same image can be started by hand:

```bash
   docker build -t thothblueprint .
   docker run -d -p 8080:80 --name thothblueprint thothblueprint
```

Note what this container is. It is a static frontend behind nginx with no application server and no database, which is exactly why the local storage story holds.

## Zones, notes, checkpoints, and zone locks for larger diagrams

Once a diagram has more than a dozen tables, the editor leans on organisation features rather than on the canvas alone. Zones group related tables, and a zone can be locked so that edits inside it are blocked, which is the practical way to keep a shared subsystem stable while you work on another part of the design. Right clicking inside a zone adds new tables or notes to that group directly. Notes are plain annotations placed on the diagram to record a decision, so the reasoning behind a schema lives next to the schema.

The checkpoint feature covers the other need. You can save a snapshot of a diagram and restore it later, which gives you a rollback point before experimenting with a restructure. Undo also covers the most common destructive action: the shortcut table lists Undo Delete Table on Ctrl or Cmd plus Z, and a Delete key removes tables, notes, and zones.

Copy and paste is scoped to whole elements. Selecting one or more tables or notes and copying them, then pasting at the cursor, duplicates a table with its column definitions intact. Keyboard shortcuts are listed in the project in a dedicated dialog reachable from the Help Center, so the shortcut reference is meant to be consulted rather than memorised.

## Two assistant routes, from a cloud key to a local Ollama model

The schema assistant comes in two flavours and the difference between them is where your diagram bytes go. The bring your own key route supports Google Gemini and OpenRouter, and provider keys are held encrypted in browser local storage, entered through the assistant settings button. OpenRouter models are pulled from its live catalogue, and the ones you mark as favourites stay at the top of the model picker. Chat history is stored locally per diagram, with a fresh chat action in the assistant header.

The local route is for people who do not want a cloud provider involved. Ollama and LM Studio are supported, and they are keyless: you point the assistant at a local server URL in the settings and then pick any model that server exposes. The prompt describes this as local, keyless AI, and it is the only route where nothing about your schema leaves the machine.

The choice is therefore a privacy decision with a quality trade-off attached. A hosted model will usually be stronger than a model you run on a laptop, and the local route depends on you having already installed and started Ollama or LM Studio. The documentation does not describe a fallback if the local server is unreachable, so treat a stopped local server as a stopped assistant.

## What the project does not cover, and what GPL-3.0 means for adoption

There are real gaps. The project is a single user designer with no server side collaboration, no shared catalogue, and no permissions model. Multi user work is out of scope by design, not by omission, because there is no backend to host it. Cross device use is also awkward: a Progressive Web App installed on a phone keeps its diagrams in that browser profile, so the same design on a desktop and on a phone is two separate stores unless you export and reimport a file.

The licence is GPL-3.0. For a company that only uses the tool to produce schemas, that is largely a non event. It becomes relevant if you plan to modify the source and ship a hosted version of it, since a modified GPL-3.0 application carries source availability obligations. The repository also includes a CODE_OF_CONDUCT.md, a CONTRIBUTING.md, and an AI_RULES.md, and hooks are managed through husky, so contributions go through a documented process.

On upkeep, the version in package.json is 0.0.13 and the tagged releases are 0.0.13, 0.0.12, and 0.0.11, dated 2026-08-12, 2026-08-05, and 2026-05-15. The last push was on 2026-08-12. The 0.0.x numbering and the release dates tell you this is pre-1.0 software with a young API surface, so expect the schema of stored diagrams to change between versions.

## Conclusion

Thoth Blueprint suits a developer who sketches schemas locally, wants to hand a Laravel, TypeORM or Django migration to a colleague, and prefers keeping design files in the browser or a self hosted container rather than on a hosted service. It is the wrong tool for a team that needs a single shared schema catalog, server side accounts or a change history beyond local checkpoints. Before adopting it, open one of your real schemas, import it, export the migration for your framework, and read the result line by line, since the documentation does not describe how generated migrations handle existing tables or destructive changes.

## FAQ

### Does Thoth Blueprint require an account or send my database design to a server?

No account is mentioned anywhere in the setup steps. The feature list states that all data is stored locally on your computer, and the app is described as offline first and Progressive Web App, so a diagram stays in your browser unless you send it to a cloud AI provider through your own Gemini or OpenRouter key.

### Which frameworks can Thoth Blueprint generate database migrations for?

The export section names Laravel, TypeORM, and Django. Migration files can be generated alongside SQL, DBML, JSON, SVG, and PNG exports, and the assistant can also work on schemas for these frameworks.

### Can I use Thoth Blueprint with a local AI model instead of Gemini or OpenRouter?

Yes. Ollama and LM Studio are supported for local, keyless AI, and you set the local server URL in the assistant settings and pick any model that server exposes. The project also offers a checkpoint feature, so you can save and restore diagram snapshots while experimenting.

## Sources

- [AHS12/thoth-blueprint on GitHub](https://github.com/AHS12/thoth-blueprint)
- [License: GPL-3.0](https://github.com/AHS12/thoth-blueprint/blob/main/LICENSE)
- [Project website](https://thoth-blueprint.vercel.app)
- [README](https://github.com/AHS12/thoth-blueprint/blob/main/README.md)
- [Releases](https://github.com/AHS12/thoth-blueprint/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ahs12-thoth-blueprint