@frontmcp/skills 0.0.1 → 1.0.0-beta.11

package/catalog/{deployment/deploy-to-lambda/SKILL.md → frontmcp-deployment/references/deploy-to-lambda.md}

@@ -1,66 +1,40 @@
 ---
 name: deploy-to-lambda
-description: Deploy a FrontMCP server to AWS Lambda with API Gateway. Use when deploying to AWS, setting up SAM or CDK, or configuring Lambda handlers.
-tags:
-  - deployment
-  - lambda
-  - aws
-  - serverless
-parameters:
-  - name: runtime
-    description: AWS Lambda runtime version
-    type: string
-    required: false
-    default: nodejs22.x
-  - name: memory
-    description: Lambda function memory in MB
-    type: number
-    required: false
-    default: 512
-  - name: timeout
-    description: Lambda function timeout in seconds
-    type: number
-    required: false
-    default: 30
-  - name: region
-    description: AWS region for deployment
-    type: string
-    required: false
-    default: us-east-1
-examples:
-  - scenario: Deploy with SAM
-    parameters:
-      memory: 512
-      timeout: 30
-      region: us-east-1
-    expected-outcome: A FrontMCP server deployed as an AWS Lambda function behind API Gateway, managed by SAM.
-  - scenario: Deploy with CDK
-    parameters:
-      memory: 1024
-      timeout: 60
-      region: eu-west-1
-    expected-outcome: A FrontMCP server deployed via AWS CDK with API Gateway and Lambda.
-compatibility: AWS CLI and SAM CLI required
-license: Apache-2.0
-visibility: both
-priority: 10
-metadata:
-  category: deployment
-  difficulty: advanced
-  platform: aws
-  docs: https://docs.agentfront.dev/frontmcp/deployment/serverless
+description: Deploy a FrontMCP server to AWS Lambda with API Gateway using SAM or CDK
 ---
 
 # Deploy a FrontMCP Server to AWS Lambda
 
 This skill walks you through deploying a FrontMCP server to AWS Lambda with API Gateway using SAM or CDK.
 
+## When to Use This Skill
+
+### Must Use
+
+- Deploying a FrontMCP server to AWS Lambda behind API Gateway
+- Setting up a SAM or CDK stack for a serverless MCP endpoint on AWS
+- Integrating with AWS-native services like ElastiCache, Secrets Manager, or CloudWatch
+
+### Recommended
+
+- Your organization standardizes on AWS and you need IAM-based access control
+- You want provisioned concurrency for predictable latency on critical MCP endpoints
+- Deploying across multiple AWS regions with infrastructure-as-code (SAM or CDK)
+
+### Skip When
+
+- Deploying to Vercel or you prefer a simpler serverless DX -- use `deploy-to-vercel` instead
+- You need a long-lived process with WebSockets or persistent connections -- use `deploy-to-node` instead
+- You do not use AWS and want to avoid managing IAM roles, VPCs, and CloudFormation stacks
+
+> **Decision:** Choose this skill when you need serverless deployment within the AWS ecosystem; choose a different target when you want simpler ops or a non-AWS platform.
+
 ## Prerequisites
 
 - AWS account with appropriate IAM permissions
 - AWS CLI configured: `aws configure`
 - SAM CLI installed: `brew install aws-sam-cli` (macOS) or see AWS docs
-- Node.js 22 or later
+- Node.js 24 or later
 - A FrontMCP project ready to build
 
 ## Step 1: Build for Lambda
@@ -83,7 +57,7 @@ Description: FrontMCP server on AWS Lambda
 Globals:
   Function:
     Timeout: 30
-    Runtime: nodejs22.x
+    Runtime: nodejs24.x
     MemorySize: 512
     Environment:
       Variables:
@@ -94,7 +68,7 @@ Resources:
   FrontMcpFunction:
     Type: AWS::Serverless::Function
     Properties:
-      Handler: dist/lambda.handler
+      Handler: handler.handler
       CodeUri: .
       Description: FrontMCP MCP server
       Architectures:
@@ -169,7 +143,7 @@ Resources:
 
 ## Step 4: Handler Configuration
 
-FrontMCP generates a Lambda handler at `dist/lambda.handler` during the build step. To customize the handler, create a `lambda.ts` entry point:
+FrontMCP generates a Lambda handler file (`handler.cjs` with a `handler` export) during the build step. In SAM/CDK, reference it as `handler.handler`. To customize the handler, create a `lambda.ts` entry point:
 
 ```typescript
 import { createLambdaHandler } from '@frontmcp/adapters/lambda';
@@ -233,8 +207,8 @@ import * as apigw from 'aws-cdk-lib/aws-apigatewayv2';
 import * as integrations from 'aws-cdk-lib/aws-apigatewayv2-integrations';
 
 const fn = new lambda.Function(this, 'FrontMcpHandler', {
-  runtime: lambda.Runtime.NODEJS_22_X,
-  handler: 'dist/lambda.handler',
+  runtime: lambda.Runtime.NODEJS_24_X,
+  handler: 'handler.handler',
   code: lambda.Code.fromAsset('.'),
   memorySize: 512,
   timeout: cdk.Duration.seconds(30),
@@ -296,9 +270,53 @@ Lambda cold starts occur when a new execution environment is initialized. Strate
 | 512 MB  | ~500ms             | ~700ms           |
 | 1024 MB | ~350ms             | ~500ms           |
 
+## Common Patterns
+
+| Pattern            | Correct                                                        | Incorrect                               | Why                                                                                                |
+| ------------------ | -------------------------------------------------------------- | --------------------------------------- | -------------------------------------------------------------------------------------------------- |
+| Build command      | `frontmcp build --target lambda`                               | `tsc` or generic bundler                | The Lambda target produces a single optimized handler with tree-shaking for cold-start performance |
+| Architecture       | `arm64` (Graviton)                                             | `x86_64`                                | ARM64 functions initialize faster and cost less per ms of compute                                  |
+| Handler path       | `handler.handler` in SAM template                              | `index.handler` or `src/lambda.handler` | The FrontMCP build outputs to `dist/`; mismatched paths cause 502 errors                           |
+| Secrets management | SSM Parameter Store or Secrets Manager (`{{resolve:ssm:...}}`) | Plaintext env vars in `template.yaml`   | SSM/Secrets Manager encrypts values at rest and supports rotation                                  |
+| Redis connectivity | Lambda in same VPC as ElastiCache with security groups         | Public Redis endpoint from Lambda       | VPC peering ensures low latency and keeps traffic off the public internet                          |
+
+## Verification Checklist
+
+**Build**
+
+- [ ] `frontmcp build --target lambda` completes without errors
+- [ ] `handler.handler` exists and exports a `handler` function
+
+**SAM / CDK**
+
+- [ ] `sam build` succeeds without errors
+- [ ] `sam deploy --guided` creates the CloudFormation stack
+- [ ] Stack outputs include the API Gateway endpoint URL
+
+**Runtime**
+
+- [ ] `curl https://<api-id>.execute-api.<region>.amazonaws.com/health` returns `{"status":"ok"}`
+- [ ] CloudWatch Logs show successful invocations without errors
+- [ ] `NODE_ENV` is set to `production` in the function configuration
+
+**Production Readiness**
+
+- [ ] Sensitive values use SSM Parameter Store or Secrets Manager
+- [ ] Log retention is configured (e.g., 14 days)
+- [ ] If using Redis, Lambda is in the same VPC as ElastiCache with correct security groups
+- [ ] Provisioned concurrency is enabled for latency-sensitive endpoints (if applicable)
+
 ## Troubleshooting
 
-- **Timeout errors**: Increase `Timeout` in the SAM template. Check if the function is waiting on an unreachable resource.
-- **502 Bad Gateway**: Check CloudWatch logs. Common causes: handler path mismatch, missing environment variables, unhandled exceptions.
-- **Cold starts too slow**: Increase memory allocation, use ARM64, or enable provisioned concurrency.
-- **Redis from Lambda**: Place the Lambda function in the same VPC as your ElastiCache cluster with appropriate security groups.
+| Problem                              | Cause                                                           | Solution                                                                                                  |
+| ------------------------------------ | --------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- |
+| Timeout errors                       | Function timeout too low or waiting on unreachable resource     | Increase `Timeout` in the SAM template; verify network connectivity to dependencies                       |
+| 502 Bad Gateway                      | Handler path mismatch, missing env vars, or unhandled exception | Check CloudWatch Logs; confirm `Handler` matches `handler.handler`                                        |
+| Cold starts too slow                 | Low memory, x86 architecture, or large bundle                   | Increase memory to 512+ MB, use `arm64`, or enable provisioned concurrency                                |
+| Redis connection refused from Lambda | Lambda not in the same VPC as ElastiCache                       | Place the Lambda in the ElastiCache VPC with appropriate security group rules                             |
+| `sam deploy` fails with IAM error    | Insufficient permissions for CloudFormation stack creation      | Ensure the deploying IAM user/role has `cloudformation:*`, `lambda:*`, `apigateway:*`, and `iam:PassRole` |
+
+## Reference
+
+- **Docs:** https://docs.agentfront.dev/frontmcp/deployment/serverless
+- **Related skills:** `deploy-to-node`, `deploy-to-vercel`

package/catalog/{deployment/deploy-to-node/references/Dockerfile.example → frontmcp-deployment/references/deploy-to-node-dockerfile.md}

@@ -1,45 +1,59 @@
+---
+name: deploy-to-node-dockerfile
+description: Multi-stage Dockerfile for building and running a FrontMCP server in production
+---
+
 # ---- Build Stage ----
-FROM node:22-alpine AS builder
+
+FROM node:24-alpine AS builder
 
 WORKDIR /app
 
 # Install dependencies first for better layer caching
+
 COPY package.json yarn.lock ./
 RUN yarn install --frozen-lockfile
 
 # Copy source and build
+
 COPY . .
 RUN yarn frontmcp build --target node
 
 # ---- Production Stage ----
-FROM node:22-alpine AS production
+
+FROM node:24-alpine AS production
 
 WORKDIR /app
 
 # Create non-root user for security
+
 RUN addgroup -S frontmcp && adduser -S frontmcp -G frontmcp
 
 # Copy only production artifacts
+
 COPY --from=builder /app/dist ./dist
 COPY --from=builder /app/package.json ./
 COPY --from=builder /app/yarn.lock ./
 
 # Install production dependencies only
+
 RUN yarn install --frozen-lockfile --production && \
-    yarn cache clean
+ yarn cache clean
 
 # Set ownership
+
 RUN chown -R frontmcp:frontmcp /app
 
 USER frontmcp
 
 # Environment defaults
+
 ENV NODE_ENV=production
 ENV PORT=3000
 
 EXPOSE 3000
 
 HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
-  CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
+ CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
 
 CMD ["node", "dist/main.js"]

package/catalog/{deployment/deploy-to-node/SKILL.md → frontmcp-deployment/references/deploy-to-node.md}

@@ -1,43 +1,37 @@
 ---
 name: deploy-to-node
-description: Deploy a FrontMCP server as a standalone Node.js application with Docker. Use when deploying to a VPS, Docker, or bare metal server.
-tags:
-  - deployment
-  - node
-  - docker
-  - production
-parameters:
-  - name: port
-    description: The port number the server will listen on
-    type: number
-    required: false
-    default: 3000
-examples:
-  - scenario: Deploy with Docker Compose
-    parameters:
-      port: 3000
-    expected-outcome: A FrontMCP server running inside a Docker container orchestrated by Docker Compose, with Redis for session storage and automatic restarts on failure.
-  - scenario: Deploy to bare metal with PM2
-    parameters:
-      port: 8080
-    expected-outcome: A FrontMCP server running directly on the host machine under PM2, listening on port 8080 with NGINX as a reverse proxy.
-compatibility: Node.js 22+, Docker recommended
-license: Apache-2.0
-visibility: both
-priority: 10
-metadata:
-  category: deployment
-  difficulty: intermediate
-  docs: https://docs.agentfront.dev/frontmcp/deployment/production-build
+description: Deploy a FrontMCP server as a standalone Node.js app with Docker and process managers
 ---
 
 # Deploy a FrontMCP Server to Node.js
 
 This skill walks you through deploying a FrontMCP server as a standalone Node.js application, optionally containerized with Docker for production use.
 
+## When to Use This Skill
+
+### Must Use
+
+- Deploying a FrontMCP server to a VPS, dedicated server, or bare-metal infrastructure
+- Running a long-lived Node.js process that needs full control over the runtime environment
+- Containerizing a FrontMCP server with Docker or Docker Compose for self-hosted production
+
+### Recommended
+
+- Using PM2 or systemd to manage a FrontMCP process with automatic restarts
+- Deploying behind NGINX or another reverse proxy for TLS termination and load balancing
+- Running in environments where serverless cold starts are unacceptable
+
+### Skip When
+
+- Deploying to Vercel -- use `deploy-to-vercel` instead
+- Deploying to AWS Lambda -- use `deploy-to-lambda` instead
+- You need zero-ops serverless scaling and do not require persistent connections or long-running processes
+
+> **Decision:** Choose this skill when you need a persistent Node.js process with full infrastructure control; choose a serverless skill when you want managed scaling.
+
 ## Prerequisites
 
-- Node.js 22 or later
+- Node.js 24 or later
 - Docker and Docker Compose (recommended for production)
 - A FrontMCP project ready to build
 
@@ -55,7 +49,7 @@ Create a multi-stage `Dockerfile` in your project root:
 
 ```dockerfile
 # Stage 1: Build
-FROM node:22-alpine AS builder
+FROM node:24-alpine AS builder
 WORKDIR /app
 COPY package.json yarn.lock ./
 RUN yarn install --frozen-lockfile
@@ -63,7 +57,7 @@ COPY . .
 RUN npx frontmcp build --target node
 
 # Stage 2: Production
-FROM node:22-alpine AS production
+FROM node:24-alpine AS production
 WORKDIR /app
 ENV NODE_ENV=production
 COPY --from=builder /app/dist ./dist
@@ -221,9 +215,48 @@ services:
           cpus: '0.5'
 ```
 
+## Common Patterns
+
+| Pattern                   | Correct                              | Incorrect                                        | Why                                                                 |
+| ------------------------- | ------------------------------------ | ------------------------------------------------ | ------------------------------------------------------------------- |
+| Build command             | `frontmcp build --target node`       | `tsc && node dist/main.js`                       | The FrontMCP build bundles deps and produces an optimized output    |
+| Docker base image         | `node:24-alpine` (multi-stage)       | `node:24` (single stage with dev deps)           | Multi-stage keeps the production image small and secure             |
+| Process manager           | PM2 with `-i max` cluster mode       | Running `node dist/main.js` directly via `nohup` | PM2 handles restarts, logging, and multi-core clustering            |
+| Redis hostname in Compose | Service name `redis`                 | `localhost` or `127.0.0.1`                       | Containers communicate via Docker's internal DNS, not localhost     |
+| Environment config        | `.env` file or orchestrator env vars | Hardcoded values in source code                  | Keeps secrets out of the codebase and allows per-environment config |
+
+## Verification Checklist
+
+**Build**
+
+- [ ] `frontmcp build --target node` completes without errors
+- [ ] `dist/main.js` exists and is runnable with `node dist/main.js`
+
+**Docker**
+
+- [ ] `docker compose up -d` starts all services without errors
+- [ ] `docker compose ps` shows all containers as healthy
+- [ ] `curl http://localhost:3000/health` returns `{"status":"ok"}`
+
+**Production Readiness**
+
+- [ ] `NODE_ENV` is set to `production`
+- [ ] Redis is reachable and `REDIS_URL` is configured
+- [ ] Resource limits (memory, CPU) are defined in Compose or the orchestrator
+- [ ] NGINX or another reverse proxy handles TLS termination
+- [ ] Logs are collected and rotated (Docker log driver or PM2 log rotation)
+
 ## Troubleshooting
 
-- **Port already in use**: Change the `PORT` environment variable or stop the conflicting process.
-- **Redis connection refused**: Verify Redis is running and `REDIS_URL` is correct. In Docker Compose, use the service name (`redis`) as the hostname.
-- **Health check failing**: Increase `start_period` in the health check configuration to give the server more startup time.
-- **Out of memory**: Increase the memory limit in Docker or use `NODE_OPTIONS="--max-old-space-size=1024" node dist/main.js`.
+| Problem                      | Cause                                        | Solution                                                                                    |
+| ---------------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| Port already in use          | Another process is bound to the same port    | Change the `PORT` environment variable or stop the conflicting process with `lsof -i :3000` |
+| Redis connection refused     | Redis is not running or `REDIS_URL` is wrong | Verify Redis is running; in Docker Compose use the service name (`redis`) as the hostname   |
+| Health check failing         | Server has not finished starting             | Increase `start_period` in the Docker health check to give the server more startup time     |
+| Out of memory (OOM kill)     | Container memory limit is too low            | Increase the memory limit in Docker or set `NODE_OPTIONS="--max-old-space-size=1024"`       |
+| PM2 not restarting on reboot | Startup hook was not saved                   | Run `pm2 save && pm2 startup` to persist the process list across reboots                    |
+
+## Reference
+
+- **Docs:** https://docs.agentfront.dev/frontmcp/deployment/production-build
+- **Related skills:** `deploy-to-vercel`, `deploy-to-lambda`

package/catalog/frontmcp-deployment/references/deploy-to-vercel-config.md

@@ -0,0 +1,65 @@
+---
+name: deploy-to-vercel-config
+description: Reference vercel.json configuration for deploying a FrontMCP server to Vercel
+---
+
+{
+"$schema": "https://openapi.vercel.sh/vercel.json",
+"framework": null,
+"buildCommand": "frontmcp build --target vercel",
+"outputDirectory": "dist",
+"rewrites": [
+{
+"source": "/(.*)",
+"destination": "/api/frontmcp"
+}
+],
+"functions": {
+"api/frontmcp.js": {
+"memory": 512,
+"maxDuration": 30
+}
+},
+"regions": ["iad1"],
+"headers": [
+{
+"source": "/health",
+"headers": [
+{
+"key": "Cache-Control",
+"value": "no-store"
+}
+]
+},
+{
+"source": "/mcp",
+"headers": [
+{
+"key": "Cache-Control",
+"value": "no-store"
+},
+{
+"key": "X-Content-Type-Options",
+"value": "nosniff"
+}
+]
+},
+{
+"source": "/(.\*)",
+"headers": [
+{
+"key": "X-Frame-Options",
+"value": "DENY"
+},
+{
+"key": "X-Content-Type-Options",
+"value": "nosniff"
+},
+{
+"key": "Referrer-Policy",
+"value": "strict-origin-when-cross-origin"
+}
+]
+}
+]
+}

package/catalog/frontmcp-deployment/references/deploy-to-vercel.md

@@ -0,0 +1,229 @@
+---
+name: deploy-to-vercel
+description: Deploy a FrontMCP server to Vercel serverless functions with Vercel KV storage
+---
+
+# Deploy a FrontMCP Server to Vercel
+
+This skill guides you through deploying a FrontMCP server to Vercel serverless functions with Vercel KV for persistent storage.
+
+## When to Use This Skill
+
+### Must Use
+
+- Deploying a FrontMCP server to Vercel serverless functions
+- Configuring Vercel KV as the persistence layer for sessions and skill cache
+- Setting up a serverless MCP endpoint with automatic TLS and global CDN
+
+### Recommended
+
+- You already use Vercel for your frontend and want a unified deployment pipeline
+- You need zero-ops scaling without managing Docker containers or servers
+- Deploying preview environments per pull request for MCP server testing
+
+### Skip When
+
+- You need persistent connections, WebSockets, or long-running processes -- use `deploy-to-node` instead
+- Deploying to AWS infrastructure or need AWS-specific services -- use `deploy-to-lambda` instead
+- Your MCP operations routinely exceed the Vercel function timeout for your plan
+
+> **Decision:** Choose this skill when you want serverless deployment on Vercel with minimal infrastructure management; choose a different target when you need persistent processes or AWS-native services.
+
+## Prerequisites
+
+- A Vercel account (https://vercel.com)
+- Vercel CLI installed: `npm install -g vercel`
+- A built FrontMCP project
+
+## Step 1: Build for Vercel
+
+```bash
+frontmcp build --target vercel
+```
+
+This produces a Vercel-compatible output structure with an `api/` directory containing the serverless function entry points, optimized bundles for cold-start performance, and a `vercel.json` configuration file.
+
+## Step 2: Configure vercel.json
+
+Create or update `vercel.json` in your project root:
+
+```json
+{
+  "rewrites": [{ "source": "/(.*)", "destination": "/api/frontmcp" }],
+  "functions": {
+    "api/frontmcp.ts": {
+      "memory": 1024,
+      "maxDuration": 60
+    }
+  },
+  "regions": ["iad1"],
+  "headers": [
+    {
+      "source": "/(.*)",
+      "headers": [
+        { "key": "X-Content-Type-Options", "value": "nosniff" },
+        { "key": "X-Frame-Options", "value": "DENY" }
+      ]
+    }
+  ]
+}
+```
+
+The rewrite rule sends all requests to the single FrontMCP API handler, which internally routes MCP and HTTP requests.
+
+## Step 3: Configure Vercel KV Storage
+
+Use the `vercel-kv` provider so FrontMCP stores sessions, skill cache, and plugin state in Vercel KV (powered by Upstash Redis):
+
+```typescript
+import { FrontMcp, App } from '@frontmcp/sdk';
+
+@App({ name: 'MyApp' })
+class MyApp {}
+
+@FrontMcp({
+  info: { name: 'my-server', version: '1.0.0' },
+  apps: [MyApp],
+  redis: { provider: 'vercel-kv' },
+  skillsConfig: {
+    enabled: true,
+    cache: {
+      enabled: true,
+      redis: { provider: 'vercel-kv' },
+      ttlMs: 60000,
+    },
+  },
+})
+class MyServer {}
+```
+
+Provision the KV store in the Vercel dashboard under **Storage > Create Database > KV (Redis)**, then link it to your project. Vercel automatically injects the required environment variables.
+
+## Step 4: Environment Variables
+
+Vercel KV variables are injected automatically when the store is linked. For manual setup or additional configuration, set them in the Vercel dashboard (**Settings > Environment Variables**) or via the CLI:
+
+```bash
+vercel env add KV_REST_API_URL "https://your-kv-store.kv.vercel-storage.com"
+vercel env add KV_REST_API_TOKEN "your-token"
+vercel env add NODE_ENV production
+vercel env add LOG_LEVEL info
+```
+
+| Variable            | Description                    | Required    |
+| ------------------- | ------------------------------ | ----------- |
+| `KV_REST_API_URL`   | Vercel KV REST endpoint        | If using KV |
+| `KV_REST_API_TOKEN` | Vercel KV authentication token | If using KV |
+| `NODE_ENV`          | Runtime environment            | Yes         |
+| `LOG_LEVEL`         | Logging verbosity              | No          |
+
+## Step 5: Deploy
+
+### Preview Deployment
+
+```bash
+vercel
+```
+
+Creates a preview deployment with a unique URL for validation.
+
+### Production Deployment
+
+```bash
+vercel --prod
+```
+
+Deploys to your production domain.
+
+### Custom Domain
+
+```bash
+vercel domains add mcp.example.com
+```
+
+Configure your DNS provider to point the domain to Vercel. TLS certificates are provisioned automatically.
+
+## Step 6: Verify
+
+```bash
+# Health check
+curl https://your-project.vercel.app/health
+
+# Test MCP endpoint
+curl -X POST https://your-project.vercel.app/mcp \
+  -H "Content-Type: application/json" \
+  -d '{"jsonrpc":"2.0","method":"tools/list","id":1}'
+```
+
+## Cold Start Notes
+
+Vercel serverless functions experience cold starts after periods of inactivity. To minimize impact:
+
+- The `frontmcp build --target vercel` output is optimized for bundle size. Avoid adding unnecessary dependencies.
+- Consider Vercel's **Fluid Compute** for latency-sensitive workloads.
+- Keep function memory at 1024 MB for faster initialization.
+
+### Execution Limits
+
+| Plan       | Max Duration |
+| ---------- | ------------ |
+| Hobby      | 10 seconds   |
+| Pro        | 60 seconds   |
+| Enterprise | 900 seconds  |
+
+Long-running MCP operations should complete within these limits or use streaming responses.
+
+### Statelessness
+
+Serverless functions are stateless between invocations. All persistent state must go through Vercel KV. FrontMCP handles this automatically when `{ provider: 'vercel-kv' }` is configured.
+
+## Common Patterns
+
+| Pattern               | Correct                                    | Incorrect                            | Why                                                                             |
+| --------------------- | ------------------------------------------ | ------------------------------------ | ------------------------------------------------------------------------------- |
+| Build command         | `frontmcp build --target vercel`           | `tsc` or generic `npm run build`     | The Vercel target produces optimized bundles and the `api/` directory structure |
+| KV provider config    | `{ provider: 'vercel-kv' }`                | `{ provider: 'redis', host: '...' }` | Vercel KV uses its own REST API; a raw Redis provider will not connect          |
+| Rewrite rule          | `"source": "/(.*)"` to `/api/frontmcp`     | No rewrite or per-route entries      | A single catch-all rewrite lets FrontMCP's internal router handle all paths     |
+| Environment variables | Link KV store in dashboard (auto-injected) | Hardcode `KV_REST_API_URL` in source | Linked stores inject vars automatically and rotate tokens safely                |
+| Function memory       | 1024 MB for faster cold starts             | 128 MB default                       | CPU scales with memory on Vercel; higher memory reduces initialization time     |
+
+## Verification Checklist
+
+**Build**
+
+- [ ] `frontmcp build --target vercel` completes without errors
+- [ ] `api/frontmcp.ts` (or `.js`) exists in the build output
+
+**Deployment**
+
+- [ ] `vercel` creates a preview deployment without errors
+- [ ] `vercel --prod` deploys to the production domain
+- [ ] `curl https://your-project.vercel.app/health` returns `{"status":"ok"}`
+
+**Storage and Configuration**
+
+- [ ] Vercel KV store is created and linked to the project
+- [ ] `KV_REST_API_URL` and `KV_REST_API_TOKEN` are present in environment variables
+- [ ] `NODE_ENV` is set to `production`
+- [ ] `vercel.json` has correct rewrite, function config, and region settings
+
+**Production Readiness**
+
+- [ ] Custom domain is configured with DNS pointing to Vercel
+- [ ] TLS certificate is provisioned (automatic on Vercel)
+- [ ] `maxDuration` in `vercel.json` matches your Vercel plan limits
+
+## Troubleshooting
+
+| Problem              | Cause                                         | Solution                                                                                       |
+| -------------------- | --------------------------------------------- | ---------------------------------------------------------------------------------------------- |
+| Function timeout     | Operation exceeds `maxDuration` or plan limit | Increase `maxDuration` in `vercel.json`; check plan limits (Hobby: 10s, Pro: 60s)              |
+| KV connection errors | KV store not linked or env vars missing       | Re-link the KV store in the Vercel dashboard; verify `KV_REST_API_URL` and `KV_REST_API_TOKEN` |
+| 404 on API routes    | Rewrite rule missing or misconfigured         | Confirm `vercel.json` has `"source": "/(.*)"` rewriting to `/api/frontmcp`                     |
+| Bundle too large     | Unnecessary dependencies included             | Review dependencies and remove unused packages to reduce bundle size                           |
+| Cold starts too slow | Low function memory or large bundle           | Increase memory to 1024 MB; audit dependencies; consider Vercel Fluid Compute                  |
+
+## Reference
+
+- **Docs:** https://docs.agentfront.dev/frontmcp/deployment/serverless
+- **Related skills:** `deploy-to-node`, `deploy-to-lambda`