The Typescript framework
for MCP Apps

Extremely fast, interactive, stateless and deployable anywhere.

How it works
export default defineTool({
  description: "Get recent blog posts",
  input: z.object({ tag: z.string().optional() }),
  output: z.object({
    posts: z.array(z.object({
      id: z.string(),
      title: z.string(),
      excerpt: z.string(),
    })),
  }),
  async execute({ tag }) {
    const posts = await fetchPosts(tag);
    return { posts };
  },
});
Get recent blog posts

MCP tools should feel like products, not protocol demos.

Bitmcp turns typed tools into interactive React experiences while keeping the server stateless, portable, and simple.

Write the tool.
Design the result.

One tiny framework for the parts users notice and the infrastructure they should never have to.

Your tool is already an app.

Put tool.ts and view.tsx in the same folder. Bitmcp wires the typed result into your React view and ships both as one MCP App.

get-forecast/view.tsx
export default function ForecastView() {
  const { result, callTool } = useApp<Forecast>();
  if (!result) return null;

  return (
    <ForecastChart
      data={result}
      onRefresh={() =>
        callTool("get-forecast.refresh", { city: result.city })
      }
    />
  );
}

Preview the consequence.

Describe a confirmation once. Compatible hosts render the plan, pause the side effect, and resume only after the user accepts.

delete-rows/tool.ts
export default defineTool({
  input: z.object({ query: z.string() }),
  async confirm({ query }) {
    const plan = planDelete(query);
    return {
      message: `Delete ${plan.rows} matching rows?`,
      preview: plan,
    };
  },
  async execute({ query }) {
    return deleteRows(query);
  },
});

Long work. Zero sessions.

Return a durable handle immediately, keep progress in your own store, and let the view follow along. The same pattern works across replicas.

ingest/tool.ts
export default defineTool({
  input: z.object({
    source: z.string(),
    jobId: z.string().optional(),
  }),
  async execute({ source, jobId }, ctx) {
    const id = jobId ?? ctx.handle();
    const job = await jobs.startOrRead(id, source);
    return { jobId: id, ...job };
  },
});

Develop over stdio. Deploy with Streamable HTTP.

Read the docs

Why bitmcp?

Build interactive MCP Apps without assembling the workflow yourself.

Compiled React Views, first-class confirmations, and durable handle-based jobs on the stateless 2026-07-28 core.

See full comparisonSee motivation

bitmcp developer overview

bitmcp helps you build MCP Apps with React Views, MRTR confirmations, and stateless Streamable HTTP. Use the sections below to jump into the docs, or fetch /llms.txt and /openapi.json for machine-readable site maps.

What bitmcp is

bitmcp is a TypeScript framework for MCP Apps on the 2026-07-28 stateless core. A tool is a server function. A View is a predeclared, hashed HTML resource. Confirmations use MRTR. State uses handles, not sessions.

Key concepts

Tools degrade gracefully from text to MRTR confirmations to Views. Each tool folder compiles to a model-visible handler, optional app-only actions, and a hashed ui:// HTML resource.

Get started

Scaffold an app, connect a host, and deploy the same tool folder to stdio or Streamable HTTP.