# Schemaforge

> Bidirectional ORM schema conversion across 11 formats (SQLAlchemy, Django, Prisma, etc.)

- **Type:** MCP server
- **Install:** `agentstack add mcp-coding-dev-tools-schemaforge`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Coding-Dev-Tools](https://agentstack.voostack.com/s/coding-dev-tools)
- **Installs:** 0
- **Category:** [Databases](https://agentstack.voostack.com/c/databases)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [Coding-Dev-Tools](https://github.com/Coding-Dev-Tools)
- **Source:** https://github.com/Coding-Dev-Tools/schemaforge
- **Website:** https://coding-dev-tools.github.io/devforge/

## Install

```sh
agentstack add mcp-coding-dev-tools-schemaforge
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# SchemaForge

> **Bidirectional ORM schema converter** — convert between SQL DDL, Prisma, Drizzle, TypeORM, Django, SQLAlchemy, Alembic migrations, JSON Schema, GraphQL SDL, EF Core (C#), and Scala case classes. **11 formats, 100 conversion directions.**

[](https://github.com/Coding-Dev-Tools/schemaforge/stargazers)
[](https://github.com/Coding-Dev-Tools/schemaforge)
[](https://github.com/Coding-Dev-Tools/schemaforge/blob/main/LICENSE)
[](https://github.com/Coding-Dev-Tools/schemaforge/actions/workflows/ci.yml)
[](https://github.com/Coding-Dev-Tools/schemaforge)
[](https://marketplace.visualstudio.com/items?itemName=revenue-holdings.vscode-schemaforge)
[](https://www.opensourcealternative.to/project/schemaforge)

**Why SchemaForge?**

Convert any schema to any format, verify equivalence with the diff command, generate Alembic migrations, produce JSON Schema definitions, create GraphQL SDL types, convert Entity Framework (C#) entities, generate Scala case classes, and batch-process entire directories. Whether you're migrating from Prisma to Drizzle, sharing a schema with a Django backend, exposing your data model as GraphQL, translating C# entities to Scala, or working with the SchemaForge VS Code extension for live preview — SchemaForge handles it.

## Quick Start

```bash
# Install (package publishing pending — install from source)
pip install git+https://github.com/Coding-Dev-Tools/schemaforge.git

# Convert Prisma → Drizzle
schemaforge convert --from prisma --to drizzle --input schema.prisma

# Generate GraphQL from SQL
schemaforge convert --from sql --to graphql --input schema.sql --output schema.graphql

# Generate JSON Schema from Prisma
schemaforge convert --from prisma --to json_schema --input schema.prisma --output schema.json

# Generate Alembic migration from SQL
schemaforge convert --from sql --to alembic --input schema.sql --output migrations/initial.py

# Apply custom type mappings
schemaforge convert --from sql --to prisma --input schema.sql --type-map my-types.yaml

# Diff two schemas
schemaforge diff schema-v1.prisma schema-v2.prisma

# Check all schemas in a directory are consistent
schemaforge check --dir ./schemas/
```

## Installation

```bash
# Install from source (recommended — PyPI publishing pending)
pip install git+https://github.com/Coding-Dev-Tools/schemaforge.git
```

Requires Python 3.10+.

## Commands

### `schemaforge convert`

Convert a schema from one format to another. Every format converts to and from every other format, except Alembic which is generator-only (a target, not a source) — 100 direction pairs.

```bash
# Format-specific examples
schemaforge convert --from sql --to prisma --input schema.sql
schemaforge convert --from prisma --to drizzle --input schema.prisma
schemaforge convert --from drizzle --to sql --input schema.drizzle.ts
schemaforge convert --from typeorm --to django --input entities/
schemaforge convert --from django --to sqlalchemy --input models.py
schemaforge convert --from sqlalchemy --to prisma --input models.py

# Alembic migration generation
schemaforge convert --from sql --to alembic --input schema.sql --output migrations/initial.py
schemaforge convert --from prisma --to alembic --input schema.prisma --output migrations/

# JSON Schema
schemaforge convert --from sql --to json_schema --input schema.sql --output schema.json
schemaforge convert --from json_schema --to prisma --input schema.json

# GraphQL SDL
schemaforge convert --from sql --to graphql --input schema.sql --output schema.graphql
schemaforge convert --from graphql --to prisma --input schema.graphql

# Custom type mapping
schemaforge convert --from sql --to prisma --input schema.sql --type-map my-types.yaml

# Dir mode (check all files are consistent)
schemaforge check --dir ./schemas/ --canonical prisma
```

### `schemaforge diff`

Compare two schema files in the same format and see line-level differences.

```bash
schemaforge diff schema-v1.prisma schema-v2.prisma
schemaforge diff schema.sql schema-updated.sql --format sql
schemaforge diff fixtures/sample.sql fixtures/sample.prisma --format prisma
```

Detects added, removed, and modified tables, columns, indexes, and constraints.

## Supported Formats

| Format | Import | Export | Roundtrip |
|--------|:------:|:------:|:---------:|
| SQL DDL | ✓ | ✓ | ✓ |
| Prisma schema | ✓ | ✓ | ✓ |
| Drizzle schema | ✓ | ✓ | ✓ |
| TypeORM entities | ✓ | ✓ | ✓ |
| Django models | ✓ | ✓ | ✓ |
| SQLAlchemy models | ✓ | ✓ | ✓ |
| Alembic migrations | — | ✓ | — |
| JSON Schema | ✓ | ✓ | ✓ |
| GraphQL SDL | ✓ | ✓ | ✓ |
| EF Core (C#) | ✓ | ✓ | ✓ |
| Scala case class | ✓ | ✓ | ✓ |

**Alembic** is generator-only: you can create migration scripts from any format, but parsing existing migrations back to IR is not yet supported.

### Limitations

- **Foreign keys & relationships** — the shared IR does not yet model foreign-key constraints or ORM relations, so `FOREIGN KEY` / `REFERENCES` clauses, Prisma/TypeORM relation fields, and Django `ForeignKey` fields are dropped during conversion rather than roundtripped. Tables, columns, types, defaults, indexes, unique constraints, and enums are preserved. FK support is on the roadmap.
- **Alembic is generator-only** (see above) — you can generate migrations from any format but not parse them back.

### Format Identifiers for `--from` / `--to`

| CLI identifier | Format |
|----------------|--------|
| `sql` | SQL DDL |
| `prisma` | Prisma schema |
| `drizzle` | Drizzle ORM schema |
| `typeorm` | TypeORM entities |
| `django` | Django models |
| `sqlalchemy` | SQLAlchemy declarative models |
| `alembic` | Alembic migration scripts |
| `json_schema` | JSON Schema (draft 2020-12) |
| `graphql` | GraphQL SDL |
| `ef` | Entity Framework Core (C#) |
| `scala` | Scala case classes (Doobie/Quill/Slick) |

## How It Works

SchemaForge uses a **shared Internal Representation (IR)** — all formats convert to and from this common schema definition. This architecture guarantees:

- **High-fidelity roundtripping**: `sql → prisma → sql` reproduces tables, columns, types, defaults, indexes, unique constraints, and enums. Foreign-key/relationship constraints are not yet modeled in the IR and are dropped (see [Limitations](#limitations)).
- **Bidirectional conversion**: every format can convert to every other format, except Alembic, which is generator-only (a target, not a source)
- **Extensibility**: adding a new format requires only a parser and a generator — no pairwise converters

```
|    SQL DDL ───┐
|    Prisma ────┤
|    Drizzle ───┤
|    TypeORM ───┤
|    Django ────┤
| SQLAlchemy ───┤
|   Alembic ────┤
| JSON Schema ──┤
|   GraphQL ────┤
|  EF Core ─────┤
|    Scala ─────┤
```

Each parser reads format-specific syntax and builds a schema IR. Each generator takes the same IR and produces format-native output. The `fn:` prefix convention preserves SQL function defaults (CURRENT_TIMESTAMP, NOW(), gen_random_uuid()) across format boundaries.

## Custom Type Mappings (v1.1.0+)

Override default type mappings with YAML or JSON configuration files.

```yaml
# type-overrides.yaml
overrides:
  prisma:
    STRING: "String @db.VarChar({length})"
    UUID: "String @db.Uuid"
  sql:
    STRING: "TEXT"
    DATETIME: "TIMESTAMP WITH TIME ZONE"
```

Template variables available: `{length}`, `{precision}`, `{scale}`, `{values}`.

```bash
# Apply overrides during conversion
schemaforge convert --from sql --to prisma --input schema.sql --type-map type-overrides.yaml
```

## Type Mapping

SchemaForge maps types intelligently between ORM systems. The core `ColumnType` enum represents all supported data types, and each format maps them to their native equivalents.

| ColumnType | SQL DDL | Prisma | Drizzle | TypeORM | Django | SQLAlchemy | Alembic | JSON Schema | GraphQL |
|------------|---------|--------|---------|---------|--------|------------|---------|-------------|---------|
| STRING | VARCHAR(n) / TEXT | String @db.VarChar(n) | varchar(n) | varchar | CharField(max_length=n) | String(n) | sa.String(n) | type: string | String |
| INTEGER | INTEGER | Int | integer | integer | IntegerField | Integer | sa.Integer | type: integer | Int |
| FLOAT | FLOAT | Float | real | float | FloatField | Float | sa.Float | type: number | Float |
| BOOLEAN | BOOLEAN | Boolean | boolean | boolean | BooleanField | Boolean | sa.Boolean | type: boolean | Boolean |
| DATETIME | TIMESTAMP | DateTime | timestamp | timestamp | DateTimeField | DateTime | sa.DateTime | format: date-time | DateTime |
| DATE | DATE | DateTime | date | date | DateField | Date | sa.Date | format: date | Date |
| TIME | TIME | DateTime | time | time | TimeField | Time | sa.Time | format: time | Time |
| TEXT | TEXT | String | text | text | TextField | Text | sa.Text | type: string | String |
| BLOB | BLOB | Bytes | blob | blob | BinaryField | LargeBinary | sa.LargeBinary | format: binary | String |
| JSON | JSON | Json | json | json | JSONField | JSON | sa.JSON | type: object | JSON |
| UUID | UUID | String | uuid | uuid | UUIDField | Uuid | sa.Uuid | format: uuid | ID |
| ENUM | ENUM('a','b') | (via enum) | pgEnum | enum | CharField | Enum | sa.Enum | (enum) | enum |
| DECIMAL | DECIMAL(p,s) | Decimal | numeric(p,s) | decimal(p,s) | DecimalField | Numeric(p,s) | sa.Numeric(p,s) | type: number | Float |
| CUSTOM | (passthrough) | (passthrough) | (passthrough) | (passthrough) | (passthrough) | (passthrough) | (passthrough) | (passthrough) | (passthrough) |

**Function defaults** (`CURRENT_TIMESTAMP`, `NOW()`, `gen_random_uuid()`, etc.) are preserved across conversions using a `fn:` prefix convention.

## Demo Fixtures

Try SchemaForge immediately with our example blog schema. The `fixtures/` directory contains an equivalent schema (users, posts, categories with enums and various data types) in all 11 formats:

```bash
# List all fixtures
ls fixtures/

# Convert SQL → Prisma
schemaforge convert --from sql --to prisma --input fixtures/sample.sql

# Convert Prisma → Django
schemaforge convert --from prisma --to django --input fixtures/sample.prisma

# Convert SQL → GraphQL
schemaforge convert --from sql --to graphql --input fixtures/sample.sql

# Convert SQL → JSON Schema
schemaforge convert --from sql --to json_schema --input fixtures/sample.sql

# Convert Prisma → Alembic migration
schemaforge convert --from prisma --to alembic --input fixtures/sample.prisma --output migrations/

# Custom type mapping demo
schemaforge convert --from sql --to prisma --input fixtures/sample.sql \
  --type-map fixtures/sample-type-overrides.yaml

# Batch convert all fixtures from SQL
schemaforge check --dir fixtures/

# Diff two format outputs
schemaforge diff fixtures/sample.sql fixtures/sample.prisma --format prisma
```

Each fixture demonstrates the same blog schema so you can compare ORM syntax side-by-side and verify roundtrip consistency.

## Features

- **Bidirectional conversion** — every format converts to and from every other format (Alembic is generator-only: a target, not a source)
- **High-fidelity roundtripping** — `sql → prisma → sql` reproduces tables, columns, types, defaults, indexes, and enums (foreign keys are not yet preserved — see [Limitations](#limitations))
- **Custom type mappings** — YAML/JSON config files to override any type mapping with template variables
- **VS Code extension** — live preview, schema diff, and one-click conversion from VS Code
- **Alembic migration generation** — create database migration scripts from any schema format
- **JSON Schema** — import/export schema definitions as JSON Schema (draft 2020-12)
- **GraphQL SDL** — generate or consume GraphQL type definitions with enums, directives, and scalars
- **EF Core (C#) support** — import/export Entity Framework entity classes with data annotations
- **Scala case class support** — generate case classes targeting Doobie/Quill/Slick
- **Diff mode** — compare two schemas in the same format with line-level differences
- **Batch mode** — convert entire directories of schema files with one command
- **Intelligent type mapping** — types map correctly across all 11 formats
- **Function default preservation** — `CURRENT_TIMESTAMP`, `NOW()`, `gen_random_uuid()` survive roundtrips
- **MySQL support** — ENGINE=InnoDB, AUTO_INCREMENT, DEFAULT CHARSET, COMMENT table options
- **Inline ENUM** — `ENUM('small', 'medium', 'large')` column types parsed and roundtripped
- **Index & constraint preservation** — indexes and unique constraints maintained across all conversions (foreign-key/relationship constraints are not yet modeled — see [Limitations](#limitations))
- **Custom type handling** — dialect-specific types (JSONB, etc.) pass through via CUSTOM type

## MCP Server

SchemaForge includes an **MCP (Model Context Protocol) server** that exposes all schema operations as tools for AI agents. This allows AI coding assistants like Claude Code, Cursor, and others to convert, diff, and check schemas directly.

```bash
# Install with MCP support
pip install "schemaforge[mcp] @ git+https://github.com/Coding-Dev-Tools/schemaforge.git"

# Start the server (stdio mode — default for AI clients)
schemaforge mcp

# Start as SSE HTTP server
schemaforge mcp --sse --port 8000
```

### Available Tools

| Tool | Description |
|------|-------------|
| `convert` | Convert a schema between any two of the 11 formats |
| `diff` | Compare two schemas and show differences |
| `check` | Verify schema consistency across a directory |
| `formats` | List all supported formats with descriptions |
| `detect_format` | Identify format from filename |

### Configuration for AI Clients

**Claude Desktop** (`claude_desktop_config.json`):
```json
{
  "mcpServers": {
    "schemaforge": {
      "command": "schemaforge",
      "args": ["mcp"]
    }
  }
}
```

**Cursor**: Add to `.cursor/mcp.json`:
```json
{
  "mcpServers": {
    "schemaforge": {
      "command": "schemaforge",
      "args": ["mcp"]
    }
  }
}
```

## VS Code Extension

The **SchemaForge VS Code extension** provides live schema preview, quick conversion, and schema diffing directly from your editor.

### Features

- **Live Preview** — opens a side panel showing your active schema file converted to all other formats (tabbed interface for quick comparison)
- **Quick Convert** — `Ctrl+Alt+S` / `Cmd+Alt+S` to convert the active editor's schema to your configured default target format
- **Format Detection** — `Ctrl+Alt+D` / `Cmd+Alt+D` to detect and display the format of the active schema file
- **Diff Two Schemas** — select two schema files to diff them side-by-side in VS Code's native diff editor
- **Right-Click Conversion** — right-click any schema file in the explorer to convert it
- **Custom Editor** — open `.schemaforge` files for a rich conversion preview
- **Auto-Refresh** — preview panel updates when you save a schema file or switch tabs

### Installation

1. Install SchemaForge: `pip install git+https://github.com/Coding-Dev-Tools/schemaforge.git`
2. Install the extension from the [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=devforge.vscode-schemaforge)
3. Open a `.sql`, `.prisma`, `.graphql`, `.cs`, or `.scala` file
4. Run `SchemaForge: Show Preview` from the command palette

### Configuration

| Setting | Default | Description |
|---------|---------|-------------|
| `schemaforge.cliPath` | `schemaforge` | Path to the schemaforge CLI executable |
| `schemaforge.defaultTargetFormat` | `prisma` | Default target format for quick conversions |
| `schemaforge.livePreview.enabled` | `true` | Enable live preview panel when editing schema files |

### Development

```bash
git clone https://github.com/Coding-Dev-Tools/vscode-schemaforge.git
cd vscode-schemaforge
npm install
npm run compile
# Press F5 in VS Code to launch extension host
```

## Roadmap

| Version | Features |
|---------|----------|
| v0.1.0 | SQL DDL ↔ Prisma bidirectional conversion |
| v0.2.0 | Drizzle schema support |
| v0.3.0 | TypeORM entities support |
| v0.4.0 | Django models support |
| v

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Coding-Dev-Tools](https://github.com/Coding-Dev-Tools)
- **Source:** [Coding-Dev-Tools/schemaforge](https://github.com/Coding-Dev-Tools/schemaforge)
- **License:** MIT
- **Homepage:** https://coding-dev-tools.github.io/devforge/

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-coding-dev-tools-schemaforge
- Seller: https://agentstack.voostack.com/s/coding-dev-tools
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.