LangGraph.js

A LangGraph.js program is a StateGraph: a state schema, nodes that return partial state updates, and edges that choose the next node, either fixed or conditional. A node can also return a Command that updates state and names the next node. The runtime follows the Pregel model of super-steps, so nodes on parallel branches run in the same step. A Functional API offers the same runtime for code written with plain functions.

The library has no agent-role abstraction of its own. Multi-agent systems are built by composing graphs, since a compiled graph can be a node in a parent graph, or by using the supervisor and swarm add-on packages in the same repository. LangChain's JavaScript multi-agent guides (subagents, handoffs, router) run on this runtime, and its createAgent loop is built on LangGraph.

Persistence has two layers. Checkpointers save a thread's state after every step under a thread_id, which enables resumption, replay and forking; official savers cover SQLite, PostgreSQL, MongoDB and Redis. Stores keep data across threads for long-term memory. MemorySaver and MemoryStore are intended for development.

Any node can call interrupt(value). The run stops, the checkpointer saves state, and the payload is returned to the caller in the __interrupt__ field. The caller resumes by invoking the graph again on the same thread_id with new Command({ resume: value }), which becomes the return value of interrupt(). The docs cover approve or reject gates, review-and-edit of generated content, and validation of human input. Since v1, StateGraph can declare typed interrupts in its constructor.

A checkpointer and a thread ID are required. On resume the node runs again from its first line, so side effects placed before the interrupt should be idempotent, and loops that call interrupt() repeatedly inside one node replay earlier iterations. Past checkpoints can be replayed or forked with edited state through time travel.

npm install @langchain/langgraph @langchain/core

import { Command, MemorySaver, START, END, StateGraph, StateSchema, interrupt } from "@langchain/langgraph";
import * as z from "zod";

const State = new StateSchema({ draft: z.string(), approved: z.boolean().nullable() });

const graph = new StateGraph(State)
  .addNode("write", () => ({ draft: "Refund order 123" }))
  .addNode("review", (state) => ({ approved: interrupt({ check: state.draft }) as boolean }))
  .addEdge(START, "write")
  .addEdge("write", "review")
  .addEdge("review", END)
  .compile({ checkpointer: new MemorySaver() });

const config = { configurable: { thread_id: "t1" } };
const first = await graph.invoke({ draft: "", approved: null }, config);
console.log(first.__interrupt__); // waiting for a reviewer
const done = await graph.invoke(new Command({ resume: true }), config);
console.log(done.approved); // true

• @langchain/langgraph declares node >=18 and needs @langchain/core (^1.1.48) and zod (^3.25.32 or ^4.2.0) as peer dependencies.
• Model providers are separate packages; the docs use LangChain integrations such as langchain plus a provider package and its API key.
• interrupt() only works with a checkpointer and a thread_id in the config; MemorySaver loses state on restart.
• On resume the interrupted node re-runs from the top, so keep side effects after interrupt() or make them idempotent.
• v1 deprecated the prebuilt createReactAgent in favour of LangChain's createAgent; the swarm add-on still only supports createReactAgent.

Partly. MCP tools come in through LangChain's separate @langchain/mcp-adapters package (MultiServerMCPClient). LangGraph.js itself has no MCP code, and its JS dev server ignores local MCP settings.

Yes, it is MIT-licensed. LangChain Inc. sells LangSmith plans for tracing and managed deployment, listed on its pricing page.

It is a separate repository and npm package (@langchain/langgraph) with the same graph, checkpoint and interrupt concepts. Some server features, such as the Agent Server A2A endpoint, are documented only for the Python server package.

@langchain/langgraph declares Node.js 18 or newer, with @langchain/core and zod as peer dependencies.

The core package @langchain/langgraph was at 1.4.18 on 2026-09-25. The repository also releases the CLI and other packages under separate tags.