# FrontMCP vs mcp-use

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

Source: https://frontmcp.dev/compare/mcp-use

mcp-use is a TypeScript stack for MCP from one company: a server framework, React views for MCP Apps, a client and an agent SDK, an inspector, a CLI and a hosting service. This page compares its server side with FrontMCP: the same tool in both, the criteria of the [comparison overview](https://frontmcp.dev/compare), and when each is the better choice.

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](https://github.com/mcp-use/mcp-use) is made by mcp-use, Inc., whose README says it's "made by manufact.com". It's MIT-licensed ([LICENSE](https://github.com/mcp-use/mcp-use/blob/mcp-use@2.8.2/LICENSE)), and the repository holds a Python SDK and the TypeScript packages. The server framework is the npm package [`mcp-use`](https://www.npmjs.com/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](https://www.npmjs.com/package/mcp-use?activeTab=versions)). The [documentation](https://docs.mcp-use.com/v2/typescript/getting-started/welcome) 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](https://docs.mcp-use.com/v2/typescript/server/index)).

On 2026-10-10, the `mcp-use/mcp-use` repository, Python SDK included, had 10,738 GitHub stars ([GitHub API](https://api.github.com/repos/mcp-use/mcp-use)), and npm counted 36,443 downloads of `mcp-use` in the week of 2026-10-02 to 2026-10-08 ([npm API](https://api.npmjs.org/downloads/point/last-week/mcp-use)). 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](https://docs.mcp-use.com/v2/typescript/getting-started/quickstart), and replaced the example tool and prompt in `index.ts`:

```ts 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`:

```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:

```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");
});
```

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](https://frontmcp.dev/learn/your-first-tool#returning-results-and-errors)), needs Node 24 or later and TypeScript's decorator settings ([Installation](https://frontmcp.dev/learn/installation)), and runs with [`frontmcp dev`](https://frontmcp.dev/reference/cli#frontmcp-dev). Both serve 2024-11-05 to 2026-07-28 on one endpoint.

## Side by side

| | mcp-use 2.8.2 | FrontMCP 1.9.4 |
| --- | --- | --- |
| MCP revisions served | 2024-11-05 to 2026-07-28; `legacy: "reject"` serves 2026-07-28 only ([Server overview](https://docs.mcp-use.com/v2/typescript/server/index)) | 2024-11-05 to 2026-07-28 ([Error codes](https://frontmcp.dev/reference/errors)) |
| Declaring a tool | `server.tool({ name, description, inputSchema }, handler)` ([Tools](https://docs.mcp-use.com/v2/typescript/server/tools)) | A [`@Tool`](https://frontmcp.dev/reference/sdk/tool) class or `tool()` function, listed in an `@App` |
| Schemas | Standard Schema: Zod 4, ArkType, Valibot; `outputSchema` ([Tools](https://docs.mcp-use.com/v2/typescript/server/tools)) | Zod 4; `outputSchema` checks every result ([Schemas Are Contracts](https://frontmcp.dev/learn/schemas-are-contracts)) |
| Shared services | No container documented. A request context, and MCP and Hono middleware ([Middleware](https://docs.mcp-use.com/v2/typescript/server/middleware)) | [`@Provider`](https://frontmcp.dev/reference/sdk/provider) services, read with `this.get()`; [hooks](https://frontmcp.dev/reference/sdk/hooks) and [plugins](https://frontmcp.dev/reference/sdk/plugin) |
| Auth | An OAuth 2.1 resource server, with providers for Auth0, Better Auth, Clerk, Convex, Keycloak, Supabase, WorkOS and Scalekit, or your own verifier; public and signed-in tools on one endpoint ([Authentication](https://docs.mcp-use.com/v2/typescript/server/authentication/index), [Mixed auth](https://docs.mcp-use.com/v2/typescript/server/authentication/mixed-auth)) | Five modes: public, static keys, JWTs from your identity provider, FrontMCP as the OAuth server with its own sign-in or an upstream provider's ([Auth modes](https://frontmcp.dev/reference/auth/modes)); per-entry rules ([Authorities](https://frontmcp.dev/reference/auth/authorities)) |
| Testing | The inspector, a CLI client and `mcp-use screenshot` for views ([CLI reference](https://docs.mcp-use.com/v2/typescript/api-reference/cli-reference)); no test library documented | `@frontmcp/testing` with MCP matchers, run by `frontmcp test` ([Testing](https://frontmcp.dev/reference/testing)) |
| Resources, prompts, completions, elicitation | All four ([Resources](https://docs.mcp-use.com/v2/typescript/server/resources), [Prompts](https://docs.mcp-use.com/v2/typescript/server/prompts), [Elicitation](https://docs.mcp-use.com/v2/typescript/server/elicitation)); server-to-client sampling isn't available ([Migration](https://docs.mcp-use.com/v2/typescript/server/migration#review-v2-limitations)) | 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)); [`this.sample()`](https://frontmcp.dev/reference/sdk/contexts#thissample-and-thislistroots) for clients that offer sampling |
| Agents, jobs, workflows | A client-side agent, `MCPAgent`, in `@mcp-use/agent` ([Agent](https://docs.mcp-use.com/v2/typescript/agent/index)); server-side jobs and workflows not documented | Agents that run on the server as tools, jobs and workflows ([`@Agent`](https://frontmcp.dev/reference/sdk/agent), [`@Job`](https://frontmcp.dev/reference/sdk/job), [`@Workflow`](https://frontmcp.dev/reference/sdk/workflow)) |
| Widgets (MCP Apps) | React views bound to tools, built with Vite, with ChatGPT extensions ([MCP Apps](https://docs.mcp-use.com/v2/typescript/mcp-apps)) | A tool's `ui` option, for MCP Apps hosts and the OpenAI Apps SDK ([Tool UI](https://frontmcp.dev/reference/ui), [Hosts](https://frontmcp.dev/reference/ui/hosts)) |
| Transports | Streamable HTTP, stateless; stdio serving is listed among v2's limitations ([Migration](https://docs.mcp-use.com/v2/typescript/server/migration)) | Streamable HTTP with or without sessions, the older HTTP+SSE, stdio, a Unix socket, in-memory ([`FrontMcpInstance`](https://frontmcp.dev/reference/sdk/frontmcp-instance)) |
| Runtimes and deployment | Node 22.22.2+; a fetch handler, a Node handler, Hono, a Next.js route, Docker, and `mcp-use deploy` to Manufact ([Self-hosted](https://docs.mcp-use.com/v2/typescript/server/deployment/self-hosted), [Next.js](https://docs.mcp-use.com/v2/typescript/server/nextjs-drop-in), [Manufact](https://docs.mcp-use.com/v2/typescript/server/deployment/mcp-use)) | Node 24+; `frontmcp build` for Node, Vercel, AWS Lambda, Cloudflare Workers and a browser module ([Production build](https://frontmcp.dev/reference/deployment/production-build)); [`createFetchHandler()`](https://frontmcp.dev/reference/sdk/create-fetch-handler) |
| CLI | `create-mcp-use-app`; `mcp-use dev`, `build`, `start`, `deploy`, `client`, `screenshot`, tunnels ([CLI reference](https://docs.mcp-use.com/v2/typescript/api-reference/cli-reference)) | `frontmcp create`, `dev`, `build`, `test`, `inspector` ([CLI](https://frontmcp.dev/reference/cli)); an [Nx plugin](https://frontmcp.dev/reference/nx) |
| License | [MIT](https://github.com/mcp-use/mcp-use/blob/mcp-use@2.8.2/LICENSE) | [Apache-2.0](https://github.com/agentfront/frontmcp/blob/main/LICENSE) |

## 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](https://docs.mcp-use.com/v2/typescript/client/index)), and `MCPAgent` runs a model against their tools with OpenAI, Anthropic, Google and other providers ([LLM providers](https://docs.mcp-use.com/v2/typescript/agent/llm-providers)). FrontMCP's [`connect()`](https://frontmcp.dev/reference/sdk/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](https://docs.mcp-use.com/v2/typescript/api-reference/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](https://docs.mcp-use.com/v2/typescript/server/authentication/index)). FrontMCP's [`transparent`](https://frontmcp.dev/reference/auth/modes) and [`remote`](https://frontmcp.dev/reference/auth/remote) modes take a provider you configure.
- **A Next.js drop-in route** ([Next.js](https://docs.mcp-use.com/v2/typescript/server/nextjs-drop-in)) 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](https://docs.mcp-use.com/v2/typescript/server/migration) lists stdio serving and session stores among its limitations. FrontMCP serves [stdio](https://frontmcp.dev/reference/sdk/frontmcp-instance#serving-over-stdio), and keeps sessions for 2025-era clients, in [Redis](https://frontmcp.dev/reference/deployment/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](https://frontmcp.dev/reference/auth/local#checking-users-yourself), [Remote and proxied auth](https://frontmcp.dev/reference/auth/remote)).
- **A dependency container**: [providers](https://frontmcp.dev/learn/sharing-state-with-providers) with scopes.
- **Agents that run on the server, jobs and workflows**: an [`@Agent`](https://frontmcp.dev/learn/your-first-agent) is a tool the client's model calls, which runs its own model loop; [jobs](https://frontmcp.dev/learn/your-first-job) run in the background; [workflows](https://frontmcp.dev/learn/chaining-jobs-into-workflows) chain them.
- **A test library** with MCP matchers and fixtures ([Testing Your Server](https://frontmcp.dev/learn/testing-your-server)).
- **Plugins** for caching, memory, approvals, feature flags and CodeCall ([Plugins and adapters](https://frontmcp.dev/reference/plugins)). mcp-use's cookbook adds rate limiting through Upstash and error reporting through Sentry.
- **Builds for AWS Lambda and Cloudflare Workers** ([Deploying Your Server](https://frontmcp.dev/learn/deploying-your-server)).

Both import tools from an OpenAPI spec ([mcp-use](https://docs.mcp-use.com/v2/typescript/server/openapi), [FrontMCP](https://frontmcp.dev/reference/adapters/openapi)), both serve tools from other MCP servers ([mcp-use](https://docs.mcp-use.com/v2/typescript/server/proxy), [FrontMCP](https://frontmcp.dev/reference/server/remote)), and both serve skills ([mcp-use](https://docs.mcp-use.com/v2/typescript/server/skills), [FrontMCP](https://frontmcp.dev/reference/sdk/skill)).

## 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](https://frontmcp.dev/learn/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`](https://github.com/mcp-use/mcp-use/blob/mcp-use@2.8.2/libraries/typescript/packages/server/src/usage.ts)); we didn't set it. The [overview](https://frontmcp.dev/compare#how-this-was-checked) describes the method for every library.