@frontmcp/skills 1.0.0-beta.13 → 1.0.0-beta.14

package/catalog/frontmcp-config/examples/configure-throttle-guard-config/full-guard-config.md

@@ -0,0 +1,99 @@
+---
+name: full-guard-config
+reference: configure-throttle-guard-config
+level: advanced
+description: 'Complete GuardConfig using every available field for maximum protection.'
+tags: [config, redis, session, throttle, guard, full]
+features:
+  - 'Every field in the `GuardConfig` interface used together'
+  - 'Priority order: IP filter -> global rate limit -> global concurrency -> per-tool limits'
+  - 'Redis `storage` for shared counters across instances'
+  - '`keyPrefix` to namespace guard keys in shared Redis'
+  - "Mixed `partitionBy` strategies: `'ip'` for global, `'session'` for per-tool"
+  - '`queueTimeoutMs` to briefly queue excess requests instead of rejecting'
+---
+
+# Full GuardConfig with All Options
+
+Complete GuardConfig using every available field for maximum protection.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App } from '@frontmcp/sdk';
+
+@App({ name: 'secure-app' })
+class SecureApp {}
+
+@FrontMcp({
+  info: { name: 'fully-guarded-server', version: '1.0.0' },
+  apps: [SecureApp],
+  throttle: {
+    enabled: true,
+
+    // Distributed storage for multi-instance deployments
+    storage: {
+      type: 'redis',
+      redis: {
+        config: {
+          host: process.env['REDIS_HOST'] ?? 'redis.internal',
+          port: 6379,
+        },
+      },
+    },
+    keyPrefix: 'myapp:guard:',
+
+    // Server-wide limits
+    global: {
+      maxRequests: 1000,
+      windowMs: 60000,
+      partitionBy: 'ip', // per-client IP rate limit
+    },
+    globalConcurrency: {
+      maxConcurrent: 50,
+      queueTimeoutMs: 2000,
+      partitionBy: 'global',
+    },
+
+    // Default per-tool limits
+    defaultRateLimit: {
+      maxRequests: 100,
+      windowMs: 60000,
+      partitionBy: 'session',
+    },
+    defaultConcurrency: {
+      maxConcurrent: 10,
+      queueTimeoutMs: 5000,
+      partitionBy: 'session',
+    },
+    defaultTimeout: {
+      executeMs: 30000,
+    },
+
+    // IP-based access control
+    ipFilter: {
+      allowList: ['10.0.0.0/8', '172.16.0.0/12'],
+      denyList: ['192.168.1.100'],
+      defaultAction: 'deny',
+      trustProxy: true,
+      trustedProxyDepth: 2,
+    },
+  },
+})
+class Server {}
+```
+
+## What This Demonstrates
+
+- Every field in the `GuardConfig` interface used together
+- Priority order: IP filter -> global rate limit -> global concurrency -> per-tool limits
+- Redis `storage` for shared counters across instances
+- `keyPrefix` to namespace guard keys in shared Redis
+- Mixed `partitionBy` strategies: `'ip'` for global, `'session'` for per-tool
+- `queueTimeoutMs` to briefly queue excess requests instead of rejecting
+
+## Related
+
+- See `configure-throttle-guard-config` for the complete interface reference
+- See `configure-throttle` for practical throttle configuration patterns

package/catalog/frontmcp-config/examples/configure-throttle-guard-config/minimal-guard-config.md

@@ -0,0 +1,55 @@
+---
+name: minimal-guard-config
+reference: configure-throttle-guard-config
+level: basic
+description: 'Enable throttle with just a global rate limit and default timeout.'
+tags: [config, throttle, guard, minimal]
+features:
+  - 'The minimum fields needed to enable the guard: `enabled`, `global`, and `defaultTimeout`'
+  - "`partitionBy: 'global'` shares one counter across all clients"
+  - '`windowMs` defaults to 60000 (1 minute) if omitted'
+  - 'Other fields (`globalConcurrency`, `ipFilter`, `storage`) are optional'
+---
+
+# Minimal GuardConfig
+
+Enable throttle with just a global rate limit and default timeout.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App } from '@frontmcp/sdk';
+
+@App({ name: 'my-app' })
+class MyApp {}
+
+@FrontMcp({
+  info: { name: 'guarded-server', version: '1.0.0' },
+  apps: [MyApp],
+  throttle: {
+    enabled: true,
+    global: {
+      maxRequests: 1000,
+      windowMs: 60000,
+      partitionBy: 'global',
+    },
+    defaultTimeout: {
+      executeMs: 30000,
+    },
+  },
+})
+class Server {}
+```
+
+## What This Demonstrates
+
+- The minimum fields needed to enable the guard: `enabled`, `global`, and `defaultTimeout`
+- `partitionBy: 'global'` shares one counter across all clients
+- `windowMs` defaults to 60000 (1 minute) if omitted
+- Other fields (`globalConcurrency`, `ipFilter`, `storage`) are optional
+
+## Related
+
+- See `configure-throttle-guard-config` for the complete GuardConfig interface
+- See `configure-throttle` for practical throttle configuration patterns

package/catalog/frontmcp-config/examples/configure-transport/custom-protocol-flags.md

@@ -0,0 +1,74 @@
+---
+name: custom-protocol-flags
+reference: configure-transport
+level: advanced
+description: 'Override individual protocol flags instead of using a preset for fine-grained control.'
+tags: [config, redis, session, transport, custom, protocol]
+features:
+  - 'Passing an object to `protocol` instead of a preset string for fine-grained control'
+  - 'Enabling SSE, streamable HTTP, and JSON-only modes simultaneously'
+  - 'Setting `strictSession: true` to require `mcp-session-id` header on streamable HTTP'
+  - "Using `distributedMode: 'auto'` to auto-detect based on whether Redis is configured"
+  - 'Disabling `legacy` SSE while keeping modern SSE support'
+---
+
+# Custom Protocol Flags
+
+Override individual protocol flags instead of using a preset for fine-grained control.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'stream_logs',
+  description: 'Stream application logs',
+  inputSchema: { service: z.string(), lines: z.number().optional() },
+  outputSchema: { logs: z.array(z.string()) },
+})
+class StreamLogsTool extends ToolContext {
+  async execute(input: { service: string; lines?: number }) {
+    return { logs: ['[INFO] Service started', '[INFO] Healthy'] };
+  }
+}
+
+@App({
+  name: 'devtools',
+  tools: [StreamLogsTool],
+})
+class DevtoolsApp {}
+
+@FrontMcp({
+  info: { name: 'custom-protocol-server', version: '1.0.0' },
+  apps: [DevtoolsApp],
+  transport: {
+    sessionMode: 'stateful',
+    protocol: {
+      sse: true, // SSE endpoint enabled
+      streamable: true, // Streamable HTTP POST enabled
+      json: true, // JSON-only responses also available
+      stateless: false, // Sessions required
+      legacy: false, // No legacy SSE
+      strictSession: true, // Require mcp-session-id header
+    },
+    distributedMode: 'auto', // auto-detect based on Redis config
+  },
+})
+class Server {}
+```
+
+## What This Demonstrates
+
+- Passing an object to `protocol` instead of a preset string for fine-grained control
+- Enabling SSE, streamable HTTP, and JSON-only modes simultaneously
+- Setting `strictSession: true` to require `mcp-session-id` header on streamable HTTP
+- Using `distributedMode: 'auto'` to auto-detect based on whether Redis is configured
+- Disabling `legacy` SSE while keeping modern SSE support
+
+## Related
+
+- See `configure-transport` for the full transport configuration reference
+- See `configure-transport-protocol-presets` for the built-in preset definitions

package/catalog/frontmcp-config/examples/configure-transport/distributed-sessions-redis.md

@@ -0,0 +1,86 @@
+---
+name: distributed-sessions-redis
+reference: configure-transport
+level: intermediate
+description: 'Configure transport with Redis persistence for multi-instance load-balanced deployments.'
+tags: [config, redis, session, transport, distributed, sessions]
+features:
+  - 'Using `distributedMode: true` for load-balanced multi-instance deployments'
+  - 'Redis `persistence` so sessions survive restarts and are shared across instances'
+  - 'Setting `defaultTtlMs` to prevent sessions from accumulating indefinitely'
+  - 'Redis-backed `eventStore` for SSE resumability across instances'
+  - "Using the `'modern'` preset (drops legacy SSE but keeps streamable HTTP)"
+---
+
+# Distributed Sessions with Redis
+
+Configure transport with Redis persistence for multi-instance load-balanced deployments.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'get_report',
+  description: 'Generate a report',
+  inputSchema: { reportId: z.string() },
+  outputSchema: { data: z.string(), generatedAt: z.string() },
+})
+class GetReportTool extends ToolContext {
+  async execute(input: { reportId: string }) {
+    return { data: 'report-data', generatedAt: new Date().toISOString() };
+  }
+}
+
+@App({
+  name: 'reports',
+  tools: [GetReportTool],
+})
+class ReportsApp {}
+
+@FrontMcp({
+  info: { name: 'distributed-server', version: '1.0.0' },
+  apps: [ReportsApp],
+  transport: {
+    sessionMode: 'stateful',
+    protocol: 'modern',
+    distributedMode: true,
+    persistence: {
+      redis: {
+        provider: 'redis',
+        host: process.env['REDIS_HOST'] ?? 'redis.internal',
+        port: 6379,
+      },
+      defaultTtlMs: 3_600_000, // 1 hour session TTL
+    },
+    eventStore: {
+      enabled: true,
+      provider: 'redis',
+      maxEvents: 10000,
+      ttlMs: 300_000, // 5 minute event TTL
+      redis: {
+        provider: 'redis',
+        host: process.env['REDIS_HOST'] ?? 'redis.internal',
+      },
+    },
+  },
+})
+class Server {}
+```
+
+## What This Demonstrates
+
+- Using `distributedMode: true` for load-balanced multi-instance deployments
+- Redis `persistence` so sessions survive restarts and are shared across instances
+- Setting `defaultTtlMs` to prevent sessions from accumulating indefinitely
+- Redis-backed `eventStore` for SSE resumability across instances
+- Using the `'modern'` preset (drops legacy SSE but keeps streamable HTTP)
+
+## Related
+
+- See `configure-transport` for the full transport configuration reference
+- See `configure-session` for session storage options
+- See `setup-redis` for Redis provisioning

package/catalog/frontmcp-config/examples/configure-transport/stateless-serverless.md

@@ -0,0 +1,69 @@
+---
+name: stateless-serverless
+reference: configure-transport
+level: basic
+description: 'Configure stateless transport for Vercel, Lambda, or Cloudflare deployments.'
+tags: [config, vercel, lambda, cloudflare, session, transport]
+features:
+  - "Using `sessionMode: 'stateless'` to disable session management"
+  - "Using the `'stateless-api'` preset: no SSE, no streaming, pure request/response"
+  - 'Each request is standalone with no server-side state between invocations'
+  - 'Required for serverless targets (Vercel, Lambda, Cloudflare Workers)'
+---
+
+# Stateless Transport for Serverless
+
+Configure stateless transport for Vercel, Lambda, or Cloudflare deployments.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'convert_currency',
+  description: 'Convert between currencies',
+  inputSchema: {
+    amount: z.number(),
+    from: z.string(),
+    to: z.string(),
+  },
+  outputSchema: { result: z.number(), rate: z.number() },
+})
+class ConvertCurrencyTool extends ToolContext {
+  async execute(input: { amount: number; from: string; to: string }) {
+    const rate = 1.1;
+    return { result: input.amount * rate, rate };
+  }
+}
+
+@App({
+  name: 'currency-api',
+  tools: [ConvertCurrencyTool],
+})
+class CurrencyApp {}
+
+@FrontMcp({
+  info: { name: 'serverless-server', version: '1.0.0' },
+  apps: [CurrencyApp],
+  transport: {
+    sessionMode: 'stateless',
+    protocol: 'stateless-api',
+  },
+})
+class Server {}
+```
+
+## What This Demonstrates
+
+- Using `sessionMode: 'stateless'` to disable session management
+- Using the `'stateless-api'` preset: no SSE, no streaming, pure request/response
+- Each request is standalone with no server-side state between invocations
+- Required for serverless targets (Vercel, Lambda, Cloudflare Workers)
+
+## Related
+
+- See `configure-transport` for the full transport configuration reference
+- See `configure-transport-protocol-presets` for all preset options

package/catalog/frontmcp-config/examples/configure-transport-protocol-presets/legacy-preset-nodejs.md

@@ -0,0 +1,65 @@
+---
+name: legacy-preset-nodejs
+reference: configure-transport-protocol-presets
+level: basic
+description: 'Use the default legacy preset for maximum compatibility with all MCP clients.'
+tags: [config, anthropic, session, transport, node, protocol]
+features:
+  - "The `'legacy'` preset is the default and can be omitted"
+  - 'Enables SSE, Streamable HTTP, and Legacy SSE for maximum client compatibility'
+  - '`strictSession: true` requires `mcp-session-id` header for streamable HTTP'
+  - 'Best for single-instance Node.js deployments (Claude Desktop, etc.)'
+---
+
+# Legacy Preset for Node.js
+
+Use the default legacy preset for maximum compatibility with all MCP clients.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'hello',
+  description: 'Say hello',
+  inputSchema: { name: z.string() },
+  outputSchema: { greeting: z.string() },
+})
+class HelloTool extends ToolContext {
+  async execute(input: { name: string }) {
+    return { greeting: `Hello, ${input.name}!` };
+  }
+}
+
+@App({
+  name: 'my-app',
+  tools: [HelloTool],
+})
+class MyApp {}
+
+@FrontMcp({
+  info: { name: 'legacy-server', version: '1.0.0' },
+  apps: [MyApp],
+  transport: {
+    protocol: 'legacy', // default -- can be omitted
+  },
+})
+class Server {}
+// Enables: SSE + Streamable HTTP + Legacy SSE
+// Flags: { sse: true, streamable: true, json: false, stateless: false, legacy: true, strictSession: true }
+```
+
+## What This Demonstrates
+
+- The `'legacy'` preset is the default and can be omitted
+- Enables SSE, Streamable HTTP, and Legacy SSE for maximum client compatibility
+- `strictSession: true` requires `mcp-session-id` header for streamable HTTP
+- Best for single-instance Node.js deployments (Claude Desktop, etc.)
+
+## Related
+
+- See `configure-transport-protocol-presets` for all preset definitions
+- See `configure-transport` for full transport configuration

package/catalog/frontmcp-config/examples/configure-transport-protocol-presets/stateless-api-serverless.md

@@ -0,0 +1,69 @@
+---
+name: stateless-api-serverless
+reference: configure-transport-protocol-presets
+level: intermediate
+description: 'Use the stateless-api preset for Vercel, Lambda, or Cloudflare Workers.'
+tags: [config, vercel, lambda, cloudflare, session, transport]
+features:
+  - "The `'stateless-api'` preset disables SSE, streaming, and sessions entirely"
+  - 'Each request is standalone with no server-side state'
+  - "Pair with `sessionMode: 'stateless'` for serverless execution"
+  - 'Required for Vercel, Lambda, Cloudflare Workers where persistent connections are not allowed'
+---
+
+# Stateless API Preset for Serverless
+
+Use the stateless-api preset for Vercel, Lambda, or Cloudflare Workers.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App, Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'translate',
+  description: 'Translate text between languages',
+  inputSchema: {
+    text: z.string(),
+    targetLang: z.string(),
+  },
+  outputSchema: { translated: z.string() },
+})
+class TranslateTool extends ToolContext {
+  async execute(input: { text: string; targetLang: string }) {
+    return { translated: `[${input.targetLang}] ${input.text}` };
+  }
+}
+
+@App({
+  name: 'translate-api',
+  tools: [TranslateTool],
+})
+class TranslateApp {}
+
+@FrontMcp({
+  info: { name: 'serverless-translate', version: '1.0.0' },
+  apps: [TranslateApp],
+  transport: {
+    sessionMode: 'stateless',
+    protocol: 'stateless-api',
+  },
+})
+class Server {}
+// Enables: Stateless HTTP only
+// Flags: { sse: false, streamable: false, json: false, stateless: true, legacy: false, strictSession: false }
+```
+
+## What This Demonstrates
+
+- The `'stateless-api'` preset disables SSE, streaming, and sessions entirely
+- Each request is standalone with no server-side state
+- Pair with `sessionMode: 'stateless'` for serverless execution
+- Required for Vercel, Lambda, Cloudflare Workers where persistent connections are not allowed
+
+## Related
+
+- See `configure-transport-protocol-presets` for all preset definitions
+- See `configure-transport` for full transport configuration

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

@@ -80,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

@@ -237,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

@@ -177,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

@@ -204,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

@@ -204,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

@@ -71,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

@@ -228,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

@@ -60,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/)