# microservices-sh/mcp [Health: Active]

**Category:** ☁️ Cloud Platforms  
**Repository:** https://github.com/microservices-sh/mcp  
**GitHub Stars:** 1  
**npm Downloads (last month):** 203  
**Views:** 4  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/microservices-sh-mcp

## Description
MCP server for microservices.sh: inspect verified Cloudflare-native modules/templates, generate app plans/projects, run checks, and trigger confirmation-gated preview deploys. Install via npx -y @microservices-sh/mcp.

## Tools
Capabilities this server exposes over MCP:

- **list_templates** — List available microservices.sh app templates, including template ids and summaries. Use this before inspect_template, compose_app, generate_project, or run_checks when choosing a foundation for a new Cloudflare app.
- **inspect_template** — Inspect one app template contract, including supported modules, default configuration, runtime metadata, and generation behavior. Use this before composing or generating a project from a specific template id.
- **list_modules** — List available verified microservices.sh modules with ids, categories, summaries, versions, and maturity status. Use this to discover production building blocks before inspect_module, compose_app, or plan_add_module.
- **inspect_module** — Inspect one module contract in detail, including permissions, hooks, events, resources, storage needs, and customization points. Use this before editing or adding a module so the agent understands the module boundaries.
- **list_module_docs** — List LLM-readable documentation pages available for module implementation guidance. Use this to discover local docs before get_module_doc or before changing generated source.
- **get_module_doc** — Return an LLM-readable documentation page for a module, including rules, implementation notes, and agent guidance. Use this before coding against a module contract.
- **compose_app** — Compose a template and selected modules into a checked app contract and lockfile plan without writing files. Use this to preview the exact app composition before generate_project or deployment planning.
- **validate_config** — Validate a template, module list, and configuration object before generation or deployment. Use this to catch unsupported modules, missing settings, and invalid config before side effects.
- **generate_project** — Generate project source files in memory for agent inspection. This tool does not write files; use it to review planned source, docs, migrations, and config before creating or editing a local project.
- **run_checks** — Run local contract and readiness checks for a template/module composition. Use this before deployment planning to verify module compatibility, generated artifacts, and operational guardrails.
- **plan_add_module** — Plan an approval-gated module addition against an optional existing microservices.lock.json. This tool reports intended lockfile changes and required review gates without writing files.
- **check_updates** — Check locked module versions against the bundled registry snapshot. Use this to identify available module updates before plan_module_upgrade.
- **plan_module_upgrade** — Plan a module version change and report approval gates, compatibility notes, and lockfile impact. Use this before applying a module upgrade.
- **get_secrets_status** — Report required secret names and configured/missing status for a template/module composition without exposing secret values. Use this before deployment planning or remote preview deploys.
- **create_preview_plan** — Create a local preview-deployment readiness plan without mutating remote state. Use this before deploy_preview to review resources, checks, errors, warnings, and required approval steps.
- **deploy_preview** — Prepare a remote preview deployment through the microservices.sh control plane. This is a mutating tool and requires confirm: preview; call create_preview_plan first and only proceed after human review.
- **get_deployment_status** — Read a remote preview deployment status from the microservices.sh control plane. Use this after deploy_preview to poll status, inspect errors, or retrieve deployment metadata.

## Claude Desktop Quick Installation
Remote MCP endpoint (confidence: high). Install path detected from listing signals. Add as a URL/SSE server in your client:

```json
"mcpServers": {
  "mcp": {
    "url": "https://api.microservices.sh"
  }
}
```

## Documentation

## What the microservices-sh/mcp MCP server does

The microservices-sh/mcp MCP server gives coding agents a structured workflow for planning and preparing Cloudflare-native applications from reusable microservices.sh templates and modules. Agents can browse available foundations, inspect the contracts behind them, select modules, and review the resulting application composition before any files or remote resources are changed.

The registry includes modules for product concerns such as authentication, booking, customer records, payments, files, and audit logs. The available inventory should be discovered through the server rather than assumed. Module inspection exposes details such as permissions, hooks, events, resources, storage requirements, and customization points.

Project generation is performed in memory. The generated source, documentation, migrations, and configuration can be inspected before a local project is created or edited. The server also supports readiness checks, secret-status reporting, update planning, and deployment planning.

## How it works

A typical workflow starts with `list_templates` or `list_modules`. Use `inspect_template` or `inspect_module` to understand the selected contracts, and consult module documentation when implementation guidance is needed. `compose_app` produces a checked app composition and lockfile plan without writing files. `validate_config` checks the selected template, modules, and configuration for unsupported combinations or missing settings.

After generation and local checks, `get_secrets_status` reports required secret names and whether they are configured, without returning secret values. `create_preview_plan` prepares a deployment-readiness report containing resources, checks, warnings, errors, and approval requirements. `deploy_preview` can then prepare a remote preview deployment, but it is mutating and requires `confirm: "preview"`. Use `get_deployment_status` afterward to inspect progress or deployment metadata.

The microservices-sh/mcp MCP server also supports module lifecycle planning. `check_updates` compares locked versions with the bundled registry snapshot, while `plan_add_module` and `plan_module_upgrade` report intended lockfile changes and review gates without applying them.

## Setup and configuration

The package is available as `@microservices-sh/mcp`. The provided direct-run installation is:

```bash
npx -y @microservices-sh/mcp
```

The package is a standalone stdio MCP server. A client can start the `microservices-mcp` command and provide configuration through environment variables. `MICROSERVICES_API_URL` selects the remote control-plane URL and defaults to `https://api.microservices.sh`. `MICROSERVICES_API_KEY` supplies the bearer token for remote tools, while `MICROSERVICES_TOKEN` is the fallback bearer token.

Local planning capabilities do not necessarily require remote credentials, but preview deployment and other control-plane operations depend on access to the configured API. The README also documents a local development mode that runs the built `dist/index.js` file with Node.js.

## Tools and capabilities

- Discover templates, modules, and module documentation.
- Inspect template and module contracts before composing an app.
- Compose and validate application plans without writing files.
- Generate project artifacts in memory for review.
- Run compatibility, contract, and readiness checks.
- Plan module additions and version upgrades with approval gates.
- Check secret requirements without exposing values.
- Create preview plans and prepare confirmation-gated remote deployments.
- Read preview deployment status from the control plane.

## Limitations and notes

The server vendors a small SDK and module-contract snapshot until the public SDK is split out. Generated projects are returned in memory; `generate_project` does not write files. Planning tools similarly report intended changes rather than applying them. Remote deployment is the exception: `deploy_preview` can mutate remote state and should only be called after a human reviews the preview plan and supplies the required confirmation.

The microservices-sh/mcp MCP server does not return secret values through its tools. Its remote features require a reachable microservices.sh control plane and a bearer token configured through the documented environment variables.

_Full upstream README: https://allmcps.com/mcp/microservices-sh-mcp/readme_