Model Context Protocol TypeScript SDK
Featuredby
Provides TypeScript libraries to build Model Context Protocol servers and clients, supporting Node.js, Bun, and Deno.
Model Context Protocol TypeScript SDK Overview
What is Model Context Protocol TypeScript SDK about?
The SDK supplies modular TypeScript packages for creating MCP servers and clients. It includes core server and client libraries, optional thin‑layer middleware for popular runtimes (Express, Fastify, Hono, plain Node HTTP), and ready‑to‑run example projects.
How to use Model Context Protocol TypeScript SDK?
- Install the packages
(Alternatively usenpx -y @modelcontextprotocol/server # installs the server package npx -y @modelcontextprotocol/client # installs the client packagenpm install,bun add, ordeno addas documented.) - Write a server – import
McpServerand a transport (e.g.,StdioServerTransport), register tools with Zod schemas, and callserver.connect(transport). - Write a client – import
McpClientand the desired transport, then list or invoke tools. - Optional: add a middleware package matching your runtime (
@modelcontextprotocol/express,@modelcontextprotocol/fastify, etc.) to simplify integration. - Run examples located in the
examples/folder for end‑to‑end demonstrations.
Key features of Model Context Protocol TypeScript SDK
- Cross‑runtime support: works on Node.js, Bun, and Deno.
- Separate server/client packages:
@modelcontextprotocol/serverand@modelcontextprotocol/client. - Pluggable transports: HTTP (Streamable), stdio, and OAuth helpers.
- Thin middleware adapters for Express, Fastify, Hono, and plain Node HTTP.
- Schema‑agnostic tool definitions: compatible with Zod v4, Valibot, ArkType, etc.
- Comprehensive documentation: tutorials, API reference, and a live docs site (
/v2). - Versioning: stable v2 line aligned with the 2026‑07‑28 spec; v1 continues receiving fixes.
Use cases of Model Context Protocol TypeScript SDK
- Building AI‑augmented services that expose reusable tools (e.g., weather lookup, data enrichment) to LLMs.
- Creating custom MCP servers for internal tooling, SaaS platforms, or open‑source extensions.
- Developing MCP clients that consume third‑party tool catalogs.
- Integrating MCP into existing web frameworks (Express, Fastify, Hono) with minimal code.
- Prototyping and testing LLM‑driven workflows in a language‑agnostic, standards‑based manner.
FAQ from the Model Context Protocol TypeScript SDK
Q: Which package do I need for a server?
A: Install @modelcontextprotocol/server and use the provided transports (e.g., StdioServerTransport).
Q: Can I run the SDK in Deno?
A: Yes—use deno add npm:@modelcontextprotocol/server (or client) and import as usual.
Q: Do I need a separate middleware package for my framework? A: Only if you want framework‑specific helpers; the core SDK works without them.
Q: How do I define tool input schemas? A: Supply any compatible schema library (Zod v4 is shown in the README) when registering a tool.
Q: Where is the full API reference? A: Visit the docs site at https://ts.sdk.modelcontextprotocol.io/v2/api/.
Model Context Protocol TypeScript SDK's README
MCP TypeScript SDK
[!IMPORTANT] This is the
mainbranch — v2 of the SDK (@modelcontextprotocol/server,@modelcontextprotocol/client), implementing the 2026-07-28 MCP spec.Have feedback? Please open a v2 issue — it is the most useful thing you can do for the SDK right now. The v2 documentation starts with a ten-minute server tutorial.
v2 is the stable release line, released alongside the 2026-07-28 spec. v1.x continues to receive bug fixes and security updates for at least 6 months after v2's release. v1 documentation: ts.sdk.modelcontextprotocol.io · v2:
/v2/.
[!WARNING] We're limiting pull requests to 1 per new contributor while v2 settles after the 2026-07-28 spec release.
Issues are the most useful feedback right now — we'll reopen PRs as v2 stabilizes.
Overview
The Model Context Protocol (MCP) allows applications to provide context for LLMs in a standardized way, separating the concerns of providing context from the actual LLM interaction.
This repository contains the TypeScript SDK implementation of the MCP specification. It runs on Node.js, Bun, and Deno, and ships:
- MCP server libraries (tools/resources/prompts, Streamable HTTP, stdio, auth helpers)
- MCP client libraries (transports, high-level helpers, OAuth helpers)
- Optional middleware packages for specific runtimes/frameworks (Express, Fastify, Hono, Node.js HTTP)
- Runnable examples (under
examples/)
Packages
This monorepo publishes split packages:
@modelcontextprotocol/server: build MCP servers@modelcontextprotocol/client: build MCP clients
Tool and prompt schemas use Standard Schema — bring Zod v4, Valibot, ArkType, or any compatible library.
Middleware packages (optional)
The SDK also publishes small "middleware" packages under packages/middleware/ that help you wire MCP into a specific runtime or web framework.
They are intentionally thin adapters: they should not introduce new MCP functionality or business logic. See packages/middleware/README.md for details.
@modelcontextprotocol/node: Node.js Streamable HTTP transport wrapper forIncomingMessage/ServerResponse@modelcontextprotocol/express: Express helpers (app defaults + Host header validation)@modelcontextprotocol/fastify: Fastify helpers (app defaults + Host header validation)@modelcontextprotocol/hono: Hono helpers (app defaults + JSON body parsing hook + Host header validation)
Installation
Server
npm install @modelcontextprotocol/server
# or
bun add @modelcontextprotocol/server
# or
deno add npm:@modelcontextprotocol/server
Client
npm install @modelcontextprotocol/client
# or
bun add @modelcontextprotocol/client
# or
deno add npm:@modelcontextprotocol/client
Optional middleware packages
The SDK also publishes optional “middleware” packages that help you wire MCP into a specific runtime or web framework (for example Express, Fastify, Hono, or Node.js http).
These packages are intentionally thin adapters and should not introduce additional MCP features or business logic. See packages/middleware/README.md for details.
# Node.js HTTP (IncomingMessage/ServerResponse) Streamable HTTP transport:
npm install @modelcontextprotocol/node
# Express integration:
npm install @modelcontextprotocol/express express
# Fastify integration:
npm install @modelcontextprotocol/fastify fastify
# Hono integration:
npm install @modelcontextprotocol/hono hono
Getting Started
Here is what an MCP server looks like. This minimal example exposes a single greet tool over stdio:
import { McpServer } from '@modelcontextprotocol/server';
import { StdioServerTransport } from '@modelcontextprotocol/server/stdio';
import * as z from 'zod/v4';
const server = new McpServer({ name: 'greeting-server', version: '1.0.0' });
server.registerTool(
'greet',
{
description: 'Greet someone by name',
inputSchema: z.object({ name: z.string() })
},
async ({ name }) => ({
content: [{ type: 'text', text: `Hello, ${name}!` }]
})
);
async function main() {
const transport = new StdioServerTransport();
await server.connect(transport);
}
main();
Ready to build something real? Follow the step-by-step tutorials:
- Build your first server — a stdio weather-alert server, from
npm initto a tool call - Build your first client — connect to that server, list its tools, and call them
For runnable, end-to-end examples beyond the tutorials, see:
examples/README.md— runnable, self-verifying client/server example pairs (one story per directory)
Documentation
- Build a server — your first MCP server, step by step
- Build a client — your first MCP client, step by step
- Documentation site — the full guides: tools, resources, prompts, serving over HTTP and stdio, clients, OAuth, and migration
- Troubleshooting — common errors and their fixes
- API reference
- MCP documentation
- MCP specification
Building docs locally
To work on the documentation site locally:
pnpm docs:api # Generate the API reference markdown (output: docs/api/)
pnpm docs:dev # Start the VitePress dev server for the V2 site
pnpm docs:build # Build the V2 site (output: docs/.vitepress/dist/)
pnpm docs:multi # Build the combined V1 + V2 site (output: tmp/docs-combined/)
The docs:multi script builds the V2 site from the current checkout, checks out the v1.x branch via a git worktree to build the V1 site, and produces a combined site with V1 docs at the root and V2 docs under /v2/.
v1 (legacy) documentation and fixes
If you are using the v1 generation of the SDK, the v1 API documentation is available at https://ts.sdk.modelcontextprotocol.io/. The v1 source code and any v1-specific fixes live on the long-lived
v1.x branch. V2 API docs are at /v2/.
Contributing
Issues and pull requests are welcome on GitHub at https://github.com/modelcontextprotocol/typescript-sdk.
License
This project is licensed under the Apache License 2.0 for new contributions, with existing code under MIT. See the LICENSE file for details.
Model Context Protocol TypeScript SDK Reviews
Login Required
Please log in to share your review and rating for this MCP.
Similar MCP Servers like Model Context Protocol TypeScript SDK
Explore related MCPs that share similar capabilities and solve comparable challenges
Headroom
by headroomlabs-ai
Compress tool outputs, logs, files, RAG chunks, and conversation history before they reach the LLM, keeping answers identical while saving up to 95% of tokens for JSON payloads.
Git
Officialby modelcontextprotocol
A Model Context Protocol server for Git repository interaction and automation.
Zed
OfficialClientby zed-industries
A high‑performance, multiplayer code editor designed for speed and collaboration.
Everything
Officialby modelcontextprotocol
Model Context Protocol Servers
Time
Officialby modelcontextprotocol
A Model Context Protocol server that provides time and timezone conversion capabilities.
Cline
OfficialClientby cline
An autonomous coding assistant that can create and edit files, execute terminal commands, and interact with a browser directly from your IDE, operating step‑by‑step with explicit user permission.
Context7 MCP
Officialby upstash
Provides up-to-date, version‑specific library documentation and code examples directly inside LLM prompts, eliminating outdated information and hallucinated APIs.
Daytona
by daytonaio
Provides a secure, elastic infrastructure that creates isolated sandboxes for running AI‑generated code with sub‑90 ms startup, unlimited persistence, and OCI/Docker compatibility.
Continue
OfficialClientby continuedev
Enables faster shipping of code by integrating continuous AI agents across IDEs, terminals, and CI pipelines, offering chat, edit, autocomplete, and customizable agent workflows.