agentfront/frontmcp-deployment

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

1. Review the Scenario Routing Table and Target Comparison below to choose a deployment target
2. Run frontmcp build --target <target> to produce the build output
3. Follow the specific deployment reference (e.g., references/deploy-to-node.md, references/deploy-to-vercel.md) for platform instructions
4. 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 | Node.js with stdio or HTTP transport, PM2/Docker for process management | | Serverless with zero config and Vercel KV | deploy-to-vercel | Vercel Functions with Streamable HTTP, Vercel KV for storage | | AWS serverless with API Gateway | deploy-to-lambda | Lambda + API Gateway with Streamable HTTP, DynamoDB or ElastiCache | | Edge computing with global distribution | deploy-to-cloudflare | Cloudflare Workers with KV or Durable Objects for storage | | Hosted FrontMCP (v1.3 skills-only model) | deploy-to-cloudflare-skills-only | Cloudflare Worker as the MCP control plane; OpenAPI is capability inventory; agent uses 4 meta-tools + AgentScript; hot-reload via GitHub Action | | Author frontmcp.deploy.yaml | deploy-manifest-yaml | v1 schema reference: runtime, server, specs, skills, tags, classification, bindings, signing, auth, secrets, environments | | Standalone executable binary for distribution | build-for-cli | Single-binary CLI with stdio transport, embedded storage | | Run MCP in a web browser | build-for-browser | Browser-compatible bundle with in-memory transport | | Embed MCP into an existing Node.js application | build-for-sdk | Library build for programmatic usage without standalone server | | Write a Dockerfile for Node.js deployment | deploy-to-node-dockerfile | Dockerfile configuration for Node.js deployment | | Configure Vercel-specific settings (vercel.json) | deploy-to-vercel-config | Vercel-specific configuration (vercel.json) | | Connect MCP clients (Claude, Cursor, VS Code) | mcp-client-integration | Configure .mcp.json for stdio, HTTP, or Unix socket transport |

CLI Commands for Deployment and Operations

Beyond frontmcp build, the CLI provides commands for the full deployment lifecycle:

| 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 Comparison

| 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 |

Note on storage: Only redis and vercel-kv are SDK-native providers. DynamoDB, Cloudflare KV, D1, and Durable Objects are platform-side — wire them in your tools using the platform SDK / Workers bindings. The Cloudflare build adapter actively rejects redis: { ... } and sqlite: { ... } configs at build time because Workers has no Node TCP / fs.

Note on browser: "In-process direct client" means an in-memory DirectClient created via connect()/create() from @frontmcp/sdk. There is no separate "in-memory transport" — the client and server share the same JS heap.

Cross-Cutting Patterns

| 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 |

Common Patterns

| 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 |

Verification Checklist

Pre-Deployment

• [ ] frontmcp build --target <target> completes without errors
• [ ] Environment variables configured for the target platform
• [ ] Storage provider configured and accessible (Redis, KV, DynamoDB, etc.)
• [ ] Transport protocol matches target requirements (stateless for serverless)

Post-Deployment

• [ ] Health check endpoint responds
• [ ] tools/list returns expected tools
• [ ] Tool execution works end-to-end
• [ ] Storage persistence verified (create, read, restart, read again)

Troubleshooting

| 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 |

Examples

Each reference has matching examples under examples/<reference>/:

build-for-browser

| 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. |

build-for-cli

| 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. |

build-for-mcpb

| Example | Level | Description | | --------------------------------------------------------------------- | ----- | ---------------------------------------------------------------------------------------------- | | mcpb-bundle-build | Basic | Produce a .mcpb archive for Claude Desktop with metadata, tools, and install-time user_config. |

build-for-sdk

| 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. |

deploy-to-cloudflare

| 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. |

deploy-to-lambda

| 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. |

deploy-to-node-dockerfile

| 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. |

deploy-to-node

| 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. |

deploy-to-vercel-config

| 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. |

deploy-to-vercel

| 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. |

mcp-client-integration

| 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. |

Accessing This Skill

Skills are distributed as plain SKILL.md files plus a sibling references/ and examples/ tree, so consumers can pick whichever access mode fits:

| 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. |

The catalog itself is not an MCP server. The skill:// URIs only resolve when a server has been configured to host this skill.

Reference

• Runtime Modes
• Related skills: deploy-to-node, deploy-to-vercel, deploy-to-lambda, deploy-to-cloudflare, build-for-cli, build-for-browser, build-for-sdk, configure-transport