The @microservices-sh/mcp server provides AI agents with a typed planning layer for discovering, composing, validating, generating, and deploying Cloudflare-native apps using reusable microservices.sh modules.
Template & Module Discovery
list_templates / inspect_template – Browse and deep-dive into available app templates (e.g., booking-sveltekit)
list_modules / inspect_module – Discover and inspect verified building-block modules (auth, booking, payment, etc.) including their contracts, permissions, hooks, events, and storage needs
Documentation
list_module_docs / get_module_doc – List and retrieve LLM-readable documentation pages with implementation guidance, rules, and agent notes
Local Planning & Validation (read-only, no file writes)
compose_app – Compose a template + modules into a checked app contract and lockfile plan
validate_config – Validate template, module list, and configuration before generation
generate_project – Generate project source files in memory for agent inspection without touching the filesystem
run_checks – Run local contract and readiness checks to verify module compatibility and operational guardrails
get_secrets_status – Report required secret names and configured/missing status without exposing values
create_preview_plan – Build a local preview-deployment readiness plan (resources, checks, warnings, approval steps) without mutating remote state
Module Lifecycle Management
plan_add_module – Plan an approval-gated module addition, reporting lockfile changes and review gates
check_updates – Compare locked module versions against the registry to identify available updates
plan_module_upgrade – Plan a version upgrade and report approval gates, compatibility notes, and lockfile impact
Remote Deployment (mutating, requires API key)
deploy_preview – Trigger a remote preview deployment via the microservices.sh control plane (requires confirm: "preview" and prior plan review)
get_deployment_status – Poll a remote preview deployment's status, errors, and metadata
Allows to build and deploy Cloudflare-native applications with verified modules, local checks, and approval-gated deploy plans.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@@microservices-sh/mcp list available templates for a new project"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server for AI agents that generate, verify, and deploy Cloudflare-native apps from reusable microservices.sh modules.
This package is a standalone stdio MCP server. It vendors a small microservices.sh SDK/module-contract snapshot until the public SDK is split out.
@microservices-sh/mcp gives coding agents a typed planning layer for building production-oriented Cloudflare apps. Agents can discover verified templates and modules, inspect module contracts, compose an app plan, validate configuration, generate project files for review, run readiness checks, and prepare approval-gated preview deployments through the microservices.sh control plane.
It is useful when an agent needs to build apps with common product modules such as auth, booking, customer records, payments, files, and audit logs without inventing each integration from scratch.
Related MCP server: mcpdeployment
pnpm add -D @microservices-sh/mcpOr run it directly after publish:
pnpm dlx @microservices-sh/mcpOr install from Glama:
{
"mcpServers": {
"microservices": {
"command": "microservices-mcp",
"env": {
"MICROSERVICES_API_URL": "https://api.microservices.sh",
"MICROSERVICES_API_KEY": "favored-secret-manager-reference"
}
}
}
}For local development inside this repo:
{
"mcpServers": {
"microservices-local": {
"command": "node",
"args": ["/absolute/path/to/mcp/dist/index.js"]
}
}
}Build the local package first:
pnpm buildFor agent-oriented one-click install guidance, see llms-install.md.
Read-only and local planning tools:
list_templates
inspect_template
list_modules
inspect_module
list_module_docs
get_module_doc
compose_app
validate_config
generate_project
run_checks
plan_add_module
check_updates
plan_module_upgrade
get_secrets_status
create_preview_plan
Remote control-plane tools:
deploy_preview
get_deployment_status
deploy_preview is mutating and requires confirm: "preview". Run create_preview_plan first.
Variable | Purpose |
| Remote control-plane URL. Defaults to |
| Bearer token for remote tools. |
| Fallback bearer token. |
Secret values are never returned by the MCP tools.
The package is published to npm, listed in the official MCP Registry, and verified by Glama:
MCP Registry: sh.microservices/mcp
Glama: @microservices-sh/mcp
awesome-mcp-servers: PR #8249
Remote endpoint: https://api.microservices.sh/mcp
The package declares "mcpName": "sh.microservices/mcp" in package.json. Docker/OCI packaging should wrap this same stdio server rather than forking behavior.
Check locked module versions against the bundled registry snapshot. Use this to identify available module updates before plan_module_upgrade.
Inputs: lock.
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.
Inputs: templateId, modules, config.
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.
Inputs: templateId, modules, config, mode.
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.
Inputs: confirm (required), templateId, modules, config, +4 more.
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.
Inputs: templateId, modules, config.
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.
Inputs: deploymentId (required), apiUrl, apiKey.
Return an LLM-readable documentation page for a module, including rules, implementation notes, and agent guidance. Use this before coding against a module contract.
Inputs: moduleId (required).
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.
Inputs: templateId, modules, config.
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.
Inputs: moduleId (required).
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.
Inputs: templateId (required).
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.
Inputs: no named parameters.
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.
Inputs: no named parameters.
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.
Inputs: no named parameters.
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.
Inputs: moduleId, version, lock.
Plan a module version change and report approval gates, compatibility notes, and lockfile impact. Use this before applying a module upgrade.
Inputs: moduleId, version, to, lock.
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.
Inputs: templateId, modules, 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.
Inputs: templateId, modules, config.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 17 tools
Each tool has a clearly distinct purpose: planning, inspecting, deploying, validating, listing, etc. Overlaps are minimal and well-differentiated by descriptions.
All tool names follow a consistent verb_noun pattern in snake_case, e.g., compose_app, inspect_module, plan_add_module. No mixing of conventions.
With 17 tools, the set is comprehensive for the microservices deployment domain without being overcrowded. Each tool serves a distinct step in the workflow.
Covers the full preview deployment lifecycle- discovery, composition, planning, validation, deployment, status, and upgrades. Minor gaps include no delete/undeploy or list deployments tool.
The MCP server that vets MCP servers: identity, risk grade and per-tool risk before you install.
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
MCP server for Appcircle mobile CI/CD platform.
MCP server that lets your AI assistant build and deploy apps, hosting each one at a live URL.
