FrontMCP vs mcp-use

This site documents FrontMCP, so read it knowing who wrote it. Every mcp-use fact below comes from its own documentation, repository and npm entries for 2.8.2, checked on 2026-10-10, and links to them. Every FrontMCP fact links to the page on this site that shows FrontMCP 1.9.4 doing it.

What mcp-use is

mcp-use is made by mcp-use, Inc., whose README says it's "made by manufact.com". It's MIT-licensed (LICENSE), and the repository holds a Python SDK and the TypeScript packages. The server framework is the npm package mcp-use, which also brings its CLI and inspector; the client is @mcp-use/client, the agent @mcp-use/agent, and create-mcp-use-app scaffolds a project. mcp-use was first published on 2025-04-20, 2.0.0 came out on 2026-08-03, and 2.8.2, the version checked here, on 2026-10-09 (npm). The documentation has a v2 section for TypeScript.

Version 2 is built on v2 of the official MCP TypeScript SDK (@modelcontextprotocol/server 2.3.1 and @modelcontextprotocol/ext-apps) and on Hono, and needs Node 22.22.2 or later. Its docs describe it as "a full-stack TypeScript framework for MCP Apps", in which "every app is powered by a stateless MCPServer" (Server overview).

On 2026-10-10, the mcp-use/mcp-use repository, Python SDK included, had 10,738 GitHub stars (GitHub API), and npm counted 36,443 downloads of mcp-use 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. mcp-use is the more widely used of the two.

The same tool in both

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

In mcp-use

We scaffolded a project with npx create-mcp-use-app@latest hello-mcp-use --template mcp-server --npm --install --no-skills, following the quickstart, and replaced the example tool and prompt in index.ts:

import { MCPServer } from "mcp-use";
import { z } from "zod";

const server = new MCPServer({
  name: "hello-mcp-use",
  title: "hello-mcp-use",
  version: "1.0.0",
  description: "An MCP server built with mcp-use",
});

export const add = server.tool(
  {
    name: "add",
    description: "Add two numbers",
    inputSchema: z.object({ a: z.number(), b: z.number() }),
  },
  async ({ a, b }) => ({
    content: [{ type: "text", text: String(a + b) }],
  })
);

export default server;

npx mcp-use dev --port 3205 served it at http://localhost:3205/mcp, with hot reload and an inspector at /mcp/inspector. Its CLI client called the tool, with npx mcp-use client local tools call add a:=2 b:=3 --json:

{"_meta":{"io.modelcontextprotocol/serverInfo":{"name":"hello-mcp-use","title":"hello-mcp-use","version":"1.0.0","description":"An MCP server built with mcp-use"}},"content":[{"type":"text","text":"5"}]}

npm run build and npx mcp-use start ran the production build, which answered the same.

In FrontMCP

The same tool in a FrontMCP server, with an app that lists it. The Playground runs it and calls add; the Tests tab runs the checks:

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

mcp-use registers the tool with a call on the server object; FrontMCP declares a class and lists it in an app. FrontMCP returns an object, which arrives as structuredContent with a text copy (Your First Tool), needs Node 24 or later and TypeScript's decorator settings (Installation), and runs with frontmcp dev. Both serve 2024-11-05 to 2026-07-28 on one endpoint.

Side by side

What each does that the other doesn't

What mcp-use documents and this site doesn't show for FrontMCP:

• A client and an agent for any MCP server. @mcp-use/client connects to servers over HTTP or stdio, in Node, the browser or React (Client), and MCPAgent runs a model against their tools with OpenAI, Anthropic, Google and other providers (LLM providers). FrontMCP's connect() adapters connect to your own server, in-process.
• An inspector inside the dev server, at /mcp/inspector, and tunnels that give a local server a public URL (CLI reference).
• Screenshots of views from the command line, for checking widgets.
• A choice of schema library through Standard Schema. FrontMCP's pages use Zod 4 only.
• Presets for identity providers: Auth0, Better Auth, Clerk, Convex, Keycloak, Supabase, WorkOS and Scalekit (Authentication). FrontMCP's transparent and remote modes take a provider you configure.
• A Next.js drop-in route (Next.js) and a hosting service the CLI deploys to.

What FrontMCP does that mcp-use's v2 docs don't document, or list as not provided:

• stdio and sessions. mcp-use v2's migration guide lists stdio serving and session stores among its limitations. FrontMCP serves stdio, and keeps sessions for 2025-era clients, in Redis if you like.
• An OAuth server. The same guide says "OAuth proxy and authorization-server mode are not provided". FrontMCP can issue the tokens itself, with its own sign-in page and your check of the user, or after a sign-in at an upstream provider (Local auth, Remote and proxied auth).
• A dependency container: providers with scopes.
• Agents that run on the server, jobs and workflows: an @Agent is a tool the client's model calls, which runs its own model loop; jobs run in the background; workflows chain them.
• A test library with MCP matchers and fixtures (Testing Your Server).
• Plugins for caching, memory, approvals, feature flags and CodeCall (Plugins and adapters). mcp-use's cookbook adds rate limiting through Upstash and error reporting through Sentry.
• Builds for AWS Lambda and Cloudflare Workers (Deploying Your Server).

Both import tools from an OpenAPI spec (mcp-use, FrontMCP), both serve tools from other MCP servers (mcp-use, FrontMCP), and both serve skills (mcp-use, FrontMCP).

When to choose mcp-use

• You're building an MCP App for ChatGPT or Claude, with React views, and want views, inspector and screenshots in one dev loop.
• You also need a client or an agent that talks to MCP servers, and want them from the same vendor as the server.
• Your server is stateless HTTP behind an identity provider that registers clients itself, like Auth0, Clerk or WorkOS.
• You want a hosted deployment target from the CLI.
• You want the more widely used of the two today.

When to choose FrontMCP

• You need stdio, sessions, or the older HTTP+SSE transport for clients that still use them.
• You want FrontMCP to be the OAuth server, rather than relying on an identity provider that registers clients.
• You want agents that run on the server, background jobs or workflows.
• The server is growing, and you want shared services, several apps, hooks and plugins to organise it (Structuring a Server).

How this was checked

On 2026-10-10 we scaffolded an mcp-use 2.8.2 project, ran it with mcp-use dev and, after mcp-use build, with mcp-use start, and called add over HTTP and with its CLI client. 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: both answered all five. The mcp-use server's source sends anonymous usage telemetry unless MCP_USE_ANONYMIZED_TELEMETRY=false is set (usage.ts); we didn't set it. The overview describes the method for every library.