# FrontMCP vs Prefect's FastMCP TypeScript

> 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.

Source: https://frontmcp.dev/compare/fastmcp-ts

FastMCP TypeScript is Prefect's TypeScript counterpart to the Python FastMCP, built on v2 of the official MCP SDK: one `FastMCP` object with `tool()`, `resource()` and `prompt()`, and in the same package a client, middleware, server composition and an apps layer. It isn't [FastMCP for TypeScript](https://frontmcp.dev/compare/fastmcp-typescript), punkpeye's `fastmcp` package, which has its own page. FrontMCP declares tools as decorated classes and adds a container for shared services, agents, jobs and workflows, a test library and builds for several platforms. This page shows the same tool in both and compares them on the criteria of the [comparison overview](https://frontmcp.dev/compare).

This site documents FrontMCP, so read it knowing who wrote it. Every FastMCP TypeScript fact below comes from its own README, documentation and source at **1.7.3**, checked on **2026-10-20**, and links to them. Every FrontMCP fact links to the page on this site that shows FrontMCP 1.10.5 doing it, or to [how this was checked](#how-this-was-checked).

## Quick answer

Choose Prefect's FastMCP TypeScript when you want the Python FastMCP's model in TypeScript, on the official SDK v2, with a client, middleware, server composition and both MCP eras over HTTP and stdio in one package. Choose FrontMCP over Prefect's FastMCP TypeScript when you want shared services, agents, jobs, workflows and MCP tasks, a test library, sessions shared between instances, or builds for Vercel, AWS Lambda and Cloudflare Workers.

---

## What FastMCP TypeScript is

[FastMCP TypeScript](https://github.com/PrefectHQ/fastmcp-ts) lives in Prefect's GitHub organization and is published on npm as [`@prefecthq/fastmcp-ts`](https://www.npmjs.com/package/@prefecthq/fastmcp-ts). Its README calls it "the official TypeScript counterpart to [FastMCP for Python](https://github.com/PrefectHQ/fastmcp)", built "by the same team at Prefect" ([README](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/README.md?plain=1#L1-L7)). Its first release was 0.0.2-alpha.0 on 2026-04-23, 1.0.0 came out on 2026-07-28, and 1.7.3, the version checked here, on 2026-10-01 ([npm](https://www.npmjs.com/package/@prefecthq/fastmcp-ts?activeTab=versions)). Its documentation is at [fastmcp-ts.docs.prefect.io](https://fastmcp-ts.docs.prefect.io), from the [`docs/`](https://github.com/PrefectHQ/fastmcp-ts/tree/v1.7.3/docs) folder that this page links to at the release tag.

Its `package.json` says Apache-2.0, and so does npm; the repository has no LICENSE file at v1.7.3 ([`package.json`](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/package.json)). The server needs Node 22 or later; the client also bundles for the browser ([Installation](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/installation.mdx)).

It's built on v2 of the official SDK, `@modelcontextprotocol/server` and `@modelcontextprotocol/client` ([README](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/README.md?plain=1#L5)), which installed 2.3.1 on 2026-10-20, and on the frozen `@modelcontextprotocol/server-legacy` for its OAuth server ([OAuth](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/auth/oauth.mdx#interim-status)). Its README says that since 1.0 it "speaks both MCP protocol generations: the 2025 legacy era and the 2026-07-28 modern era. A server serves both at once, and a client negotiates one" ([README](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/README.md?plain=1#L7)).

Two names collide with punkpeye's FastMCP for TypeScript: the library's name, and its CLI, which is called `fastmcp` in both packages.

On 2026-10-20, FastMCP TypeScript had 78 GitHub stars ([GitHub API](https://api.github.com/repos/PrefectHQ/fastmcp-ts)) and 9,609 npm downloads in the week of 2026-10-12 to 2026-10-18 ([npm API](https://api.npmjs.org/downloads/point/last-week/@prefecthq/fastmcp-ts)). FrontMCP had 146 stars and 15,574 downloads of `@frontmcp/sdk` in the same week.

## The same tool in both

One tool, `add`, that takes two numbers and returns their sum, called with `{ "a": 2, "b": 3 }`.

### In FastMCP TypeScript

This is the server from the [README](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/README.md#servers) and the [Quickstart](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/quickstart.mdx), with only its tool, as we ran it with `@prefecthq/fastmcp-ts` 1.7.3, `zod` 4.6.7 and `tsx`, in a project with `"type": "module"`:

```ts server.ts
import { FastMCP } from '@prefecthq/fastmcp-ts/server'
import { z } from 'zod'

const server = new FastMCP({ name: 'my-server', version: '1.0.0' })

server.tool(
  {
    name: 'add',
    description: 'Add two numbers',
    input: z.object({ a: z.number(), b: z.number() }),
  },
  ({ a, b }) => a + b
)

await server.run()                              // stdio (default)
// await server.run({ transport: 'http', port: 3000 })
```

`npx fastmcp call add --file server.ts a=2 b=3`, from its [CLI](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/cli.mdx#call-tools-and-read-resources), started the server over stdio, called the tool and printed `5`. The CLI asks for 2026-07-28 first; with `--json` the result carried the server's info in `_meta`, as a 2026-07-28 result does, and with `--legacy` it was the same `5` after an `initialize` handshake. A number comes back as a text block ([Return values](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/tools.mdx#return-values)).

With `server.run({ transport: 'http', port: 3209 })` instead, the same server answered at `http://127.0.0.1:3209/mcp`. A client from `@modelcontextprotocol/client` 2.3.1 called `add` with its default, which opens a 2025-era session with `initialize`, and with `versionNegotiation: { mode: "auto" }`, which asks for 2026-07-28 first:

```text
legacy 2025-11-25 {"content":[{"type":"text","text":"5"}]}
modern 2026-07-28 {"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"my-server","version":"1.0.0"}},"content":[{"type":"text","text":"5"}]}
```

There's no build step and no configuration file: `npx fastmcp run server.ts` or `npx tsx server.ts` runs it.

### In FrontMCP

The same tool, in a one-app FrontMCP server. The Playground runs it and calls `add`; the **Tests** tab runs the checks below it.

```ts main.ts active
import { App, FrontMcp, Tool, ToolContext, z } from "@frontmcp/sdk";

@Tool({
  name: "add",
  description: "Add two numbers",
  inputSchema: { a: z.number(), b: z.number() },
})
export class Add extends ToolContext {
  async execute({ a, b }: { a: number; b: number }) {
    return { sum: a + b };
  }
}

@App({ id: "calc", name: "Calculator", tools: [Add] })
export class CalcApp {}

@FrontMcp({ info: { name: "calc", version: "1.0.0" }, apps: [CalcApp] })
export default class Server {}
```

```ts add.test.ts
import { test, expect } from "@frontmcp/testing";

test("adds two numbers", async ({ mcp }) => {
  const result = await mcp.tools.call("add", { a: 2, b: 3 });
  expect(result).toBeSuccessful();
  expect(result.json()).toEqual({ sum: 5 });
});

test("rejects a string where a number belongs", async ({ mcp }) => {
  const result = await mcp.tools.call("add", { a: "2", b: 3 });
  expect(result).toBeError("INVALID_INPUT");
});
```

The FrontMCP version is longer: a tool class, an app that lists it, and a server that lists the app. It returns an object, which arrives as `structuredContent` with a text copy ([Your First Tool](https://frontmcp.dev/learn/your-first-tool#returning-results-and-errors)). An argument of the wrong type is a tool error in FrontMCP, as the second test shows, which the model reads as a result. In FastMCP TypeScript it's a JSON-RPC error: `{ "a": "2", "b": 3 }` got `-32602` `Validation failed` in our run, as its docs say ([Schemas](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/tools.mdx#schemas)). FrontMCP needs Node 24 or later and TypeScript's decorator settings ([Installation](https://frontmcp.dev/learn/installation)); FastMCP TypeScript needs Node 22. `npm install @prefecthq/fastmcp-ts` installed 149 packages on 2026-10-20, and `npm install @frontmcp/sdk` 126.

## Side by side

| | FastMCP TypeScript 1.7.3 | FrontMCP 1.10.5 |
| --- | --- | --- |
| MCP revisions served | 2024-11-05 to 2026-07-28 on one endpoint, over Streamable HTTP and stdio; the older four with a session, unless stateless mode is on ([Protocol eras](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/concepts/protocol-eras.mdx), [Running your server](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/running.mdx#transports)) | 2024-11-05 to 2026-07-28 over Streamable HTTP and stdio, with a session for the older four ([Protocol versions](https://frontmcp.dev/reference/server/protocol-versions#revisions-over-stdio)) |
| Declaring a tool | `server.tool({ name, description, input }, handler)` ([Tools](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/tools.mdx#registration)) | A [`@Tool`](https://frontmcp.dev/reference/sdk/tool) class, or the `tool()` function |
| Schemas | Standard Schema: Zod, Valibot, ArkType; `output` checked after the handler; JSON Schema generated, or set by hand ([Schemas](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/tools.mdx#schemas)) | Zod 4; `outputSchema` checks every result ([Schemas Are Contracts](https://frontmcp.dev/learn/schemas-are-contracts), [Shaping Tool Results](https://frontmcp.dev/learn/shaping-tool-results)) |
| Shared services | No container documented. Handlers get an ambient context from `server.getContext()`, with logging, progress, request state and session state ([Context](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/context.mdx)) | [`@Provider`](https://frontmcp.dev/reference/sdk/provider) services, read with `this.get()` |
| Code around every call | Middleware: logging, caching per caller, rate limiting, size limits, error normalization, cancellation ([Middleware](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/middleware.mdx)) | [Hooks](https://frontmcp.dev/reference/sdk/hooks) and [plugins](https://frontmcp.dev/reference/plugins); rate limits, concurrency caps and timeouts ([Guard options](https://frontmcp.dev/reference/sdk/guard)) |
| Auth | Token verifiers: JWTs against a JWKS, introspection, static tokens, several at once, or headers from a trusted proxy; `oauthProvider` and `oauthProxy`, which the docs call "a supported interim"; `requireScopes` and per-component checks ([Auth overview](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/auth/overview.mdx), [OAuth](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/auth/oauth.mdx), [Authorization](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/auth/authorization.mdx)) | Five modes: public, static keys, JWTs from your identity provider, and FrontMCP as the OAuth server, with its own sign-in page or an upstream provider's ([Auth modes](https://frontmcp.dev/reference/auth/modes)); per-entry rules ([Authorities](https://frontmcp.dev/reference/auth/authorities)) |
| Testing | An in-process `Client.connect(server)`, stdio stream overrides, and `fastmcp call`, `list` and `inspect` ([Transports](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/clients/transports.mdx#in-process-connections), [Running your server](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/running.mdx#stream-overrides)); no test matchers documented | `@frontmcp/testing` with MCP matchers, run by `frontmcp test` ([Testing](https://frontmcp.dev/reference/testing)) |
| Resources, prompts, completions, elicitation | All four, with resource subscriptions on both eras; elicitation, sampling and roots as requests on a 2025-era session, or a returned `inputRequired()` on both eras ([Resources](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/resources.mdx), [Prompts](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/prompts.mdx), [Context](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/context.mdx#asking-the-client-for-input)) | All four ([`@Resource`](https://frontmcp.dev/reference/sdk/resource), [`@Prompt`](https://frontmcp.dev/reference/sdk/prompt), [completers](https://frontmcp.dev/reference/sdk/resource-template#completing-parameters), [`this.elicit`](https://frontmcp.dev/reference/sdk/elicit), which serves both eras); [`this.sample()` and `this.listRoots()`](https://frontmcp.dev/reference/sdk/contexts#thissample-and-thislistroots) for clients that offer them |
| Agents, jobs, workflows, tasks | Not documented; MCP tasks are "planned" ([Tasks](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/tasks.mdx)) | [`@Agent`](https://frontmcp.dev/reference/sdk/agent), [`@Job`](https://frontmcp.dev/reference/sdk/job), [`@Workflow`](https://frontmcp.dev/reference/sdk/workflow); [background tasks](https://frontmcp.dev/reference/server/tasks) |
| Widgets (MCP Apps) | `FastMCPApp`: screens built from a server-side component library, ready-made approval, choice, file upload and form providers, and generative UI ([Apps overview](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/apps/overview.mdx)) | A tool's `ui` option with HTML or React, for MCP Apps hosts and the OpenAI Apps SDK ([Tool UI](https://frontmcp.dev/reference/ui), [Hosts](https://frontmcp.dev/reference/ui/hosts)) |
| Combining servers | `mount()` with a prefix, `createProxy()` for remote servers, and transforms that rename, filter or namespace what's listed ([Composition](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/composition.mdx), [Transforms](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/transforms.mdx)) | Several apps on one server, or one endpoint per app ([Apps, discovery and splitting](https://frontmcp.dev/reference/server/apps)); remote servers served as apps ([Remote servers](https://frontmcp.dev/reference/server/remote)) |
| Client | `Client` for any server, with multi-server connections and sampling adapters for Anthropic, OpenAI and Google ([README](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/README.md#clients)) | [`connect()`](https://frontmcp.dev/reference/sdk/connect) to your own server, in-process |
| Transports | Streamable HTTP, with sessions or stateless; stdio; no standalone SSE ([Running your server](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/running.mdx#transports)) | Streamable HTTP with or without sessions, the older HTTP+SSE, stdio, a Unix socket, in-memory ([`FrontMcpInstance`](https://frontmcp.dev/reference/sdk/frontmcp-instance), [`transport`](https://frontmcp.dev/reference/sdk/frontmcp#transport)) |
| Runtimes and deployment | Node 22+; `server.fetch()` serves a web-standard `Request`, statelessly; a health endpoint and custom routes ([Installation](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/installation.mdx), [`FastMCP`](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/api/server/classes/FastMCP.mdx#fetch), [Running your server](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/running.mdx#health-endpoint)) | Node 24+; `frontmcp build` targets for Node, Vercel, AWS Lambda, Cloudflare Workers and a browser module ([Production build](https://frontmcp.dev/reference/deployment/production-build)); a fetch handler for other runtimes ([`createFetchHandler()`](https://frontmcp.dev/reference/sdk/create-fetch-handler)) |
| CLI | `fastmcp run`, `inspect`, `call`, `list`, `dev inspector`, `install` for Claude Code, Cursor and Claude Desktop, `discover`; no project generator ([CLI](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/cli.mdx)) | `frontmcp create`, `dev`, `build`, `test`, `inspector` ([CLI](https://frontmcp.dev/reference/cli)); an [Nx plugin](https://frontmcp.dev/reference/nx) |
| License | Apache-2.0 in [`package.json`](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/package.json); no LICENSE file in the repository | [Apache-2.0](https://github.com/agentfront/frontmcp/blob/main/LICENSE) |

## What each does that the other doesn't

What FastMCP TypeScript documents, or did in our run, and this site doesn't show for FrontMCP:

- **The official SDK v2 underneath.** Its protocol code is the SDK's, and its docs say it runs the MCP conformance suite on every pull request ([Migration](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/migration.mdx#conformance)). FrontMCP is built on v1 of the SDK and implements 2026-07-28 itself ([FrontMCP vs the official SDK](https://frontmcp.dev/compare/official-typescript-sdk#what-frontmcp-uses-from-it)).
- **A client for any MCP server**, in Node or the browser, with connections to several servers at once and sampling adapters for Anthropic, OpenAI and Google ([README](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/README.md#clients)).
- **Transforms**: a view of what's listed that renames tools, filters them by tag or version, prefixes every name, or adds a tool that lists resources or prompts ([Transforms](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/transforms.mdx)).
- **UI from server-side components**: screens described as a JSON component tree, ready-made approval, choice, file upload and form screens, and generative UI that lets the model build a screen ([Apps overview](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/apps/overview.mdx)). FrontMCP's widgets are HTML or React that you write.
- **A choice of schema library.** Any [Standard Schema](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/tools.mdx#schemas) library works. FrontMCP's pages use Zod 4 only.
- **Completion of prompt arguments** ([Prompts](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/prompts.mdx#argument-completion)). This site shows FrontMCP completing resource template parameters only.
- **Installing a server file into Cursor and Claude Desktop** with `fastmcp install` ([CLI](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/cli.mdx#install-into-editors-and-clients)). A FrontMCP server built with the `cli` target installs itself into Claude Code and Codex ([CLI](https://frontmcp.dev/reference/cli#installing-into-claude-code-and-codex)).
- **The Python FastMCP's conventions**: the same entrypoint exports for the CLI ([CLI](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/cli.mdx#entrypoint-exports)), and OpenAPI generation that matches Python's output ([OpenAPI](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/openapi.mdx#python-parity)).
- **Node 22.** FrontMCP needs Node 24.

What FrontMCP does that FastMCP TypeScript's docs don't document:

- **Sessions shared between instances**, through [Redis](https://frontmcp.dev/reference/deployment/redis). FastMCP TypeScript keeps a 2025-era session in the memory of the instance that answered `initialize`, and its answer for several instances is stateless mode, which turns off session state and requests from the server ([Stateless mode](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/running.mdx#stateless-mode)).
- **One `this.elicit()` for both eras**: on a session it waits for the answer, and for a 2026-07-28 client it becomes `input_required` ([How an elicitation travels](https://frontmcp.dev/reference/sdk/elicit#how-an-elicitation-travels)). In FastMCP TypeScript, `ctx.elicit()` throws on a 2026-07-28 request, and a handler that serves both returns `inputRequired()` ([Context](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/context.mdx#asking-the-client-for-input)).
- **A dependency container**: [providers](https://frontmcp.dev/learn/sharing-state-with-providers) with scopes, which tools, resources and prompts get with `this.get()`.
- **Agents, jobs, workflows and tasks**: [agents](https://frontmcp.dev/learn/your-first-agent) that run a model loop on the server, [jobs](https://frontmcp.dev/learn/your-first-job) that run in the background, [workflows](https://frontmcp.dev/learn/chaining-jobs-into-workflows) that chain them, and tools that run as [MCP tasks](https://frontmcp.dev/reference/server/tasks), which FastMCP TypeScript lists as planned.
- **A test library** with MCP matchers and fixtures ([Testing Your Server](https://frontmcp.dev/learn/testing-your-server)).
- **An OAuth server with client ID metadata documents**: in `local` mode FrontMCP serves the sign-in page and issues the tokens ([Local auth](https://frontmcp.dev/reference/auth/local#checking-users-yourself)), and accepts clients identified by a metadata URL ([CIMD](https://frontmcp.dev/reference/auth/cimd)). FastMCP TypeScript's `oauthProvider` and `oauthProxy` register clients with Dynamic Client Registration, which 2026-07-28 deprecates, from the frozen `server-legacy` package ([OAuth](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/auth/oauth.mdx#interim-status)).
- **Plugins** for memory, approvals, feature flags and CodeCall ([Plugins and adapters](https://frontmcp.dev/reference/plugins)), next to the cache that both have.
- **Project scaffolding and platform builds**: `frontmcp create`, and `frontmcp build` for Vercel, AWS Lambda and Cloudflare Workers ([Deploying Your Server](https://frontmcp.dev/learn/deploying-your-server)). FastMCP TypeScript's server runs on Node.
- **The older HTTP+SSE transport**, for clients that still use it ([`transport`](https://frontmcp.dev/reference/sdk/frontmcp#transport)).

Both import tools from an OpenAPI spec ([FastMCP TypeScript](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/openapi.mdx), [FrontMCP](https://frontmcp.dev/reference/adapters/openapi)), both serve tools from other MCP servers ([FastMCP TypeScript](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/composition.mdx#proxying), [FrontMCP](https://frontmcp.dev/reference/server/remote)), and both cache results per caller ([FastMCP TypeScript](https://github.com/PrefectHQ/fastmcp-ts/blob/v1.7.3/docs/servers/middleware.mdx#built-in-middleware), [FrontMCP](https://frontmcp.dev/reference/plugins/cache)).

## When to choose FastMCP TypeScript

- You use the Python FastMCP, or run Python and TypeScript servers side by side, and want the same model and CLI conventions in both.
- You want the official SDK v2 underneath, with both protocol eras over HTTP and stdio from one server.
- You also need a client: for several servers at once, in the browser, or with sampling handled by Anthropic, OpenAI or Google.
- You assemble a gateway from other servers, with prefixes, proxies and transforms.
- You want UI screens from a component library, or generated by the model, rather than HTML you write.
- You want Valibot or ArkType rather than Zod, or you're on Node 22.

## When to choose FrontMCP

- The server is growing, and you want shared services, several apps, hooks and plugins to organise it ([Structuring a Server](https://frontmcp.dev/learn/structuring-a-server)).
- You want agents, background jobs, workflows or MCP tasks from the same framework.
- You run several instances behind a load balancer and want 2025-era sessions to work on all of them ([Running Several Instances](https://frontmcp.dev/learn/running-several-instances)).
- You want tests written against your server with a dedicated library, or a build for Vercel, AWS Lambda or Cloudflare Workers.
- You want FrontMCP to be the OAuth server, with client ID metadata documents.

## How this was checked

On 2026-10-20 we installed `@prefecthq/fastmcp-ts` 1.7.3, with Node 24.18.1 and npm 11.16.0, ran the server above over stdio, with its CLI and with `tsx`, and over Streamable HTTP, and called `add`. We then sent each server an `initialize` request for every MCP revision from 2024-11-05 to 2025-11-25, and the 2026-07-28 `server/discover` and `tools/call` requests, with the `MCP-Protocol-Version: 2026-07-28` header and the revision in `_meta`. Over stdio and over HTTP, all five answered and returned `5`; over HTTP each older revision got an `Mcp-Session-Id`, and none did with `stateless: true`. `server/discover` listed only `2026-07-28` in `supportedVersions`. We didn't try the OAuth server, the apps layer or the client's sampling adapters.

FrontMCP serves all five revisions over Streamable HTTP and stdio. Its stdio router returns discovery and `resultType` results for 2026-07-28, and keeps `initialize` sessions for older clients. Changed in 1.10.5: before, `server/discover` over stdio returned `-32601` and a 2026-07-28 call received an older-revision result. The [overview](https://frontmcp.dev/compare#how-this-was-checked) describes the method for every library.