FrontMCP vs FastMCP for TypeScript

This site documents FrontMCP, so read it knowing who wrote it. Every FastMCP fact below comes from FastMCP's own README and repository at 4.22.4, checked on 2026-10-10, and links to it. Every FrontMCP fact links to the page on this site that shows FrontMCP 1.9.4 doing it.

What FastMCP is

FastMCP is written by Frank Fiegel (punkpeye on GitHub and npm) and is MIT-licensed. It's published on npm as fastmcp and on JSR as @punkpeye/fastmcp. Its first release was 1.0.0 on 2024-12-23; 4.22.4, the version checked here, came out on 2026-10-04, after 238 versions across four major versions (npm). Its documentation is the README and a few guides in docs/.

It isn't the Python FastMCP. Its README says it's inspired by Jonathan Lowin's Python implementation, and its OAuth proxy is described as a port of the Python one.

FastMCP is built on the official SDK, v1: its package.json asks for @modelcontextprotocol/sdk ^1.24.3, which installed 1.32.1 on 2026-10-10. Its HTTP transport comes from the author's mcp-proxy package, and its HTTP server is Hono.

On 2026-10-10, FastMCP had 3,274 GitHub stars (GitHub API) and 709,121 npm downloads in the week of 2026-10-02 to 2026-10-08 (npm API). FrontMCP had 146 stars and 8,479 downloads of @frontmcp/sdk in the same week. FastMCP has been released for a year longer and is far more widely used.

The same tool in both

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

In FastMCP

This is FastMCP's Quickstart, as we ran it with fastmcp 4.22.4, zod 4.6.5 and tsx, in a project with "type": "module":

import { FastMCP } from "fastmcp";
import { z } from "zod"; // Or any validation library that supports Standard Schema

const server = new FastMCP({
  name: "My Server",
  version: "1.0.0",
});

server.addTool({
  name: "add",
  description: "Add two numbers",
  parameters: z.object({
    a: z.number(),
    b: z.number(),
  }),
  execute: async (args) => {
    return String(args.a + args.b);
  },
});

server.start({
  transportType: "stdio",
});

npx fastmcp dev server.ts --tool add --args '{"a":2,"b":3}' ran it and called the tool:

{
  "content": [
    {
      "type": "text",
      "text": "5"
    }
  ]
}

With start({ transportType: "httpStream", httpStream: { port: 3204 } }) instead, the same server answered at http://localhost:3204/mcp, and a client built with @modelcontextprotocol/sdk got the same result. There's no build step and no configuration file: 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.

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 {}

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). FrontMCP needs Node 24 or later (Installation) and TypeScript's decorator settings, and frontmcp dev runs it.

Side by side

What each does that the other doesn't

What FastMCP documents and this site doesn't show for FrontMCP:

• A choice of schema library. Any Standard Schema library works, ArkType and Valibot included, and so does plain JSON Schema. FrontMCP's pages use Zod 4 only.
• Ready-made OAuth providers. GoogleProvider, GitHubProvider and AzureProvider set up the OAuth proxy for those sign-ins. FrontMCP's remote mode takes an OpenID Connect provider you configure, like Auth0, Okta or Keycloak; a plain OAuth provider such as GitHub, whose users have no sub, can't be used.
• Completion of prompt arguments, including from an enum (Prompt argument auto-completion). This site shows FrontMCP completing resource template parameters only.
• Streaming partial tool output with streamContent, which the README marks as a FastMCP extension that isn't in the MCP specification (Streaming Output).
• HTTPS, mutual TLS and CORS options on the built-in server (Remote Server Options), and custom routes on its Hono app.
• Deno Deploy and Bun are named as runtimes. This site shows a fetch handler for such runtimes but no deployment guide for them.

What FrontMCP does that FastMCP's README doesn't document:

• MCP 2026-07-28. FastMCP's README says it serves 2025-11-25 and earlier, and points to another framework for 2026-07-28. FrontMCP serves both eras on one endpoint.
• A dependency container: providers with scopes, which tools, resources and prompts get with this.get().
• Agents, jobs and workflows: agents that run a model loop on the server, jobs that run in the background, and workflows that chain them.
• Widgets. A tool's ui option renders an HTML or React widget for MCP Apps hosts and the OpenAI Apps SDK (Your First Widget).
• Plugins for caching, memory, approval, feature flags and CodeCall (Plugins and adapters).
• Sign-in without an upstream provider: in local mode FrontMCP is the OAuth server and serves the sign-in page, and you check the user in authenticate (Local auth). FastMCP's OAuth proxy signs users in through a provider.
• Project scaffolding and platform builds: frontmcp create, and frontmcp build for Vercel, AWS Lambda and Cloudflare Workers (Deploying Your Server).
• A test library with MCP matchers and fixtures (Testing Your Server).

Both have an OpenAPI importer: FastMCP's fromOpenAPI() and FrontMCP's OpenAPI adapter.

When to choose FastMCP

• You want the smallest setup that works: one file, no decorators, no build, run with tsx. FastMCP's README describes its audience as people who want to build MCP servers quickly without dealing with low-level details.
• Your clients speak MCP 2025-11-25 or earlier, and you don't need 2026-07-28 yet.
• You want ArkType, Valibot or plain JSON Schema rather than Zod.
• You sign users in with Google, GitHub or Azure and want the provider preset.
• You want a library that many more people use today, with a longer release history.

When to choose FrontMCP

• You need MCP 2026-07-28 next to the older revisions.
• The server is growing past a handful of tools, and you want shared services, several apps, plugins and hooks to organise it (Structuring a Server).
• You want agents, background jobs, workflows or widgets from the same framework.
• You deploy to Vercel, AWS Lambda or Cloudflare Workers and want a build for each.

How this was checked

On 2026-10-10 we installed fastmcp 4.22.4, ran the Quickstart above over stdio and 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: the four older revisions answered and returned 5, and over HTTP the 2026-07-28 requests got 400 with server_missing_modern_protocol_support. Stateless mode answered the same. The overview describes the method for every library.