mcp-use
Build, inspect, and ship typed MCP servers and interactive apps with TypeScript.
The source shows read-only, destructive, and open-world tool annotations, while the security policy advises permission review, restricted tool access, and environment variables for secrets; workflow write permissions and external effects are also visible. Deductions apply because no framework-wide user-confirmation mechanism, complete data-flow description, dependency audit evidence, or vulnerability-mitigation process is shown. Public tunneling and hosted deployment data boundaries are not explained, and rollback is absent. Authors, community, Manufact, and security contacts are attributed, but the publisher remains unverified rather than established.
The README, examples, and agent integration test are broadly consistent about clients, agents, tool invocation, and cleanup. The view example exposes pending and error states, and the test closes the agent in a finally block. Deductions apply because the only supplied agent integration case depends on live OpenAI service and credentials, with no shown offline substitute, dependency-availability guarantees, or comprehensive framework-level failure diagnostics.
The material thoroughly identifies TypeScript and Python users and scenarios spanning servers, clients, agents, Inspector, React Views, ChatGPT, Claude, hosted deployment, and self-hosting. Schemas, annotations, name binding, and transport configuration provide useful capability and trigger boundaries. Deductions apply because platform prerequisites, runtime differences, model compatibility, and unsuitable scenarios are not comprehensively documented, and open-world policy remains largely application-defined.
The README is well organized around setup, build, inspection, deployment, comparison, examples, ecosystem, security, and contribution paths. The MIT license text is complete, package responsibilities are named, and a v1-to-v2 migration path is supplied. Deductions apply because installation uses latest, the supplied material lacks complete pinned requirements, a substantive FAQ, centralized known limitations, and actual changelog contents. Maintainers and reporting channels are named, but formal release and long-term governance responsibilities are not established.
Typed inputs and outputs, structured results, view binding, Inspector workflows, CLI invocation, and screenshot capture support directly usable development and debugging outputs. Deductions apply because performance, footprint, and competitor advantages are predominantly README claims without the referenced benchmark methodology or results in the supplied evidence. The free deployment claim also omits quotas, hosted-service dependencies, and long-term cost boundaries.
Separate LICENSE and SECURITY files corroborate README statements about licensing, reporting contacts, and security practices, while the integration test concretely traces one agent-to-tool calculation path. Deductions apply because conformance, benchmark, performance, and competitor-feature claims depend on external links or badges and cannot be traced from the supplied files. Marketing claims, measurements, and inference are not consistently distinguished.
- Public tunneling exposes a local MCP server externally; authentication, access control, logging, and retention behavior should be checked before enabling it.
- The agent integration test uses ChatOpenAI and gpt-4o, but the static material does not define credential requirements, spending limits, transmitted data, or an offline test path.
- The destructiveHint and readOnlyHint fields are metadata and should not be treated as enforcement without runtime controls, user confirmation, and compensating operations.
- The npx -y create-mcp-use-app@latest command retrieves a moving version; pin and review it and its dependency chain before production use.
- Performance, protocol-conformance, and competitor-comparison claims are not fully substantiated by the supplied files and should be independently verified before adoption.
What does this agent do, and when should you use it?
mcp-use is a full-stack MCP framework centered on TypeScript rather than a single ready-made agent. Its ecosystem includes `MCPServer`, Zod contracts, React Views, a client, agent components, an Inspector, tunneling, and project scaffolding for MCP servers, ChatGPT plugins, and Claude connectors. A tool can return both text `content` and typed `structuredContent`, then bind that data to a React interface through its `view` metadata. Developers can invoke and inspect tools in a browser or run headless client calls and View screenshot checks from the command line. The resulting MCP HTTP endpoint can be deployed through Manufact or operated using the documented self-hosting path, and it also serves a client-facing landing page with connection details.
The workflow starts with npx -y create-mcp-use-app@latest, which scaffolds a server, TypeScript configuration, development scripts, the Inspector, and a React View pipeline. Developers register operations with MCPServer.tool, define inputSchema and outputSchema using Zod, and optionally associate a tool with view: { name: "..." }. When called, the handler reads the validated tool input, performs the implemented operation, and returns MCP text content plus typed structuredContent. A component under views/<name>/view.tsx reads the input, status, and output through useToolContext, and can invoke the tool again with useCallTool. npm run dev serves the MCP endpoint and Inspector, mcp-use client connects to and calls the server, and mcp-use screenshot renders a View to an image. Production output is created with npm run build and can be delivered with npm run deploy or a self-hosted runtime.
- A TypeScript product team building an MCP App that displays interactive React cards, charts, diagrams, or maps inside ChatGPT.
- A Claude integration developer exposing business operations as connectors with validated inputs, structured outputs, and MCP annotations.
- An MCP server author who wants tool invocation, input validation, and View inspection in one browser-based development loop.
- A CI or test engineer who needs to connect from a terminal, enumerate tools, run representative calls, and capture UI screenshots.
- An engineering organization that wants the option of managed deployment and tunneling while retaining a documented self-hosting path.
- An agent developer combining
@mcp-use/clientand@mcp-use/agentto let model-powered applications operate through MCP servers.
What are this agent's strengths and limitations?
- Zod schemas flow through tool inputs, structured results, View props, and calls, providing a concrete typed contract between server logic and UI.
- Native React Views bind directly to MCP tools while preserving both textual and structured output for interactive host experiences.
- The browser Inspector, headless client, tool-call CLI, and View screenshot command cover implementation, debugging, and visual verification.
- The ecosystem includes server, client, agent, Inspector, tunnel, and scaffolding packages, with documented ChatGPT and Claude delivery paths.
- It builds on the official TypeScript SDK v2 while adding MCP 2026 native Views, one-line OAuth adapters, tunneling, and deployment tooling.
- The primary quickstart and complete View workflow assume TypeScript, React, Zod, and npm; the separately listed Python package does not make the demonstrated React pipeline language-neutral.
- Existing v1 projects require a dedicated v2 migration process, creating upgrade work and possible compatibility risk.
- Testing a local service from ChatGPT or Claude requires a public tunnel or reachable deployment, adding network exposure and configuration considerations.
- The supplied material does not state a minimum Node.js version, Manufact authentication procedure, production resource requirements, or detailed self-hosting topology.
- The speed, disk-size, and package-count claims come from the repository's own comparison material; no independent reproduction or complete benchmark environment is provided here.
How do you install or deploy this agent?
Use a Node.js environment with npx and npm; the supplied material does not specify a minimum Node.js version or require credentials for local development. Scaffold a project with:
npx -y create-mcp-use-app@latestEnter the generated project and start it with:
npm run devOpen http://localhost:3000/mcp/inspector; the MCP endpoint is http://localhost:3000/mcp. For headless client commands, add:
npm install --save-dev @mcp-use/clientCreate a production build with npm run build. Managed deployment uses npm run deploy, although the supplied material does not document Manufact authentication or credentials. It identifies a self-hosting guide but does not include the detailed production runtime configuration.
How do you use this agent?
Import MCPServer and z, create a server, and register each operation with server.tool(...). Supply the tool name, description, Zod input and output schemas, optional View name, and applicable read-only, destructive, or open-world annotations. Return an object containing textual content and the typed business result in structuredContent. If the tool declares view: { name: "weather-card" }, implement views/weather-card/view.tsx and read the result with useToolContext<"get-weather">(). After starting the server, run:
npx mcp-use client connect local http://localhost:3000/mcp
npx mcp-use client local tools list
npx mcp-use client local tools call get-weather city=TokyoTo verify the interface, run:
npx mcp-use screenshot --server local --tool get-weather city=Tokyo --output weather-card.pngFor testing from ChatGPT or Claude, start a tunnel in the Inspector or run mcp-use dev --tunnel to obtain a public URL.
How does this agent compare with similar options?
The project explicitly compares mcp-use v2 with FastMCP TS, the official TypeScript SDK v2, xmcp, Skybridge, and mcp-handler. Its table reports 10,982 ops/s, a 74.4 MiB MCP App development stack, and 51 installed packages for mcp-use, alongside support for Views, MCP 2026 native Views, one-line OAuth adapters, a screenshot CLI, tunneling, and an Inspector. The official SDK comparison includes @modelcontextprotocol/ext-apps, Vite, and Zod, while the FastMCP stack includes its Apps extension and React development dependencies. These are repository-supplied benchmark claims, so adopters should reproduce the relevant workload and weigh the bundled tooling against a thinner SDK approach.
FAQ
Does local development require an API key?
npm run dev and the local Inspector. Manufact deployment, managed tunneling, or specific ChatGPT and Claude connection flows may require accounts or authorization, but those credential steps are not provided.Is Manufact the only deployment option?
npm run deploy for Manufact and explicitly points to a self-hosting guide. The supplied material does not detail the self-hosted infrastructure or runtime configuration.Can a View represent loading and tool failures?
pending and error states from useToolContext, while useCallTool exposes isPending, data, and error for refresh behavior and failure messages.Can the server be tested without a browser?
@mcp-use/client and the mcp-use client commands connect to a server, list tools, and invoke them. mcp-use screenshot can call a tool and save its View rendering from the CLI.