frontmcp-deployment

Use when deploying, building for production, packaging, or shipping a FrontMCP server. Covers build targets (node, cli SEA binary, browser, embeddable SDK, mcpb archive for Claude Desktop, serverless) and deploying to Vercel (with Vercel KV), AWS Lambda (API Gateway, SAM, CDK), Cloudflare Workers (KV, D1, Durable Objects, v1.3 skills-only), and Node (multi-stage Docker, docker-compose, PM2, nginx). Also the frontmcp.deploy.yaml manifest plus GitHub Action push-resync, MCP client integration / .mcp.json for Claude Desktop, Claude Code, Cursor, and VS Code over stdio or HTTP, and MCP protocol revisions (serving 2026-07-28 alongside 2024-11-05 through 2025-11-25). Triggers: deploy, build for production, dockerize, containerize, serverless, edge runtime, go live, ship it.

Jump to install

Repository: agentfront/frontmcp
Last source activity: August 2, 2026 at 00:55
Detected SKILL.md language: English
Stars: 147
Forks: 6

Install options

The review-first prompt is selected by default. You can switch to a direct command or download a local copy.

Review the source files

Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.

Back to search Back to installation

name	frontmcp-deployment
description	Use when deploying, building for production, packaging, or shipping a FrontMCP server. Covers build targets (node, cli SEA binary, browser, embeddable SDK, mcpb archive for Claude Desktop, serverless) and deploying to Vercel (with Vercel KV), AWS Lambda (API Gateway, SAM, CDK), Cloudflare Workers (KV, D1, Durable Objects, v1.3 skills-only), and Node (multi-stage Docker, docker-compose, PM2, nginx). Also the frontmcp.deploy.yaml manifest plus GitHub Action push-resync, MCP client integration / .mcp.json for Claude Desktop, Claude Code, Cursor, and VS Code over stdio or HTTP, and MCP protocol revisions (serving 2026-07-28 alongside 2024-11-05 through 2025-11-25). Triggers: deploy, build for production, dockerize, containerize, serverless, edge runtime, go live, ship it.
tags	["router","deployment","node","vercel","lambda","cloudflare","cli","browser","sdk","guide"]
category	deployment
targets	["all"]
bundle	["recommended","minimal","full"]
priority	10
visibility	both
license	Apache-2.0
metadata	{"docs":"https://docs.agentfront.dev/frontmcp/deployment/runtime-modes"}

FrontMCP Deployment Router

Entry point for deploying and building FrontMCP servers. This skill helps you choose the right deployment target or build format based on your infrastructure requirements.

When to Use This Skill

Must Use

Choosing between deployment targets (Node vs Vercel vs Lambda vs Cloudflare) for a new project
Deciding on a build format (server vs CLI vs browser vs SDK) for distribution
Planning infrastructure and need to understand trade-offs between deployment options

Recommended

Comparing serverless platforms for cost, cold-start, and feature support
Understanding which transport protocol and storage provider each target requires
Migrating from one deployment target to another

Skip When

You already know your deployment target (go directly to deploy-to-node, deploy-to-vercel, etc.)
You need to configure server settings, not deploy (see frontmcp-config)
You need to build components, not ship them (see frontmcp-development)

Decision: Use this skill when you need to figure out WHERE to deploy. Open the matching reference under references/ directly when you already know.

Prerequisites

A working FrontMCP server with at least one @App and one @Tool (see frontmcp-development)
Server configuration completed (see frontmcp-config)
Tests passing locally (see frontmcp-testing)

Steps

Review the Scenario Routing Table and Target Comparison below to choose a deployment target
Run frontmcp build --target <target> to produce the build output
Follow the specific deployment reference (e.g., references/deploy-to-node.md, references/deploy-to-vercel.md) for platform instructions
Verify with the Post-Deployment checklist at the end of this skill

Scenario Routing Table

Scenario	Reference	Description
Long-running server on VPS, Docker, or bare metal

deploy-to-node

Command	Description
`frontmcp build -t <target>`	Build for target: `node`, `vercel`, `lambda`, `cloudflare`, `cli`, `browser`, `sdk`
`frontmcp build -t cli --js`	Build CLI as JS bundle (instead of native binary via SEA)
`frontmcp start <name>`	Start a named MCP server with supervisor (process management)
`frontmcp stop <name>`	Stop managed server (`-f` for force kill)
`frontmcp restart <name>`	Restart managed server
`frontmcp status [name]`	Show process status (detail if name given, table if omitted)
`frontmcp list`	List all managed processes
`frontmcp logs <name>`	Tail log output (`-F` follow, `-n` lines)
`frontmcp socket <entry>`	Start Unix socket daemon for local MCP server
`frontmcp service <action>`	Install/uninstall systemd (Linux) or launchd (macOS) service
`frontmcp install <source>`	Install MCP app from npm, local path, or git
`frontmcp uninstall <name>`	Remove installed MCP app
`frontmcp configure <name>`	Re-run setup questionnaire for installed app
`frontmcp doctor`	Check Node.js/npm versions and tsconfig requirements
`frontmcp inspector`	Launch MCP Inspector for debugging
`frontmcp init`	Create or fix tsconfig.json for FrontMCP

Target	Transport	Storage	Cold Start	Stateful	Best For
Node	stdio, SSE, Streamable HTTP	Redis, SQLite, memory	None	Yes	Full-featured production servers
Vercel	Streamable HTTP (stateless)	Vercel KV	~250ms	No	Rapid deployment, hobby/startup
Lambda	Streamable HTTP (stateless)	DynamoDB, ElastiCache	~500ms	No	AWS ecosystem, event-driven
Cloudflare	Streamable HTTP (stateless)	KV, Durable Objects	~5ms	Limited	Edge-first, global latency
CLI	stdio	SQLite, memory	None	Yes	Desktop tools, local agents
Browser	In-process direct client	memory	None	Yes	Client-side AI, demos
SDK	Programmatic	Configurable	None	Yes	Embedding in existing apps

Pattern	Rule
Transport selection	Stateful servers (Node, CLI) can use stdio or SSE; serverless must use Streamable HTTP (stateless)
Storage mapping	SDK-native: `redis` (Node, Lambda+ElastiCache, CLI), `vercel-kv` (Vercel, can also work on Cloudflare via Upstash HTTP). Platform-side (you wire it in tools): DynamoDB, Cloudflare KV/D1/DO. Cloudflare build rejects `redis`/`sqlite` configs.
Environment variables	Never hardcode secrets; use `.env` locally, platform secrets in production
Build command	All targets: `frontmcp build --target <target>` produces optimized output
Entry point	All targets require `export default` of the `@FrontMcp` class from `main.ts`

Pattern	Correct	Incorrect	Why
Target selection	Choose based on infrastructure constraints	Choose based on familiarity	Each target has different transport, storage, and cold-start characteristics
Serverless storage	Use platform-native storage (Vercel KV, DynamoDB)	Use Redis on serverless	Platform-native storage avoids VPC/connection overhead on cold starts
Environment config	Platform secrets (Vercel env, AWS SSM)	`.env` files in production	Platform secrets are encrypted, rotatable, and not committed to git
Build verification	Run `frontmcp build --target <target>` before deploying	Deploy source code directly	Build step validates config, bundles dependencies, and optimizes output

Problem	Cause	Solution
Cold start timeout on serverless	Bundle too large or heavy initialization	Lazy-load providers; reduce bundle with tree shaking; increase function timeout
Session lost between requests	Using memory storage on stateless serverless	Switch to platform-native storage (Vercel KV, DynamoDB, etc.)
CORS errors on browser/web clients	HTTP CORS not configured	Add CORS config via `configure-http` skill
Build fails with missing module	Node-only module in browser/edge build	Use conditional imports or `@frontmcp/utils` cross-platform utilities

Example	Level	Description
`browser-build-with-custom-entry`	Intermediate	Build a browser bundle using a dedicated client entry file that avoids Node.js-only imports.
`browser-crypto-and-storage`	Advanced	Use `@frontmcp/utils` crypto functions (WebCrypto API) and in-memory storage in browser environments.
`react-provider-setup`	Basic	Connect a React application to a remote FrontMCP server using `@frontmcp/react`.

Example	Level	Description
`cli-binary-build`	Basic	Build a FrontMCP server as a standalone binary using Node.js Single Executable Applications (SEA).
`unix-socket-daemon`	Intermediate	Run a FrontMCP server as a local daemon accessible via Unix socket for IDE extensions and local MCP clients.

Example	Level	Description
`connect-openai`	Intermediate	Use `connectOpenAI()` to get tools formatted for OpenAI's function-calling API.
`create-flat-config`	Basic	Spin up an in-memory FrontMCP server from a flat config object using `create()`.
`multi-platform-connect`	Advanced	Connect the same FrontMCP server to multiple LLM platforms using platform-specific `connect*()` functions.

Example	Level	Description
`basic-worker-deploy`	Basic	Deploy a FrontMCP server to Cloudflare Workers with a minimal configuration.
`worker-custom-domain`	Advanced	Scaffold a FrontMCP project targeting Cloudflare, configure a custom domain, and verify the deployment.
`worker-with-kv-storage`	Intermediate	Deploy a FrontMCP server to Cloudflare Workers with KV namespace for session and state storage.

Example	Level	Description
`cdk-deployment`	Advanced	Deploy a FrontMCP server to AWS Lambda using CDK with provisioned concurrency and secrets management.
`lambda-handler-with-cors`	Intermediate	Create a custom Lambda handler with an explicit API Gateway definition for CORS support.
`sam-template-basic`	Basic	Deploy a FrontMCP server to AWS Lambda with API Gateway using a SAM template.

Example	Level	Description
`basic-multistage-dockerfile`	Basic	A minimal multi-stage Dockerfile for building and running a FrontMCP server in production.
`secure-nonroot-dockerfile`	Advanced	A production Dockerfile with a non-root user, proper ownership, and security hardening.

Example	Level	Description
`docker-compose-with-redis`	Basic	Deploy a FrontMCP server with Redis using Docker Compose for production.
`pm2-with-nginx`	Intermediate	Deploy a FrontMCP server on bare metal using PM2 for process management and NGINX for TLS termination.
`resource-limits`	Advanced	Configure resource limits, health checks, and environment variables for a production FrontMCP deployment.

Example	Level	Description
`minimal-vercel-config`	Basic	The minimum `vercel.json` needed to deploy a FrontMCP server to Vercel.
`vercel-config-with-security-headers`	Intermediate	A complete `vercel.json` with per-route security headers for health, MCP, and all other endpoints.

Example	Level	Description
`vercel-mcp-endpoint-test`	Advanced	Verify a Vercel-deployed FrontMCP server by testing health, tool listing, and tool invocation.
`vercel-with-kv`	Basic	Deploy a FrontMCP server to Vercel serverless functions with Vercel KV for session persistence.
`vercel-with-skills-cache`	Intermediate	Deploy a FrontMCP server to Vercel with skills enabled and KV-backed skill caching.

Example	Level	Description
`stdio-npx`	Basic	Publish a FrontMCP server to npm and configure MCP clients to use it with npx --stdio.
`http-remote`	Basic	Connect an MCP client to a FrontMCP server running as an HTTP server, locally or remotely.
`stdio-binary-with-env`	Intermediate	Configure a local FrontMCP CLI binary with environment variables and custom arguments in MCP client configs.

Mode	How it works
Filesystem	Read `libs/skills/catalog/frontmcp-deployment/` directly from a clone of the catalog repo, or from a published `@frontmcp/skills` install. SKILL.md is the entry point.
`frontmcp` CLI	`frontmcp skills list`, `frontmcp skills read frontmcp-deployment`, `frontmcp skills read frontmcp-deployment:references/<file>.md`, `frontmcp skills install frontmcp-deployment` — no server required.
MCP `skill://`	When a developer mounts this skill into their own FrontMCP server (`@FrontMcp({ skills: [...] })`), the SDK exposes it via SEP-2640 resources: `skill://frontmcp-deployment/SKILL.md`, `skill://frontmcp-deployment/references/{file}.md`, etc. The server’s `skill://index.json` returns the SEP-2640 discovery document for everything mounted on it.