Express REST API and MCP Server Framework

codecov Documentation Status

Express REST API and MCP Server Framework is a comprehensive development framework for building RESTful APIs with Express.js. It provides a complete template for creating production-ready APIs using Node.js, Express, Mongoose (MongoDB), and Sequelize (SQL databases). Every generated service exposes both REST endpoints and an MCP (Model Context Protocol) server so LLMs can interact with your API directly.

GitHub repository: iolufemi/Express-REST-API-and-MCP-Server-Framework

What is API?

In computer programming, an application programming interface (API) is a set of clearly defined methods of communication between various software components. A good API makes it easier to develop a computer program by providing all the building blocks, which are then put together by the programmer. An API may be for a web-based system, operating system, database system, computer hardware or software library. Just as a graphical user interface makes it easier for people to use programs, application programming interfaces make it easier for developers to use certain technologies in building applications. - Wikipedia

What is REST?

Representational state transfer (REST) or RESTful web services is a way of providing interoperability between computer systems on the Internet. REST-compliant Web services allow requesting systems to access and manipulate textual representations of Web resources using a uniform and predefined set of stateless operations. - Wikipedia

NOTE: The use of this project requires that you have a basic knowledge of using Express in building a REST API.

What is MCP?

MCP (Model Context Protocol) is an open protocol that lets AI assistants (e.g. Claude, ChatGPT, Cursor) interact with your application through a standard interface. Instead of the LLM calling your REST API with raw HTTP, it uses MCP to discover and use tools (actions like create, update, delete) and resources (read-only data like list and get-by-id). - Wikipedia

This framework ships with a built-in MCP server. When you generate a service with npm run generate -- --name users, the same data is exposed as:

You get one codebase, dual access: traditional REST for clients and MCP for AI. See MCP Guide for setup (including Cursor) and details.

Why use Express REST API and MCP Server Framework?

  1. Fast development — Generate full CRUD + MCP with one command (npm run generate -- --name <Name>)
  2. Dual interface — Every generated service exposes both REST API and MCP (tools + resources) for LLMs
  3. LLM-ready — Connect Cursor, Claude, or other MCP clients via HTTP; no extra glue code
  4. TypeScript — Full type safety, strict mode, and a clear structure for controllers and models
  5. API versioning — Route files like users.v1.ts map to /v1/users; latest stays at /users
  6. Testing — Auto-generated tests for routes, controllers, and models; run with npm test
  7. Quality — Linting, consistent error handling, and uniform JSON response shapes
  8. Security — Optional encryption, rate limiting, and security headers; x-tag for POST
  9. Data safety — Deleted records go to trash and can be restored
  10. Audit — Request/response logging for debugging and compliance
  11. Background jobs — Bull queue + clock + workers for scheduled and async tasks
  12. Database choice — MongoDB (Mongoose) or SQL (Sequelize), or an external API as the data source
  13. Organized layout — Clear separation of routes, controllers, models, services, and MCP

Installation

Prerequisites

Setup

Clone the repository and install dependencies:

$ git clone https://github.com/iolufemi/Express-REST-API-and-MCP-Server-Framework.git ./yourProjectName 
$ cd yourProjectName
$ npm install

Key scripts

Command Description
npm run generate -- --name <Name> Generate a MongoDB CRUD endpoint (route, controller, model, MCP registration, tests). Use -n for short.
npm run generate -- --name <Name> --sql Generate a SQL CRUD endpoint (Sequelize model, SQL controller/routes/tests).
npm run generate -- --name <Name> --baseurl <URL> --endpoint <path> Generate an API-as-DB endpoint (proxy to external API). Short: -n, -b, -e.
npm run dev Start development server with hot reload
npm run build Compile TypeScript to dist/
npm start Run production server
npm test Run unit tests (Mocha, spec reporter)
npm run type-check Run TypeScript type-check only
npm run release -- --release-type patch Bump version, changelog, tag, and GitHub release (use minor or major for --release-type as needed)

For release to create the GitHub release, set GITHUB_TOKEN, GIT_OAUTH_TOKEN, or CONVENTIONAL_GITHUB_RELEASER_TOKEN to a Personal Access Token: classic token needs repo scope; fine-grained token needs Releases: Read and write for this repository. Example: GITHUB_TOKEN=ghp_xxx npm run release -- --release-type patch. You can also use RELEASE_TYPE=minor npm run release (no extra args).

The generate script runs npx gulp --gulpfile gulpfile.cjs service so the correct gulpfile is always used (avoids “No gulpfile found” when running gulp directly).

Generate Your First Service

Generate a complete CRUD service with both REST API and MCP server support using the generate script (runs the gulp service task with the correct config via npx):

$ npm run generate -- --name yourFirstEndpoint

Or using the short form:

$ npm run generate -- -n yourFirstEndpoint

This single command generates:

Why npm run generate? The project uses gulpfile.cjs. Running gulp service directly can fail with “No gulpfile found”. The generate script runs npx gulp --gulpfile gulpfile.cjs service, so you don’t need to install gulp globally or remember the gulpfile path.

With the generate command, you have the option of using either Mongo DB, an SQL compatible DB or using an API generated by this framework as a database model. To use an API as a database you can pass the baseurl and the endpoint option; for an SQL compatible db, pass the sql option. See examples below.

Using an API as a DB

$ npm run generate -- --name yourEndpointWithAPIAsDB --baseurl http://localhost:8080 --endpoint users

See API as DB specification for the contract your API must implement and how to test for compliance.

Important for MCP: After generating an API-based model, you need to:

  1. Inspect the actual API response structure
  2. Update the schemaObject in the generated model file to match the real data structure
  3. Add description and mcpDescription fields for each schema field
  4. This ensures the MCP server has proper context about the data structure

The generated template includes a schema definition section with examples - replace them with your actual API response fields. The schema endpoint (GET /{service}/schema) can optionally discover schema from the external API at GET {baseurl}/{endpoint}/schema; if that fails or is not available, it falls back to the _schema defined in the model file.

Using an SQL compatible database

$ npm run generate -- --name yourEndpointWITHSQL --sql

Note: You can use -n instead of --name, -b instead of --baseurl, -e instead of --endpoint.

Try out your new endpoint.

Start the app

$ npm start

by default, the app will start on POST 8080

You can change the PORT by adding a PORT environment variable. eg.

$ PORT=6000 npm start

now the app will start on PORT 6000

To start the app for development, run

$ npm run dev

This will automatically restart your app whenever a change is detected using tsx watch.

Generated Service Features

When you generate a service, you get access to:

REST API Endpoints

Health Check Endpoints

MCP Configuration Endpoints

MCP Server Integration

Every generated service is automatically exposed as MCP tools and resources (model name is lowercased; e.g. Items → items):

MCP Tools (actions LLMs can call):

MCP Resources (read-only; LLMs read via resource URIs):

Example for a generated Items service: tools create_items, create_many_items, update_items, delete_items; resources items://list, items://search, items://{id}.

Note: For every POST API call, you need to send an x-tag value in the header. This value is used for secure communication between the server and client. It is used for AES encryption when secure mode is enabled. To get a valid x-tag, call the [GET] /initialize endpoint.

Background Job Processing

Queue System

The framework includes a distributed job queue system for background processing.

Current: Uses Bull queue system (Redis-based) for robust job processing

Start the Clock

The clock dispatches scheduled tasks to workers (similar to a crontab). Only run one instance at a time.

$ npm run clock

To define a scheduled job, create a record in the Clock collection in MongoDB (connected via LOG_MONGOLAB_URL):

{ 
    "crontab" : "* * * * *", 
    "name" : "Task Name", 
    "job" : "theJobAsDefinedInTheWorkerFile", 
    "enabled" : true,
    "arguments" : {}
}

Note: After changing clock configuration in the database, restart the clock process.

Start the Workers

Workers process background jobs from the queue:

$ npm run workers

Workers are useful for:

See src/services/queue/jobs.ts for sample tasks and src/services/queue/workers.ts for worker configuration.

Versioning your API endpoints

You can create multiple versions of your API endpoints by simply adding the version number to your route file name. eg. users.v1.ts will put a version of the users resources on the /v1/users endpoint. users.v2.ts will put a version of the users resources on the /v2/users endpoint. The latest version of the resources will always be available at the /users endpoint.

NOTE: This project will automatically load route files found in the src/routes/ folder.

Project Structure

Express-REST-API-Generator/
├── src/
│   ├── config/         # Configuration (env, app config)
│   ├── controllers/    # Request handlers (business logic)
│   ├── models/         # Data models (Mongoose/Sequelize)
│   ├── routes/         # Express routes (loaded automatically)
│   ├── services/      # Service layer
│   │   ├── queue/     # Job queue (Bull), clock, workers
│   │   ├── database/  # MongoDB, Redis, SQL, API client
│   │   ├── logger/    # Logging
│   │   └── ...
│   └── mcp/           # MCP server (tools, resources, HTTP transport)
│       ├── servers/   # Models, controllers, unified server
│       └── services/  # Auto-generated MCP service registrations
├── template/          # Code generation templates (gulp)
├── test/               # Test suites
└── docs/               # Documentation

MCP (Model Context Protocol) Integration

This framework provides a built-in MCP server so LLMs can use your API via tools and resources (see What is MCP? above).

How it works

When you generate a service with npm run generate -- --name users, the framework automatically:

  1. Creates REST API endpoints (existing functionality)
  2. Generates MCP server code that exposes:
    • All controller methods as MCP tools
    • Model data as MCP resources
  3. Registers the service with the unified MCP server
  4. Makes it immediately available to LLM clients

Connecting LLMs

Once your service is running, you can connect LLM clients via:

Generating MCP Client Configuration

The framework provides endpoints to generate MCP client configuration files:

GET /mcp/config - Generate configuration JSON for LLM clients

GET /mcp/info - Get MCP server information

See MCP Guide for complete documentation on using and configuring MCP servers.

Getting support, Reporting Bugs and Issues

If you need support or want to report a bug, please log an issue here

Testing

All generated services come with comprehensive test suites covering:

Run Tests

$ npm test

Test Coverage

The project maintains 90%+ test coverage with:

Coverage reports are generated automatically and can be viewed in the coverage/ directory.

How to contribute

View how to contribute here

Code of Conduct

View the code of conduct here

Contributors

Modernization Status

This project has been fully modernized with:

Architecture & Execution Order

The application follows a strict initialization sequence to ensure reliability:

  1. Configuration loaded
  2. Database connections initialized and awaited (with retry logic)
  3. Express app created and configured
  4. Routes loaded dynamically (ES modules)
  5. Server starts listening
  6. MCP servers initialized (after databases ready)

Documentation

FAQs

What is MCP and why should I use it?

MCP (Model Context Protocol) allows LLMs to interact with your API directly. Instead of making HTTP requests, LLMs can call tools and access resources through the MCP protocol. This enables AI-powered features like:

Do I need to write MCP code manually?

No! When you generate a service with npm run generate -- --name users, the framework automatically generates all MCP server code. Your service is immediately available to LLMs without any additional configuration.

What’s the difference between REST API and MCP?

Both are generated automatically and work together seamlessly.

When will TypeScript migration be complete?

The TypeScript migration is complete! All source files have been migrated to TypeScript. Test files are being migrated next.