mcp-use – Build MCP Apps for Claude and ChatGPT

TL;DR

TL;DR: mcp-use is an open-source framework for building MCP servers and MCP Apps in TypeScript and Python, with an integrated inspector for local testing and one-click deployment to Manufact Cloud.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: manufact.com
• Source repository: github.com/mcp-use/mcp-use
• Documentation: mcp-use.com/docs
• License: MIT (verified via GitHub API license.spdx_id)
• Latest release: mcp-use v1.34.3 (verified via GitHub Releases API)
• HN launch thread: news.ycombinator.com/item?id=48762862 (111 points, YC S25)

What Is mcp-use?

mcp-use is the open-source framework behind Manufact’s MCP tooling. It provides SDKs in both TypeScript and Python for building two things: MCP Servers (back-end services AI agents call via the Model Context Protocol) and MCP Apps (interactive widgets that run inside ChatGPT, Claude, and other MCP-compatible clients).

The project sits at the intersection of the MCP ecosystem and the “build apps for AI agents” wave that took off in 2024-2025. At its core, it abstracts the boilerplate of the MCP protocol so you can define tools, resources, and prompts as plain TypeScript or Python functions.

The company behind it, Manufact, is a YC S25 startup. The open-source SDK is MIT-licensed; Manufact Cloud is the hosted deployment layer that adds observability, metrics, branch-based previews, and logs on top.

Setup Workflow

Prerequisites

• Node.js 18+ (for TypeScript SDK) or Python 3.10+ (for Python SDK)
• npm, pnpm, or yarn
• An MCP-compatible client (Claude Code, Cursor, VS Code with Continue, Windsurf, or any client that speaks MCP)

Step 1: Scaffold a Project

npx create-mcp-use-app@latest

The scaffolder prompts for TypeScript or Python, project name, and whether you want an MCP Server or MCP App template.

Step 2: Define a Tool

For an MCP Server, define tools as plain functions with Zod schemas:

import { MCPServer, text } from "mcp-use/server";
import { z } from "zod";

const server = new MCPServer({
  name: "my-server",
  version: "1.0.0",
});

server.tool({
  name: "get_weather",
  description: "Get weather for a city",
  schema: z.object({ city: z.string() }),
}, async ({ city }) => {
  return text(`Temperature: 22C, Condition: sunny in ${city}`);
});

await server.listen(3000);
// Inspector available at http://localhost:3000/inspector

Step 3: Test with the Inspector

Every mcp-use server automatically mounts an interactive inspector at /inspector. Navigate there in your browser to step through tool calls, inspect request/response payloads, and verify your schema validation — no extra configuration required.

You can also use the standalone MCP Inspector or its open-source version in the mcp-use repo.

Step 4: Deploy to Manufact Cloud

# Connect your GitHub repo
# Manufact Cloud handles the rest:
# - Production deployment
# - Observability and metrics
# - Branch-based preview deployments
# - Log aggregation

The Manufact Cloud workflow connects to a GitHub repository and automatically deploys on push to main, with per-branch preview URLs for testing before merging.

Deeper Analysis

What makes it different from raw MCP SDKs?

The official Anthropic MCP SDK and its TypeScript counterpart give you the raw protocol layer. mcp-use layers developer ergonomics on top: automatic OpenAPI schema generation, a built-in inspector endpoint, and first-class support for MCP Apps (the widget-in-ChatGPT pattern) that the official SDK does not cover.

The MCP App model is the more novel piece. Instead of a tool that returns text, you define a tool paired with a React widget component. When a client like ChatGPT or Claude renders the tool, it shows the widget inline rather than a plain text response — enabling richer interactions without the agent leaving its chat context.

Skills for Coding Agents

mcp-use ships a ready-made skill definition for AI coding agents. If you use Claude Code, Codex, Cursor, or similar tools, you can point them at skills.sh/mcp-use/mcp-use/mcp-apps-builder and the agent can scaffold and extend MCP Apps without manual boilerplate.

Python SDK parity

The Python SDK (pip install mcp_use) mirrors the TypeScript API surface. The Zod schema validation step is replaced by Python type hints and Pydantic models. This matters for teams that have Python microservices they want to wrap as MCP servers without a full TypeScript migration.

Practical Evaluation Checklist

• Clone the repo and run npx create-mcp-use-app@latest — does it scaffold cleanly?
• Define a simple two-tool server and verify it appears in the inspector
• Check that the Python SDK has feature parity for the server use case
• Evaluate Manufact Cloud pricing vs. self-hosting the Docker container
• Test branch preview URLs on Manufact Cloud if you connect a GitHub repo

Security Notes

• The SDK executes your tool functions server-side — treat tool input as untrusted user content, same as any API endpoint
• MCP Apps run React widgets in the client’s environment — review the widget sandboxing posture for your target clients
• Manufact Cloud is a hosted product — review their data processing terms if you plan to deploy proprietary tooling there

FAQ

Q: Is mcp-use tied to Anthropic’s Claude, or does it work with any MCP client? A: The SDK implements the open Model Context Protocol standard. It works with any client that speaks MCP, including ChatGPT, Claude Code, Cursor, Windsurf, and any other MCP-compatible agent or IDE.

Q: How does this compare to building raw MCP servers with the official SDK? A: The official SDK gives you the protocol layer; mcp-use adds automatic inspector mounting, schema-to-documentation generation, MCP App widget support, and Manufact Cloud deployment. For simple single-tool servers the official SDK is lighter; for production multi-tool services with a CI/CD pipeline, mcp-use reduces boilerplate significantly.

Q: Can I self-host without using Manufact Cloud? A: Yes. mcp-use is MIT-licensed and runs entirely on your own infrastructure. Manufact Cloud is a convenience layer, not a requirement. The inspector, the CLI tooling, and the SDK all work offline.

Q: What is the MCP App model exactly? A: An MCP App pairs a server tool with a React widget. When an MCP client renders the tool call, it shows the widget inline instead of plain text. The widget receives the tool’s output as props and can render interactive UI inside ChatGPT or Claude. It is a relatively new pattern — browser-native rendering inside an AI chat context.

Conclusion

mcp-use fills the gap between “I understand the MCP protocol” and “I have a production MCP service my AI agent can call.” The SDK handles the wiring, the inspector handles the debugging, and Manufact Cloud handles the deployment pipeline. With 10,000-plus GitHub stars and active development (latest release: v1.34.3, pushed July 2026), it is one of the more credible entries in the MCP framework space. If you are building AI agents that need to call external tools, it is worth evaluating against a raw SDK approach.