The official TypeScript SDK is @modelcontextprotocol/sdk on npm (npm install @modelcontextprotocol/sdk), maintained at github.com/modelcontextprotocol/typescript-sdk. It ships both server (McpServer) and client (Client) APIs. Tool argument schemas are declared as Zod schemas: one declaration gives you runtime validation, TypeScript type inference, and JSON Schema for the LLM. Transports include StdioServerTransport (local), StreamableHTTPServerTransport (remote, current standard), and the deprecated SSEServerTransport. The SDK runs on Node, Bun, Deno, and Cloudflare Workers, making it the most common SDK for cloud-hosted MCP servers.
The official **TypeScript MCP SDK** is the `@modelcontextprotocol/sdk` package on npm. Install it with `npm install @modelcontextprotocol/sdk` (or pnpm add, bun add, etc.). The source lives at github.com/modelcontextprotocol/typescript-sdk, maintained by the protocol team.
The SDK ships both server and client APIs. A minimal server:
```ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const server = new McpServer({ name: "my-server", version: "1.0.0" });
server.tool(
"add",
{ a: z.number(), b: z.number() },
async ({ a, b }) => ({ content: [{ type: "text", text: String(a + b) }] }),
);
await server.connect(new StdioServerTransport());
```
The Zod schema (`{ a: z.number(), b: z.number() }`) is converted automatically to JSON Schema that the host sends to the LLM. JSON-RPC plumbing, the initialize lifecycle, and stdio framing are inside `server.connect`.
This SDK powers most community servers and nearly every Cloudflare Workers MCP server because TypeScript runs on Node, Bun, Deno, and Workers with the same code.
The official **TypeScript MCP SDK** is `@modelcontextprotocol/sdk` on npm (`npm install @modelcontextprotocol/sdk`), maintained at github.com/modelcontextprotocol/typescript-sdk. It is one of two first-party SDKs (the Python one is the other) and is the most widely used SDK across the broader MCP server ecosystem.
The SDK ships both server (`McpServer`) and client (`Client`) APIs in one package. A minimal server:
```ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const server = new McpServer({ name: "my-server", version: "1.0.0" });
server.tool(
"add",
{ a: z.number(), b: z.number() },
async ({ a, b }) => ({ content: [{ type: "text", text: String(a + b) }] }),
);
await server.connect(new StdioServerTransport());
```
The **Zod pairing** is the design choice that defines the SDK. The Zod schema serves as the single source of truth for three things at once: runtime validation (Zod parses incoming arguments and rejects malformed input), TypeScript inference (the handler's `{ a, b }` is typed as `{ a: number, b: number }` without manual annotation), and JSON Schema for the LLM (the SDK converts the Zod schema to JSON Schema and emits it on tools/list). One declaration, three uses.
The same pattern extends to `server.resource()` and `server.prompt()` for the other two MCP primitives.
Transports include `StdioServerTransport` (default for local hosts), `StreamableHTTPServerTransport` (the 2026 standard for remote servers), and the deprecated `SSEServerTransport` (kept for backward compatibility only). The SDK runs on Node, Bun, Deno, and Cloudflare Workers, which is why most cloud-hosted MCP servers in 2026 are built with it.
Quick reference
TL;DR
Install `@modelcontextprotocol/sdk` from npm. Zod schemas give runtime validation, TS types, and JSON Schema for the LLM. Ships stdio and streamable HTTP transports.
Imagine you have a small TypeScript program with a few functions you want an AI to call. The TypeScript MCP SDK is a library you install with one npm command. You register each function with a Zod schema describing its arguments (Zod is just TypeScript code), and the SDK turns your program into a server any MCP host can connect to. Because TypeScript runs on Node, Bun, Deno, and Cloudflare Workers, this same SDK is how most cloud-hosted MCP servers are built.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Writing a server in Python or another non-JavaScript language. Use the language-native SDK (mcp for Python, Kotlin SDK for Kotlin, etc.); the TypeScript SDK is JS-runtime only.
Needing the absolute fastest possible JSON-RPC server with zero validation overhead. Zod adds a small per-call parsing cost. A hand-rolled JSON-RPC handler is leaner but loses every ergonomic the SDK provides.
Targeting a JavaScript runtime too old for the SDK's requirements. Modern Node (20+), Bun, Deno, and Workers are the supported set. Very old Node versions may need polyfills.
Quick scan · 2–4 min
Everything important, quickly.
3 min: scoped npm name and install command, McpServer/Client dual API, Zod pairing as the headline ergonomic (one schema gives runtime validation, TS types, and JSON Schema), transports (stdio, streamable HTTP, deprecated SSE), and Cloudflare Workers as the dominant cloud-hosting target.
Real-world examples
Real products, models, and research that use this idea.
1Cloudflare Workers MCP servers (the GitHub MCP server's hosted variant, SaaS vendor servers) are built on this SDK and deployed via Cloudflare's workers-mcp tooling with automatic OAuth.
2VS Code extensions like Continue use the Client API from the same package to connect to MCP servers the user has configured.
3A team writes a single TypeScript MCP server wrapping their internal SaaS API, runs it on Bun locally during development and deploys to Cloudflare Workers for production from the same codebase.
4The MCP Inspector (the official debugging tool) is built on the TypeScript SDK's client, demonstrating both sides of the package in action.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QHow does the Zod-to-JSON-Schema conversion work inside the SDK?
Sign in or go Pro to see the approach for this follow-up.
QWhy is Cloudflare Workers a popular hosting target for TypeScript MCP servers?
Sign in or go Pro to see the approach for this follow-up.
QWhat changed between SSEServerTransport and StreamableHTTPServerTransport?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Searching npm for `mcp` or `mcp-sdk` instead of the scoped package `@modelcontextprotocol/sdk`. The scope signals it is the official org-owned SDK.