Module●Since v1.0

index

import { ... } from "@langchain/langgraph";

Functions

function

convertToProtocolEvent→ ProtocolEvent[]

function

createGraphRunStream→ GraphRunStream<TValues, InferExtensions<TTransformers>>

function

createLifecycleTransformer→ NativeStreamTransformer<LifecycleProjection>

function

createMessagesTransformer→ StreamTransformer<MessagesTransformerProjection>

function

createSubgraphDiscoveryTransformer→ NativeStreamTransformer<SubgraphDiscoveryProjection<TStream>>

function

createValuesTransformer→ StreamTransformer<ValuesTransformerProjection>

function

entrypoint→ Pregel<Record<string, PregelNode<InputT, EntrypointReturnT<OutputT>>>, __type, Record<string, unknown>, InputT, EntrypointReturnT<OutputT>, any, Awaited<EntrypointReturnT<OutputT>>>

function

filterLifecycleEntries→ AsyncIterable<LifecycleEntry>

function

filterSubgraphHandles→ AsyncIterable<TStream>

function

getConfig→ LangGraphRunnableConfig

function

getCurrentTaskInput→ T

function

getJsonSchemaFromSchema→ Record<string, unknown> | undefined

function

getPreviousState→ StateT

function

getSchemaDefaultGetter→ () => unknown | undefined

function

getStore→ BaseStore | undefined

function

getSubgraphsSeenSet→ any

function

getWriter→ (chunk: unknown) => void | undefined

function

interrupt→ R

function

isCheckpointEnvelope→ boolean

function

isCommand→ x is Command<unknown, Record<string, unknown>, string>

function

isGraphBubbleUp→ e is GraphBubbleUp

function

isGraphDrained→ e is GraphDrained

function

isGraphInterrupt→ e is GraphInterrupt

function

isInterrupted→ values is __type

function

isNativeTransformer→ t is NativeStreamTransformer<unknown>

function

isNodeError→ e is NodeError

function

isNodeTimeoutError→ e is NodeTimeoutError

function

isParentCommand→ e is ParentCommand

function

isSerializableSchema→ schema is SerializableSchema<Input, Output>

function

isStandardSchema→ schema is StandardSchemaV1<Input, Output>

function

messagesDeltaReducer→ BaseMessage<MessageStructure<MessageToolSet>, MessageType>[]

function

messagesStateReducer→ BaseMessage<MessageStructure<MessageToolSet>, MessageType>[]

function

pushMessage→ BaseMessage<MessageStructure<MessageToolSet>, MessageType>

function

task→ (args: ArgsT) => Promise<OutputT>

function

writer

function

addMessages→ BaseMessage<MessageStructure<MessageToolSet>, MessageType>[]

Classes

Interfaces

Type Aliases

Variables

Namespaces

View source on GitHub

typeAlias

DeltaReducer: (state: ValueType, writes: UpdateType[])

A batch reducer for use with DeltaChannel.

Receives the current accumulated value and a batch of writes in one call, returning the new accumulated value: reducer(state, [write1, write2, ...]) -> newState.

Reducers must be deterministic and batching-invariant (associative across folds): applying two consecutive write batches separately must produce the same state as applying their concatenation once:

reducer(reducer(state, xs), ys) === reducer(state, xs.concat(ys))

This lets LangGraph replay checkpointed writes in larger batches than they were originally produced without changing reconstructed state. If your reducer is not associative, use BinaryOperatorAggregate instead — DeltaChannel is not a drop-in replacement for every reducer.

typeAlias

StateSchemaFieldsToStateDefinition: { [K in keyof TFields]: StateSchemaFieldToChannel<TFields[K]> }

Converts StateSchema fields into a strongly-typed State Definition object, where each field is mapped to its channel type.

This utility type is used internally to create the shape of the state channels for a given schema, substituting each field with the result of StateSchemaFieldToChannel.

If you define a state schema as:

const fields = {
  a: ReducedValue<number, string>(),
  b: UntrackedValue<boolean>(),
  c: SomeSerializableSchemaType, // SerializableSchema<in, out>
}

then StateSchemaFieldsToStateDefinition<typeof fields> yields:

{
  a: BaseChannel<number, string>;
  b: BaseChannel<boolean, boolean>;
  c: BaseChannel<typeof schema's output type, typeof schema's input type>;
}

variable

MessagesAnnotation: AnnotationRoot<__type>

Prebuilt state annotation that combines returned messages. Can handle standard messages and special modifiers like RemoveMessage instances.

Specifically, importing and using the prebuilt MessagesAnnotation like this:

import { MessagesAnnotation, StateGraph } from "@langchain/langgraph";

const graph = new StateGraph(MessagesAnnotation)
  .addNode(...)
  ...

import { BaseMessage } from "@langchain/core/messages";
import { Annotation, StateGraph, messagesStateReducer } from "@langchain/langgraph";

export const StateAnnotation = Annotation.Root({
  messages: Annotation<BaseMessage[]>({
    reducer: messagesStateReducer,
    default: () => [],
  }),
});

const graph = new StateGraph(StateAnnotation)
  .addNode(...)
  ...

variable

MessagesDeltaValue: DeltaValue<BaseMessage<MessageStructure<MessageToolSet>, MessageType>[], Messages>

Experimental. A messages state field backed by a DeltaChannel.

A drop-in alternative to MessagesValue that persists only per-step message deltas (plus periodic snapshots) instead of the full accumulated history in every checkpoint blob. Useful for long-running threads where re-serializing the entire message list on each step is costly.

import { StateSchema, MessagesDeltaValue } from "@langchain/langgraph";

const State = new StateSchema({ messages: MessagesDeltaValue });

variable

MessagesZodMeta: SchemaMeta<BaseMessage[], Messages>

Prebuilt schema meta for Zod state definition.

import { z } from "zod/v4-mini";
import { MessagesZodState, StateGraph } from "@langchain/langgraph";

const AgentState = z.object({
  messages: z.custom<BaseMessage[]>().register(registry, MessagesZodMeta),
});

variable

MessagesZodState: ZodObject<__type, "strip", ZodTypeAny, __type, __type>

Prebuilt state object that uses Zod to combine returned messages. This utility is synonymous with the MessagesAnnotation annotation, but uses Zod as the way to express messages state.

You can use import and use this prebuilt schema like this:

import { MessagesZodState, StateGraph } from "@langchain/langgraph";

const graph = new StateGraph(MessagesZodState)
  .addNode(...)
  ...

import { z } from "zod";
import type { BaseMessage, BaseMessageLike } from "@langchain/core/messages";
import { StateGraph, messagesStateReducer } from "@langchain/langgraph";
import "@langchain/langgraph/zod";

const AgentState = z.object({
  messages: z
    .custom<BaseMessage[]>()
    .default(() => [])
    .langgraph.reducer(
       messagesStateReducer,
       z.custom<BaseMessageLike | BaseMessageLike[]>()
    ),
});
const graph = new StateGraph(AgentState)
  .addNode(...)
  ...

namespace

Annotation

Helper that instantiates channels within a StateGraph state.

Can be used as a field in an Annotation.Root wrapper in one of two ways:

Directly: Creates a channel that stores the most recent value returned from a node.
With a reducer: Creates a channel that applies the reducer on a node's return value.

import { StateGraph, Annotation } from "@langchain/langgraph";

// Define a state with a single string key named "currentOutput"
const SimpleAnnotation = Annotation.Root({
  currentOutput: Annotation<string>,
});

const graphBuilder = new StateGraph(SimpleAnnotation);

// A node in the graph that returns an object with a "currentOutput" key
// replaces the value in the state. You can get the state type as shown below:
const myNode = (state: typeof SimpleAnnotation.State) => {
  return {
    currentOutput: "some_new_value",
  };
}

const graph = graphBuilder
  .addNode("myNode", myNode)
  ...
  .compile();

import { type BaseMessage, AIMessage } from "@langchain/core/messages";
import { StateGraph, Annotation } from "@langchain/langgraph";

// Define a state with a single key named "messages" that will
// combine a returned BaseMessage or arrays of BaseMessages
const AnnotationWithReducer = Annotation.Root({
  messages: Annotation<BaseMessage[]>({
    // Different types are allowed for updates
    reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
      if (Array.isArray(right)) {
        return left.concat(right);
      }
      return left.concat([right]);
    },
    default: () => [],
  }),
});

const graphBuilder = new StateGraph(AnnotationWithReducer);

// A node in the graph that returns an object with a "messages" key
// will update the state by combining the existing value with the returned one.
const myNode = (state: typeof AnnotationWithReducer.State) => {
  return {
    messages: [new AIMessage("Some new response")],
  };
};

const graph = graphBuilder
  .addNode("myNode", myNode)
  ...
  .compile();

LangChain Assistant

Menu

index

Functions

Classes

Interfaces

Type Aliases

Variables

Namespaces

Function signature

Helper functions

Streaming

State management