# FrontMCP

> FrontMCP is the TypeScript framework for MCP servers: typed tools with Zod, dependency injection, auth, testing, agents and jobs, and builds for Node, Vercel, AWS Lambda and Cloudflare Workers.

Each link is the Markdown version of a page on frontmcp.dev. The site documents FrontMCP 1.10.11; release notes are at https://frontmcp.dev/releases.md, and the blog's posts at https://frontmcp.dev/blog.md.

The MDX documentation and blog posts are available together at https://frontmcp.dev/llms-full.txt; one section at a time, at https://frontmcp.dev/llms-learn.txt, https://frontmcp.dev/llms-reference.txt, https://frontmcp.dev/llms-examples.txt and https://frontmcp.dev/llms-compare.txt. The list of every page is https://frontmcp.dev/sitemap.xml.

An MCP server serves these docs to coding agents, for the FrontMCP release a project uses: https://mcp.frontmcp.dev (the latest), or https://mcp.frontmcp.dev/<version> to pin one. See https://frontmcp.dev/learn/docs-for-your-agent.md.

Start with https://frontmcp.dev/index.md for the product explanation. Prefer one page or a docs MCP section read; the bulk export can exceed a client's context window. Standalone pages are linked at https://frontmcp.dev/versions.md, https://frontmcp.dev/releases.md, https://frontmcp.dev/blog.md and https://frontmcp.dev/playground.md.

## Learn

- [Quick Start](https://frontmcp.dev/learn.md): Build an MCP server in TypeScript with FrontMCP. The 80% you'll use every day, with every example running in your browser.
- [Tutorial: Help Desk Server](https://frontmcp.dev/learn/tutorial-help-desk.md): Build a complete MCP server for a support team one step at a time, with tools, clear errors, annotations, a confirmation, a resource, a prompt, an app and tests.
- [Thinking in MCP](https://frontmcp.dev/learn/thinking-in-mcp.md): A design process for turning what people need from an AI assistant into tools, resources and prompts, worked through for a help desk.
- [Installation](https://frontmcp.dev/learn/installation.md): Create a FrontMCP project with Node.js 24+, run it locally and connect an MCP client. Includes existing-project setup and troubleshooting.
- [Docs for Your Agent](https://frontmcp.dev/learn/docs-for-your-agent.md): Give your coding agent FrontMCP's docs for the release your project uses, through FrontMCP's own MCP server at mcp.frontmcp.dev.
- [Migrate from the TypeScript SDK](https://frontmcp.dev/learn/migrating-from-the-typescript-sdk.md): Preserve an MCP server's tools, resources, errors and access rules while moving shared services into FrontMCP. Includes a reproducible contract comparison.
- [Migrate from FastMCP](https://frontmcp.dev/learn/migrating-from-fastmcp.md): Move a FastMCP for TypeScript server to FrontMCP one client contract at a time: tools, errors, logs, resources, prompts, auth and transports.
- [Evaluate CodeCall](https://frontmcp.dev/learn/evaluating-codecall.md): Compare the same CRM task through direct tool calls and CodeCall. Measure bytes and calls, separate discovery overhead, and record model evaluation independently.
- [Upgrade a server](https://frontmcp.dev/learn/upgrading-a-server.md): Identify an installed FrontMCP version, read matching changes, compare a pinned fixture before and after upgrade, and keep a rollback path.
- [Describing Capabilities](https://frontmcp.dev/learn/describing-capabilities.md): How to describe what your MCP server can do, so AI models use it well. Tools, schemas, results, resources, prompts and apps.
- [Your First Tool](https://frontmcp.dev/learn/your-first-tool.md): Build a typed MCP tool with FrontMCP, validate input with Zod and return results and errors a client can use.
- [Schemas Are Contracts](https://frontmcp.dev/learn/schemas-are-contracts.md): How a tool's Zod input schema becomes the JSON Schema a model reads, what FrontMCP checks before execute() runs, and how to write schemas models fill in correctly.
- [Shaping Tool Results](https://frontmcp.dev/learn/shaping-tool-results.md): What a tool call sends back, how FrontMCP turns your return value into content and structuredContent, and how to return results and errors a model can act on.
- [Exposing Data with Resources](https://frontmcp.dev/learn/exposing-data-with-resources.md): When data should be a resource instead of a tool, how to declare fixed resources and URI templates, and what clients get back when they read one.
- [Reusable Prompts](https://frontmcp.dev/learn/reusable-prompts.md): What a prompt is and who picks it, how to declare required and optional arguments, return several messages, and put ticket data into a prompt.
- [Grouping Capabilities into Apps](https://frontmcp.dev/learn/grouping-capabilities-into-apps.md): How @App groups tools, resources, prompts and providers, how a @FrontMcp server composes several apps, what happens when their names collide, and how apps share a provider.
- [Writing Descriptions Agents Understand](https://frontmcp.dev/learn/writing-descriptions-agents-understand.md): How to write tool, argument and resource descriptions that tell a model when to use a capability, how to fill it in, and what comes back, and how to check them with tests.
- [Talking to Clients](https://frontmcp.dev/learn/talking-to-clients.md): How a tool talks to the client while it runs. Asking the user a question mid-call, and reporting progress and logs from long-running tools.
- [Asking the User Mid-Call](https://frontmcp.dev/learn/asking-the-user.md): How a tool asks the person using the client a question in the middle of a call, with this.elicit(), and what happens on the wire under MCP 2026-07-28.
- [Reporting Progress and Logs](https://frontmcp.dev/learn/reporting-progress.md): How a long-running tool tells the client how far along it is and what it's doing, with this.progress() and this.notify(), and how clients opt in under MCP 2026-07-28.
- [Structuring a Server](https://frontmcp.dev/learn/structuring-a-server.md): Where the code that isn't any one tool's job goes in a FrontMCP server. Providers for shared services and state, plugins for reusable behaviour, and hooks that run around every call.
- [Sharing State with Providers](https://frontmcp.dev/learn/sharing-state-with-providers.md): Why tools shouldn't keep shared state in module variables, and how @Provider shares services instead. Scopes per request, factories built from configuration, and swapping a provider in tests.
- [Extending with Plugins](https://frontmcp.dev/learn/extending-with-plugins.md): What a FrontMCP plugin is, how to write one that adds providers, tools and hooks to an app, how to configure and register it, and what the official plugins do.
- [Hooking into Calls](https://frontmcp.dev/learn/hooking-into-calls.md): How FrontMCP runs a tool call as a flow of stages, and how plugin hooks run before and after them to log calls, normalize input, block calls and change results. Which order hooks run in, and what they can change.
- [Securing a Server](https://frontmcp.dev/learn/securing-a-server.md): Who may connect to a FrontMCP server, what each caller may do, and how often and how long a tool may run. Authentication, authorization, rate limits and timeouts.
- [Authenticating Clients](https://frontmcp.dev/learn/authenticating-clients.md): How MCP clients prove who they are to a FrontMCP server: the five auth modes, how each maps to the MCP authorization spec's OAuth 2.1 roles, and how to choose.
- [Deciding Who Can Call What](https://frontmcp.dev/learn/authorizing-calls.md): How a FrontMCP tool finds out who is calling, refuses calls it shouldn't make with an error the model can act on, and declares who may use it with authorities.
- [Limiting and Timing Out Calls](https://frontmcp.dev/learn/limiting-calls.md): How to cap how often a FrontMCP tool runs, how many copies run at once, and how long a call may take, with rateLimit, concurrency and timeout, and what callers get back when a limit trips.
- [Doing Work in the Background](https://frontmcp.dev/learn/background-work.md): When a tool isn't enough. FrontMCP jobs for slow, flaky and long-running work, the tools clients run them with, background runs and retries, and workflows that chain jobs.
- [Your First Job](https://frontmcp.dev/learn/your-first-job.md): How to write a FrontMCP job with @Job and JobContext, register it on an app, run it with the execute_job tool, and read the result, logs and errors that come back.
- [Running Jobs in the Background](https://frontmcp.dev/learn/running-jobs-in-the-background.md): How to start a FrontMCP job in the background and check on it with get_job_status, what states a run goes through, how to retry a flaky job with backoff, who may read a run, and where runs are stored.
- [Chaining Jobs into Workflows](https://frontmcp.dev/learn/chaining-jobs-into-workflows.md): How to chain FrontMCP jobs into a workflow with @Workflow, pass each step's output to the next, run independent steps in parallel, and decide what a failing step does to the rest.
- [Delegating to Agents](https://frontmcp.dev/learn/delegating-to-agents.md): When the client's model shouldn't do every step itself. FrontMCP agents run a model of their own, with their own instructions and tools, so a client can hand off a whole task in one call; skills teach the client's model a procedure instead.
- [Your First Agent](https://frontmcp.dev/learn/your-first-agent.md): How to write a FrontMCP agent with @Agent and AgentContext, register it on an app, call it through its invoke_ tool, and read what its model is sent and what comes back.
- [Giving an Agent Tools](https://frontmcp.dev/learn/giving-an-agent-tools.md): Give a FrontMCP agent a limited tool set, follow its execution loop and handle tool failures before connecting a real model.
- [Connecting a Real Model](https://frontmcp.dev/learn/connecting-a-real-model.md): Connect a FrontMCP agent to Anthropic or OpenAI: API keys, requests and replies, provider failures, and what a real model costs in tokens and time.
- [Agents That Call Agents](https://frontmcp.dev/learn/agents-that-call-agents.md): How one FrontMCP agent hands a task to another: nested agents, swarm handoffs, this.callTool() from execute(), handling failures, and the handoff depth limit.
- [Teaching the Model Skills](https://frontmcp.dev/learn/teaching-the-model-skills.md): Write a FrontMCP skill with @Skill, how clients find and load it via skill:// resources and skills/search, and when to use a skill instead of an agent or prompt.
- [Tools with a UI](https://frontmcp.dev/learn/tools-with-a-ui.md): How a FrontMCP tool gives its result a widget, an HTML page a host shows next to the answer. Writing one with a template, choosing how it's served, and building it in React, with what works today.
- [Your First Widget](https://frontmcp.dev/learn/your-first-widget.md): Give a FrontMCP tool's result a UI with the ui option: an HTML template rendered on every call, what the host receives, calling tools back, and theme and size.
- [Choosing How a Widget Is Served](https://frontmcp.dev/learn/choosing-how-a-widget-is-served.md): Choose inline or static MCP widgets. Understand host delivery, schemas and CSP settings.
- [Building Widgets with React](https://frontmcp.dev/learn/building-widgets-with-react.md): Build FrontMCP widgets as React components: bundling, props, @frontmcp/ui/react hooks, calling tools with useCallTool, theme and size. Runs on Node, not the Playground.
- [Built-in Plugins and Adapters](https://frontmcp.dev/learn/built-in-plugins-and-adapters.md): The plugins and the adapter the FrontMCP team publishes, and when to reach for each. Caching results, remembering values across calls, asking for approval, feature flags, CodeCall, and turning an OpenAPI spec into tools.
- [Caching Results](https://frontmcp.dev/learn/caching-results.md): How to answer repeated calls to a slow FrontMCP tool from a cache with @frontmcp/plugin-cache, whose calls share an entry, what makes two calls the same, how long an entry lives, and what not to cache.
- [Remembering Across Calls](https://frontmcp.dev/learn/remembering-across-calls.md): Keep values between FrontMCP tool calls with @frontmcp/plugin-remember and this.remember: scopes, signed-in and anonymous callers, expiry, and memory tools.
- [Asking for Approval](https://frontmcp.dev/learn/asking-for-approval.md): Require recorded user approval before a FrontMCP tool runs. Build the approval UI and control expiration and withdrawal.
- [Turning Features On and Off](https://frontmcp.dev/learn/turning-features-on-and-off.md): How to put a FrontMCP tool, resource or prompt behind a feature flag with @frontmcp/plugin-feature-flags, what a caller sees while its flag is off, and how to turn a flag on for some callers first.
- [Letting the Model Write Code with CodeCall](https://frontmcp.dev/learn/letting-the-model-write-code-with-codecall.md): Why long tool lists cost a model, and how @frontmcp/plugin-codecall lets it search tools, read their schemas and call them directly or from a short server-side script.
- [Wrapping an OpenAPI Service](https://frontmcp.dev/learn/wrapping-an-openapi-service.md): Turn an OpenAPI 3 specification into MCP tools. Choose operations, configure server-side credentials and handle API errors.
- [Testing and Shipping](https://frontmcp.dev/learn/testing-and-shipping.md): How to test a FrontMCP server end to end with @frontmcp/testing, deploy it somewhere clients can reach, and run several instances of it behind a load balancer.
- [Testing Your Server](https://frontmcp.dev/learn/testing-your-server.md): End-to-end tests for a FrontMCP server with @frontmcp/testing: the mcp fixture, MCP matchers, results, errors, elicitation, plugins and hooks, and frontmcp test.
- [Deploying Your Server](https://frontmcp.dev/learn/deploying-your-server.md): How to take a FrontMCP server from frontmcp build to a running server clients can reach. Choosing a target, the endpoint path, production mode and its secrets, running in a container, health checks, and connecting a client.
- [Running Several Instances](https://frontmcp.dev/learn/running-several-instances.md): Run multiple FrontMCP instances behind a load balancer. Share required secrets and state, accounting for each client's MCP revision.
- [Escape Hatches](https://frontmcp.dev/learn/escape-hatches.md): Stepping outside FrontMCP's declarative model when you have to. Reading the request behind a call, calling other services from a tool, and running FrontMCP without its built-in server.
- [Reading the Request](https://frontmcp.dev/learn/reading-the-request.md): What a tool can learn about the call it's handling beyond its input, like the request id, the trace, the caller and the client, and which of those a client can simply make up.
- [Calling Other Services](https://frontmcp.dev/learn/calling-other-services.md): How a tool calls an HTTP API with this.fetch(), what it adds to each request, whose credentials it sends, and how to turn a slow or failing service into errors the model can act on.
- [Running FrontMCP Anywhere](https://frontmcp.dev/learn/running-frontmcp-anywhere.md): The entry points under @FrontMcp's built-in server. createFetchHandler() serves MCP from Workers and other web-standard runtimes, and connect() and createDirect() call your tools in-process.

## Reference

- [Overview](https://frontmcp.dev/reference.md): The FrontMCP API reference for TypeScript MCP servers, from decorators and contexts to auth, plugins, testing and deployment, checked against the SDK it describes, with a runnable example for everything that can run in a browser.
- [Maintainers and corrections](https://frontmcp.dev/reference/maintainers.md): FrontMCP's publisher, source, license, article authors and public documentation correction route.
- [Site usage and privacy](https://frontmcp.dev/reference/site-privacy.md): What runs locally in the FrontMCP Playground, which usage events the site records, and what Global Privacy Control changes.
- [SDK overview](https://frontmcp.dev/reference/sdk.md): The decorators that declare what a FrontMCP server exposes, the context members your code calls inside a tool, resource or prompt, and the entry points that run a server over HTTP, in a Worker or in your own process.
- [@FrontMcp](https://frontmcp.dev/reference/sdk/frontmcp.md): Declare an MCP server, the apps it hosts, and the settings that apply to all of them.
- [@App](https://frontmcp.dev/reference/sdk/app.md): Group related tools, resources, prompts and providers into an app that a FrontMCP server hosts.
- [@Tool](https://frontmcp.dev/reference/sdk/tool.md): Declare a function an AI model can call, with validated input and optional structured output.
- [@Resource](https://frontmcp.dev/reference/sdk/resource.md): Declare data at a fixed URI that clients can list and read, like a policy document or a settings file.
- [@ResourceTemplate](https://frontmcp.dev/reference/sdk/resource-template.md): Declare a family of resources whose URIs follow a pattern, like ticket://{id}, and read the parameters from the URI.
- [@Prompt](https://frontmcp.dev/reference/sdk/prompt.md): Declare a reusable message template that users pick in their client and fill in with arguments.
- [@Provider](https://frontmcp.dev/reference/sdk/provider.md): Declare a shared service, like a database client or a cache, that tools, resources and prompts get with this.get().
- [@Job](https://frontmcp.dev/reference/sdk/job.md): Declare a unit of work with validated input that clients run by name, while they wait or in the background, with retries.
- [@Workflow](https://frontmcp.dev/reference/sdk/workflow.md): Chain jobs into steps that run in order or in parallel, each step's input built from the results of the steps before it.
- [@Agent](https://frontmcp.dev/reference/sdk/agent.md): Declare an agent, a tool that runs its own model loop with its own instructions and tools, so a client's model can hand it a whole task in one call.
- [@Skill](https://frontmcp.dev/reference/sdk/skill.md): Declare a skill, a written procedure with the tools it uses, that clients find and load for their model to follow.
- [@Plugin](https://frontmcp.dev/reference/sdk/plugin.md): Package providers, tools, resources, prompts, skills and hooks into a plugin that an app or a whole server turns on with one line.
- [@Adapter](https://frontmcp.dev/reference/sdk/adapter.md): Write an adapter, a class whose fetch() builds tools, resources and prompts from another source when the server starts, and can replace them while it runs.
- [@Channel](https://frontmcp.dev/reference/sdk/channel.md): Push events into a connected Claude Code session as they happen, with @Channel. Sources, ChannelContext, emitting events from your code, two-way replies, hooks, and exactly what a client receives.
- [Hook decorators](https://frontmcp.dev/reference/sdk/hooks.md): Run code before, after, around or inside any request stage with Will, Did, Around and Stage hooks: flows, priority, filters, what ctx can change, and run order.
- [Context classes](https://frontmcp.dev/reference/sdk/contexts.md): What `this` is inside a tool, resource, prompt, agent, job, channel or skill, and every member each context class has.
- [this.auth](https://frontmcp.dev/reference/sdk/auth.md): Who is calling a tool, resource, prompt, agent or job, with their scopes, roles and claims, and what each auth mode and entry point fills in.
- [this.context](https://frontmcp.dev/reference/sdk/context.md): The request a call belongs to, with its id, trace, auth info and HTTP metadata, what each entry point fills in, and a store that lasts for the request.
- [this.elicit](https://frontmcp.dev/reference/sdk/elicit.md): Ask the user for input in the middle of a tool call, and continue with their answer as typed data.
- [this.progress](https://frontmcp.dev/reference/sdk/progress.md): Tell the client how far a long-running tool call has got, when the client asked for progress.
- [this.notify](https://frontmcp.dev/reference/sdk/notify.md): Send log messages to the client while a tool runs, at the levels the client asked for.
- [this.get](https://frontmcp.dev/reference/sdk/get.md): Get a provider, like a ticket store or your configuration, inside a tool, resource or prompt.
- [this.fetch](https://frontmcp.dev/reference/sdk/fetch.md): Call other HTTP services from a tool or resource, with the request's tracing headers and a default timeout.
- [this.fail](https://frontmcp.dev/reference/sdk/fail.md): End a tool call with an error the model can read, and choose the code it carries.
- [this.callTool](https://frontmcp.dev/reference/sdk/call-tool.md): Call another tool of the same server from inside a tool, resource, prompt, agent or job, as the same caller, and handle what it returns or throws.
- [this.respond](https://frontmcp.dev/reference/sdk/respond.md): End a tool call early with a result you built yourself, answer a call from a hook, and what respond() does in resources, prompts, jobs and agents.
- [FrontMcpInstance](https://frontmcp.dev/reference/sdk/frontmcp-instance.md): The class that builds and runs a server from its @FrontMcp configuration, over HTTP, stdio, a Unix socket, a serverless handler or in-process.
- [createFetchHandler()](https://frontmcp.dev/reference/sdk/create-fetch-handler.md): Serve an MCP server from any runtime that speaks web Request and Response, like Cloudflare Workers, Deno, Bun or a framework's route.
- [create() and createDirect()](https://frontmcp.dev/reference/sdk/create.md): Build a server inside your own process and call its tools, resources, prompts and jobs as plain async functions, as a user you name.
- [server.registerTool()](https://frontmcp.dev/reference/sdk/register-tool.md): Add and remove tools on a running FrontMCP server with server.registerTool(), including WebMCP calls and disposal hooks.
- [connect() and client adapters](https://frontmcp.dev/reference/sdk/connect.md): Connect an MCP client to your server in memory, and get its tools and results in the shape Claude, OpenAI, LangChain or the Vercel AI SDK expects.
- [Guard options](https://frontmcp.dev/reference/sdk/guard.md): Every FrontMCP option that limits tool calls, a tool's rateLimit, concurrency and timeout and @FrontMcp's throttle, whose calls each limit counts, and the error each one produces.
- [Error classes](https://frontmcp.dev/reference/sdk/error-classes.md): The error classes of @frontmcp/sdk, grouped by area, with the code a client receives, whether its message survives production, and whether you throw it or FrontMCP does.
- [Error codes](https://frontmcp.dev/reference/errors.md): What FrontMCP's JSON-RPC error codes and tool error results mean, and how to fix them.
- [Scope and registries](https://frontmcp.dev/reference/sdk/scope.md): What this.scope gives a FrontMCP tool, resource or prompt, which registries you can list and search, what you can add at runtime, and which parts are FrontMCP's own machinery.
- [Server overview](https://frontmcp.dev/reference/server.md): How a FrontMCP server is configured: apps, config files, environment variables, MCP revisions, background tasks, logging, tracing and request flows.
- [Apps, discovery and splitting](https://frontmcp.dev/reference/server/apps.md): How a FrontMCP server is built from apps, what clients see and discover, what happens when two apps use the same name, and how standalone apps and splitByApp give apps endpoints and auth of their own.
- [Flows and stages](https://frontmcp.dev/reference/server/flows.md): Every request FrontMCP handles runs through named flows, each a fixed plan of stages. Every flow FrontMCP runs, with its stages in order and the state each one sets, how flows nest in one request, and how to write your own.
- [Loading apps from npm (ESM)](https://frontmcp.dev/reference/server/esm.md): App.esm() loads a package's tools, resources and prompts from npm when the server starts, and runs them in your server's process.
- [Remote servers](https://frontmcp.dev/reference/server/remote.md): App.remote() mounts another MCP server as an app, so its tools, resources and prompts appear on your server and calls are forwarded to it.
- [Protocol versions](https://frontmcp.dev/reference/server/protocol-versions.md): Which MCP revisions a FrontMCP server speaks on one endpoint, how it picks the revision for each request, and what changed in MCP 2026-07-28.
- [Background tasks](https://frontmcp.dev/reference/server/tasks.md): Let a slow tool run as an MCP task, so the client gets a task id at once, polls for the result, answers the tool's questions and can cancel it.
- [Configuration files](https://frontmcp.dev/reference/server/config-files.md): Every place a FrontMCP server takes settings from, the @FrontMcp options, the environment variables FrontMCP reads, .env and YAML files through ConfigPlugin, and the frontmcp.config file the CLI reads, and which one wins.
- [Logging](https://frontmcp.dev/reference/server/logging.md): The server's own log — levels, where lines go, custom transports, request tags, and the line that matches an error ID.
- [Observability and telemetry](https://frontmcp.dev/reference/server/observability.md): Trace every request with OpenTelemetry, add your own spans and counters, serve /metrics, and answer health checks.
- [Environment awareness](https://frontmcp.dev/reference/server/environment.md): Offer a tool, resource or prompt only on some runtimes, platforms or deployments with availableWhen, and branch on where the server runs with this.runtimeContext.
- [Authentication overview](https://frontmcp.dev/reference/auth.md): How a FrontMCP server authenticates MCP clients and decides what each caller may do: auth modes, tokens and sessions, OAuth sign-in, access rules on tools, resources and prompts, and running it in production.
- [Auth modes](https://frontmcp.dev/reference/auth/modes.md): The five ways a FrontMCP server decides who may connect, what each one advertises and answers without credentials, who your code sees as the caller, how anonymous access works, and how to choose.
- [Tokens and sessions](https://frontmcp.dev/reference/auth/tokens.md): How FrontMCP checks the credential on every request: provider JWTs, tokens it issues and static keys, what your code reads from a token, expiry, sessions and errors.
- [Local auth](https://frontmcp.dev/reference/auth/local.md): FrontMCP as its own OAuth 2.1 authorization server, with auth mode local: every option, the endpoints it serves, the flow a client follows, and what its tokens hold.
- [Custom login UI](https://frontmcp.dev/reference/auth/login-ui.md): The sign-in, consent and error pages FrontMCP serves in local mode, how to change or replace them, what data each one gets, and what protects them.
- [Progressive auth](https://frontmcp.dev/reference/auth/progressive.md): Letting a signed-in user start with part of a local-mode server and grant more when a tool needs it: app grants with incremental authorization tickets, credentials connected mid-session, and tool consent.
- [Remote and proxied auth](https://frontmcp.dev/reference/auth/remote.md): mode: "remote" puts FrontMCP between MCP clients and your identity provider: users sign in at the provider, and FrontMCP issues the tokens clients send. Every option, what tools see, and what FrontMCP checks.
- [Upstream providers](https://frontmcp.dev/reference/auth/upstream-providers.md): Linking several OAuth providers in one local-mode sign-in: auth.providers, the provider picker, federatedAuth, the callback each provider returns to, and reading each provider's token in a tool.
- [Client ID metadata (CIMD)](https://frontmcp.dev/reference/auth/cimd.md): How FrontMCP accepts MCP clients whose client_id is a metadata document URL: what it fetches and checks, caching, SSRF protection, cimd options and bad documents.
- [Authorities](https://frontmcp.dev/reference/auth/authorities.md): Rules on tools, resources, prompts, skills and agents that decide who may call them, from roles, permissions, token claims, the call's arguments or your own code, and what a caller the rules refuse gets.
- [Auth in production](https://frontmcp.dev/reference/auth/production.md): What to set and check before a FrontMCP server authenticates real users, from secrets, HTTPS and allowed hosts to token checks, what production hides, rate limits and several instances, and the gaps to work around.
- [Plugins overview](https://frontmcp.dev/reference/plugins.md): The official FrontMCP plugins and the OpenAPI adapter, which package each one is in, how to install and register them, what they add to your server, and what to know before you use one, including ES module projects.
- [Cache](https://frontmcp.dev/reference/plugins/cache.md): @frontmcp/plugin-cache answers repeated tool calls from a store instead of running the tool again. Every option, what the key is made of, who gets which entry, and what it caches and doesn't.
- [Remember](https://frontmcp.dev/reference/plugins/remember.md): @frontmcp/plugin-remember gives tools an encrypted key-value memory, this.remember, in session, user, tool and global scopes, plus four tools that let the model remember things. Every option, what each scope keeps, and who can read it back.
- [Approval](https://frontmcp.dev/reference/plugins/approval.md): @frontmcp/plugin-approval refuses to run a tool until an approval is recorded for the caller. Every option, how approvals are granted, revoked and expire, what the client sees, and what the gate does and doesn't enforce.
- [Feature flags](https://frontmcp.dev/reference/plugins/feature-flags.md): Hide tools, resources, prompts and skills behind flags with @frontmcp/plugin-feature-flags: LaunchDarkly, Split and Unleash adapters, per-user targeting, failures.
- [CodeCall](https://frontmcp.dev/reference/plugins/codecall.md): @frontmcp/plugin-codecall puts a large tool set behind a handful of meta-tools: the model searches for the tools it needs, reads their schemas, and calls them one at a time or from a short script that runs in a sandbox on the server.
- [Skilled OpenAPI](https://frontmcp.dev/reference/plugins/skilled-openapi.md): Serve a large REST API through skills and workflow tools. Configure signed bundles, credentials, authorization and execution limits.
- [WebMCP](https://frontmcp.dev/reference/plugins/webmcp.md): Expose a browser-based FrontMCP server's tools through document.modelContext for compatible browser agents.
- [OpenAPI adapter](https://frontmcp.dev/reference/adapters/openapi.md): OpenapiAdapter turns every operation of an OpenAPI 3 spec into a tool that calls your REST API. Every option, how arguments are checked, what a call sends and returns, credentials, transforms and spec polling.
- [Tool UI](https://frontmcp.dev/reference/ui.md): A tool's ui option: templates, what FrontMCP adds to tools/list, tools/call and the ui://widget resource, serving modes and defaults, and the widget's CSP.
- [Widget components](https://frontmcp.dev/reference/ui/components.md): Building a widget as a React file: how FrontMCP bundles it, the props and bridge hooks it gets from @frontmcp/ui/react, the MUI-based components, theme and renderers in @frontmcp/ui, and the React-free helpers in @frontmcp/uipack.
- [Hosts and platforms](https://frontmcp.dev/reference/ui/hosts.md): How FrontMCP recognizes the client that calls a tool, what each platform gets, how the widget's bridge talks to MCP Apps hosts and the OpenAI Apps SDK, and how a widget's tool calls reach the server as the host's own.
- [@frontmcp/react](https://frontmcp.dev/reference/react.md): @frontmcp/react runs a FrontMCP server in the same process as a React app and gives components hooks to call it. FrontMcpProvider, the client it connects, several servers, stores, and building it with Vite.
- [React hooks](https://frontmcp.dev/reference/react/hooks.md): Every hook in @frontmcp/react: calling tools, reading resources and prompts, listing what the server has, live resources, registering tools and resources from components, and the hooks in /state, /api and /ai.
- [React components](https://frontmcp.dev/reference/react/components.md): The components in @frontmcp/react: forms generated from tools and prompts, viewers for results, mcpComponent for UI a model fills in, DynamicRenderer, DOM resources, and the router bridge, with what each renders and where each falls short.
- [test and the mcp client](https://frontmcp.dev/reference/testing.md): Test a FrontMCP server end to end, with a connected MCP client in every test and matchers that understand MCP results.
- [Matchers](https://frontmcp.dev/reference/testing/matchers.md): The MCP and widget matchers @frontmcp/testing adds to expect, and the Jest matchers you can use with them in the Playground.
- [Fixtures](https://frontmcp.dev/reference/testing/fixtures.md): The fixtures every @frontmcp/testing test receives, mcp, server and auth: how test.use() configures them, what each one offers, and when each is created and torn down.
- [Interceptors and HTTP mocking](https://frontmcp.dev/reference/testing/interceptors.md): Fake what the test client sends and receives with mcp.mock and mcp.intercept, and the APIs your tools call with MockAPIServer and httpMock: every option, and which process each one works in.
- [Testing authentication](https://frontmcp.dev/reference/testing/auth.md): Test FrontMCP authentication with user tokens, mock OAuth providers and CIMD clients. Check accepted credentials and rejected requests.
- [Deployment overview](https://frontmcp.dev/reference/deployment.md): Build and run a FrontMCP server in production: Node and Docker, Vercel, AWS Lambda, Cloudflare Workers, Redis or SQLite state, scaling, health checks and MCP clients.
- [Production build](https://frontmcp.dev/reference/deployment/production-build.md): frontmcp build and its targets: what each one writes, what it bundles and what it leaves in node_modules, how the result runs, which endpoint path it serves, and when it's in production mode.
- [Node.js and Docker](https://frontmcp.dev/reference/deployment/node.md): Run the node build of a FrontMCP server on a machine, in a Docker image, with Redis in Docker Compose, behind nginx, or on a Unix socket: what it needs, the environment it reads, how it stops, and what the generated Docker files do.
- [Vercel](https://frontmcp.dev/reference/deployment/vercel.md): Build and deploy a FrontMCP Node.js function on Vercel. Check generated files, the MCP endpoint, production settings and shared storage.
- [AWS Lambda](https://frontmcp.dev/reference/deployment/aws-lambda.md): Deploy a FrontMCP server to AWS Lambda with frontmcp build --target lambda: the handler, what to deploy, NODE_ENV, supported events and Redis sessions.
- [Cloudflare Workers](https://frontmcp.dev/reference/deployment/cloudflare-workers.md): Deploy a FrontMCP server as a Cloudflare Worker with frontmcp build --target cloudflare: the entry and wrangler.toml it writes, secrets and bindings, when the Worker is in production, and the storage it takes and refuses.
- [@frontmcp/edge](https://frontmcp.dev/reference/deployment/edge.md): createEdgeMcp() runs a FrontMCP server on Cloudflare Workers from plain configuration, with no build step or decorators: Durable Object sessions and managed mode.
- [Browser](https://frontmcp.dev/reference/deployment/browser.md): Running a FrontMCP server inside a web page or a Web Worker: the SDK's browser build, the entry points that never listen, what works there and what needs Node, keeping keys in IndexedDB or localStorage, and calling a model from the page.
- [Redis](https://frontmcp.dev/reference/deployment/redis.md): The @FrontMcp redis option: its fields, what FrontMCP keeps in Redis and under which keys, how long sessions last, what doesn't use it, and what happens when Redis can't be reached.
- [SQLite](https://frontmcp.dev/reference/deployment/sqlite.md): The @FrontMcp sqlite option: keep sessions, background tasks and pending questions in a SQLite file on one machine, with the packages it needs, where the file goes, what it stores, locking, and encryption.
- [High availability](https://frontmcp.dev/reference/deployment/high-availability.md): Configure shared state, routing and failover for multiple FrontMCP instances, including older session-based clients.
- [Health checks and metrics](https://frontmcp.dev/reference/deployment/health-and-metrics.md): What /healthz, /readyz and /metrics answer on each FrontMCP runtime, and how to point container health checks, Kubernetes probes, load balancers and Prometheus at them.
- [Security headers and transport](https://frontmcp.dev/reference/deployment/security.md): What FrontMCP does at the HTTP layer: the security headers it sends and how to turn on HSTS and a CSP, bind address and host checks, body size limits, the endpoints the Node server exposes, and the startup audit.
- [Connecting MCP clients](https://frontmcp.dev/reference/deployment/mcp-clients.md): How MCP clients reach a FrontMCP server: Streamable HTTP by URL, stdio, or a Unix socket; publishing to npm for npx; client snippets from the CLI; and MCP Bundles.
- [MCP Registry](https://frontmcp.dev/reference/deployment/mcp-registry.md): Serve a domain proof, server card and AI Catalog, then publish and manage your server's MCP Registry listing with the CLI.
- [frontmcp CLI](https://frontmcp.dev/reference/cli.md): FrontMCP CLI commands for creating, building, testing and deploying MCP servers, with outputs and troubleshooting.
- [Nx plugin](https://frontmcp.dev/reference/nx.md): @frontmcp/nx adds 21 generators and 7 executors to an Nx workspace. What it adds, the two ways to install it, the workspace layout it expects, and what to change in an older workspace.
- [Nx generators](https://frontmcp.dev/reference/nx/generators.md): Every generator in @frontmcp/nx, with its options, the files it writes, and what its output does: init, workspace, app, lib and server; the thirteen component generators; and the three UI generators.
- [Nx executors](https://frontmcp.dev/reference/nx/executors.md): Every executor in @frontmcp/nx (build, build-exec, dev, serve, test, inspector and deploy): the options each takes, the command it runs, what is cached, and how to run an app's tests and build it for another target.
- [Monorepo patterns](https://frontmcp.dev/reference/nx/monorepo.md): Lay out a FrontMCP Nx workspace with @frontmcp/nx: apps, shared libraries and server shells, composing apps into one server, builds, tags, and moving a project in.
- [Rules of FrontMCP](https://frontmcp.dev/reference/rules.md): The short list of rules that keep FrontMCP servers correct, safe and easy for models to use.
- [Security](https://frontmcp.dev/reference/security.md): How to report a vulnerability in FrontMCP, the defaults a new server starts with, what to set before production, and what FrontMCP does about each risk in the OWASP MCP Top 10, and what it leaves to you.

## Examples

- [Tenant reporting](https://frontmcp.dev/examples/tenant-reporting.md): A read-only reporting server with two tenants, server-side API credentials and allow/deny checks. Run the fixture and take it into a local project.
- [All examples](https://frontmcp.dev/examples.md): Complete MCP servers in TypeScript, built with FrontMCP, that you can run in your browser, each with its tests and a walkthrough of how it's built.
- [Nightly Ticket Report](https://frontmcp.dev/examples/nightly-ticket-report.md): A help desk server that builds a daily SLA report with a workflow, a job per step, started in the background by a tool and read back by another.
- [Triage Agent](https://frontmcp.dev/examples/triage-agent.md): A help desk server whose triage agent reads a new ticket, looks up the customer and related tickets, then sets the priority and the team, with a skill that tells a client's model how to triage a whole queue with it.
- [Research Assistant](https://frontmcp.dev/examples/research-assistant.md): A help desk server whose research agent answers a hard question from knowledge-base articles and closed tickets, by handing the searching to another agent and returning only claims that cite the sources it was given.
- [Order Tracker Widget](https://frontmcp.dev/examples/order-tracker-widget.md): A help desk server whose track_order tool answers the model with an order and its shipping timeline, and shows a support agent the same timeline as a widget with buttons that call tools back and update it.
- [Expense Dashboard](https://frontmcp.dev/examples/expense-dashboard.md): A help desk server whose expense_report tool answers the model with what support spent in a month and shows the team lead the same numbers as a static dashboard widget, with filters that call the tool for another month or team.
- [CRM with CodeCall](https://frontmcp.dev/examples/crm-with-codecall.md): A help desk's CRM server with 47 tools, put behind the CodeCall plugin so a model searches for the tools it needs, reads their schemas, and answers a question that spans customers, tickets and accounts with one script.
- [Pet Store from OpenAPI](https://frontmcp.dev/examples/pet-store-from-openapi.md): A help desk server built from the Swagger Petstore API with the OpenAPI adapter, with model-ready names, server-held keys, read-only tools and actionable errors.

## Compare

- [Overview](https://frontmcp.dev/compare.md): Compare eight TypeScript MCP server options by auth, testing, protocol support and deployment. Choose for your workload and inspect the sources and test limits.
- [Why FrontMCP](https://frontmcp.dev/compare/why-frontmcp.md): When a TypeScript MCP server needs a framework around the protocol, what FrontMCP adds as a server grows, and when the official SDK or another library is the better choice.
- [Evaluate for production](https://frontmcp.dev/compare/production-readiness.md): Evaluate FrontMCP with protocol checks, tenant-access tests, deployment requirements and recorded migration results. Reproduce the fixtures and see their limits.
- [vs the official SDK](https://frontmcp.dev/compare/official-typescript-sdk.md): How FrontMCP and the official MCP TypeScript SDK differ, what each is for, and when to use which.
- [vs FastMCP (punkpeye)](https://frontmcp.dev/compare/fastmcp-typescript.md): How FrontMCP and FastMCP for TypeScript (punkpeye/fastmcp) differ in protocol support, tools, auth, testing and deployment, and when to choose each.
- [vs ViteMCP](https://frontmcp.dev/compare/vitemcp.md): How FrontMCP and ViteMCP, the stateless successor to punkpeye's FastMCP, differ in protocol support, sessions, auth, testing and deployment, and when to choose each.
- [vs FastMCP TypeScript (Prefect)](https://frontmcp.dev/compare/fastmcp-ts.md): How FrontMCP and FastMCP TypeScript (@prefecthq/fastmcp-ts), Prefect's counterpart to the Python FastMCP, differ in protocol support, auth, composition, testing and deployment, and when to choose each.
- [vs mcp-framework](https://frontmcp.dev/compare/mcp-framework.md): How FrontMCP and mcp-framework differ in protocol support, tool classes, auth, testing and deployment, and when to choose each.
- [vs mcp-use](https://frontmcp.dev/compare/mcp-use.md): How FrontMCP and the mcp-use TypeScript SDK differ as server frameworks, in protocol support, auth, widgets, testing and deployment, and when to choose each.
- [vs xmcp](https://frontmcp.dev/compare/xmcp.md): How FrontMCP and xmcp differ in protocol support, tool declaration, auth, widgets and deployment, and when to choose each.

## Blog

- [Build an MCP Server With Claude Code Connected to It](https://frontmcp.dev/blog/claude-code-hot-reload.md): Develop an MCP server with Claude Code connected through frontmcp dev --stdio --serve: hot reload in half a second, and the next call runs the new code.
- [We Gave a Coding Agent Our FastMCP Migration Prompt. Here's What It Did](https://frontmcp.dev/blog/coding-agent-fastmcp-migration.md): We gave a coding agent our guide's prompt and FastMCP's own example server. What it ported in 21 minutes, what clients see now, and what it got wrong.
- [WebMCP on frontmcp.dev: A FrontMCP Server in the Docs Page](https://frontmcp.dev/blog/webmcp-docs-site.md): WebMCP lets a website offer tools to the agent in a reader's browser. How frontmcp.dev offers 13 from a FrontMCP server in the page, and what we learned.
- [Versioned Docs for Coding Agents: How We Built FrontMCP's Docs MCP Server](https://frontmcp.dev/blog/docs-mcp-server.md): Coding agents can now read FrontMCP's docs for the release a project uses, from an MCP server built with FrontMCP on a Cloudflare Worker. How it finds the version, what its tools do, and what we learned building it.
- [MCP 2026-07-28 Dropped the Handshake: Where the TypeScript MCP Frameworks Stand](https://frontmcp.dev/blog/mcp-went-stateless.md): MCP 2026-07-28 removed initialize and sessions. What changed in the protocol, what it means for an MCP server, which TypeScript frameworks serve the new revision, the old ones or both, and how to move a server over.
- [Organize several MCP servers in an Nx workspace](https://frontmcp.dev/blog/nx-plugin.md): Share tools and libraries across FrontMCP apps, create deployment entry points and use Nx caching and affected-project commands.
- [Add interactive widgets to MCP tool results](https://frontmcp.dev/blog/tool-ui.md): Return data for the model and a widget for the user. Build a FrontMCP template, connect its actions and check host compatibility.
- [Deploy a FrontMCP server to Vercel](https://frontmcp.dev/blog/deploy-to-vercel.md): Build a Vercel Node.js function, deploy it, verify the MCP endpoint and configure shared storage when your server needs it.
- [Expose a FrontMCP agent as an MCP tool](https://frontmcp.dev/blog/agent-as-tool.md): Define an agent with its own instructions and tools, call it through MCP and control how it delegates work to other agents.
- [Reduce MCP tool context with CodeCall](https://frontmcp.dev/blog/codecall-plugin.md): Discover tools on demand and combine their results in server-side scripts. Includes setup, execution limits and tradeoffs.
- [Keep credentials out of OpenAPI-generated MCP tools](https://frontmcp.dev/blog/openapi-mcp-security.md): Resolve API credentials on the server, isolate request headers and check tenant access when exposing a REST API through MCP.
- [Serve multiple MCP clients from one FrontMCP server](https://frontmcp.dev/blog/mcp-run-out-of-socket.md): Group tools into apps and share a server across clients. Choose authentication, request scope and state for the supported MCP revisions.
- [Introducing FrontMCP, a TypeScript framework for MCP servers](https://frontmcp.dev/blog/introducing-frontmcp.md): Build MCP servers with typed tools, shared providers, authentication and tests. Start with a small example and the installation guide.