@frontmcp/skills 1.0.0-beta.9 → 1.0.0

package/catalog/frontmcp-config/references/configure-auth-modes.md

@@ -1,3 +1,8 @@
+---
+name: configure-auth-modes
+description: Detailed comparison of public, transparent, remote, and managed auth modes
+---
+
 # Auth Modes Detailed Comparison
 
 ## Public Mode
@@ -75,3 +80,13 @@ auth: {
 | Credential vault | No            | No              | Yes         | Yes          |
 | Consent flow     | No            | No              | Optional    | Optional     |
 | Federated auth   | No            | No              | Optional    | Optional     |
+
+## Examples
+
+| Example                                                                                        | Level        | Description                                                                                 |
+| ---------------------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------- |
+| [`local-self-signed-tokens`](../examples/configure-auth-modes/local-self-signed-tokens.md)     | Intermediate | Configure a server that signs its own JWT tokens with consent and incremental auth enabled. |
+| [`remote-enterprise-oauth`](../examples/configure-auth-modes/remote-enterprise-oauth.md)       | Advanced     | Delegate authentication to an external OAuth orchestrator with Redis-backed token storage.  |
+| [`transparent-jwt-validation`](../examples/configure-auth-modes/transparent-jwt-validation.md) | Basic        | Validate externally-issued JWTs without managing token lifecycle on the server.             |
+
+> See all examples in [`examples/configure-auth-modes/`](../examples/configure-auth-modes/)

package/catalog/frontmcp-config/references/configure-auth.md

@@ -1,3 +1,8 @@
+---
+name: configure-auth
+description: Set up authentication modes, credential vault, and OAuth flows for FrontMCP servers
+---
+
 # Configure Authentication for FrontMCP
 
 This skill covers setting up authentication in a FrontMCP server. FrontMCP supports four auth modes, each suited to different deployment scenarios. All authentication logic lives in the `@frontmcp/auth` library.
@@ -232,6 +237,16 @@ The `authProviders` accessor (from `@frontmcp/auth`) provides:
 | `VAULT_SECRET is not defined` error     | The vault encryption secret environment variable is missing                  | Set `VAULT_SECRET` in your environment or `.env` file before starting the server                  |
 | OAuth redirect fails in local dev       | `remote` mode requires HTTPS and reachable callback URLs                     | Set `NODE_ENV=development` to relax HTTPS requirements, or use a local OAuth mock server          |
 
+## Examples
+
+| Example                                                                            | Level        | Description                                                                                                                                                |
+| ---------------------------------------------------------------------------------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [`multi-app-auth`](../examples/configure-auth/multi-app-auth.md)                   | Advanced     | Configure a single FrontMCP server with multiple apps, each using a different auth mode -- public for open endpoints and remote for admin endpoints.       |
+| [`public-mode-setup`](../examples/configure-auth/public-mode-setup.md)             | Basic        | Set up a FrontMCP server with public (unauthenticated) access and anonymous scopes.                                                                        |
+| [`remote-oauth-with-vault`](../examples/configure-auth/remote-oauth-with-vault.md) | Intermediate | Configure a FrontMCP server with remote OAuth 2.1 authentication and use the credential vault to call downstream APIs on behalf of the authenticated user. |
+
+> See all examples in [`examples/configure-auth/`](../examples/configure-auth/)
+
 ## Reference
 
 - Docs: [Authentication Overview](https://docs.agentfront.dev/frontmcp/authentication/overview)

package/catalog/frontmcp-config/references/configure-elicitation.md

@@ -1,3 +1,8 @@
+---
+name: configure-elicitation
+description: Configure interactive user input during tool execution for confirmations, choices, and forms
+---
+
 # Configuring Elicitation
 
 Elicitation allows tools to request interactive input from users mid-execution — confirmations, choices, or structured form data.
@@ -172,6 +177,15 @@ frontmcp dev
 | User sees raw JSON instead of a form              | The MCP client renders the `requestedSchema` as raw data rather than a form | Use standard JSON Schema types (`boolean`, `string`, `enum`) that clients can render as UI controls |
 | Tool hangs indefinitely waiting for user response | No timeout configured and user never responds                               | Implement a timeout or cancellation mechanism in the tool logic to handle non-responsive users      |
 
+## Examples
+
+| Example                                                                                               | Level        | Description                                                                         |
+| ----------------------------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------------- |
+| [`basic-confirmation-gate`](../examples/configure-elicitation/basic-confirmation-gate.md)             | Basic        | Request user confirmation before executing a destructive action.                    |
+| [`distributed-elicitation-redis`](../examples/configure-elicitation/distributed-elicitation-redis.md) | Intermediate | Configure elicitation with Redis storage for multi-instance production deployments. |
+
+> See all examples in [`examples/configure-elicitation/`](../examples/configure-elicitation/)
+
 ## Reference
 
 - [Elicitation Docs](https://docs.agentfront.dev/frontmcp/servers/elicitation)

package/catalog/frontmcp-config/references/configure-http.md

@@ -1,3 +1,8 @@
+---
+name: configure-http
+description: Configure HTTP server port, CORS policy, unix sockets, and entry path prefix
+---
+
 # Configuring HTTP Options
 
 Configure the HTTP server — port, CORS policy, unix sockets, and entry path prefix.
@@ -199,6 +204,16 @@ curl --unix-socket /tmp/my-mcp-server.sock http://localhost/
 | Routes return 404 after setting `entryPath`      | Client is still requesting the root path without the prefix                                | Update client base URL to include the entry path (e.g., `http://localhost:3001/api/mcp`)                |
 | Server binds but external clients cannot connect | Server bound to `localhost` or `127.0.0.1` inside a container                              | Set `host: '0.0.0.0'` or use Docker port mapping to expose the container port                           |
 
+## Examples
+
+| Example                                                                              | Level        | Description                                                                          |
+| ------------------------------------------------------------------------------------ | ------------ | ------------------------------------------------------------------------------------ |
+| [`cors-restricted-origins`](../examples/configure-http/cors-restricted-origins.md)   | Basic        | Configure CORS to allow only specific frontend origins with credentials.             |
+| [`entry-path-reverse-proxy`](../examples/configure-http/entry-path-reverse-proxy.md) | Intermediate | Mount the MCP server under a URL prefix for reverse proxy or multi-service setups.   |
+| [`unix-socket-local`](../examples/configure-http/unix-socket-local.md)               | Intermediate | Bind the server to a unix socket instead of a TCP port for local-only communication. |
+
+> See all examples in [`examples/configure-http/`](../examples/configure-http/)
+
 ## Reference
 
 - [HTTP Server Docs](https://docs.agentfront.dev/frontmcp/deployment/local-dev-server)

package/catalog/frontmcp-config/references/configure-session.md

@@ -1,3 +1,8 @@
+---
+name: configure-session
+description: Set up session storage with Redis or Vercel KV for persistent user state across requests
+---
+
 # Configure Session Management
 
 This skill covers setting up session storage in FrontMCP. Sessions track authenticated user state, token storage, and request context across MCP interactions.
@@ -199,6 +204,16 @@ const pubsubStore = createPubsubStore({
 | Session key collisions between servers | Multiple servers share the same Redis instance and `keyPrefix` | Set a unique `keyPrefix` per server (e.g., `billing-mcp:session:`, `api-mcp:session:`)         |
 | Pub/sub not working with Vercel KV     | Vercel KV does not support pub/sub operations                  | Add a separate `pubsub` config pointing to a real Redis instance                               |
 
+## Examples
+
+| Example                                                                               | Level        | Description                                                                      |
+| ------------------------------------------------------------------------------------- | ------------ | -------------------------------------------------------------------------------- |
+| [`multi-server-key-prefix`](../examples/configure-session/multi-server-key-prefix.md) | Intermediate | Use unique key prefixes when multiple FrontMCP servers share one Redis instance. |
+| [`redis-session-store`](../examples/configure-session/redis-session-store.md)         | Basic        | Configure Redis-backed session storage for production deployments.               |
+| [`vercel-kv-session`](../examples/configure-session/vercel-kv-session.md)             | Intermediate | Configure Vercel KV for session storage in serverless Vercel deployments.        |
+
+> See all examples in [`examples/configure-session/`](../examples/configure-session/)
+
 ## Reference
 
 - [Session Storage Docs](https://docs.agentfront.dev/frontmcp/deployment/redis-setup)

package/catalog/frontmcp-config/references/configure-throttle-guard-config.md

@@ -1,3 +1,8 @@
+---
+name: configure-throttle-guard-config
+description: Complete GuardConfig interface reference for rate limiting, concurrency, and IP filtering
+---
+
 # GuardConfig Full Reference
 
 ## Complete Configuration
@@ -66,3 +71,12 @@ interface IpFilterConfig {
 4. Per-tool rate limit — checked per tool
 5. Per-tool concurrency — checked per tool
 6. Per-tool timeout — enforced during execution
+
+## Examples
+
+| Example                                                                                       | Level    | Description                                                              |
+| --------------------------------------------------------------------------------------------- | -------- | ------------------------------------------------------------------------ |
+| [`full-guard-config`](../examples/configure-throttle-guard-config/full-guard-config.md)       | Advanced | Complete GuardConfig using every available field for maximum protection. |
+| [`minimal-guard-config`](../examples/configure-throttle-guard-config/minimal-guard-config.md) | Basic    | Enable throttle with just a global rate limit and default timeout.       |
+
+> See all examples in [`examples/configure-throttle-guard-config/`](../examples/configure-throttle-guard-config/)

package/catalog/frontmcp-config/references/configure-throttle.md

@@ -1,3 +1,8 @@
+---
+name: configure-throttle
+description: Protect servers with rate limiting, concurrency control, execution timeouts, and IP filtering
+---
+
 # Configuring Throttle, Rate Limits, and IP Filtering
 
 Protect your FrontMCP server with rate limiting, concurrency control, execution timeouts, and IP filtering — at both server and per-tool levels.
@@ -223,6 +228,16 @@ done
 | `X-Forwarded-For` header ignored                | `ipFilter.trustProxy` not enabled or `trustedProxyDepth` too low         | Set `trustProxy: true` and adjust `trustedProxyDepth` to match your proxy chain |
 | Rate limit resets not aligned with expectations | `windowMs` misunderstood as a sliding window when it is a fixed window   | The window is fixed; all counters reset at the end of each `windowMs` interval  |
 
+## Examples
+
+| Example                                                                                      | Level        | Description                                                                                 |
+| -------------------------------------------------------------------------------------------- | ------------ | ------------------------------------------------------------------------------------------- |
+| [`distributed-redis-throttle`](../examples/configure-throttle/distributed-redis-throttle.md) | Advanced     | Configure Redis-backed rate limiting for multi-instance deployments behind a load balancer. |
+| [`per-tool-rate-limit`](../examples/configure-throttle/per-tool-rate-limit.md)               | Intermediate | Override server defaults with per-tool rate limits and concurrency caps.                    |
+| [`server-level-rate-limit`](../examples/configure-throttle/server-level-rate-limit.md)       | Basic        | Configure global rate limits and IP filtering at the server level.                          |
+
+> See all examples in [`examples/configure-throttle/`](../examples/configure-throttle/)
+
 ## Reference
 
 - [Guard Configuration Docs](https://docs.agentfront.dev/frontmcp/servers/guard)

package/catalog/frontmcp-config/references/configure-transport-protocol-presets.md

@@ -1,3 +1,8 @@
+---
+name: configure-transport-protocol-presets
+description: Reference for legacy, modern, stateless, and minimal transport protocol presets
+---
+
 # Transport Protocol Presets Reference
 
 ## Preset Configurations
@@ -55,3 +60,12 @@ All protocols enabled. Maximum flexibility.
 | AWS Lambda                | `'stateless-api'`              | Stateless execution model                 |
 | Cloudflare Workers        | `'stateless-api'`              | Stateless edge runtime                    |
 | Development               | `'full'`                       | Test all protocols                        |
+
+## Examples
+
+| Example                                                                                                    | Level        | Description                                                                   |
+| ---------------------------------------------------------------------------------------------------------- | ------------ | ----------------------------------------------------------------------------- |
+| [`legacy-preset-nodejs`](../examples/configure-transport-protocol-presets/legacy-preset-nodejs.md)         | Basic        | Use the default legacy preset for maximum compatibility with all MCP clients. |
+| [`stateless-api-serverless`](../examples/configure-transport-protocol-presets/stateless-api-serverless.md) | Intermediate | Use the stateless-api preset for Vercel, Lambda, or Cloudflare Workers.       |
+
+> See all examples in [`examples/configure-transport-protocol-presets/`](../examples/configure-transport-protocol-presets/)

package/catalog/frontmcp-config/references/configure-transport.md

@@ -1,3 +1,8 @@
+---
+name: configure-transport
+description: Configure client transport protocols including SSE, Streamable HTTP, and stateless API modes
+---
+
 # Configuring Transport
 
 Configure how clients connect to your FrontMCP server — SSE, Streamable HTTP, stateless API, or a combination.
@@ -189,6 +194,16 @@ curl -X POST http://localhost:3001/ -H 'Content-Type: application/json' -d '{"js
 | Session not found after server restart | In-memory sessions do not survive restarts                                 | Enable Redis persistence with `distributedMode: true`                                      |
 | Streamable HTTP returns 404            | Streamable HTTP is not enabled in the current preset                       | Use `'modern'`, `'legacy'`, or `'full'` preset, or set `streamable: true` in custom config |
 
+## Examples
+
+| Example                                                                                       | Level        | Description                                                                              |
+| --------------------------------------------------------------------------------------------- | ------------ | ---------------------------------------------------------------------------------------- |
+| [`custom-protocol-flags`](../examples/configure-transport/custom-protocol-flags.md)           | Advanced     | Override individual protocol flags instead of using a preset for fine-grained control.   |
+| [`distributed-sessions-redis`](../examples/configure-transport/distributed-sessions-redis.md) | Intermediate | Configure transport with Redis persistence for multi-instance load-balanced deployments. |
+| [`stateless-serverless`](../examples/configure-transport/stateless-serverless.md)             | Basic        | Configure stateless transport for Vercel, Lambda, or Cloudflare deployments.             |
+
+> See all examples in [`examples/configure-transport/`](../examples/configure-transport/)
+
 ## Reference
 
 - **Docs:** [Runtime Modes and Transport Configuration](https://docs.agentfront.dev/frontmcp/deployment/runtime-modes)

package/catalog/frontmcp-config/references/setup-redis.md

@@ -1,4 +1,14 @@
+---
+name: setup-redis
+description: Cross-reference to the full Redis configuration guide in frontmcp-setup
+---
+
 # Redis Setup Reference
 
 > This reference is maintained in `frontmcp-setup/references/setup-redis.md`.
 > See that file for the full Redis configuration guide including connection options, Vercel KV setup, Docker Compose examples, and troubleshooting.
+
+## Examples
+
+> Examples for Redis setup are maintained alongside the canonical reference.
+> See [`frontmcp-setup/examples/setup-redis/`](../../frontmcp-setup/examples/setup-redis/).

package/catalog/frontmcp-config/references/setup-sqlite.md

@@ -1,4 +1,14 @@
+---
+name: setup-sqlite
+description: Cross-reference to the full SQLite configuration guide in frontmcp-setup
+---
+
 # SQLite Setup Reference
 
 > This reference is maintained in `frontmcp-setup/references/setup-sqlite.md`.
 > See that file for the full SQLite configuration guide including WAL mode, encryption, daemon mode, and troubleshooting.
+
+## Examples
+
+> Examples for SQLite setup are maintained alongside the canonical reference.
+> See [`frontmcp-setup/examples/setup-sqlite/`](../../frontmcp-setup/examples/setup-sqlite/).

package/catalog/frontmcp-deployment/SKILL.md

@@ -1,12 +1,15 @@
 ---
 name: frontmcp-deployment
-description: "Domain router for shipping MCP servers \u2014 deploy to Node, Vercel, Lambda, Cloudflare, or build for CLI, browser, and SDK. Use when choosing a deployment target or build format."
+description: 'Use when you need to deploy, build for production, containerize, or ship a FrontMCP server. Covers Vercel, Lambda, Cloudflare, Docker, edge runtime, serverless, bundle for CLI, and Node targets. Triggers: deploy, build for production, dockerize, serverless, go live.'
 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/overview
+  docs: https://docs.agentfront.dev/frontmcp/deployment/runtime-modes
 ---
 
 # FrontMCP Deployment Router
@@ -50,15 +53,40 @@ Entry point for deploying and building FrontMCP servers. This skill helps you ch
 
 ## Scenario Routing Table
 
-| Scenario                                          | Skill                  | 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               |
-| 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          |
+| Scenario                                          | Skill                       | 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               |
+| 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)                             |
+
+### 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
 
@@ -120,5 +148,5 @@ Entry point for deploying and building FrontMCP servers. This skill helps you ch
 
 ## Reference
 
-- [Deployment Overview](https://docs.agentfront.dev/frontmcp/deployment/overview)
+- [Runtime Modes](https://docs.agentfront.dev/frontmcp/deployment/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`

package/catalog/frontmcp-deployment/examples/build-for-browser/browser-build-with-custom-entry.md

@@ -0,0 +1,43 @@
+---
+name: browser-build-with-custom-entry
+reference: build-for-browser
+level: intermediate
+description: 'Build a browser bundle using a dedicated client entry file that avoids Node.js-only imports.'
+tags: [deployment, browser, node, custom, entry]
+features:
+  - 'Creating a separate browser entry point (`src/client.ts`) that avoids importing Node.js-only modules like `fs` or `node:crypto`'
+  - 'Using the `-e` and `-o` flags to customize the entry file and output directory'
+---
+
+# Browser Build with Custom Entry
+
+Build a browser bundle using a dedicated client entry file that avoids Node.js-only imports.
+
+## Code
+
+```typescript
+// src/client.ts
+// Browser-safe entry point - no Node.js modules imported here
+import { FrontMcpProvider, useTools, useResources } from '@frontmcp/react';
+
+export { FrontMcpProvider, useTools, useResources };
+```
+
+```bash
+# Build with custom entry and output directory
+frontmcp build --target browser -e ./src/client.ts -o ./dist/browser
+```
+
+```bash
+# Verify output contains no Node.js-only modules
+ls dist/browser/
+```
+
+## What This Demonstrates
+
+- Creating a separate browser entry point (`src/client.ts`) that avoids importing Node.js-only modules like `fs` or `node:crypto`
+- Using the `-e` and `-o` flags to customize the entry file and output directory
+
+## Related
+
+- See `build-for-browser` for the full browser limitations table and verification checklist

package/catalog/frontmcp-deployment/examples/build-for-browser/browser-crypto-and-storage.md

@@ -0,0 +1,85 @@
+---
+name: browser-crypto-and-storage
+reference: build-for-browser
+level: advanced
+description: 'Use `@frontmcp/utils` crypto functions (WebCrypto API) and in-memory storage in browser environments.'
+tags: [deployment, browser, database, remote, node, crypto]
+features:
+  - 'Using `@frontmcp/utils` for PKCE and hashing in the browser (backed by WebCrypto, not `node:crypto`)'
+  - 'Avoiding filesystem and native database storage in browser builds by relying on a remote server for persistence'
+---
+
+# Browser-Safe Crypto and Storage
+
+Use `@frontmcp/utils` crypto functions (WebCrypto API) and in-memory storage in browser environments.
+
+## Code
+
+```typescript
+// src/browser-auth.ts
+import { generateCodeVerifier, generateCodeChallenge, sha256Base64url, randomUUID } from '@frontmcp/utils';
+
+// PKCE flow in the browser - uses WebCrypto API automatically
+async function startPkceFlow(): Promise<{
+  verifier: string;
+  challenge: string;
+  state: string;
+}> {
+  const verifier = generateCodeVerifier();
+  const challenge = await generateCodeChallenge(verifier);
+  const state = randomUUID();
+
+  return { verifier, challenge, state };
+}
+
+// Hash a value using WebCrypto (works in browsers)
+async function hashToken(token: string): Promise<string> {
+  return sha256Base64url(token);
+}
+
+export { startPkceFlow, hashToken };
+```
+
+```typescript
+// src/client-app.tsx
+import { FrontMcpProvider, useTools } from '@frontmcp/react';
+
+// Browser environments cannot use Redis or SQLite.
+// Use in-memory stores or connect to a remote server that handles persistence.
+function App() {
+  return (
+    <FrontMcpProvider
+      config={{
+        serverUrl: 'https://my-mcp.example.com',
+        // No local storage config - the remote server handles persistence
+      }}
+    >
+      <ToolDashboard />
+    </FrontMcpProvider>
+  );
+}
+
+function ToolDashboard() {
+  const { tools, callTool } = useTools();
+
+  return (
+    <div>
+      <h1>MCP Tools</h1>
+      {tools.map((tool) => (
+        <div key={tool.name}>{tool.name}</div>
+      ))}
+    </div>
+  );
+}
+
+export default App;
+```
+
+## What This Demonstrates
+
+- Using `@frontmcp/utils` for PKCE and hashing in the browser (backed by WebCrypto, not `node:crypto`)
+- Avoiding filesystem and native database storage in browser builds by relying on a remote server for persistence
+
+## Related
+
+- See `build-for-browser` for the complete browser support table and troubleshooting guide

package/catalog/frontmcp-deployment/examples/build-for-browser/react-provider-setup.md

@@ -0,0 +1,61 @@
+---
+name: react-provider-setup
+reference: build-for-browser
+level: basic
+description: 'Connect a React application to a remote FrontMCP server using `@frontmcp/react`.'
+tags: [deployment, react, browser, remote, provider, setup]
+features:
+  - 'Wrapping your React app with `FrontMcpProvider` and pointing it at a remote server URL'
+  - 'Using the `useTools` hook to list and invoke MCP tools from a React component'
+---
+
+# React Provider Setup
+
+Connect a React application to a remote FrontMCP server using `@frontmcp/react`.
+
+## Code
+
+```typescript
+// src/App.tsx
+import { FrontMcpProvider, useTools } from '@frontmcp/react';
+
+function App() {
+  return (
+    <FrontMcpProvider config={{ serverUrl: 'https://my-mcp.example.com' }}>
+      <ToolUI />
+    </FrontMcpProvider>
+  );
+}
+
+function ToolUI() {
+  const { tools, callTool } = useTools();
+
+  const handleClick = async (toolName: string) => {
+    const result = await callTool(toolName, { query: 'hello' });
+    console.log(result);
+  };
+
+  return (
+    <ul>
+      {tools.map((tool) => (
+        <li key={tool.name}>
+          <button onClick={() => handleClick(tool.name)}>
+            {tool.name}: {tool.description}
+          </button>
+        </li>
+      ))}
+    </ul>
+  );
+}
+
+export default App;
+```
+
+## What This Demonstrates
+
+- Wrapping your React app with `FrontMcpProvider` and pointing it at a remote server URL
+- Using the `useTools` hook to list and invoke MCP tools from a React component
+
+## Related
+
+- See `build-for-browser` for the full build command and browser limitations

package/catalog/frontmcp-deployment/examples/build-for-cli/cli-binary-build.md

@@ -0,0 +1,66 @@
+---
+name: cli-binary-build
+reference: build-for-cli
+level: basic
+description: 'Build a FrontMCP server as a standalone binary using Node.js Single Executable Applications (SEA).'
+tags: [deployment, cli, local, node, binary]
+features:
+  - 'Building a FrontMCP server as a self-contained binary with `--target cli`'
+  - 'Using `socketPath` for local communication instead of a TCP port'
+  - 'The `--js` flag to produce a bundled JS file without the native binary wrapper'
+---
+
+# CLI Binary Build
+
+Build a FrontMCP server as a standalone binary using Node.js Single Executable Applications (SEA).
+
+## Code
+
+```typescript
+// src/main.ts
+import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'greet',
+  description: 'Greet a user by name',
+  inputSchema: { name: z.string() },
+})
+class GreetTool extends ToolContext<{ name: string }> {
+  async execute(input: { name: string }) {
+    return { content: [{ type: 'text' as const, text: `Hello, ${input.name}!` }] };
+  }
+}
+
+@App({ name: 'GreeterApp', tools: [GreetTool] })
+class GreeterApp {}
+
+@FrontMcp({
+  info: { name: 'greeter-cli', version: '1.0.0' },
+  apps: [GreeterApp],
+  http: { socketPath: '/tmp/greeter.sock' },
+})
+class GreeterCLI {}
+```
+
+```bash
+# Build the SEA binary (requires Node.js 24+)
+frontmcp build --target cli
+
+# Test the binary
+./dist/greeter-cli --help
+
+# Or build a JS bundle only (no SEA)
+frontmcp build --target cli --js
+node dist/greeter-cli.cjs.js
+```
+
+## What This Demonstrates
+
+- Building a FrontMCP server as a self-contained binary with `--target cli`
+- Using `socketPath` for local communication instead of a TCP port
+- The `--js` flag to produce a bundled JS file without the native binary wrapper
+
+## Related
+
+- See `build-for-cli` for SEA requirements, process management, and system service installation