How do I install BackendGen?

Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.

Does BackendGen need an API key?

The publisher lists these environment variables: BACKENDGEN_ALLOWED_ROOTS.

What transport does BackendGen use?

BackendGen runs locally over stdio.

When was BackendGen last checked?

Last checked 2026-11-09. Validate compact backend specs and generate tested NestJS, Prisma, and PostgreSQL repositories.

BackendGen MCP server

Power your agent

Add this server

The publisher's own command. Not a PlugMCP endpoint.

Add to Cursor Add to VS Code Run on PlugMCP

Host a copy with our keys and logs.

Local command

npx -y @2hemi/[email protected]

Credentials from the publisher

BACKENDGEN_ALLOWED_ROOTS — Optional list of filesystem roots BackendGen may read and write, separated by ';' (or ':' between POSIX absolute paths).

Claude Code has no install link for a local command. Copy the command below and run it in a terminal.

shClaude Code

1BACKENDGEN_ALLOWED_ROOTS=<value> claude mcp add io.github.sitouhemi-backendgen -- npx -y @2hemi/backendgen-mcp@0.2.2

Run in a terminal.

jsonClaude Desktop

1{2  "mcpServers": {3    "io.github.sitouhemi-backendgen": {4      "command": "npx",5      "args": [6        "-y",7        "@2hemi/[email protected]"8      ],9      "env": {10        "BACKENDGEN_ALLOWED_ROOTS": "<value>"11      }12    }13  }14}

claude_desktop_config.json

Local · npmPublisher installStep-by-step: add this in Claude

Remote URL or a command on your machine? How the two installs differ

Run on PlugMCP

Host a copy with our keys and logs.

A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.

Launch

Server facts

Local

Transport: stdio
Version: 0.2.2
API key

Tools

No tool list yet. Remote servers get one after the first health check.

FAQ

Questions

BackendGen

BackendGen is a deterministic backend compiler for AI coding agents. Give an agent a compact, versioned YAML or JSON specification and it can generate a structured, tested backend instead of inventing database models, permissions, API routes, and migrations from scratch.

It currently generates NestJS 11 + Prisma 6 + PostgreSQL repositories, including a typed TypeScript client and a small frontend-contract.json for the frontend agent to consume. Generated projects have no BackendGen runtime dependency.

Alpha status: BackendGen is ready for design-partner trials and local projects. Review generated applications before production use; it has not yet completed independent security review or three design-partner trials.

npm CLI · npm MCP server · Report an issue · Design-partner program

What it is for

BackendGen is useful when an AI agent needs a real backend behind a frontend:

model entities, relations, filters, sorting, and pagination;
add authentication, roles, row ownership, organizations, and tenant isolation;
generate reservations, notifications, webhooks, durable jobs, and uploads;
preserve a clean boundary between compiler-owned code and application-owned custom code;
safely regenerate after a specification changes, with incremental migrations and explicit review gates for destructive changes.

BackendGen is not a hosted backend service, deployment platform, or frontend builder. It runs locally and produces code that a developer or coding agent can review, customize, test, deploy, and connect to a frontend.

Requirements

Node.js 22 or newer
npm 10 or newer
PostgreSQL only when you want to run a generated project's integration tests

Try it in five minutes

You do not need an npm account or this repository to try BackendGen.

mkdir backendgen-try
cd backendgen-try

npx -y @2hemi/backendgen init backend.yaml --name team-api
npx -y @2hemi/backendgen validate backend.yaml
npx -y @2hemi/backendgen generate backend.yaml --output ./team-api

cd team-api
npm install
npm test

The generated project runs prisma generate during installation, so this first-run path does not require a separate Prisma command. From the parent directory, use npx -y @2hemi/backendgen test-generated --output ./team-api --install when an agent should perform installation, validation, build, and unit tests through one bounded compiler command.

init creates a valid starter specification. Edit backend.yaml, then run validate and generate again. Before regenerating an existing project, use diff to preview what would change:

npx -y @2hemi/backendgen diff backend.yaml --output ./team-api

Test a complete SaaS example

The repository includes working specifications from basic CRUD to a full-featured backend. This multi-tenant task example is a good first test:

git clone https://github.com/SiTouhemi/Backendgen.git
cd Backendgen

npx -y @2hemi/backendgen validate examples/saas-tasks/backend.yaml
npx -y @2hemi/backendgen generate examples/saas-tasks/backend.yaml --output ./generated/saas-tasks

cd generated/saas-tasks
npm install
npm test

Browse every example and what it demonstrates in examples/README.md:

Example	Demonstrates
notes API	CRUD, filtering, pagination, and sorting
auth notes	Accounts, roles, ownership, and authentication
SaaS tasks	Organizations and enforced tenant isolation
hotel booking	Reservations, overlap prevention, and notifications
all features	CRUD, auth, organizations, reservations, notifications, webhooks, jobs, and uploads

Use it with an AI coding agent (MCP)

The MCP package lets an AI agent discover supported backend features, validate a spec, preview changes, generate a backend, run generated tests, return the frontend handoff contract and customization guidance. It can also explain customization points. It runs locally over stdio—no BackendGen account or network listener is required.

Migration SQL is returned only when the agent explicitly requests it for review; generated source remains omitted from normal responses.

Add this server to an MCP-capable client, giving it only a directory you trust:

{
  "mcpServers": {
    "backendgen": {
      "command": "npx",
      "args": ["-y", "@2hemi/backendgen-mcp"],
      "env": {
        "BACKENDGEN_ALLOWED_ROOTS": "/absolute/path/to/projects"
      }
    }
  }
}

For Codex, Claude Code, Cursor, ChatGPT desktop, Windows, Lovable Desktop, and the correct v0 handoff, follow the client-specific commands in docs/AI_BUILDERS.md. The complete MCP security and tool reference is in docs/MCP.md.

Once connected, give your agent a request such as:

Create a multi-tenant task-management backend. First inspect BackendGen's capabilities and relevant features. Write a spec, validate it, preview the generation, generate it inside this project, and run the generated tests. Keep custom behavior in the documented customization points.

What is generated

For a valid specification, BackendGen produces a standalone repository with:

a NestJS API, Prisma schema, PostgreSQL migrations, OpenAPI setup, and tests;
generated endpoints and permission rules derived from the normalized spec;
src/generated/ for compiler-owned code and src/custom/ for code you own;
a .backendgen/manifest.json that records ownership and hashes;
frontend-contract.json and a typed TypeScript client for frontend agents.

On regeneration, BackendGen preserves custom files, refuses to overwrite edited generated files unless you explicitly use --force, and requires explicit review for destructive or data-dependent schema changes. Read docs/MIGRATIONS.md before changing a live schema.

Verification and limits

The repository's CI verifies compiler, CLI, MCP, security-contract fuzzing, package-installation, and generated-project scenarios. Generated projects are also built and tested against PostgreSQL in the release test matrix. See the local verification record and security contract for the exact evidence.

That evidence does not prove that every generated application is safe for production. You remain responsible for reviewing the specification, generated code, secrets, infrastructure, and deployment configuration.

Current boundaries:

one production target: NestJS + Prisma + PostgreSQL;
FastAPI and other backend targets are intentionally out of scope;
no hosted BackendGen SaaS or direct browser-v0 MCP integration yet;
do not make token-savings claims until the paired benchmark has real results.

Documentation

If you need to…	Read
Write a specification	Specification reference
Understand each supported feature	Feature packs
Connect an AI agent or MCP client	AI builder integration
Customize a generated project	Customization guide
Safely regenerate or change a schema	Migrations guide
Run tests locally	Local testing
Understand security boundaries	Threat model
Contribute	Contributing

Feedback and support

We are looking for developers and AI builders who will test BackendGen on a real, non-production project. Please open an issue with:

what you were trying to build;
your sanitized backend.yaml specification;
the command or MCP client you used;
what worked, what was confusing, and what you expected instead.

Never include API keys, .env files, private customer code, or production database data. For security vulnerabilities, follow SECURITY.md instead of opening a public issue. Full support details are in SUPPORT.md.

Development

To work on BackendGen itself:

npm ci
npm test
npm run test:fuzz:ci
npm run test:e2e
npm run test:distribution

Maintainers preparing a release can run the same non-publishing gate through npm run verify:release. PostgreSQL-backed execution remains the separate npm run verify:local:postgres workflow described in local testing.

BackendGen is licensed under Apache-2.0. Generated projects belong to their users.