backgen-mcp
This server allows AI assistants to scaffold, manage, and extend production-ready Express.js + TypeScript backend projects through natural language commands.
Scaffold new projects — Create a full backend project with your choice of ORM (Prisma, Drizzle, or Mongoose), an optional domain preset (saas-core, healthcare, ecommerce, crm, lms), and sensible defaults for AI-driven use.
Add plugins — Install auth (JWT, Clerk), payments (Stripe), storage (S3), rate limiting, and DevOps tooling (CI/CD, Dependabot, CodeQL, Docker registry, semantic release).
Remove plugins — Cleanly uninstall a previously added plugin, removing its files, dependencies, and manifest entries.
Generate CRUD resources — Create full resource modules (controller, service, repository, validation, routes, tests) with typed fields, relations, and Swagger docs.
Generate seed files — Produce database seed files for a resource with a configurable number of records.
Generate test factories — Create test factories for resources to streamline unit and integration testing.
Run project health checks — Validate Node.js version,
.env, database config, dependencies, and file integrity, with an optional auto-fix mode.List available plugins — Browse all supported plugins with descriptions and categories.
List available presets — Browse all domain presets and their included resources.
Inspect project metadata — Read the
.backgenrc.jsonmanifest to view the project's ORM, installed plugins, versions, and file ownership.
Integrates Clerk authentication as-a-service, including user management and session handling, into generated backend projects.
Configures Dependabot for automated dependency updates in the generated project.
Generates multi-stage Dockerfile and docker-compose configuration for the project, ready for containerized deployment.
Generates a project using Drizzle ORM for database access, with schema definitions and migrations configured.
Sets up GitHub Actions CI pipeline for linting, type checking, testing, and optional deployment in the generated project.
Generates a project using Mongoose ODM for MongoDB, with models and validation set up.
Generates a project using Prisma ORM for database access, with schema and migrations configured out of the box.
Integrates Stripe payments, enabling checkout sessions, webhooks, and customer management in the generated project.
Auto-generates Swagger/OpenAPI documentation for all API endpoints in the generated project.
BackGen
🤖 AI-Ready
BackGen ships a built-in MCP (Model Context Protocol) server that AI assistants (Claude, Cursor, GitHub Copilot, VS Code) can use to scaffold projects on your behalf.
Run via CLI:
backgen mcpOr configure your AI tool's MCP client:
{
"mcpServers": {
"backgen": {
"command": "npx",
"args": ["-y", "@ibrahimkhaled19/backgen", "mcp"]
}
}
}Available MCP tools:
Tool | Description |
| Scaffold a new production-ready backend project with chosen ORM, preset, and plugins |
| Install a plugin (jwt, clerk, stripe, s3, ratelimit, ci-github, dependabot, codeql, docker-registry, release) |
| Remove a previously installed plugin |
| Generate a CRUD resource with fields, relations, validation, and Swagger |
| Generate a database seed file for a resource |
| Generate a test factory for a resource |
| Validate an existing BackGen project for configuration issues |
| List all available plugins with descriptions |
| List all available domain presets |
| Show project metadata from the manifest |
Then just ask: "Scaffold a SaaS backend with Prisma, JWT auth, and Stripe payments"
BackGen is a CLI tool that generates complete Express.js backend projects on Prisma, Drizzle, or Mongoose — with authentication, multi-tenant infrastructure, production hardening, Docker, and testing — all working out of the box.
npx @ibrahimkhaled19/backgen init my-api --orm drizzle
cd my-api
npm run devSwagger docs at http://localhost:3000/docs in under 60 seconds. Pick your ORM, keep everything else.
Related MCP server: Supabase MCP Server
Features
Express + TypeScript — strict mode, ESLint 9 (flat config), Vitest
Multi-ORM — Prisma, Drizzle, or Mongoose. Pick at
inittime, switch later via the manifestSaaS-ready —
saas-corepreset ships Organizations, Memberships, Invitations, RBAC, tenant-scoped queriesHardened by default — helmet, strict CORS, request ID, request timeout, xss + mongo-sanitize, graceful shutdown,
/health+/ready, error envelopePlugin System — JWT, Clerk, Stripe, S3, ratelimit via
backgen addResource Generator — CRUD modules with relations, validation, Swagger
Domain Presets — saas-core, healthcare, SaaS, ecommerce, CRM, LMS — full domain in one command
Seed & Factory Generators — development data and test factories
Docker — multi-stage Dockerfile + docker-compose
Swagger/OpenAPI — auto-generated API documentation
Manifest —
.backgenrc.jsontracks ORM, plugins, versions, and ownership for upgrade/rollback
Quick Start
# Install globally
npm install -g @ibrahimkhaled19/backgen
# Create a project (pick your ORM)
backgen init my-api --orm prisma
backgen init my-api --orm drizzle
backgen init my-api --orm mongoose
# Create a full multi-tenant domain
backgen init my-saas --preset saas-core --defaults
# Add authentication
backgen add jwt
backgen add clerk
# Add production hardening
backgen add ratelimit
# Generate a resource
backgen generate resource Product name:string price:number stock:number
# Start developing
cd my-api
npm run devCommands
backgen init [name]
Generate a new backend project.
backgen init my-api # interactive ORM picker
backgen init my-api --orm prisma # explicit ORM
backgen init my-api --orm drizzle --defaults # Drizzle, non-interactive
backgen init my-api --orm mongoose --skip-install
backgen init my-api --preset saas-core --defaults # full multi-tenant domain
backgen init my-api --preset healthcare # healthcare domainOutput:
Express app with TypeScript strict mode
ORM-specific data layer (Prisma / Drizzle / Mongoose)
Environment validation (Zod)
Swagger/OpenAPI documentation
Docker + docker-compose
Hardened by default: helmet, CORS, request ID, timeout, xss + mongo-sanitize, graceful shutdown, health checks
ESLint 9 + Vitest
.backgenrc.jsonmanifest (recordsproject.orm+ plugins)
No auth by default — choose your auth provider with backgen add.
backgen add [plugin]
Install a plugin. Interactive multi-select if no argument.
backgen add # interactive multi-select
backgen add jwt # JWT authentication
backgen add clerk # Clerk auth-as-a-service
backgen add stripe # Stripe payments
backgen add s3 # AWS S3 storage
backgen add ratelimit # Per-IP / per-user rate limiting
backgen add devops # Install all devops plugins at onceAvailable Plugins:
Plugin | Category | Description |
| auth | JWT authentication with refresh tokens |
| auth | Clerk auth-as-a-service (conflicts with jwt) |
| payment | Stripe checkout, webhooks, customers |
| storage | AWS S3 upload, download, presigned URLs |
| production | Per-IP rate limiting with Redis-ready store |
| devops | GitHub Actions CI pipeline (lint, typecheck, test, build, optional deploy) |
| devops | Automated dependency updates via Dependabot |
| devops | CodeQL security analysis on push and schedule |
| devops | Docker image build and publish to GHCR |
| devops | Semantic release with npm publish and GitHub releases |
Conflict detection: jwt and clerk cannot be installed together.
Domain Presets
Generate a complete domain in one command. Each preset creates multiple resources with relations, auto-installs JWT auth, and wires everything together.
backgen init my-api --preset healthcare
backgen init my-api --preset saas --defaultshealthcare
Patient, Doctor, Appointment, Prescription, MedicalRecord — appointments between patients and doctors, prescriptions linked to patients, medical records per patient.
saas
Organization, Team, Membership, Subscription, Invoice — organizations with teams and memberships, subscriptions with invoices.
ecommerce
Category, Product, Cart, Order, OrderItem, Payment — products in categories, carts with items, orders with line items and payments.
crm
Contact, Company, Deal, Activity — companies with contacts, deals tracked through pipeline, activity logging.
lms
Course, Lesson, Enrollment, Progress, Certificate — courses with lessons, student enrollments, progress tracking, certificates.
backgen remove [plugin]
Remove a plugin. Interactive multi-select if no argument. Supports devops shorthand to remove all devops plugins.
backgen remove # interactive multi-select
backgen remove stripe # remove specific plugin
backgen remove devops # remove all devops pluginsbackgen generate resource <name> [fields...]
Generate a CRUD resource module.
# Interactive
backgen generate resource Product
# Non-interactive
backgen generate resource Product name:string price:number stock:number
# With relations
backgen generate resource Appointment date:datetime status:string \
--relations "doctor:Doctor,patient:Patient"
# With --fields flag
backgen generate resource Product --fields "name:string,price:number"Generated files:
src/modules/product/
product.controller.ts # CRUD endpoints
product.service.ts # business logic
product.repository.ts # database operations
product.validation.ts # Zod schemas
product.types.ts # TypeScript interfaces
product.routes.ts # route definitions + Swagger
product.test.ts # test placeholderField types: string, number, boolean, date, datetime
Relations: doctor:Doctor (belongsTo), patients:Patient (hasMany)
backgen generate seed <resource>
Generate seed data for development.
backgen generate seed Product --count 10Output: prisma/seeds/product.ts (Prisma), db/seeds/product.ts (Drizzle), or seeds/product.ts (Mongoose)
backgen generate factory <resource>
Generate a test factory.
backgen generate factory ProductOutput: src/factories/product.factory.ts
Usage:
import { createProduct } from "./factories/product.factory.js";
const product = await createProduct({ name: "Widget" });backgen generate route [name]
Generate a custom route module with a complete controller, service, validation, types, and route file -- including Swagger annotations. Routes are automatically registered in app.ts with the REGISTER_ROUTES marker.
Use this when you need a custom endpoint that doesn't fit the CRUD pattern (e.g., dashboards, reports, webhooks, custom actions). For standard CRUD, use generate resource instead.
backgen generate route # interactive prompt
backgen generate route reports # generate a /api/reports module
backgen generate route webhooks # generate a /api/webhooks moduleGenerated files:
src/modules/reports/
reports.controller.ts # request handlers
reports.service.ts # business logic
reports.validation.ts # Zod schemas
reports.types.ts # TypeScript interfaces
reports.routes.ts # route definitions + SwaggerKey differences from generate resource:
No database model, repository, or test file
No field specification required
Pure controller/service pattern for custom endpoints
Mounted at
/api/<name>with full Swagger docs
backgen generate migration [name]
Generate a database migration (ORM-aware).
backgen generate migration add-product-table # runs prisma migrate dev / drizzle-kit generate / no-op for Mongoosebackgen sync
Reconcile .backgenrc.json with the project. Regenerates missing plugin files.
backgen syncbackgen mcp
Start BackGen as an MCP server over stdio. Used by AI assistants (Claude, Cursor, VS Code) to scaffold projects programmatically.
backgen mcpThis is the same server exposed via the npx @ibrahimkhaled19/backgen backgen-mcp binary. It registers all 10 MCP tools listed in the AI-Ready section.
backgen health
Show system health information.
backgen healthDisplays:
Node.js version
Platform and architecture
BackGen version
backgen doctor
Check project health with ownership integrity diagnostics.
backgen doctor # health check + ownership audit
backgen doctor --fix # auto-fix missing manifest entriesChecks:
Node.js version (>= 18)
npm availability
.env file
DATABASE_URL
Prisma schema / Drizzle config / Mongoose connection
Dependencies
Package manager version
File integrity — all manifest-tracked files exist on disk
Ownership integrity — framework vs user file classification
backgen upgrade
Upgrade a generated project to the latest template version. Creates a backup, then applies pending migrations sequentially.
backgen upgrade # show pending migrations, prompt before applying
backgen upgrade --yes # skip confirmation, apply all pendingWhat happens:
Reads current
generatedVersionfrom.backgenrc.jsonLoads pending core + plugin migrations
Creates backup in
.backgen/backups/pre-<version>/Applies migrations in order (semver-sorted)
Updates ownership register +
generatedVersionin manifest
backgen rollback
Restore a project to its pre-upgrade state from the most recent backup.
backgen rollback # show latest backup, prompt before restoring
backgen rollback --yes # skip confirmationWhat happens:
Lists available backups in
.backgen/backups/Restores the most recent backup (all tracked files + manifest)
Project returns to exact pre-upgrade state
backgen rotate-secrets
Rotate JWT secrets in the project's .env file. Generates cryptographically secure 256-bit random hex values for JWT_SECRET and JWT_REFRESH_SECRET, backs up the current .env to .env.backup, and writes new values.
All existing tokens are immediately invalidated on next server restart -- users must re-login.
backgen rotate-secretsWhat happens:
Generates two 256-bit random hex secrets via
crypto.randomBytesOld
.envsaved to.env.backupPrevious values preserved as comments in the new
.envPrint summary of changes
Plugin System
Every plugin implements the BackGenPlugin interface:
interface BackGenPlugin {
name: string;
category: string;
description: string;
version: string;
dependencies?: string[];
devDependencies?: string[];
requires?: string[];
conflicts?: string[];
env?: Record<string, string>;
templates: string[];
migrations?: PluginMigration[]; // versioned plugin migration scripts
install(ctx: InstallContext): Promise<void>;
uninstall?(ctx: InstallContext): Promise<void>;
}Plugins can:
Install npm dependencies
Inject environment variables
Register routes in app.ts
Replace existing middleware
Add database models (Prisma / Drizzle / Mongoose)
Carry versioned migrations for own upgrades
Project Manifest
.backgenrc.json tracks plugins, versions, generated version, and file ownership:
{
"version": "1.0.0",
"generatedVersion": "1.9.0",
"project": {
"name": "my-api",
"framework": "express",
"database": "postgresql",
"orm": "prisma",
"preset": "saas-core"
},
"plugins": {
"jwt": {
"version": "1.0.0",
"installedAt": "2026-06-01",
"source": "core"
}
},
"files": {
"src/app.ts": { "owner": "shared", "version": "1.9.0" },
"src/server.ts": { "owner": "framework", "version": "1.9.0" },
"src/config/env.ts": { "owner": "framework-editable", "version": "1.9.0" },
"prisma/schema.prisma": { "owner": "user" },
"src/modules/user/user.service.ts": { "owner": "user" },
"docker-compose.yml": { "owner": "shared", "version": "1.9.0" }
}
}Ownership levels:
Level | Description | Upgrade behavior |
| BackGen owns fully | Safe to overwrite |
| Generated but user may customize | Smart merge via migration |
| Generated skeleton, user extends (e.g. docker-compose) | Migration-aware update |
| User owns entirely | Never touched |
Generated Project Structure
my-api/
├── prisma/ # Prisma ORM only
│ ├── schema.prisma
│ └── seeds/
├── src/db/ # Drizzle ORM only
│ ├── schema/
│ │ └── index.ts
│ └── seeds/
├── src/models/ # Mongoose ORM only
│ └── seeds/
├── src/
│ ├── app.ts # Express app setup
│ ├── server.ts # Server entry point
│ ├── config/
│ │ ├── env.ts # Zod env validation
│ │ ├── database.ts # Prisma client / Drizzle db / Mongoose connection
│ │ └── swagger.ts # Swagger config
│ ├── middleware/
│ │ ├── auth.ts # JWT/Clerk auth
│ │ ├── validate.ts # Zod validation
│ │ ├── error.ts # Global error handler
│ │ └── logger.ts # Request logging
│ ├── modules/
│ │ ├── auth/ # Auth module (if jwt installed)
│ │ ├── stripe/ # Stripe module (if installed)
│ │ └── <resource>/ # Generated resources
│ ├── services/
│ │ └── logger.service.ts # Winston logger
│ ├── utils/
│ │ ├── api-error.ts # Error class
│ │ ├── async-handler.ts # Async wrapper
│ │ └── response.ts # Response formatters
│ └── factories/ # Test factories
├── .env.example
├── .backgenrc.json # Manifest
├── Dockerfile
├── docker-compose.yml
├── package.json
└── tsconfig.jsonDevelopment
# Clone
git clone https://github.com/your-username/backgen.git
cd backgen
# Install
npm install
# Build
npm run build
# Test
npm run test
# Lint
npm run lintTest Suite
277+ tests covering:
CLI help and version
Init: project structure, configs, manifest (all 3 ORMs)
Init with domain presets: preset-specific resources and relations
Init with saas-core preset: multi-tenant organizations, memberships, RBAC
Add plugin: files, routes, env vars, manifest (V4.6 plugin suite)
Generate resource: module files, ORM model, routes, validation
Generate with relations: foreign keys, ORM includes
Seed and factory generators (all 3 ORMs)
Drizzle: schema generation, client setup, codegen
Mongoose: model generation, schema definition, connection
Remove plugin: file + dependency + manifest cleanup
Sync: file restoration
Doctor: health checks, ownership integrity
Upgrade: migration engine, pending detection, backup creation
Rollback: backup listing, file restoration, manifest recovery
Error handling: unknown plugin, non-empty directory
Tech Stack
Layer | Technology |
CLI | Commander.js |
Prompts | Inquirer.js |
Templates | Handlebars |
Spinner | Ora |
Colors | Chalk |
Testing | Vitest |
Linting | ESLint 9 (flat config) |
Language | TypeScript (strict) |
Generated Projects
Layer | Technology |
Framework | Express.js |
Language | TypeScript (strict) |
Database | PostgreSQL |
ORM | Prisma / Drizzle / Mongoose |
Validation | Zod |
Auth | JWT or Clerk |
Payments | Stripe |
Storage | AWS S3 |
Docs | Swagger/OpenAPI |
Logging | Winston + Morgan |
Testing | Vitest |
Deployment | Docker |
BackGen vs Alternatives
Tool | ORM Choice | Auth | Plugin System | Presets | Upgrade Engine | Docs Site |
BackGen | Prisma, Drizzle, Mongoose | JWT, Clerk | ◈ 7+ plugins | 5 domains | ◈ Backup + rollback | — |
NestJS CLI | No (fixed NestJS) | Built-in | ◈ Modules | — | — | ◈ |
Express Generator | No (fixed plain JS) | — | — | — | — | — |
T3 Stack | Prisma | NextAuth | — | — | — | ◈ |
AdonisJS | Lucid ORM | Built-in | ◈ Ace | — | — | ◈ |
LoopBack | Built-in | Built-in | ◈ | — | — | ◈ |
Key differentiators:
◈ ORM-switchable — change Prisma ↔ Drizzle ↔ Mongoose via manifest, not rewrite
◈ Domain presets — healthcare, SaaS, ecommerce, CRM, LMS in one command
◈ Upgrade engine — versioned migrations + backup + rollback for generated projects
◈ Multi-ORM from day one — not locked into one data layer
Roadmap
Version | Focus | Status |
V1 | Foundation | Done |
V2 | Plugin System | Done |
V3 | Resource Generator | Done |
V4 | Domain Presets | Done |
V4.5 | SaaS Essentials | Done |
V4.6 | Production Hardening | Done |
V4.6.1 | Base Hardening Default-On | Done |
V5 | Multi-ORM (Prisma, Drizzle, Mongoose) | Done |
V6 | DevOps & Infrastructure | Done |
V6.1 | Ownership Tracking & Doctor --fix | Done |
V6.2 | Upgrade Engine & Migration Runner | Done |
V6.3 | Backups & Rollback | Done |
V6.4 | Plugin Migrations | Done |
V7 | Upgrade Polish & Diffing | In Progress |
V8 | Schema-First Development | Planned |
V9 | Enterprise Features | Planned |
V10 | Plugin Authoring SDK | Planned |
V11 | Marketplace | Planned |
V12 | AI Context Layer | Planned |
See docs/ROADMAP.md for details.
License
MIT
Available Tools
10 toolsadd_pluginA
Installs a feature plugin into an existing BackGen-generated project. Each plugin injects its own source files (controllers, routes, middleware, services), registers routes in app.ts, adds npm dependencies, injects environment variables into .env, and updates the .backgenrc.json manifest with ownership tracking. Call list_plugins first to see all available options with descriptions and categories. Run doctor afterwards to verify the project is healthy. IMPORTANT: jwt and clerk conflict — they cannot be installed together. The devops shorthand ('ci-github', 'dependabot', 'codeql', 'docker-registry', 'release') installs the full DevOps suite.
Inputs: plugin (required), dir.
doctorA
Runs 6 health check categories against a BackGen-generated project and returns a structured pass/fail report for each one. (1) Runtime — Node version >= 18, npm availability. (2) Configuration — .env exists, DATABASE_URL is set, all required env vars from installed plugins are present. (3) Database — Prisma schema / Drizzle config / Mongoose connection string is reachable. (4) Dependencies — package.json deps match installed node_modules, no missing peer deps. (5) File integrity — every file tracked in .backgenrc.json exists on disk with the correct ownership classification (framework vs user). (6) Ownership — all files are properly classified as framework/shared/user, no orphaned plugins. Run this tool BEFORE telling the user that a project is ready to use. Use --fix to auto-resolve missing manifest entries and file ownership issues.
Inputs: dir, fix.
generate_factoryA
Creates a test factory file for a resource — a reusable builder that generates valid resource instances with sensible defaults for writing tests. Factories let you create test data in one line (e.g. createProduct({ name: 'Widget' })) instead of manually constructing full objects with required fields, timestamps, and relations every time. The generated factory is ORM-aware: it uses the same schema as your generated resource. Factories are written to src/factories/.factory.ts and use the faker library for realistic default values. Run generate_resource for a resource first — the factory matches its fields. Only PascalCase resource names are valid (e.g. 'Product', not 'product').
Inputs: resource (required), dir.
generate_resourceA
Generates a full CRUD module for a resource — controller with 5 REST endpoints (GET /:id, GET /, POST, PATCH /:id, DELETE /:id), service layer with business logic, repository with database operations, Zod validation schemas, TypeScript interfaces, route definitions auto-registered in the Express app with Swagger/OpenAPI docs, and a test file. If fields are not provided, the CLI will prompt interactively (use non-interactive mode by passing fields directly). Relations create foreign key columns in the database and populate the Prisma/Drizzle/Mongoose schema with the correct association types (belongsTo for singular, hasMany for plural relation names). Run add_plugin first if you need auth protection on the generated endpoints.
Inputs: name (required), dir, fields, relations.
generate_seedA
Creates a database seed file for a resource — a script that inserts realistic development data into your database so you don't manually populate tables while building features. The seed file is ORM-aware: it outputs to prisma/seeds/.ts for Prisma, db/seeds/.ts for Drizzle, or seeds/.ts for Mongoose. Each seed record uses faker-generated realistic values matching the resource's field types. Run generate_resource first for the resource you want to seed. After generating, you run the seed via 'npm run seed' in the project directory to insert the data. Use count to control how many records to generate — 10 is fine for development, 50-100 for load testing or demo environments. Maximum 1000.
Inputs: resource (required), dir, count.
init_projectA
Creates a new backend project directory with Express.js + TypeScript strict mode, ORM data layer (Prisma/Drizzle/Mongoose), Zod env validation, Swagger docs, Docker, ESLint, Vitest, and a .backgenrc.json manifest. Run add_plugin afterwards to add auth, payments, storage, rate-limiting, or CI/CD. Run generate_resource to add CRUD modules. Use --preset to generate a full domain (healthcare/saas/ecommerce/crm/lms) with pre-built resources and auto-installed JWT auth in one command. Call list_presets first to see what each domain preset includes. Typical generation takes 10–30 seconds with npm install being the longest step.
Inputs: name (required), dir, orm, preset, +2 more.
list_pluginsA
List all available BackGen plugins with their descriptions and categories. Call this first to show the user what features they can add, then call add_plugin with the chosen plugin name. Call list_presets to see domain presets.
Inputs: no named parameters.
list_presetsA
List all available domain presets with their pre-built resources and relationships. Each preset generates multiple interconnected resources with database models, CRUD endpoints, and Swagger docs in a single command. Call this first to help the user choose the right domain, then call init_project with --preset to generate it. All presets auto-install JWT authentication and wire resources together with proper foreign keys.
Inputs: no named parameters.
project_infoA
Runs 6-category diagnostics on a BackGen-generated project and returns a structured report covering Node.js version, npm availability, .env configuration, database connection (Prisma/Drizzle/Mongoose), dependency integrity, file ownership classification, and manifest data from .backgenrc.json. Use this BEFORE or AFTER making changes to verify the project is in a valid state. Read-only — never modifies any files. For a focused health check with auto-fix capability, use doctor instead.
Inputs: dir.
remove_pluginA
Removes a previously installed plugin from a BackGen-generated project. This is a destructive but safe operation: it deletes plugin-owned source files (controllers, routes, middleware), removes npm dependencies, strips injected environment variables from .env, reverts route registrations in app.ts, and removes the plugin entry from .backgenrc.json. User-owned files are never touched. Only files that the plugin originally installed are affected. Use this to undo an add_plugin command, switch auth providers (e.g. jwt → clerk), or clean up unused features. Run doctor afterwards to verify the project is healthy after removal. Run list_plugins first to see what's currently installed. Use add_plugin if you want to install (not remove) a plugin.
Inputs: plugin (required), dir.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 10 tools
Most tools have clearly distinct purposes (e.g., init_project, add_plugin, remove_plugin, generate_*). However, doctor and project_info both run 6-category diagnostics with overlapping descriptions, potentially causing confusion for an agent despite doctor having auto-fix capability.
The majority of tools follow a verb_noun pattern in snake_case (add_plugin, generate_resource, list_plugins). Two tools break the pattern: doctor (just a noun) and project_info (noun_noun). This minor inconsistency is manageable.
With 10 tools covering project initialization, plugin management, resource generation, and diagnostics, the count is well-scoped for the server's purpose. Each tool serves a distinct role without unnecessary bloat.
Core workflows are covered: init, add/remove plugins, generate resources/factories/seeds, and diagnostics. A minor gap is the lack of a dedicated tool to list installed plugins (only available through diagnostics/manifest), but this does not significantly hinder typical usage.
Maintenance
Related MCP Connectors
A full backend your AI coding agent can set up over MCP
Butterbase MCP server — manage your backend: schemas, auth, functions, storage, RAG, deploys.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
Backend for vibe coders. Connect Butterbase to any MCP-compatible AI coding tool and provision a full backend automatically — database, authentication, file storage, edge functions, and real-time — from a natural language prompt. No SQL, no configuration, no backend knowledge required. Free to start at butterbase.ai.
Related MCP Servers
- AlicenseAqualityBmaintenanceZero-config MCP server that gives AI coding assistants a real-time diagnostic snapshot of your local dev environment. Detects framework, running services, recent errors, git state, and provides a health diagnosis in one call.3487 npm2MIT
- AlicenseNot gradedqualityDmaintenanceA production-ready MCP server providing AI assistants with intelligent Supabase database access, featuring dynamic schema discovery, complete user management, and file storage operations.1MIT
- AlicenseNot gradedqualityDmaintenanceGenerates production-ready MCP servers from natural language, OpenAPI specs, database schemas, GraphQL schemas, or ontologies.71 npm1MIT
- FlicenseNot gradedqualityDmaintenanceMulti-stack scaffolding engine for generating production-ready module structures (NestJS, Java Spring, Python FastAPI) directly from an MCP-compatible AI client, reducing token usage for boilerplate code.-