Agent skill

frontmcp-development

Use when you want to create a tool, add a resource, build a prompt, write a provider, implement an adapter, add OpenAPI integration, create a plugin, agent, job, or workflow. The skill for BUILDING any FrontMCP component.

View SKILL.md on GitHub Repository
Stars 142
Forks 7

Install this agent skill to your Project

npx add-skill https://github.com/agentfront/frontmcp/tree/main/libs/skills/catalog/frontmcp-development

Metadata

Additional technical details for this skill

docs
https://docs.agentfront.dev/frontmcp/fundamentals/overview

SKILL.md

FrontMCP Development Router

Entry point for building MCP server components. This skill helps you find the right development skill based on what you want to build. It does not teach implementation details itself — it routes you to the specific skill that does.

When to Use This Skill

Must Use

  • Starting a FrontMCP development task and unsure which component type to build (tool vs resource vs prompt vs agent)
  • Onboarding to the FrontMCP development model and need an overview of all building blocks
  • Planning a feature that may require multiple component types working together

Recommended

  • Looking up the canonical name of a development skill to install or search
  • Comparing component types to decide which fits your use case
  • Understanding how tools, resources, prompts, agents, and skills relate to each other

Skip When

  • You already know which component to build (go directly to create-tool, create-resource, etc.)
  • You need to configure server settings, not build components (see frontmcp-config)
  • You need to deploy or build, not develop (see frontmcp-deployment)

Decision: Use this skill when you need to figure out WHAT to build. Use the specific skill when you already know.

Scenario Routing Table

Scenario Skill Description
Expose an executable action that AI clients can call create-tool Class-based or function-style tools with Zod input/output validation
Expose read-only data via a URI create-resource Static resources or URI template resources for dynamic data
Create a reusable conversation template or system prompt create-prompt Prompt entries with arguments and multi-turn message sequences
Build an autonomous AI loop that orchestrates tools create-agent Agent entries with LLM config, inner tools, and swarm handoff
Register shared services or configuration via DI create-provider Dependency injection tokens, lifecycle hooks, factory providers
Run a background task with progress and retries create-job Job entries with attempt tracking, retry config, and progress
Chain multiple jobs into a sequential pipeline create-workflow Workflow entries that compose jobs with data passing
Write instruction-only AI guidance (no code execution) create-skill Skill entries with markdown instructions from files, strings, or URLs
Write AI guidance that also orchestrates tools create-skill-with-tools Skill entries that combine instructions with registered tools
Look up any decorator signature or option decorators-guide Complete reference for @Tool, @Resource, @Prompt, @Agent, @App, @FrontMcp, and more
Overview of all official adapters official-adapters Router to all adapter types; adapter vs plugin comparison
Integrate an external API via OpenAPI spec openapi-adapter OpenapiAdapter with auth, polling, filtering, transforms, format resolution, $ref security
Use official plugins (caching, remember, feature flags) official-plugins Built-in plugins for caching, session memory, approval, and feature flags (dashboard is beta)
Connect to an external data source via a custom adapter create-adapter Create custom adapters for external data sources
Configure LLM settings for an agent component create-agent-llm-config Configure LLM settings for agent components
Add will/did/around lifecycle hooks to a plugin create-plugin-hooks Add lifecycle hooks to plugins (will/did/around)
Annotate tools with client hints for AI clients create-tool-annotations Add MCP tool annotations for client hints
Define typed output schemas for tool responses create-tool-output-schema-types Define typed output schemas for tools

Recommended Reading Order

  1. decorators-guide — Start here to understand the full decorator landscape
  2. create-tool — The most common building block; learn tools first
  3. create-resource — Expose data alongside tools
  4. create-prompt — Add reusable conversation templates
  5. create-provider — Share services across tools and resources via DI
  6. create-agent — Build autonomous AI loops (advanced)
  7. create-job / create-workflow — Background processing (advanced)
  8. create-skill / create-skill-with-tools — Author your own skills (meta)
  9. official-adapters / openapi-adapter — Integrate external APIs via OpenAPI specs
  10. official-plugins — Add caching, session memory, feature flags, and more

Cross-Cutting Patterns

Pattern Applies To Rule
Naming convention Tools Use snake_case for tool names (get_weather, not getWeather)
Naming convention Skills, resources Use kebab-case for skill and resource names
File naming All components Use <name>.<type>.ts pattern (e.g., fetch-weather.tool.ts)
DI access Tools, resources, prompts, agents Use this.get(TOKEN) (throws) or this.tryGet(TOKEN) (returns undefined)
Error handling All components Use this.fail(err) with MCP error classes, not raw throw
Input validation Tools Always use Zod raw shapes (not z.object()) for inputSchema
Output validation Tools Always define outputSchema to prevent data leaks
Registration All components Add to tools, resources, prompts, agents, etc. arrays in @App or @FrontMcp
Test files All components Use .spec.ts extension, never .test.ts

Common Patterns

Pattern Correct Incorrect Why
Choosing component type Tool for actions, Resource for data, Prompt for templates Using a tool to return static data Each type has protocol-level semantics; misuse confuses AI clients
Component registration Register in @App arrays, compose apps in @FrontMcp Register tools directly in @FrontMcp without an @App Apps provide modularity; direct registration bypasses app-level hooks
Shared logic Extract to a @Provider and inject via DI Duplicate code across multiple tools Providers are testable, lifecycle-managed, and scoped
Complex orchestration Use @Agent with inner tools Chain tool calls manually in a single tool Agents handle LLM loops, retries, and tool selection automatically
Background work Use @Job with retry config Run long tasks inside a tool's execute() Jobs have progress tracking, attempt awareness, and timeout handling

Verification Checklist

Architecture

  • Each component type matches its semantic purpose (action=tool, data=resource, template=prompt)
  • Shared services use @Provider with DI tokens, not module-level singletons
  • Components are registered in @App arrays, apps composed in @FrontMcp

Development Workflow

  • Files follow <name>.<type>.ts naming convention
  • Each component has a corresponding .spec.ts test file
  • decorators-guide consulted for unfamiliar decorator options

Troubleshooting

Problem Cause Solution
Unsure which component type to use Requirements are ambiguous Check the Scenario Routing Table above; if the action modifies state, use a tool; if it returns data by URI, use a resource
Component not discovered at runtime Not registered in @App or @FrontMcp arrays Add to the appropriate array (tools, resources, prompts, etc.)
DI token not resolving Provider not registered in scope Register the provider in the providers array of the same @App
Need both AI guidance and tool execution Used create-skill but need tools too Switch to create-skill-with-tools which combines instructions with registered tools

Reference

  • FrontMCP Overview
  • Related skills: create-tool, create-resource, create-prompt, create-agent, create-provider, create-job, create-workflow, create-skill, create-skill-with-tools, decorators-guide, official-adapters, openapi-adapter, official-plugins

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

agentfront/frontmcp

docs-skill

A fixture skill with references and examples for E2E testing.

142 7
Explore
agentfront/frontmcp

fix-pr

Review a CodeRabbit PR comment and produce an action plan when prompted to analyze a review comment.

142 7
Explore
agentfront/frontmcp

frontmcp-observability

Use when you want to add tracing, structured logging, or monitoring to your FrontMCP server. Covers OpenTelemetry instrumentation, vendor integrations (Coralogix, Datadog, Logz.io, Grafana), this.telemetry API for custom spans, structured JSON logging with sinks, and testing observability. Triggers: observability, telemetry, tracing, logging, monitoring, opentelemetry, otel, spans, datadog, coralogix, logz, grafana, winston, pino.

142 7
Explore
agentfront/frontmcp

frontmcp-authorities

Use when implementing authorization, access control, RBAC, ABAC, or ReBAC for tools, resources, or prompts. Covers JWT claims mapping, authority profiles, and policy enforcement.

142 7
Explore
agentfront/frontmcp

frontmcp-setup

Domain router for project setup, scaffolding, and organization. Use this skill whenever someone asks to create a new FrontMCP project, set up an Nx monorepo, configure Redis or SQLite storage, organize project structure, compose multiple apps into one server, or manage the skills system. Also triggers for questions like 'how do I start', 'project layout', 'folder structure', 'add redis', 'set up database', or 'create a new app'.

142 7
Explore
agentfront/frontmcp

frontmcp-config

Use when you want to configure auth, set up CORS, add rate limiting, throttle requests, manage sessions, choose transport, set HTTP options, add authentication, configure JWT, or set up OAuth. The skill for server CONFIGURATION.

142 7
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results