A TypeScript team is starting a new chat product and is choosing between Vercel AI SDK and LangChain.js. Make the case for Vercel AI SDK being the more pragmatic default in 2026, and call out the cases where LangChain.js still wins.
Free · 2 AI evals / day
Vercel AI SDK and LangChain.js solve overlapping problems but with very different shapes.
**Vercel AI SDK** was designed TypeScript-first for streaming AI UIs. The surface is small and direct. `streamText({ model, messages })` returns a streaming text generator. `generateObject({ model, schema })` returns a typed object validated against a Zod schema. `useChat()` is a React hook that wires a streaming chat endpoint to a component in a few lines. React Server Components integration is first-class. Tools are defined with Zod-typed parameter schemas, so the `args` your tool handler receives are fully typed end to end.
The other lever is ejection cost. Vercel AI SDK is intentionally small. Under the hood it is mostly thin wrappers over provider SDKs. If you outgrow it, you replace its calls with direct provider calls and you are out. There is no deep framework state to unwind.
**LangChain.js** is the TypeScript port of LangChain's Python framework. It inherits the Python framework's full abstraction surface. Runnables, LCEL, callbacks, agent executors, dozens of integrations. The TS port often lags the Python release, and the abstraction layer is heavier than most TS chat apps need.
**Where LangChain.js still wins:** the integration ecosystem (vector stores, retrievers, parsers wired up out of the box), LangGraph.js for explicit agent graphs, and LangSmith tracing without setting up OTel yourself.
The heuristic: streaming chat UIs default to Vercel AI SDK; multi-step agents with heavy retrieval often still need LangChain.js + LangGraph.
Vercel AI SDK won the default position for TypeScript chat products in 2025-2026 because it matches the shape of the actual workload. The shape is: streaming text into a UI, occasional tool calls with typed arguments, structured outputs validated against a schema, hooks into React or Svelte or Vue. Vercel AI SDK has primitives for each: `streamText`, `generateText`, `generateObject`, `useChat`, `useCompletion`, `tool({ parameters: z.object({...}), execute })`. Each primitive is small, model-agnostic (swap `openai('gpt-4o')` for `anthropic('claude-sonnet-4.6')` and the rest stays the same), and ejection cost conscious.
Three things make it material in practice. **Zod-typed tools** mean your tool's `execute` handler receives fully typed `args` and TypeScript catches schema-handler drift at compile time. **RSC integration** lets you stream LLM output as React components from the server with `streamUI`. A pattern LangChain.js does not natively support. **The hooks** turn a streaming chat endpoint into a working component in 15 lines.
LangChain.js suffers from being a port. It inherits the Python framework's Runnable / LCEL / callback / AgentExecutor surface, which is heavier than most TS apps need. The TS port lags Python releases. Features ship later, bug fixes ship later, and some Python features never get TS ports. For a streaming chat product, you are paying that abstraction weight for capabilities you do not exercise.
LangChain.js earns its keep in specific cases. The integration ecosystem is broader. Dozens of vector stores, document loaders, retrievers, output parsers wired up. LangGraph.js exists in TS and is the right primitive for explicit agent graphs with checkpointer-backed persistence. LangSmith tracing is built in (Vercel AI SDK needs OTel setup). For a multi-step agent with heavy retrieval, those three together still beat assembling them from Vercel AI SDK plus piecemeal libraries.
The production heuristic: streaming chat → Vercel AI SDK.
Quick reference
TL;DR
Vercel AI SDK is TS-first with streaming primitives, Zod-typed tools, framework hooks, RSC support, and near-zero ejection cost.
Picture two toolboxes for a TypeScript chat app. The first is a small box with exactly the tools needed to stream messages into a React component. Sharp, light, easy to put back on the shelf when you outgrow it. The second is a big inherited workshop with every tool the Python team ever built, including saws you do not need and saws that have not been sharpened in months. For most TS chat apps the small box is the right buy. For builds that need the big workshop's specialty tools, the workshop earns its rent.
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.
Workloads needing broad first-class integrations (many vector stores, document loaders, parsers wired up) Vercel AI SDK is small by design; LangChain.js's integration breadth is its main moat and the right choice when you need it
Multi-step agents needing typed state, persistence, and human in the loop LangGraph.js is the production-grade primitive for this; Vercel AI SDK's tools and streaming model does not generalize to stateful agents
Teams that need built-in tracing without setting up OpenTelemetry LangSmith tracing is one env var with LangChain.js; Vercel AI SDK requires OTel instrumentation work
Python-first teams sharing code paths between Python and TS LangChain's cross-language API parity (when it works) reduces duplication; Vercel AI SDK is TS-only
Quick scan · 2–4 min
Everything important, quickly.
4 minutes: name three concrete Vercel AI SDK advantages (Zod tools, RSC streamUI, ejection cost), explain why LangChain.js's Python-inherited surface is heavy for TS chat workloads, and concede the specific cases where LangChain.js plus LangGraph still wins.