@frontmcp/skills 1.0.0-beta.9 → 1.0.0

package/catalog/frontmcp-development/examples/official-adapters/authenticated-adapter-with-polling.md

@@ -0,0 +1,84 @@
+---
+name: authenticated-adapter-with-polling
+reference: official-adapters
+level: intermediate
+description: 'Demonstrates configuring authentication (API key and bearer token) and automatic spec polling for OpenAPI adapters.'
+tags: [development, auth, openapi, security, adapters, authenticated]
+features:
+  - 'Three authentication methods: `staticAuth.apiKey`, `staticAuth.jwt`, and dynamic `securityResolver`'
+  - 'Using `securityResolver` for per-request dynamic authentication based on the calling context'
+  - 'Enabling `polling` to automatically refresh tool definitions when the upstream spec changes'
+  - 'Loading secrets from environment variables instead of hardcoding them'
+  - 'Each adapter has a unique `name` to avoid tool naming collisions'
+---
+
+# Authenticated Adapter with Spec Polling
+
+Demonstrates configuring authentication (API key and bearer token) and automatic spec polling for OpenAPI adapters.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App } from '@frontmcp/sdk';
+import { OpenapiAdapter } from '@frontmcp/adapters';
+
+@App({
+  name: 'integrations',
+  adapters: [
+    // API key authentication via staticAuth
+    OpenapiAdapter.init({
+      name: 'analytics-api',
+      url: 'https://api.analytics.example.com/openapi.json',
+      baseUrl: 'https://api.analytics.example.com',
+      staticAuth: {
+        apiKey: process.env.ANALYTICS_API_KEY!,
+      },
+    }),
+
+    // Bearer token authentication via staticAuth
+    OpenapiAdapter.init({
+      name: 'crm-api',
+      url: 'https://crm.example.com/openapi.json',
+      baseUrl: 'https://crm.example.com',
+      staticAuth: {
+        jwt: process.env.CRM_API_TOKEN!,
+      },
+    }),
+
+    // Dynamic auth with spec polling
+    OpenapiAdapter.init({
+      name: 'evolving-api',
+      url: 'https://api.example.com/openapi.json',
+      baseUrl: 'https://api.example.com',
+      securityResolver: (tool, ctx) => {
+        return { jwt: ctx.authInfo?.token };
+      },
+      polling: {
+        intervalMs: 300000, // Re-fetch spec every 5 minutes
+      },
+    }),
+  ],
+})
+class IntegrationsApp {}
+
+@FrontMcp({
+  info: { name: 'integration-hub', version: '1.0.0' },
+  apps: [IntegrationsApp],
+  http: { port: 3000 },
+})
+class MyServer {}
+```
+
+## What This Demonstrates
+
+- Three authentication methods: `staticAuth.apiKey`, `staticAuth.jwt`, and dynamic `securityResolver`
+- Using `securityResolver` for per-request dynamic authentication based on the calling context
+- Enabling `polling` to automatically refresh tool definitions when the upstream spec changes
+- Loading secrets from environment variables instead of hardcoding them
+- Each adapter has a unique `name` to avoid tool naming collisions
+
+## Related
+
+- See `official-adapters` for inline specs, multiple adapter registration, and troubleshooting
+- See `decorators-guide` for the full `@App` and `@FrontMcp` field reference

package/catalog/frontmcp-development/examples/official-adapters/basic-openapi-adapter.md

@@ -0,0 +1,54 @@
+---
+name: basic-openapi-adapter
+reference: official-adapters
+level: basic
+description: 'Demonstrates converting an OpenAPI specification into MCP tools automatically using `OpenapiAdapter` with minimal configuration.'
+tags: [development, openapi, adapters, adapter]
+features:
+  - 'Using `OpenapiAdapter.init()` with just `name` and `url` to auto-generate MCP tools'
+  - 'Each OpenAPI operation becomes a tool named `<adapter-name>:<operationId>`'
+  - 'The adapter is registered in the `adapters` array of `@App`, not in `plugins`'
+  - 'The `name` field serves as the namespace prefix to prevent tool name collisions'
+---
+
+# Basic OpenAPI Adapter
+
+Demonstrates converting an OpenAPI specification into MCP tools automatically using `OpenapiAdapter` with minimal configuration.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App } from '@frontmcp/sdk';
+import { OpenapiAdapter } from '@frontmcp/adapters';
+
+@App({
+  name: 'petstore',
+  adapters: [
+    OpenapiAdapter.init({
+      name: 'petstore',
+      url: 'https://petstore3.swagger.io/api/v3/openapi.json',
+    }),
+  ],
+})
+class PetstoreApp {}
+
+@FrontMcp({
+  info: { name: 'petstore-server', version: '1.0.0' },
+  apps: [PetstoreApp],
+  http: { port: 3000 },
+})
+class MyServer {}
+// Generated tools: petstore:addPet, petstore:getPetById, petstore:deletePet, etc.
+```
+
+## What This Demonstrates
+
+- Using `OpenapiAdapter.init()` with just `name` and `url` to auto-generate MCP tools
+- Each OpenAPI operation becomes a tool named `<adapter-name>:<operationId>`
+- The adapter is registered in the `adapters` array of `@App`, not in `plugins`
+- The `name` field serves as the namespace prefix to prevent tool name collisions
+
+## Related
+
+- See `official-adapters` for authentication options, spec polling, and inline specs

package/catalog/frontmcp-development/examples/official-adapters/multi-api-hub-with-inline-spec.md

@@ -0,0 +1,130 @@
+---
+name: multi-api-hub-with-inline-spec
+reference: official-adapters
+level: advanced
+description: 'Demonstrates registering multiple OpenAPI adapters from different APIs in a single app, including one with an inline spec definition instead of a remote URL.'
+tags: [development, openapi, remote, adapters, multi, api]
+features:
+  - 'Registering multiple adapters in a single `@App` with unique names for tool namespacing'
+  - 'Using `additionalHeaders` for header-based authentication (GitHub token)'
+  - 'Providing an inline `spec` object instead of a remote `url` for APIs without hosted specs'
+  - "Each adapter's tools are namespaced: `github:*`, `jira:*`, `internal:*`"
+  - 'Only one of `url` or `spec` should be provided per adapter; `spec` takes precedence'
+---
+
+# Multi-API Hub with Inline Spec
+
+Demonstrates registering multiple OpenAPI adapters from different APIs in a single app, including one with an inline spec definition instead of a remote URL.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App } from '@frontmcp/sdk';
+import { OpenapiAdapter } from '@frontmcp/adapters';
+
+@App({
+  name: 'integration-hub',
+  adapters: [
+    // Remote specs from public APIs
+    OpenapiAdapter.init({
+      name: 'github',
+      url: 'https://api.github.com/openapi.json',
+      additionalHeaders: {
+        Authorization: `token ${process.env.GITHUB_TOKEN!}`,
+      },
+    }),
+
+    OpenapiAdapter.init({
+      name: 'jira',
+      url: 'https://jira.example.com/openapi.json',
+      staticAuth: {
+        apiKey: process.env.JIRA_API_KEY!,
+      },
+    }),
+
+    // Inline spec for an internal API without a hosted spec URL
+    OpenapiAdapter.init({
+      name: 'internal',
+      spec: {
+        openapi: '3.0.0',
+        info: { title: 'Internal API', version: '1.0.0' },
+        paths: {
+          '/health': {
+            get: {
+              operationId: 'getHealth',
+              summary: 'Health check endpoint',
+              responses: {
+                '200': {
+                  description: 'Service is healthy',
+                  content: {
+                    'application/json': {
+                      schema: {
+                        type: 'object',
+                        properties: {
+                          status: { type: 'string' },
+                          uptime: { type: 'number' },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          '/users/{id}': {
+            get: {
+              operationId: 'getUserById',
+              summary: 'Get user by ID',
+              parameters: [{ name: 'id', in: 'path', required: true, schema: { type: 'string' } }],
+              responses: {
+                '200': {
+                  description: 'User found',
+                  content: {
+                    'application/json': {
+                      schema: {
+                        type: 'object',
+                        properties: {
+                          id: { type: 'string' },
+                          name: { type: 'string' },
+                          email: { type: 'string' },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      baseUrl: 'https://internal.example.com',
+      staticAuth: {
+        jwt: process.env.INTERNAL_API_TOKEN!,
+      },
+    }),
+  ],
+})
+class IntegrationHub {}
+// Tools: github:createIssue, jira:createTicket, internal:getHealth, internal:getUserById
+
+@FrontMcp({
+  info: { name: 'multi-api-server', version: '1.0.0' },
+  apps: [IntegrationHub],
+  http: { port: 3000 },
+})
+class MyServer {}
+```
+
+## What This Demonstrates
+
+- Registering multiple adapters in a single `@App` with unique names for tool namespacing
+- Using `additionalHeaders` for header-based authentication (GitHub token)
+- Providing an inline `spec` object instead of a remote `url` for APIs without hosted specs
+- Each adapter's tools are namespaced: `github:*`, `jira:*`, `internal:*`
+- Only one of `url` or `spec` should be provided per adapter; `spec` takes precedence
+
+## Related
+
+- See `official-adapters` for spec polling, `securityResolver`, and the adapter vs plugin comparison
+- See `decorators-guide` for the `@Adapter` decorator and how adapters fit in the hierarchy

package/catalog/frontmcp-development/examples/official-plugins/cache-and-feature-flags.md

@@ -0,0 +1,117 @@
+---
+name: cache-and-feature-flags
+reference: official-plugins
+level: intermediate
+description: 'Demonstrates combining the Cache plugin for tool result caching with the Feature Flags plugin for gating tools behind flags.'
+tags: [development, feature-flags, cache, plugins, feature, flags]
+features:
+  - 'Combining `CachePlugin` and `FeatureFlagPlugin` in the same server'
+  - 'Using `toolPatterns` glob patterns to cache groups of tools without per-tool configuration'
+  - 'Per-tool `cache` metadata with custom `ttl` (seconds) and `slideWindow` for TTL refresh on hits'
+  - 'Using `cache: true` for simple default-TTL caching'
+  - "Gating a tool with `featureFlag: 'beta-search'` -- the tool is hidden from `list_tools` when the flag is off"
+  - 'Accessing `this.featureFlags.isEnabled()` inside a tool for runtime flag checks'
+---
+
+# Cache Plugin and Feature Flags Plugin
+
+Demonstrates combining the Cache plugin for tool result caching with the Feature Flags plugin for gating tools behind flags.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App } from '@frontmcp/sdk';
+import CachePlugin from '@frontmcp/plugin-cache';
+import FeatureFlagPlugin from '@frontmcp/plugin-feature-flags';
+
+@App({
+  name: 'api',
+  tools: [GetWeatherTool, GetUserProfileTool, BetaSearchTool],
+})
+class ApiApp {}
+
+@FrontMcp({
+  info: { name: 'cached-flagged-server', version: '1.0.0' },
+  apps: [ApiApp],
+  plugins: [
+    CachePlugin.init({
+      type: 'memory',
+      defaultTTL: 3600,
+      toolPatterns: ['api:get-*', 'search:*'],
+      bypassHeader: 'x-frontmcp-disable-cache',
+    }),
+    FeatureFlagPlugin.init({
+      adapter: 'static',
+      flags: {
+        'beta-search': true,
+        'experimental-agent': false,
+      },
+    }),
+  ],
+})
+class MyServer {}
+```
+
+```typescript
+// src/tools/get-weather.tool.ts
+import { Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+// Per-tool cache metadata with custom TTL and sliding window
+@Tool({
+  name: 'get_weather',
+  description: 'Get current weather for a city',
+  inputSchema: {
+    city: z.string().describe('City name'),
+  },
+  cache: {
+    ttl: 1800,
+    slideWindow: true,
+  },
+})
+class GetWeatherTool extends ToolContext {
+  async execute(input: { city: string }) {
+    const weather = await this.get(WeatherService).getCurrent(input.city);
+    return { city: input.city, temperature: weather.temp, condition: weather.condition };
+  }
+}
+```
+
+```typescript
+// src/tools/beta-search.tool.ts
+import { Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+// Tool gated behind a feature flag -- hidden from list_tools when flag is off
+@Tool({
+  name: 'beta_search',
+  description: 'New search algorithm (beta)',
+  inputSchema: {
+    query: z.string(),
+  },
+  featureFlag: 'beta-search',
+  cache: true,
+})
+class BetaSearchTool extends ToolContext {
+  async execute(input: { query: string }) {
+    const enabled = await this.featureFlags.isEnabled('beta-search');
+    const results = await this.get(SearchService).search(input.query);
+    return { results, algorithm: 'v2-beta' };
+  }
+}
+```
+
+## What This Demonstrates
+
+- Combining `CachePlugin` and `FeatureFlagPlugin` in the same server
+- Using `toolPatterns` glob patterns to cache groups of tools without per-tool configuration
+- Per-tool `cache` metadata with custom `ttl` (seconds) and `slideWindow` for TTL refresh on hits
+- Using `cache: true` for simple default-TTL caching
+- Gating a tool with `featureFlag: 'beta-search'` -- the tool is hidden from `list_tools` when the flag is off
+- Accessing `this.featureFlags.isEnabled()` inside a tool for runtime flag checks
+
+## Related
+
+- See `official-plugins` for all plugin configuration options, Redis cache, and external flag adapters
+- See `create-tool-annotations` for additional tool metadata like `readOnlyHint` and `destructiveHint`

package/catalog/frontmcp-development/examples/official-plugins/production-multi-plugin-setup.md

@@ -0,0 +1,147 @@
+---
+name: production-multi-plugin-setup
+reference: official-plugins
+level: advanced
+description: 'Demonstrates a production-ready server configuration combining CodeCall, Remember, Approval, Cache, and Feature Flags plugins with Redis storage and external flag services.'
+tags: [development, feature-flags, redis, keyword-search, cache, approval]
+features:
+  - 'Configuring all 5 stable official plugins together in a production server'
+  - 'CodeCall in `codecall_only` mode with TF-IDF search and synonym expansion for semantic tool discovery'
+  - 'Remember plugin with Redis storage, encryption enabled, and LLM-accessible memory tools'
+  - 'Approval plugin in `webhook` mode with external PKCE-secured approval flow and audit logging'
+  - 'Cache plugin with Redis storage and 24-hour default TTL'
+  - 'Feature Flags with LaunchDarkly integration for external flag management'
+  - 'Per-tool `approval` metadata with risk level and scope configuration'
+  - 'Per-tool `featureFlag` with a `defaultValue` fallback if flag evaluation fails'
+  - 'Using `this.approval.isApproved()` and `this.remember.set()` together in a single tool'
+---
+
+# Production Multi-Plugin Setup
+
+Demonstrates a production-ready server configuration combining CodeCall, Remember, Approval, Cache, and Feature Flags plugins with Redis storage and external flag services.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App } from '@frontmcp/sdk';
+import CodeCallPlugin from '@frontmcp/plugin-codecall';
+import RememberPlugin from '@frontmcp/plugin-remember';
+import { ApprovalPlugin } from '@frontmcp/plugin-approval';
+import CachePlugin from '@frontmcp/plugin-cache';
+import FeatureFlagPlugin from '@frontmcp/plugin-feature-flags';
+
+@App({ name: 'core', tools: [ReadDataTool, WriteDataTool, DeleteDataTool] })
+class CoreApp {}
+
+@FrontMcp({
+  info: { name: 'production-server', version: '1.0.0' },
+  apps: [CoreApp],
+  plugins: [
+    CodeCallPlugin.init({
+      mode: 'codecall_only',
+      topK: 8,
+      maxDefinitions: 8,
+      vm: {
+        preset: 'secure',
+        timeoutMs: 5000,
+        allowLoops: false,
+      },
+      embedding: {
+        strategy: 'tfidf',
+        synonymExpansion: { enabled: true },
+      },
+    }),
+
+    RememberPlugin.init({
+      type: 'redis',
+      config: { host: process.env.REDIS_HOST!, port: 6379 },
+      keyPrefix: 'remember:',
+      encryption: { enabled: true },
+      tools: { enabled: true },
+    }),
+
+    ApprovalPlugin.init({
+      mode: 'webhook',
+      webhook: {
+        url: 'https://approval.example.com/webhook',
+        challengeTtl: 300,
+        callbackPath: '/approval/callback',
+      },
+      enableAudit: true,
+      maxDelegationDepth: 3,
+    }),
+
+    CachePlugin.init({
+      type: 'redis',
+      config: { host: process.env.REDIS_HOST!, port: 6379 },
+      defaultTTL: 86400,
+    }),
+
+    FeatureFlagPlugin.init({
+      adapter: 'launchdarkly',
+      config: { sdkKey: process.env.LD_SDK_KEY! },
+    }),
+  ],
+})
+class ProductionServer {}
+```
+
+```typescript
+// src/tools/delete-data.tool.ts
+import { Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'delete_data',
+  description: 'Permanently delete a data record',
+  inputSchema: {
+    recordId: z.string(),
+    confirm: z.boolean(),
+  },
+  approval: {
+    required: true,
+    defaultScope: 'session',
+    category: 'write',
+    riskLevel: 'high',
+    approvalMessage: 'Allow data deletion for this session?',
+  },
+  featureFlag: { key: 'enable-delete', defaultValue: false },
+})
+class DeleteDataTool extends ToolContext {
+  async execute(input: { recordId: string; confirm: boolean }) {
+    if (!input.confirm) {
+      return { deleted: false, reason: 'Confirmation required' };
+    }
+
+    const isApproved = await this.approval.isApproved('delete_data');
+    if (!isApproved) {
+      return { deleted: false, reason: 'Awaiting approval' };
+    }
+
+    const db = this.get(DatabaseToken);
+    await db.deleteRecord(input.recordId);
+
+    await this.remember.set(`deleted:${input.recordId}`, new Date().toISOString());
+
+    return { deleted: true, recordId: input.recordId };
+  }
+}
+```
+
+## What This Demonstrates
+
+- Configuring all 5 stable official plugins together in a production server
+- CodeCall in `codecall_only` mode with TF-IDF search and synonym expansion for semantic tool discovery
+- Remember plugin with Redis storage, encryption enabled, and LLM-accessible memory tools
+- Approval plugin in `webhook` mode with external PKCE-secured approval flow and audit logging
+- Cache plugin with Redis storage and 24-hour default TTL
+- Feature Flags with LaunchDarkly integration for external flag management
+- Per-tool `approval` metadata with risk level and scope configuration
+- Per-tool `featureFlag` with a `defaultValue` fallback if flag evaluation fails
+- Using `this.approval.isApproved()` and `this.remember.set()` together in a single tool
+
+## Related
+
+- See `official-plugins` for all plugin options, storage types, and troubleshooting
+- See `create-plugin-hooks` for adding custom lifecycle hooks alongside official plugins

package/catalog/frontmcp-development/examples/official-plugins/remember-plugin-session-memory.md

@@ -0,0 +1,104 @@
+---
+name: remember-plugin-session-memory
+reference: official-plugins
+level: basic
+description: 'Demonstrates installing the Remember plugin and using `this.remember` in tools to store and retrieve session memory.'
+tags: [development, session, plugins, remember, plugin, memory]
+features:
+  - "Installing `RememberPlugin` with `type: 'memory'` for development"
+  - 'Enabling `tools: { enabled: true }` to expose LLM-callable memory tools (`remember_this`, `recall`, etc.)'
+  - 'Using `this.remember.set()` with default `session` scope and explicit `user` scope'
+  - 'Using `this.remember.get()` with a `defaultValue` fallback'
+  - 'Using `this.remember.knows()` to check key existence without retrieving the value'
+---
+
+# Remember Plugin for Session Memory
+
+Demonstrates installing the Remember plugin and using `this.remember` in tools to store and retrieve session memory.
+
+## Code
+
+```typescript
+// src/server.ts
+import { FrontMcp, App } from '@frontmcp/sdk';
+import RememberPlugin from '@frontmcp/plugin-remember';
+
+@App({ name: 'my-app', tools: [PreferencesTool, GreetingTool] })
+class MyApp {}
+
+@FrontMcp({
+  info: { name: 'memory-server', version: '1.0.0' },
+  apps: [MyApp],
+  plugins: [
+    RememberPlugin.init({
+      type: 'memory',
+      tools: { enabled: true },
+    }),
+  ],
+})
+class MyServer {}
+```
+
+```typescript
+// src/tools/preferences.tool.ts
+import { Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'set_preferences',
+  description: 'Save user preferences for the session',
+  inputSchema: {
+    theme: z.enum(['light', 'dark']).describe('UI theme preference'),
+    language: z.string().describe('Preferred language code'),
+  },
+})
+class PreferencesTool extends ToolContext {
+  async execute(input: { theme: string; language: string }) {
+    await this.remember.set('theme', input.theme);
+    await this.remember.set('language', input.language, { scope: 'user' });
+
+    return { saved: true, theme: input.theme, language: input.language };
+  }
+}
+```
+
+```typescript
+// src/tools/greeting.tool.ts
+import { Tool, ToolContext } from '@frontmcp/sdk';
+import { z } from 'zod';
+
+@Tool({
+  name: 'get_greeting',
+  description: 'Get a personalized greeting using remembered preferences',
+  inputSchema: {
+    name: z.string().describe('User name'),
+  },
+})
+class GreetingTool extends ToolContext {
+  async execute(input: { name: string }) {
+    const theme = await this.remember.get('theme', { defaultValue: 'light' });
+    const language = await this.remember.get('language', { defaultValue: 'en' });
+    const hasOnboarded = await this.remember.knows('onboarding_complete');
+
+    return {
+      greeting: `Hello ${input.name}!`,
+      theme,
+      language,
+      showOnboarding: !hasOnboarded,
+    };
+  }
+}
+```
+
+## What This Demonstrates
+
+- Installing `RememberPlugin` with `type: 'memory'` for development
+- Enabling `tools: { enabled: true }` to expose LLM-callable memory tools (`remember_this`, `recall`, etc.)
+- Using `this.remember.set()` with default `session` scope and explicit `user` scope
+- Using `this.remember.get()` with a `defaultValue` fallback
+- Using `this.remember.knows()` to check key existence without retrieving the value
+
+## Related
+
+- See `official-plugins` for Redis storage, Vercel KV, memory scopes, and all Remember API methods
+- See `create-plugin-hooks` for building custom plugins with lifecycle hooks

package/catalog/frontmcp-development/references/create-adapter.md

@@ -1,3 +1,8 @@
+---
+name: create-adapter
+description: Build adapters that generate MCP tools and resources from external sources automatically
+---
+
 # Creating Custom Adapters
 
 Build adapters that automatically generate MCP tools, resources, and prompts from external sources — databases, GraphQL schemas, proprietary APIs, or any definition format.
@@ -159,6 +164,15 @@ Creates a `DynamicAdapter` subclass in `src/adapters/my-adapter.adapter.ts`.
 | Duplicate tool name error                  | Multiple adapters produce tools with the same name          | Use unique `name` parameter in `init()` to namespace tools                       |
 | Adapter not found at runtime               | Registered in wrong `@App` or not in `adapters` array       | Ensure `.init()` result is in the `adapters` array of the correct `@App`         |
 
+## Examples
+
+| Example                                                                  | Level        | Description                                                                                                             |
+| ------------------------------------------------------------------------ | ------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| [`basic-api-adapter`](../examples/create-adapter/basic-api-adapter.md)   | Basic        | A minimal adapter that fetches operation definitions from an external API and generates MCP tools.                      |
+| [`namespaced-adapter`](../examples/create-adapter/namespaced-adapter.md) | Intermediate | An adapter that namespaces generated tools to avoid collisions and includes proper error handling for startup failures. |
+
+> See all examples in [`examples/create-adapter/`](../examples/create-adapter/)
+
 ## Reference
 
 - [Adapter Documentation](https://docs.agentfront.dev/frontmcp/adapters/overview)

package/catalog/frontmcp-development/references/create-agent-llm-config.md

@@ -1,3 +1,8 @@
+---
+name: create-agent-llm-config
+description: Reference for supported LLM provider configurations including Anthropic and OpenAI
+---
+
 # Agent LLM Configuration Reference
 
 ## Supported Providers
@@ -44,3 +49,12 @@ apiKey: 'sk-...';
 | Anthropic | `claude-opus-4-20250514`   | Most capable         |
 | OpenAI    | `gpt-4o`                   | General purpose      |
 | OpenAI    | `gpt-4o-mini`              | Fast, cost-effective |
+
+## Examples
+
+| Example                                                                       | Level | Description                                                                |
+| ----------------------------------------------------------------------------- | ----- | -------------------------------------------------------------------------- |
+| [`anthropic-config`](../examples/create-agent-llm-config/anthropic-config.md) | Basic | Configuring an agent with the Anthropic provider and common model options. |
+| [`openai-config`](../examples/create-agent-llm-config/openai-config.md)       | Basic | Configuring an agent with the OpenAI provider and different model options. |
+
+> See all examples in [`examples/create-agent-llm-config/`](../examples/create-agent-llm-config/)