No entries match these filters. Clear filters
LangGraph CLI adds --image-uri flag for self-hosted deployments and refines deploy command args.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.32 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.32
└──▷ USE IT
Deploy a self-hosted LangGraph instance using a custom container image specified by the new flag.
shell
copy
langgraph deploy --image-uri my-custom-registry.io/langgraph-agent:v1.2
Target a specific agent and environment when running the deployment command.
shell
copy
langgraph deploy --agent-id my-agent-uuid --environment production
Adds --image-uri flag to control the container image for self-hosted LangGraph deployments Not checked yet Updates langgraph deploy to use agent_id and environment arguments for deployment targeting Not checked yet Clarifies agent flags and supports environment variable defaults in CLI commands Not checked yet
3 details in Everything
LangGraph adds response_schema argument to interrupt() for structured interruption handling
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.4.5 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.4.5
└──▷ USE IT
Enforce a specific JSON structure for data passed through an interruption point in a LangGraph workflow.
code
copy
interrupt(
...,
response_schema={"type": "object", "properties": {"key": {"type": "string"}}}
)
LangGraph SDK adds decrypt replacement result support
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.4.3 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.4.3
LangGraph 1.2.11 exposes trace_policy on add_node for per-node tracing control.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.2.11 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.2.11
LangGraph checkpoint 4.2.0 adds opt-in omit_expired flag to skip expired rows on checkpoint reads.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==4.2.0 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==4.2.0
LangGraph checkpoint 4.2.0 adds opt-in omit_expired flag to skip expired rows when reading checkpoint state.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==4.2.0 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==4.2.0
LangGraph checkpoint-postgres 3.1.1 adds opt-in omit_expired flag to skip expired checkpoint rows on read.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==3.1.1 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==3.1.1
checkpointpostgres==3.1.1
Jul 30, 2026
·
issue 031
LangGraph checkpoint-postgres 3.1.1 adds opt-in omit_expired to skip expired checkpoint rows on read.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==3.1.1 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==3.1.1
LangGraph 1.2.10 adds per-node trace policies and typed v3 stream_events with native projections.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.2.10 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.2.10
└──▷ USE IT
Restrict tracing on a sensitive node by setting a custom trace policy at node registration time.
python
copy
graph.add_node("sensitive_step", sensitive_fn, trace_policy=my_trace_policy)
Exposes trace_policy parameter on add_node, enabling per-node control over tracing behaviour. Not checked yet Adds typed return for v3 stream_events and supports native projections for more precise event filtering. Not checked yet Removes tags from TracePolicy, simplifying the tracing configuration surface. Not checked yet
3 details in Everything
LangGraph CLI now supports prebuild images for langgraph deploy.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.31 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.31
LangGraph CLI now supports prebuild images for langgraph deploy.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.31 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.31
LangGraph CLI now supports compatible API version ranges for more flexible server compatibility checks.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.30 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.30
Adds support for compatible API version ranges, enabling the CLI to negotiate compatibility with a range of server API versions rather than a single pinned version. Not checked yet
1 detail in Everything
LangGraph CLI now supports running the dev server over HTTPS HTTPS HTTP carried over an encrypted TLS connection. It protects traffic in transit and lets a browser verify the server's certificate. with custom certificate and key files.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.29 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.29
└──▷ TRY IT
Run the local dev server with TLS when your agent client or browser requires HTTPS endpoints during development.
copy
$ langgraph dev --certfile cert.pem --keyfile key.pem
Adds --certfile and cert key options to langgraph dev so the local development server can be served over HTTPS. Not checked yet
1 detail in Everything
LangGraph 1.2.3 adds v3 streaming, WebSocket WebSocket A protocol that upgrades an HTTP connection into a persistent, full-duplex channel, letting a server push data to a client without repeated polling. Cyber tools use it for real-time event streaming and live command output. transport, and tool-dispatched subagent naming to RemoteGraph.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.2.3 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.2.3
└──▷ USE IT
Stream a remote graph run over WebSocket for low-latency, persistent connections instead of HTTP SSE SSE Server-Sent Events, a browser API and HTTP-based protocol where a server pushes a stream of text events to a client over a single long-lived connection, giving tools a lightweight alternative to WebSockets for one-way real-time updates. .
python
copy
from langgraph_sdk import get_client
client = get_client(url="https://my-deployment.example.com")
async for chunk in client.runs.stream(
thread_id,
assistant_id,
input={"messages": [{"role": "user", "content": "Hello"}]},
stream_mode="messages",
transport="websocket",
):
print(chunk)
Use interleave_projections on a RemoteGraph to merge streamed message and tool-call events into a single ordered sequence.
python
copy
from langgraph.pregel.remote import RemoteGraph
remote = RemoteGraph(
"my-agent",
url="https://my-deployment.example.com",
)
async for chunk in remote.astream(
{"messages": [{"role": "user", "content": "Plan a trip"}]},
stream_mode="messages",
interleave_projections=True,
):
print(chunk)
Adds v3 streaming support to RemoteGraph, enabling the latest streaming protocol for remote graph execution. Not checked yet Wires RemoteGraph.interleave_projections to the SDK's interleave_projections, allowing interleaved stream projection control from the client. Not checked yet Names tool-dispatched subagents via lc_agent_name, giving clearer identity to dynamically spawned subagents in multi-agent graphs. Not checked yet Adds WebSocket stream transport to the Python SDK for persistent, low-latency streaming connections. Not checked yet Adds messages and tool call projections to the Python SDK, enabling filtered views of streamed agent output. Not checked yet
+1 more
show less
Adds v3 streaming primitives and SSE transport to the Python SDK, aligning the client with the updated server-side streaming protocol. Not checked yet
6 details in Everything
└──▷ BREAKING ON UPGRADE
! The ProtocolEvent.eventId field is renamed to event_id to match the wire field
LangGraph SDK 0.4.1 adds interleave_projections stream decoder and v3 streaming support for RemoteGraph.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.4.1 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.4.1
Extracts stream decoders into a reusable module and adds interleave_projections stream decoder. Not checked yet Adds v3 streaming protocol support to RemoteGraph, enabling richer real-time output from remote graph execution. Not checked yet
2 details in Everything
LangGraph SDK 0.4.1 adds interleave_projections for stream decoding and v3 streaming support in RemoteGraph.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.4.1 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.4.1
Adds interleave_projections capability via extracted stream decoders in the Python SDK, enabling finer control over streamed output projection. Not checked yet Enables v3 streaming protocol support in RemoteGraph, allowing remote graphs to leverage the latest streaming features. Not checked yet
2 details in Everything
LangGraph SDK 0.4.0 adds WebSocket WebSocket A protocol that upgrades an HTTP connection into a persistent, full-duplex channel, letting a server push data to a client without repeated polling. Cyber tools use it for real-time event streaming and live command output. streaming, reconnect resilience, scoped subgraph handles, and sync/async thread stream helpers.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.4.0 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.4.0
Adds WebSocket stream transport support, enabling lower-latency bidirectional streaming as an alternative to SSE SSE Server-Sent Events, a browser API and HTTP-based protocol where a server pushes a stream of text events to a client over a single long-lived connection, giving tools a lightweight alternative to WebSockets for one-way real-time updates. . Not checked yet Adds SSE transport and v3 streaming primitives as a foundational streaming layer. Not checked yet Adds WebSocket stream selection wiring so clients can choose between SSE and WebSocket transports. Not checked yet Adds async stream reconnect support with hardened reconnect logic for resilient long-running streams. Not checked yet Adds async and sync thread stream helpers for high-level, ergonomic consumption of streamed thread output. Not checked yet
+4 more
show less
Adds scoped subgraph handles (async and sync) for targeting and streaming specific subgraph execution. Not checked yet Adds messages and tool call projections to extract structured message and tool-call data from stream events. Not checked yet Adds output, values, and controller extraction from stream lifecycle state. Not checked yet Adds shared stream subscriptions for multiplexing a single stream across multiple consumers. Not checked yet
9 details in Everything
LangGraph SDK 0.3.15 adds metadata filtering for cron job search and count operations.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.3.15 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.3.15
└──▷ USE IT
Filter cron job searches by metadata to find only crons matching specific labels or properties.
python
copy
crons = await client.crons.search(metadata={"env": "production", "team": "infra"})
Supports metadata filter parameter when searching and counting cron jobs via the SDK. Not checked yet
1 detail in Everything
LangGraph 1.2.1 adds before_builtins opt-in for stream transformers.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.2.1 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.2.1
LangGraph 1.2.0 adds node defaults, durable error-handler resume, and delta-channel snapshot guarantees.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.2.0 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.2.0
└──▷ USE IT
Apply shared defaults (e.g. a model or retry policy) to every node in a graph without repeating config on each .add_node() call.
python
copy
from langgraph.graph import StateGraph
builder = StateGraph(MyState)
builder.set_node_defaults(config={"model": "gpt-4o", "temperature": 0})
builder.add_node("extract", extract_node)
builder.add_node("summarize", summarize_node)
Adds set_node_defaults() to StateGraph, letting you set shared default configuration across nodes. Not checked yet Enables durable error-handler resume so graph execution can recover across host crashes. Not checked yet Forces a delta channel snapshot after a configurable max number of supersteps since the last snapshot, preventing unbounded replay. Not checked yet Overrides get_delta_channel_history in the SQLite checkpoint backend with a streaming walk for more efficient history retrieval. Not checked yet
4 details in Everything
LangGraph checkpoint 4.1.0 forces delta channel snapshots after max supersteps to ensure durability.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==4.1.0 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==4.1.0
Adds forced delta channel snapshot after a configurable maximum number of supersteps since the last snapshot, preventing unbounded checkpoint gaps. Not checked yet
1 detail in Everything
LangGraph CLI gains Studio deploy support for pushing graphs directly to LangGraph Studio.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.25 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.25
Adds studio deploy command to the LangGraph CLI, enabling direct deployment to LangGraph Studio. Not checked yet
1 detail in Everything
LangGraph SQLite checkpointer gains a public get_writes_history API and streaming delta channel history.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointsqlite==3.1.0a1 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointsqlite==3.1.0a1
Adds public get_writes_history saver API for retrieving write history with reworked delta cadence. Not checked yet Overrides get_delta_channel_history with a streaming walk implementation for more efficient history retrieval. Not checked yet
2 details in Everything
LangGraph SDK 0.3.14 adds return_minimal to thread updates, trimming response payload size.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.3.14 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.3.14
└──▷ USE IT
Reduce response payload size when updating a thread — useful in high-throughput pipelines where the full thread object is not needed.
python
copy
client.threads.update(thread_id, return_minimal=True)
Adds return_minimal parameter to the threads update API, allowing callers to request a reduced response payload. Not checked yet
1 detail in Everything
checkpointpostgres==3.1.0a4
Prerelease
May 4, 2026
· release notes
langgraph-checkpoint-postgres 3.1.0a4 exposes a public get_writes_history saver API with reworked delta cadence.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==3.1.0a4 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==3.1.0a4
└──▷ USE IT
Retrieve the full write history for a thread to audit or replay state transitions stored in Postgres.
python
copy
history = await saver.get_writes_history(config)
Adds public get_writes_history API on the checkpoint saver, enabling programmatic retrieval of write history for a thread. Not checked yet Reworks delta cadence logic for checkpoint writes, enabling finer-grained control over how incremental state changes are persisted. Not checked yet
2 details in Everything
LangGraph prebuilt 1.1.0a1 adds stream_events v3 dispatch and streaming transformer infrastructure.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==1.1.0a1 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==1.1.0a1
Dispatches stream_events(version='v3') on Pregel, enabling finer-grained streaming event visibility. Not checked yet Adds streaming transformer infrastructure, providing a new layer for composing and testing stream transformations in the graph runtime. Not checked yet
2 details in Everything
LangGraph 1.2.0a3 adds node-level error handlers, graceful shutdown/drain, stream_events v3, and richer streaming infrastructure.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.2.0a3 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.2.0a3
└──▷ USE IT
Subscribe to v3 stream events from a Pregel graph for fine-grained observability of node execution.
python
copy
# (Python) — stream_events v3
async for event in graph.astream_events(input, version='v3'):
print(event)
Return a mix of Commands and ToolMessages from a ToolNode tool to drive conditional graph routing alongside structured output structured output Forcing a model's response to match a given format or JSON schema, so software can parse it reliably instead of hoping the text is well formed. .
python
copy
from langgraph.prebuilt import ToolNode
from langgraph.types import Command
from langchain_core.messages import ToolMessage
def my_tool(tool_call_id: str, query: str) -> list:
return [
ToolMessage(content="result", tool_call_id=tool_call_id),
Command(goto="follow_up_node"),
]
node = ToolNode([my_tool])
Adds node-level error handlers, letting graphs catch and handle errors at individual nodes rather than propagating them globally. Not checked yet Supports graceful graph shutdown/drain on request, allowing in-flight work to complete cleanly before termination. Not checked yet Dispatches stream_events(version='v3') on Pregel graphs, enabling richer event streaming for observability pipelines. Not checked yet Introduces DeltaChannel for storing sentinels in blobs and reconstructing state from checkpoint writes. Not checked yet Adds native v2 projections for custom, updates, checkpoints, debug, and tasks stream modes. Not checked yet
+2 more
show less
Introduces streaming transformer infrastructure for composable, testable stream processing. Not checked yet Allows ToolNode tools to return list[Command | ToolMessage], enabling richer tool output patterns. Not checked yet
7 details in Everything
LangGraph checkpoint 4.1.0a3 introduces DeltaChannel with sentinel storage and checkpoint_writes reconstruction.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==4.1.0a3 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==4.1.0a3
Adds DeltaChannel: stores sentinels in blobs and reconstructs state from checkpoint_writes, enabling more efficient incremental state tracking. Not checked yet
1 detail in Everything
LangGraph 1.2.0a2 adds node-level error handlers for fine-grained fault control in graphs.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.2.0a2 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.2.0a2
Adds node-level error handlers, enabling per-node fault handling logic directly in graph definitions. Not checked yet
1 detail in Everything
checkpointpostgres==3.1.0a1
Prerelease
Apr 30, 2026
· release notes
checkpoint-postgres 3.1.0a1 adds DeltaChannel sentinel storage in blobs with checkpoint_writes reconstruction.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==3.1.0a1 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==3.1.0a1
LangGraph prebuilt 1.0.13 adds alpha timer support and streaming transformer infrastructure.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==1.0.13 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==1.0.13
Introduces alpha timer support for scheduling and time-based graph behaviors. Not checked yet Adds streaming transformer infrastructure enabling new streaming pipeline patterns in graphs. Not checked yet
2 details in Everything
LangGraph checkpoint 4.1.0a1 adds timer support Alpha and a new DeltaChannel for efficient checkpoint reconstruction.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==4.1.0a1 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==4.1.0a1
Adds alpha timer support for checkpoint-based workflows. Not checked yet Introduces DeltaChannel: stores sentinel values in blobs and reconstructs state from checkpoint_writes rather than full snapshots. Not checked yet
2 details in Everything
LangGraph 1.2.0a1 adds graceful shutdown/drain, timer support, DeltaChannel checkpointing, and native v2 streaming projections.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.2.0a1 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.2.0a1
Adds graceful shutdown/drain support, allowing graphs to finish in-flight work before stopping on request. Not checked yet Introduces alpha timer primitives for scheduling time-based graph behavior. Not checked yet New DeltaChannel stores sentinel values in blobs and reconstructs state from checkpoint writes. Not checked yet Adds native v2 projections for custom, updates, checkpoints, debug, and tasks streams. Not checked yet Adds streaming transformer infrastructure enabling richer, composable stream processing pipelines. Not checked yet
5 details in Everything
LangGraph 1.1.10 lets ToolNode tools return mixed lists of Command and ToolMessage objects.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.1.10 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.1.10
└──▷ USE IT
When a tool needs to both update graph state (via Command) and return a ToolMessage to the model in the same invocation.
python
copy
from langgraph.prebuilt import ToolNode
from langgraph.types import Command
from langchain_core.messages import ToolMessage
def my_tool(tool_call_id: str, query: str) -> list:
# Emit a state update command AND a tool result message
return [
Command(update={"retrieved": query}),
ToolMessage(content=f"Result for {query}", tool_call_id=tool_call_id),
]
node = ToolNode([my_tool])
Enables ToolNode tools to return list[Command | ToolMessage], allowing a single tool call to emit both control-flow commands and tool messages in one response. Not checked yet
1 detail in Everything
LangGraph prebuilt 1.0.11 lets ToolNode return mixed Command/ToolMessage lists and exposes available tools on ToolRuntime.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==1.0.11 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==1.0.11
└──▷ USE IT
Return a mix of graph-control Commands and ToolMessages from a single tool — useful when a tool needs to both update state and produce an observable message.
python
copy
from langgraph.prebuilt import ToolNode
from langgraph.types import Command
from langchain_core.messages import ToolMessage
def my_tool(tool_call_id: str, query: str) -> list:
# Return a Command to update state AND a ToolMessage for the model
return [
Command(update={"retrieved": query}),
ToolMessage(content=f"Searched for: {query}", tool_call_id=tool_call_id),
]
node = ToolNode([my_tool])
Enables ToolNode tools to return list[Command | ToolMessage], allowing a single tool call to emit a mix of graph commands and tool messages. Not checked yet Exposes the set of available tools on ToolRuntime, making it possible to inspect or enumerate registered tools at runtime. Not checked yet
2 details in Everything
LangGraph checkpoint 4.0.2 documents LANGGRAPH_STRICT_MSGPACK environment variable for checkpoint security hardening.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==4.0.2 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==4.0.2
LangGraph 1.1.7a1 adds graph lifecycle callback handlers for hooking into graph execution events.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.1.7a1 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.1.7a1
LangGraph CLI gains remote build support for langgraph deploy
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.20 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.20
LangGraph SDK adds langsmith_tracing parameter to runs.create/stream/wait for per-call tracing control.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.3.13 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.3.13
└──▷ USE IT
Disable LangSmith tracing for a specific run invocation to avoid logging sensitive payloads.
python
copy
result = await client.runs.create(
thread_id=thread_id,
assistant_id=assistant_id,
input={"messages": [{"role": "user", "content": "hello"}]},
langsmith_tracing=False,
)
LangGraph 1.1.5 adds remote build support for langgraph deploy and richer runtime execution information.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.1.5 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.1.5
Adds remote build support to langgraph deploy in the CLI. Not checked yet Enhances the runtime with more execution information. Not checked yet
2 details in Everything
LangGraph prebuilt 1.0.9 exposes richer execution information at runtime for agent observability.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==1.0.9 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==1.0.9
Enhances the runtime with additional execution information, giving agents and tools access to more context about the current run. Not checked yet
1 detail in Everything
LangGraph 1.1.4 adds LangSmith integration metadata to graph runs.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.1.4 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.1.4
LangGraph CLI 0.4.19 adds deploy revisions list command to inspect deployment revisions.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.19 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.19
└──▷ TRY IT
List all revisions for a deployed LangGraph app to audit deployment history or roll back.
copy
$ langgraph deploy revisions list
LangGraph 1.1.3 adds execution info to the runtime context.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.1.3 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.1.3
LangGraph CLI gains deploy logs, list, delete subcommands and distributed runtime support.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.16 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.16
└──▷ TRY IT
Tail logs from a running LangGraph deployment to debug production agent behavior.
copy
$ langgraph deploy logs <deployment-id>
List all active deployments to audit or identify targets for cleanup.
copy
$ langgraph deploy list
Delete a specific deployment to decommission a retired agent service.
copy
$ langgraph deploy delete <deployment-id>
Adds langgraph deploy logs subcommand to stream or retrieve logs from a deployment. Not checked yet Adds langgraph deploy list subcommand to enumerate active deployments. Not checked yet Adds langgraph deploy delete subcommand to remove a deployment. Not checked yet Adds distributed runtime support to the LangGraph CLI for scalable deployment configurations. Not checked yet
4 details in Everything
LangGraph 1.1.2 adds context support for remote graph API calls.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.1.2 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.1.2
LangGraph 1.1 adds opt-in version="v2" for type-safe streaming and invoke with Pydantic/dataclass output coercion.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.1.0 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.1.0
└──▷ USE IT
Get a typed return value and cleanly inspect interrupts after invoking a graph — no more fishing through result["__interrupt__"] in a plain dict.
python
copy
result = graph.invoke({"input": "hello"}, version="v2")
result.value # your output state
result.interrupts # tuple[Interrupt, ...], empty if none
Stream graph events with full type narrowing — branch on part["type"] and let your type checker know exactly what part["data"] contains for each mode.
python
copy
from langgraph.types import ValuesStreamPart, UpdatesStreamPart
for part in graph.stream({"input": "hello"}, version="v2"):
if part["type"] == "values":
state = part["data"] # OutputT — full typed state
interrupts = part["interrupts"]
elif part["type"] == "updates":
delta = part["data"] # dict[str, Any]
When your state is a Pydantic model, confirm the output is already coerced to the right type — no manual MyState(**result) call needed.
python
copy
from pydantic import BaseModel
from langgraph.graph import StateGraph
class MyState(BaseModel):
answer: str
count: int
compiled = StateGraph(MyState).compile() # ... add nodes/edges first
result = compiled.invoke({"answer": "", "count": 0}, version="v2")
assert isinstance(result.value, MyState)
Adds version="v2" opt-in to invoke() , ainvoke() , stream() , and astream() for fully type-safe outputs. Not checked yet New GraphOutput return type from invoke(..., version="v2") exposes .value and .interrupts attributes, cleanly separating state from interrupt signals. Not checked yet New strongly-typed StreamPart discriminated union (and per-mode TypedDicts: ValuesStreamPart, UpdatesStreamPart, MessagesStreamPart, CustomStreamPart, CheckpointStreamPart, TasksStreamPart, DebugStreamPart) enables full type narrowing in editors and type checkers. Not checked yet Automatic output coercion to Pydantic models or dataclasses when the graph's state schema is declared as one — no manual parsing needed. Not checked yet Non-"values" stream modes with version="v2" return list[StreamPart] from invoke() instead of list[tuple]. Not checked yet
5 details in Everything
LangGraph CLI gains a langgraph deploy command for direct deployment from the CLI.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.15 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.15
└──▷ TRY IT
Deploy a LangGraph application to LangGraph Cloud without leaving the terminal.
Adds langgraph deploy command to deploy LangGraph applications directly from the CLI. Not checked yet
1 detail in Everything
LangGraph SDK 0.3.10 adds type-safe stream/invoke with proper output type coercion
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.3.10 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.3.10
LangGraph CLI gains a keep_latest prune strategy for ThreadTTLConfig and checkpointer config passthrough.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.14 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.14
Adds keep_latest prune strategy to ThreadTTLConfig, giving finer control over which threads are retained when TTL TTL Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. cleanup runs. Not checked yet Passes checkpointer config through to the CLI, enabling checkpointer settings to be applied via CLI invocation. Not checked yet
2 details in Everything
LangGraph Python SDK 0.3.8 adds stream_mode, stream_subgraphs, stream_resumable, and durability options to cron jobs, plus improved store auth type safety.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.3.8 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.3.8
Adds stream_mode, stream_subgraphs, stream_resumable, and durability parameters to cron job creation in the Python SDK. Not checked yet Improves type safety and docstrings for store auth in the Python SDK. Not checked yet
2 details in Everything
LangGraph Python SDK gains cron job update, enable, and disable methods in the crons client.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.3.4 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.3.4
Adds update method to the crons client for modifying existing cron jobs. Not checked yet Supports enabling and disabling cron jobs via the crons client. Not checked yet
2 details in Everything
LangGraph prebuilt 1.0.7 adds dynamic tool calling tool calling A model's ability to answer with a structured request to run a named function or API, which the application executes and returns. It is how agents take actions. via a tool override in wrap_model_call.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==1.0.7 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==1.0.7
LangGraph 1.0.6 adds compile-time checkpointer type validation to catch configuration errors early.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.0.6 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.0.6
Validates checkpointer type at compile time, surfacing misconfigured checkpointers before runtime. Not checked yet
1 detail in Everything
LangGraph prebuilt 1.0.6 adds compile-time checkpointer validation, custom encryption at rest, and paginated assistant search.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==1.0.6 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==1.0.6
Validates checkpointer type at compile time, catching misconfiguration before runtime. Not checked yet Supports custom encryption at rest for checkpoint data. Not checked yet Includes pagination in assistants search responses. Not checked yet
3 details in Everything
LangGraph 1.0.5 adds custom encryption at rest, stream event IDs, and pagination for assistants search.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.0.5 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.0.5
Adds custom encryption at rest for persisted graph state. Not checked yet Emits id as part of stream events in the Python SDK. Not checked yet Includes pagination in assistants search responses. Not checked yet
3 details in Everything
LangGraph CLI 0.4.8 adds webhook configuration and custom encryption at rest.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.8 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.8
Adds webhook configuration support to the CLI. Not checked yet Supports custom encryption at rest for stored data. Not checked yet
2 details in Everything
LangGraph SDK 0.2.12 adds pagination to assistants search and a sentinel to skip auto-loading API keys.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.2.12 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.2.12
└──▷ USE IT
Instantiate the SDK client without auto-loading the API key from the environment, supplying credentials explicitly instead.
python
copy
from langgraph_sdk import get_client, SKIP_LOAD_API_KEY
client = get_client(url="http://localhost:8123", api_key=SKIP_LOAD_API_KEY)
Adds pagination metadata to the assistants search response, enabling clients to page through large assistant lists. Not checked yet Introduces a sentinel value to skip automatic API key loading when instantiating the SDK client, allowing explicit credential control. Not checked yet
2 details in Everything
LangGraph Python SDK 0.2.10 adds name filtering to Assistants search and cursory Python 3.14 support.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.2.10 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.2.10
└──▷ USE IT
Filter the Assistants search results to a specific assistant name instead of iterating all assistants.
python
copy
assistants = await client.assistants.search(name="my-assistant")
Adds name parameter to the Assistants search API, enabling filtering assistants by name. Not checked yet Adds cursory Python 3.14 support. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! Python 3.9 is no longer supported; projects running on Python 3.9 must upgrade their runtime.
LangGraph 1.0.2 adds Overwrite reducer bypass, Python 3.14 support, and ships Checkpointers 3.0.
└──▷ GET THIS VERSION
copy
$ git clone --branch 1.0.2 https://github.com/langchain-ai/langgraph.git
$ git checkout 1.0.2
└──▷ USE IT
Use Overwrite on a state field when you want the latest value to always win instead of being merged by a reducer.
python
copy
from langgraph.types import Overwrite
from typing import Annotated
from typing_extensions import TypedDict
class State(TypedDict):
messages: Annotated[list, Overwrite()] # latest assignment replaces, no reducer merging
Adds Overwrite type to bypass reducers and directly overwrite state channel values without merging. Not checked yet Adds cursory Python 3.14 support. Not checked yet Ships Checkpointers 3.0 release. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! Python 3.9 is no longer supported; the minimum supported Python version has been raised.
LangGraph prebuilt 1.0.2 adds Python 3.14 support and drops Python 3.9.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==1.0.2 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==1.0.2
Adds cursory Python 3.14 support for prebuilt components. Not checked yet Un-deprecates ToolNode, restoring it as a supported API. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! Python 3.9 is no longer supported; setups running on Python 3.9 will break on upgrade.
LangGraph prebuilt 0.6.5 adds Redis node-level caching and SDK client query-parameter support.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==0.6.5 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==0.6.5
Adds Redis node-level cache via feat(langgraph): implement redis node level cache, enabling per-node result caching backed by Redis. Not checked yet Adds query-parameter support to the Python SDK client (feat(sdk-py): client qparams), allowing callers to pass arbitrary query parameters through SDK calls. Not checked yet
2 details in Everything
langgraph-checkpoint-postgres 3.0 adds cursory Python 3.14 support.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==3.0.0 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==3.0.0
└──▷ BREAKING ON UPGRADE
! Python 3.9 is no longer supported; setups running langgraph-checkpoint-postgres on Python 3.9 will break on upgrade.
LangGraph checkpointsqlite 3.0 adds Python 3.14 support and drops Python 3.9.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointsqlite==3.0.0 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointsqlite==3.0.0
Adds cursory Python 3.14 support, keeping the library compatible with the upcoming CPython release. Not checked yet Drops Python 3.9 support; minimum supported Python version is now 3.10 or higher. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! Python 3.9 is no longer supported; running checkpointsqlite on Python 3.9 will break after upgrading to 3.0.0.
LangGraph checkpoint 3.0 drops Python 3.9 and adds cursory Python 3.14 support.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==3.0.0 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==3.0.0
Adds cursory Python 3.14 support to the checkpointers library. Not checked yet Restricts json type deserialization deserialization Turning stored or transmitted data back into objects a program can use. Unsafe handling of untrusted data can allow unexpected behavior or code execution. for tighter serialization safety. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! Python 3.9 is no longer supported; upgrade to Python 3.10 or later before upgrading to checkpoint 3.0.0.
LangGraph CLI 0.4.3 adds auth control on custom routes and server customization ordering.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.4.3 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.4.3
Adds auth flag in HttpConfig to enable or disable authentication on custom routes. Not checked yet Adds configuration for controlling the ordering of server customization (middleware/routers). Not checked yet
2 details in Everything
LangGraph 0.6.8 adds guardrails that prevent arbitrary resumes when multiple interrupts are pending.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.6.8 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.6.8
LangGraph CLI gains monorepo support for managing multi-package LangGraph projects.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.6.7 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.6.7
Adds monorepo support in the LangGraph CLI, enabling multi-package project structures to be managed from a single repository. Not checked yet
1 detail in Everything
LangGraph 0.6.3 adds a durability mode to invoke and ainvoke for controlling checkpoint persistence.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.6.3 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.6.3
└──▷ USE IT
Control whether LangGraph persists checkpoints during a synchronous graph run — useful when you want to skip persistence overhead for ephemeral, fire-and-forget invocations.
python
copy
graph.invoke(input, durability="ephemeral")
LangGraph 0.6 introduces a typed Context/Runtime API, durability modes, dynamic model/tool selection, and a solidified public API surface.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.6.0 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.6.0
└──▷ USE IT
Pass typed, run-scoped context (e.g. authenticated user ID and DB connection) to graph nodes without nesting values inside config['configurable'].
python
copy
from dataclasses import dataclass
from langgraph.graph import StateGraph
from langgraph.runtime import Runtime
@dataclass
class Context:
user_id: str
db_connection: str
def node(state: State, runtime: Runtime[Context]):
user_id = runtime.context.user_id
db_conn = runtime.context.db_connection
...
builder = StateGraph(state_schema=State, context_schema=Context)
# add nodes, edges, compile...
result = graph.invoke(
{'input': 'abc'},
context=Context(user_id='123', db_connection='conn_mock')
)
Dynamically swap the LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. provider and toolset per-invocation in a ReAct agent based on runtime context.
python
copy
from dataclasses import dataclass
from typing import Literal
from langgraph.prebuilt import create_react_agent
from langgraph.runtime import Runtime
@dataclass
class CustomContext:
provider: Literal['anthropic', 'openai']
tools: list[str]
def select_model(state, runtime: Runtime[CustomContext]):
model = {'openai': openai_model, 'anthropic': anthropic_model}[runtime.context.provider]
selected_tools = [t for t in [weather, compass] if t.name in runtime.context.tools]
return model.bind_tools(selected_tools)
agent = create_react_agent(select_model, tools=[weather, compass])
agent.invoke(some_input, context=CustomContext(provider='openai', tools=['compass']))
Adds a new Context API with Runtime[Context] parameter for type-safe, run-scoped context injection, replacing the config['configurable'] pattern. Not checked yet Introduces context_schema argument on StateGraph as the successor to config_schema, enabling typed context definitions via dataclasses. Not checked yet Adds durability argument with three modes — "exit", "async", and "sync" — giving fine-grained control over checkpoint persistence behavior. Not checked yet Enables create_react_agent to dynamically select model and tools at runtime via a custom context object. Not checked yet Makes StateGraph and Pregel generic over state_schema, context_schema, input_schema, and output_schema for compile-time type checking of node signatures and invoke/stream inputs. Not checked yet
+3 more
show less
Refines the Interrupt interface: adds id (unique identifier encoding namespace) and value attributes as the canonical surface. Not checked yet Centralizes all error classes under langgraph.errors; moves Send and Interrupt imports to langgraph.types. Not checked yet Adds get_context_jsonschema for graph introspection, superseding get_config_jsonschema. Not checked yet
8 details in Everything
└──▷ BREAKING ON UPGRADE
! Importing from langgraph.channels is removed — all error classes must now be imported from langgraph.errors.! The TAG_NOSTREAM_ALT constant is removed from langgraph.constants; use NOSTREAM instead.! The Interrupt attributes when, resumable, and ns are removed; namespace info is now encoded in the id attribute.
LangGraph prebuilt 0.6.0 adds dynamic model selection in create_react_agent and a new context API replacing config['configurable'].
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==0.6.0 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==0.6.0
Adds dynamic model support to create_react_agent, allowing the LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. to be swapped at runtime per invocation. Not checked yet Introduces a new context API as a cleaner replacement for config['configurable'] and config_schema patterns. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! Public/private differentiations have been solidified — previously accessible private symbols may no longer be importable from their old paths.
LangGraph CLI 0.3.6 introduces an api-version option and a new context API replacing config['configurable'] and config_schema.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.3.6 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.3.6
Adds api-version option for explicit API version control. Not checked yet Introduces new context API as a replacement for config['configurable'] and config_schema for passing configuration to graph nodes. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The new context API replaces config['configurable'] and config_schema; existing code relying on these patterns will need to be migrated.
LangGraph Python SDK 0.2.0 adds context API support and exposes interrupts in thread state
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.2.0 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.2.0
└──▷ USE IT
Inspect interrupts on a thread after a run is suspended, to determine why execution paused.
python
copy
thread_state = await client.threads.get_state(thread_id)
interrupts = thread_state.interrupts
Adds SDK support for the context API, enabling callers to pass context through the LangGraph SDK. Not checked yet Adds interrupts field to thread state, making interrupt information accessible when inspecting thread state. Not checked yet Cleans up the Interrupt interface for v1, refining the interrupt contract. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The Interrupt interface has been changed as part of a v1 cleanup — existing code relying on the previous Interrupt interface shape may break.
LangGraph 0.5.4 adds ParentCommand handling in RemoteGraph for cross-graph command propagation.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.5.4 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.5.4
Supports ParentCommand in RemoteGraph, enabling commands issued inside a remote graph to propagate up to the parent graph. Not checked yet
1 detail in Everything
LangGraph SDK 0.1.73 exposes is_studio_user flag to identify Studio-originated requests.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.73 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.73
Adds is_studio_user attribute to identify whether the current user is a LangGraph Studio user. Not checked yet
1 detail in Everything
LangGraph checkpoint-postgres 2.0.22 adds numpy array serialization and pandas pickle fallback in JsonPlusSerializer.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.22 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.22
Supports numpy array serialization in JsonPlusSerializer, enabling checkpoint storage of numpy arrays without manual conversion. Not checked yet Adds pickle fallback for pandas objects in JsonPlusSerializer via serialize/deserialize path, so DataFrames and Series round-trip through checkpoints reliably. Not checked yet Extends pipeline mode in checkpoint-postgres to use the same lock used in non-pipeline mode, improving consistency under concurrent writes. Not checked yet Centralizes CheckpointTuple creation into a shared helper function within checkpoint_postgres, reducing duplication across sync and async paths. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! Checkpoint.metadata.writes has been removed; any code reading or writing this field will break on upgrade.! Checkpoint.pending_sends has been removed; any code referencing this field will break on upgrade.
LangGraph CLI 0.3.4 adds a flag to retain build dependencies (setuptools, pip, wheel) in container builds.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.3.4 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.3.4
LangGraph 0.5 adds NodeBuilder, granular streaming modes, NumPy serialization, and a stricter StateGraph API ahead of 1.0.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.5.0 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.5.0
└──▷ USE IT
Subscribe only to task-level stream events to reduce overhead when you don't need checkpoint deltas.
python
copy
for event in graph.stream(input, stream_mode="tasks"):
print(event)
Define a typed graph with explicit input and output schemas using the new required state_schema and renamed schema parameters.
python
copy
from langgraph.graph import StateGraph
graph = StateGraph(
state_schema=MyState,
input_schema=UserQuery,
output_schema=AssistantResponse,
)
New NodeBuilder utility provides a declarative way to create nodes and attach them to channels, replacing Channel.subscribe_to. Not checked yet Introduces stream_mode="tasks" and stream_mode="checkpoints" as individually selectable streaming modes (and "debug" becomes an alias for both). Not checked yet Adds print_mode= argument to invoke/stream for controlling output printing. Not checked yet StateGraph now accepts input_schema and output_schema parameters (replacing input/output). Not checked yet JsonPlusSerializer now natively handles NumPy arrays (including Fortran-ordered) without pickle fallback. Not checked yet
+3 more
show less
Checkpoints are leaner: redundant keys dropped, per-task writes stored directly, and legacy pending_sends data is auto-migrated on first load. Not checked yet Allows same-name channels and nodes in StateGraph. Not checked yet Task masquerading with update_state is now supported. Not checked yet
8 details in Everything
└──▷ BREAKING ON UPGRADE
! state_schema is now required in StateGraph.__init__; graphs constructed without it will error.! The input and output keyword arguments to StateGraph are deprecated and renamed to input_schema and output_schema; the old names raise a deprecation warning.! Subclassing both PregelNode and Runnable is no longer supported; drop the Runnable base class.! add_conditional_edge(..., then=) has been removed.! Checkpoint.writes and Checkpoint.pending_sends fields have been removed.! The postgres shallow checkpointer has been removed.! Context channel/managed value and SharedValue have been removed.! Support for a node reading a single managed value has been removed.! The retry parameter is renamed to retry_policy.! Dict subclasses used for values/updates stream chunks have been removed.! The default for checkpoint_during has been flipped.! Channel.subscribe_to (the Channel node builder) has been removed.
LangGraph 0.4.10 adds tasks and checkpoints stream modes and numpy/pandas serialization support.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.4.10 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.4.10
└──▷ USE IT
Stream both task-level and checkpoint events to observe exactly when each node runs and when state is persisted.
python
copy
async for chunk in graph.astream(inputs, stream_mode=["tasks", "checkpoints"]):
print(chunk)
Introduces tasks and checkpoints stream modes for finer-grained visibility into graph execution. Not checked yet Supports numpy array serialization in JsonPlusSerializer, enabling numpy data in graph state. Not checked yet Adds pickle fallback for pandas serialization/deserialization deserialization Turning stored or transmitted data back into objects a program can use. Unsafe handling of untrusted data can allow unexpected behavior or code execution. via JsonPlusSerializer. Not checked yet Allows same-name channels and nodes in StateGraph, removing a previous naming constraint. Not checked yet Skips saving checkpoints for subgraphs when checkpoint_during=False, reducing unnecessary checkpoint overhead. Not checked yet
5 details in Everything
langgraph-checkpoint 2.1.0 adds NumPy array and pandas serialization support to JsonPlusSerializer
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.1.0 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.1.0
Supports NumPy array serialization in JsonPlusSerializer, enabling checkpoint storage of array-heavy state. Not checked yet Adds pickle fallback for pandas serialization, allowing DataFrames and Series to round-trip through the checkpoint layer. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! Checkpoint.writes has been removed.! Checkpoint.pending_sends has been removed.
LangGraph CLI 0.2.11 adds image_distro config support and warns when distro is not set to Wolfi.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.2.11 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.2.11
Supports image_distro setting in the LangGraph config file for controlling the base image distribution used in Dockerfile generation. Not checked yet Adds a warning when the image distro is not configured as Wolfi, nudging users toward the recommended distro. Not checked yet
2 details in Everything
LangGraph 0.4.8 adds NodeBuilder to replace Channel.subscribe_to and flips the default for checkpoint_during.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.4.8 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.4.8
Adds NodeBuilder class as the new way to define node subscriptions, replacing Channel.subscribe_to. Not checked yet Flips the default value for checkpoint_during, changing checkpoint behavior out of the box. Not checked yet Stream modes messages and custom now respect subgraphs=False, giving finer control over subgraph output filtering. Not checked yet Requires state_schema in StateGraph.__init__, enforcing explicit schema declaration at graph construction. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! MessageGraph has been removed; graphs using MessageGraph will break on upgrade.! add_conditional_edge(..., then=) argument has been removed; any call using the then= parameter will break.! Checkpoint.writes has been removed; code reading or writing this field will break.! Checkpoint.pending_sends has been removed; code reading or writing this field will break.! The postgres shallow checkpointer has been removed; setups using it must migrate to another checkpointer.! UntrackedValue channel has been removed; any code referencing it will break.! Context channel/managed value and SharedValue have been removed; code relying on them will break.! ChannelsManager has been removed; managed values are now static classes and can no longer be instantiated.! SchemaCoercionMapper has been removed; code referencing it will break.! Dict subclasses used for values/updates stream chunks have been removed; code that relied on the specific types of those chunks may break.! The non-state Graph base class has been removed; code subclassing it directly will break.! The Channel node builder has been removed; use the new NodeBuilder class instead.! state_schema is now required in StateGraph.__init__; existing code that omits it will raise an error.! The default for checkpoint_during has been flipped; existing graphs that relied on the previous default behavior will behave differently without an explicit override.
LangGraph 0.4.6 adds push_message() for manual stream writes, SQLiteStore, and smarter stream_mode=values emission.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.4.6 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.4.6
└──▷ USE IT
Use SqliteStore as a persistence backend for checkpointing or memory in a LangGraph application.
python
copy
from langgraph.store.sqlite import SqliteStore
store = SqliteStore("./my_app.db")
results = store.list_namespaces(max_depth=2)
Adds push_message() method to manually push messages directly to the messages / message-tuple stream from within a graph node. Not checked yet Introduces SqliteStore as a new built-in store backend. Not checked yet Optimizes stream_mode=values to emit chunks only when output channels have actually changed, reducing noise in high-frequency graphs. Not checked yet Prints output for cached @task functions, making task caching observable in the stream. Not checked yet Updates list_namespaces in SQLite with max_depth support for scoped namespace queries. Not checked yet
5 details in Everything
LangGraph prebuilt 0.2.0 adds a post_model_hook, HumanInterruptNode, parallel tool calls via Send, and a SqliteStore with namespace search.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==0.2.0 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==0.2.0
└──▷ USE IT
Inject a post-model validation or logging step into a ReAct agent without subclassing.
python
copy
from langgraph.prebuilt import create_react_agent
def my_post_model_hook(state):
# inspect or mutate state after each model call
print("Model output:", state["messages"][-1].content)
return state
agent = create_react_agent(
model=llm,
tools=[...],
post_model_hook=my_post_model_hook,
)
Persist agent memory across sessions using the new SqliteStore backend.
python
copy
from langgraph.store.sqlite import SqliteStore
store = SqliteStore("agent_memory.db")
# list namespaces up to 2 levels deep
namespaces = store.list_namespaces(max_depth=2)
print(namespaces)
Adds post_model_hook parameter to inject custom logic after model responses in create_react_agent. Not checked yet Introduces HumanInterruptNode for structured human-in-the-loop human-in-the-loop Human in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. interruption handling in prebuilt agents. Not checked yet Switches parallel tool call execution to use Send by default, enabling concurrent tool dispatch in the ReAct agent. Not checked yet Releases SqliteStore as a persistent key-value store backend with namespace search and list_namespaces supporting max_depth filtering. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! The state_modifier parameter has been removed from create_react_agent; existing code passing state_modifier will break on upgrade.
LangGraph SQLite checkpoint adds SqliteStore and InMemoryCache for persistent and in-memory state storage.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointsqlite==2.0.8 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointsqlite==2.0.8
└──▷ USE IT
Clear all entries from a store in one call, useful for resetting state between test runs.
python
copy
store = SqliteStore("./agent_state.db")
# ... populate store ...
store.clear() # deletes all entries when called without arguments
New SqliteStore provides a SQLite-backed key-value store for persisting LangGraph state across runs. Not checked yet New InMemoryCache (moved into the sqlite package alongside FileCache) enables fast, non-persistent caching without a database. Not checked yet Adds SqliteStore release as the official sqlite store integration for LangGraph checkpointing. Not checked yet Overloaded clear() method on the store now deletes all entries when called without arguments. Not checked yet
4 details in Everything
LangGraph checkpoint 2.0.26 adds InMemoryCache, namespace-scoped cache keys, TTL TTL Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. support, and pickle fallback for the JSON serializer.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.26 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.26
Adds InMemoryCache as a new cache backend alongside the existing file-based cache. Not checked yet Moves FileCache to the sqlite package and re-implements it using SQLite for more reliable storage. Not checked yet Adds namespace support to cache keys, enabling isolated cache spaces across different workloads. Not checked yet Implements TTL (time-to-live time-to-live Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. ) expiry in FileCache, allowing automatic cache entry invalidation. Not checked yet Overloads the clear method so calling it without arguments deletes all cache entries. Not checked yet
+2 more
show less
Adds pickle_fallback option to the JSON-plus serializer, enabling serialization of objects that are not natively JSON-serializable. Not checked yet Removes Python version upper bounds, allowing installation on future Python releases without constraint conflicts. Not checked yet
7 details in Everything
LangGraph 0.4.4 adds update_state for the functional API, a caching layer with InMemoryCache, and deferred node execution.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.4.4 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.4.4
└──▷ USE IT
Apply a state update inside a functional-API entrypoint, the same way you would in a StateGraph.
python
copy
from langgraph.func import entrypoint, task
from langgraph.types import Command
from langgraph.checkpoint.memory import MemorySaver
checkpointer = MemorySaver()
@entrypoint(checkpointer=checkpointer)
def my_graph(state):
return state
# Update state for a specific thread mid-run
my_graph.update_state({"configurable": {"thread_id": "thread-1"}}, {"key": "new_value"})
Implements update_state for the functional API, enabling state updates mid-graph in entrypoint-based workflows. Not checked yet Introduces a cache interface with InMemoryCache and FileCache (moved to sqlite package), including clear methods and namespace-scoped cache keys. Not checked yet Adds cache_policy acceptance on graph, entrypoint, and pregel for default caching configuration. Not checked yet Adds support for Deferred Nodes, enabling nodes whose execution can be deferred within a graph. Not checked yet Adds ability to start the dev server externally. Not checked yet
5 details in Everything
LangGraph Python SDK adds customizable client timeouts, loop-safe ASGI ASGI A Python async web server interface specification that defines how servers and applications exchange HTTP and WebSocket messages; cyber tools use it to serve high-concurrency APIs without blocking on I/O. transport, and a new running RunStatus.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.69 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.69
└──▷ USE IT
Set per-request timeouts when initializing the LangGraph client to avoid hung calls in production.
python
copy
from langgraph_sdk import get_client
client = get_client(url="http://localhost:8123", timeout=30)
Supports customizable timeouts in get_client() for fine-grained control over request lifecycle. Not checked yet Adds optional loop-safe ASGI transport to avoid event-loop conflicts in async environments. Not checked yet Adds missing 'running' value to RunStatus enum, enabling accurate status checks on in-progress runs. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! Private SDK functions are now prefixed with _; any code calling these functions by their former unprefixed names will break.
LangGraph 0.4.3 uses tuples for streamed message events in RemoteGraph and adds a draw limit to Pregel graphs.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.4.3 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.4.3
Uses tuples for streamed message events in RemoteGraph, aligning remote streaming with local graph conventions. Not checked yet Adds a node limit to Pregel.draw to prevent rendering failures on very large graphs. Not checked yet
2 details in Everything
LangGraph 0.4.2 decouples RemoteGraph name from assistant ID and executes parallel tool calls via Send by default.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.4.2 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.4.2
Decouples the graph name from the assistant ID in RemoteGraph, allowing them to be set independently. Not checked yet Switches prebuilt parallel tool calls to execute via Send by default, enabling more controlled parallel tool dispatch. Not checked yet
2 details in Everything
LangGraph checkpoint-sqlite 2.0.7 adds a delete_thread method to the Checkpointer class.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointsqlite==2.0.7 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointsqlite==2.0.7
└──▷ USE IT
Delete all checkpoint state for a specific thread to free storage or reset a conversation.
python
copy
checkpointer.delete_thread(thread_id)
LangGraph CLI 0.2.8 adds custom base image support and configurable headers schema for Docker workflows.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.2.8 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.2.8
Supports specifying a custom base image in Docker commands. Not checked yet Adds schema updates for configurable headers. Not checked yet
2 details in Everything
LangGraph SDK 0.1.66 adds checkpoint_during parameter to control mid-execution checkpointing in graph runs.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.66 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.66
└──▷ USE IT
Disable mid-run checkpointing for a streaming run to reduce storage overhead when you only need a final checkpoint on completion or interruption.
python
copy
async for chunk in client.runs.stream(
thread_id,
assistant_id,
input=input_data,
checkpoint_during=False,
):
print(chunk)
Force checkpointing after every node when running long graphs where intermediate state recovery matters.
python
copy
run = await client.runs.create(
thread_id,
assistant_id,
input=input_data,
checkpoint_during=True,
)
LangGraph SDK 0.1.65 adds sorting support to assistants search with new sort_by and sort_order parameters.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.65 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.65
└──▷ USE IT
Retrieve the most recently updated assistants first — useful for auditing or surfacing active agents in a large deployment.
python
copy
results = await client.assistants.search(sort_by="updated_at", sort_order="desc")
Adds sort_by and sort_order parameters to Client.search for assistants, enabling sorting by assistant_id, graph_id, name, created_at, or updated_at in ascending or descending order. Not checked yet Introduces new type aliases AssistantSortBy, ThreadSortBy, and SortOrder for strongly-typed sort parameter hints across assistant and thread searches. Not checked yet
2 details in Everything
LangGraph 0.4.1 adds incremental UI message merging and drops Pydantic V1 support.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.4.1 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.4.1
└──▷ USE IT
Stream incremental prop updates to a UI message (e.g. progressively reveal content) instead of replacing the whole message on each update.
python
copy
from langgraph.graph.ui import push_ui_message
# First emission creates the message
push_ui_message("my-component", {"status": "loading"}, message_id="msg-1")
# Subsequent call merges new props into the existing message
push_ui_message("my-component", {"status": "done", "result": "42"}, message_id="msg-1", merge=True)
Adds a merge parameter to push_ui_message enabling incremental/partial updates to existing UI messages without replacing them wholesale. Not checked yet Drops Pydantic V1 support — SchemaCoercionMapper and langgraph.utils.pydantic now exclusively use Pydantic V2 APIs. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! Pydantic V1 models are no longer supported in SchemaCoercionMapper; graphs using Pydantic V1 models will break on upgrade.! TAG_NOSTREAM value changed from "langsmith:nostream" to "nostream"; code comparing against the old string literal will no longer match (the old value is available as TAG_NOSTREAM_ALT for backward compatibility).
LangGraph 0.4.0 adds targeted interrupt resumption by ID and exposes pending interrupts on StateSnapshot
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.4.0 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.4.0
└──▷ USE IT
Resume a specific interrupt by ID when multiple interrupts are pending in the same graph run, rather than sending a single resume value for all.
python
copy
graph.invoke(Command(resume={interrupt.interrupt_id: "approved"}), config)
Inspect which interrupts are still pending after a step before deciding how to resume each one.
python
copy
snapshot = graph.get_state(config)
for interrupt in snapshot.interrupts:
print(interrupt.interrupt_id, interrupt.value)
Adds interrupt_id property on Interrupt that generates a unique ID from its namespace, enabling precise identification of individual interrupts. Not checked yet Enhances Command.resume to accept a mapping of interrupt IDs to resume values, allowing targeted resumption of specific interrupts rather than all-or-nothing. Not checked yet Adds interrupts field to StateSnapshot to track interrupts that occurred in a step and are pending resolution. Not checked yet Propagates interrupts in "values" stream mode so invoke/ainvoke and streaming consumers now see interrupts emitted during graph execution. Not checked yet Adds add_edge utility in graph visualization to prevent duplicate edges when rendering graphs with END nodes. Not checked yet
5 details in Everything
LangGraph checkpoint savers gain delete_thread and adelete_thread methods to remove all data for a given thread ID.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.25 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.25
└──▷ USE IT
Purge all checkpoint data for a completed or abandoned thread to free storage and enforce data-retention policies.
python
copy
from langgraph.checkpoint.memory import InMemorySaver
saver = InMemorySaver()
# synchronous
saver.delete_thread(thread_id="thread-abc123")
# async
await saver.adelete_thread(thread_id="thread-abc123")
Adds delete_thread and adelete_thread methods to BaseCheckpointSaver and InMemorySaver for deleting all checkpoints and writes associated with a specific thread ID. Not checked yet
1 detail in Everything
LangGraph 0.3.32 adds draw_graph for graph visualization and get_static_writes for static analysis of conditional edges.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.32 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.32
└──▷ USE IT
Visualize a compiled graph including subgraphs and conditional edges using the new dedicated draw_graph function.
python
copy
from langgraph.pregel.draw import draw_graph
draw_graph(compiled_graph)
Adds get_static_writes method to ChannelWrite to support static analysis of what a writer might write, enabling better resolution of conditional edges. Not checked yet Extends ChannelWrite.register_writer to accept static declarations for writers, with a new static field on ChannelWriteTupleEntry to declare writes for static analysis. Not checked yet Adds new langgraph.pregel.draw module with a draw_graph function that simulates execution to discover edges, correctly handling subgraphs and conditional edges. Not checked yet
3 details in Everything
LangGraph CLI gains --image option to deploy pre-built Docker images without a rebuild step.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.2.7 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.2.7
└──▷ TRY IT
Deploy a previously built LangGraph image directly in CI without rebuilding — useful for promotion workflows where langgraph build already ran in an earlier stage.
copy
$ langgraph up --image my-custom-langgraph-image:latest
Adds --image option to langgraph up to specify a pre-built Docker image for the langgraph-api service, skipping the build process entirely. Not checked yet
1 detail in Everything
LangGraph CLI 0.2.6 adds --tunnel flag to expose local dev server publicly via Cloudflare.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.2.6 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.2.6
└──▷ TRY IT
Expose your local LangGraph dev server publicly so remote teammates or browser-based frontends can reach it without localhost blocking.
copy
$ langgraph dev --tunnel
LangGraph SDK 0.1.62 adds sort_by and sort_order parameters to thread search for ordered result retrieval.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.62 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.62
└──▷ USE IT
Retrieve the most recently updated threads first — useful when triaging active or stalled agent runs.
python
copy
threads = await client.threads.search(
sort_by="updated_at",
sort_order="desc"
)
LangGraph Postgres checkpoint library adds thread deletion and tightens search method signatures.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.20 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.20
└──▷ USE IT
Purge all checkpoint data for a completed or abandoned thread to reclaim storage.
python
copy
saver = PostgresSaver(conn)
saver.delete_thread(thread_id="thread-abc123")
Purge thread data in an async workflow without blocking the event loop.
python
copy
saver = AsyncPostgresSaver(conn)
await saver.adelete_thread(thread_id="thread-abc123")
Adds delete_thread method to PostgresSaver for complete removal of all checkpoints and writes tied to a specific thread ID. Not checked yet Adds adelete_thread (async) and delete_thread (sync, with main-thread safety checks) to AsyncPostgresSaver for the same capability in async workflows. Not checked yet Updates search on PostgresStore and asearch on AsyncPostgresStore to require query as an explicit keyword argument rather than a positional parameter. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The query parameter in PostgresStore.search is now a named (keyword) parameter; callers passing it positionally will break.! The query parameter in AsyncPostgresStore.asearch is now a named (keyword) parameter; callers passing it positionally will break.
LangGraph CLI 0.2.5 adds internal config option to override Docker tags in generated Dockerfiles.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.2.5 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.2.5
└──▷ USE IT
Pin a specific base image tag in your generated Dockerfile instead of relying on the auto-detected Python/Node.js version.
json
copy
{
"_INTERNAL_docker_tag": "3.11-slim-bookworm"
}
LangGraph 0.3.31 adds CONFIG_KEY_THREAD_ID constant for tracking thread IDs in concurrent graph invocations.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.31 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.31
└──▷ USE IT
Access the current invocation's thread ID inside a node or custom checkpointer to correlate concurrent runs.
python
copy
from langgraph.constants import CONFIG_KEY_THREAD_ID
def my_node(state, config):
thread_id = config["configurable"].get(CONFIG_KEY_THREAD_ID)
print(f"Running on thread: {thread_id}")
return state
LangGraph 0.3.28 adds support for multiple retry policies per node or task, applying the first matching policy on exception.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.28 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.28
└──▷ USE IT
Assign different retry policies per exception type on a node — e.g., retry rate-limit errors aggressively and network errors conservatively.
python
copy
from langgraph.types import RetryPolicy
from langgraph.graph import StateGraph
rate_limit_policy = RetryPolicy(retry_on=RateLimitError, max_attempts=5, backoff_factor=2.0)
network_policy = RetryPolicy(retry_on=ConnectionError, max_attempts=2, backoff_factor=1.0)
graph = StateGraph(MyState)
graph.add_node("my_node", my_node_fn, retry=[rate_limit_policy, network_policy])
Apply ordered retry policies to a functional task so the first matching policy governs backoff and attempt count.
python
copy
from langgraph.func import task
from langgraph.types import RetryPolicy
@task(retry=[RetryPolicy(retry_on=TimeoutError, max_attempts=3), RetryPolicy(retry_on=Exception, max_attempts=1)])
def fetch_data(url: str):
...
Supports passing a sequence of retry policies to StateGraph.add_node, langgraph.func.task, and Pregel , applying the first matching policy when an exception occurs. Not checked yet Improves SchemaCoercionMapper performance with functools.lru_cache caching, fast paths for basic types, and better handling of tuple, set, and other collection types. Not checked yet Adds compatibility with both Pydantic v1 and v2 in schema coercion via SchemaCoercionMapper. Not checked yet
3 details in Everything
LangGraph CLI 0.2.2 adds auto-detection of Python/JS graphs and smarter Docker base-image selection for mixed-language projects.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.2.2 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.2.2
Automatically detects Python and JavaScript graphs by file extension, eliminating manual language configuration. Not checked yet Selects the appropriate Docker base image automatically based on project composition via new default_base_image logic. Not checked yet Supports mixed Python/Node.js projects in a single configuration, with validate_config now auto-detecting and setting correct runtime versions for each graph file. Not checked yet New docker_tag utility generates correct Docker image tags based on project configuration. Not checked yet
4 details in Everything
LangGraph 0.3.27 adds checkpoint_during parameter to skip per-step checkpointing and boost large-graph performance.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.27 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.27
└──▷ USE IT
Skip per-step checkpointing on a large graph to reduce saver overhead during a high-throughput batch run.
python
copy
result = graph.invoke({"messages": messages}, config=config, checkpoint_during=False)
Use the async streaming interface with end-only checkpointing to reduce latency in production pipelines.
python
copy
async for chunk in graph.astream({"messages": messages}, config=config, checkpoint_during=False):
process(chunk)
Adds checkpoint_during parameter to stream() , astream() , invoke() , and ainvoke() — set to False to checkpoint only at run end, reducing overhead in large graphs. Not checked yet
1 detail in Everything
└──▷ BREAKING ON UPGRADE
! checkpoint_every_step is renamed to checkpoint_during in PregelLoop — any code referencing the old name will break.
LangGraph CLI now accepts dictionary-format graph definitions with a path key in addition to plain import-path strings.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.89 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.89
LangGraph 0.3.25 adds a UI messaging system to push, remove, and reduce UI component updates during graph execution.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.25 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.25
└──▷ USE IT
Stream UI component updates to a frontend during graph execution — e.g. show a progress card that is later replaced.
python
copy
from langgraph.graph.ui import push_ui_message, delete_ui_message, ui_message_reducer
# Inside a graph node:
def my_node(state):
msg = push_ui_message("progress-card", {"status": "running", "step": 1})
# ... do work ...
delete_ui_message(msg["id"])
return state
Wire ui_message_reducer into a typed state so your graph automatically merges UI additions and removals across nodes.
python
copy
from typing import Annotated
from langgraph.graph.ui import AnyUIMessage, ui_message_reducer
from typing_extensions import TypedDict
class GraphState(TypedDict):
ui: Annotated[list[AnyUIMessage], ui_message_reducer]
New UIMessage TypedDict represents UI component updates with properties and metadata during graph execution. Not checked yet New RemoveUIMessage TypedDict enables removal of UI components from the current graph state. Not checked yet New AnyUIMessage Union type combines UIMessage and RemoveUIMessage for flexible type annotations. Not checked yet New push_ui_message() function creates and sends UI messages to render components mid-execution. Not checked yet New delete_ui_message() function removes a UI component from state by ID. Not checked yet
+1 more
show less
New ui_message_reducer() function merges UI message lists, handling both additions and deletions. Not checked yet
6 details in Everything
LangGraph prebuilt 0.1.8 adds a pre_model_hook to create_react_agent for trimming or summarizing long message histories before LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. calls.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==0.1.8 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==0.1.8
└──▷ USE IT
Trim a long conversation to the last N messages before each LLM call to avoid exceeding the model's context window context window The maximum amount of text, counted in tokens, a model can take in and produce in one request. Everything the model knows about the task has to fit inside it. .
python
copy
from langgraph.prebuilt import create_react_agent
from langchain_core.messages import trim_messages
def pre_model_hook(state):
trimmed = trim_messages(state["messages"], max_tokens=4096, token_counter=len)
return {"llm_input_messages": trimmed}
agent = create_react_agent(
model=llm,
tools=tools,
pre_model_hook=pre_model_hook,
)
Summarize earlier conversation turns and replace them with a summary message before each LLM call, without mutating the stored state.
python
copy
def summarizing_hook(state):
messages = state["messages"]
if len(messages) > 20:
summary = llm.invoke(f"Summarize this conversation: {messages[:-5]}")
return {"llm_input_messages": [summary] + messages[-5:]}
return {"llm_input_messages": messages}
agent = create_react_agent(
model=llm,
tools=tools,
pre_model_hook=summarizing_hook,
)
Adds pre_model_hook parameter to create_react_agent, letting you inject a custom node before every LLM call to preprocess message history via trimming, summarization, or other logic. Not checked yet Hook can return messages to update agent state or llm_input_messages to reshape only what the LLM sees, leaving persisted state untouched. Not checked yet
2 details in Everything
LangGraph CLI 0.1.84 adds custom UI configuration support for dev server and Docker builds.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.84 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.84
Supports ui and ui_config options in config files for customized UI when running langgraph dev. Not checked yet Docker image builds now automatically detect and install UI dependencies (npm, yarn, pnpm, bun) when UI is configured. Not checked yet Docker images now include LANGGRAPH_UI and LANGGRAPH_UI_CONFIG environment variables when UI is configured. Not checked yet
3 details in Everything
LangGraph SDK 0.1.61 adds description support to assistant create and update methods.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.61 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.61
└──▷ USE IT
Tag a new assistant with a human-readable description so teammates can identify its purpose at a glance.
python
copy
assistant = await client.assistants.create(
graph_id="my-graph",
description="Triages incoming support tickets and routes to the correct queue."
)
Update an existing assistant's description after a workflow change without recreating it.
python
copy
await client.assistants.update(
assistant_id="asst_abc123",
description="Revised: handles both support tickets and billing inquiries."
)
Adds optional description field to AssistantBase TypedDict for storing assistant descriptions. Not checked yet Adds description parameter to create and update methods (async and sync) on the assistants client. Not checked yet
2 details in Everything
LangGraph checkpoint 2.0.24 adds explicit None serialization support in JsonPlusSerializer.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.24 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.24
└──▷ USE IT
Serialize and deserialize a None value in checkpoint state without errors — useful when graph state fields are legitimately null.
python
copy
from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
serde = JsonPlusSerializer()
type_tag, data = serde.dumps_typed(None) # returns ("null", b"")
value = serde.loads_typed((type_tag, data)) # returns None
Supports None values in JsonPlusSerializer via a new "null" type designation, enabling round-trip serialization of null checkpoint state fields. Not checked yet
1 detail in Everything
LangGraph 0.3.23 adds REMOVE_ALL_MESSAGES to clear entire conversation histories in one operation.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.23 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.23
└──▷ USE IT
Clear an entire conversation history in one step instead of removing messages one by one — useful when resetting context between sessions or tasks.
python
copy
from langgraph.graph.message import REMOVE_ALL_MESSAGES
from langchain_core.messages import RemoveMessage
# Pass this to your graph state update to discard all prior messages
state_update = {"messages": [RemoveMessage(id=REMOVE_ALL_MESSAGES)]}
Adds REMOVE_ALL_MESSAGES constant to wipe an entire MessageGraph conversation history in a single RemoveMessage call. Not checked yet
1 detail in Everything
LangGraph CLI 0.1.83 adds TTL TTL Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. -based checkpointer config for automatic thread data cleanup in deployments.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.83 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.83
└──▷ USE IT
Configure automatic deletion of stale thread checkpoints after a set period to keep storage lean in long-running deployments.
python
copy
from langgraph_cli.config import CheckpointerConfig, ThreadTTLConfig
checkpointer = CheckpointerConfig(
ttl=ThreadTTLConfig(
default_minutes=1440, # delete thread data older than 24 hours
sweep_interval_minutes=60,
strategy="delete",
)
)
Adds CheckpointerConfig class to configure the built-in checkpointer in LangGraph deployments via the main config file. Not checked yet Adds ThreadTTLConfig class to set default TTL (in minutes), sweep interval, and expiry strategy (delete ) for automatic cleanup of thread checkpoints. Not checked yet Supports passing checkpointer configuration to Docker environments via the LANGGRAPH_CHECKPOINTER environment variable automatically. Not checked yet Switches from msgpack to ormsgpack for improved serialization performance. Not checked yet
4 details in Everything
LangGraph CLI dev command gains --allow-blocking flag to suppress synchronous I/O blocking errors
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.82 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.82
└──▷ TRY IT
Run the dev server with a graph that intentionally uses blocking I/O (e.g., a synchronous HTTP client or file read) without the server aborting on detection.
copy
$ langgraph dev --allow-blocking
LangGraph CLI 0.1.81 adds ui_config parameter to customize the LangGraph UI via configuration.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.81 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.81
Adds ui_config parameter to the LangGraph configuration for customizing the LangGraph UI. Not checked yet Exposes LANGGRAPH_UI_CONFIG Docker environment variable when UI configurations are provided, enabling container-level UI customization. Not checked yet
2 details in Everything
LangGraph SDK 0.1.60 adds dictionary-like access to the auth user object — index, check, and iterate over user properties.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.60 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.60
└──▷ USE IT
Access, check, and iterate over user properties inside a LangGraph auth handler without calling getattr.
python
copy
from langgraph_sdk.auth import Auth
auth = Auth()
@auth.authenticate
async def authenticate(headers: dict) -> Auth.types.MinimalUserDict:
# ... token validation ...
return {"identity": "user-123", "role": "admin"}
@auth.on
async def handle(ctx, value):
user = ctx.user
role = user["role"] # __getitem__
if "role" in user: # __contains__
for key in user: # __iter__
print(key, user[key])
Adds __getitem__ to the auth user object, enabling dictionary-style property access (e.g., user["sub"]). Not checked yet Adds __contains__ to the auth user object so you can check property existence with the in operator. Not checked yet Adds __iter__ to the auth user object, allowing iteration over all user properties in auth handlers. Not checked yet
3 details in Everything
LangGraph CLI now reads package.json metadata to auto-detect Yarn, pnpm, or Bun when no lock file is present.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.80 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.80
LangGraph SDK 0.1.59 adds per-request custom HTTP headers across all API client methods.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.59 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.59
└──▷ USE IT
Pass a correlation or tenant-tracking header on a per-run basis without modifying the global client config.
python
copy
run = await client.runs.create(
thread_id="<thread_id>",
assistant_id="<assistant_id>",
headers={"X-Tenant-ID": "org-42", "X-Request-ID": "req-abc123"}
)
Inject a per-request auth token when streaming a run, e.g. for short-lived credentials that differ from the client's default.
python
copy
async for chunk in client.runs.stream(
thread_id="<thread_id>",
assistant_id="<assistant_id>",
headers={"Authorization": "Bearer <ephemeral_token>"}
):
print(chunk)
Adds an optional headers parameter to all HTTP methods (get, post, put, patch, delete, stream) on HttpClient and SyncHttpClient, merging custom headers with existing request headers. Not checked yet Adds optional headers parameter to all methods on AssistantsClient and SyncAssistantsClient (including get, create, update, delete, search). Not checked yet Adds optional headers parameter to all thread-related methods on ThreadsClient and SyncThreadsClient, including state management, history, and creation. Not checked yet Adds optional headers parameter to all run methods on RunsClient and SyncRunsClient, covering create, stream, wait, and management operations. Not checked yet Adds optional headers parameter to all cron job methods on CronClient and SyncCronClient (create, search, delete). Not checked yet
+1 more
show less
Adds optional headers parameter to all store operations on StoreClient and SyncStoreClient, including item storage, retrieval, and namespace management. Not checked yet
6 details in Everything
langgraph-checkpoint 2.0.22 adds blob storage for InMemorySaver, upgrades to ormsgpack, and supports custom serialization hooks.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.22 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.22
Adds dedicated blob storage system to InMemorySaver for more efficient, lower-memory channel value management via a new blobs store and _load_blobs method. Not checked yet Bumps checkpoint format to LATEST_VERSION = 2, adopted by empty_checkpoint() and create_checkpoint() , to support the new storage layout. Not checked yet Replaces msgpack with ormsgpack in JsonPlusSerializer for faster serialization, including new bytearray support and optimized serialization options. Not checked yet Adds customizable JsonPlusSerializer.__init__ accepting an optional custom unpacking hook, plus _msgpack_ext_hook_to_json for better MessagePack-to-JSON type translation. Not checked yet
4 details in Everything
LangGraph 0.3.19 adds dependency-aware node scheduling and XXH3-based task ID hashing for faster graph execution.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.19 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.19
└──▷ USE IT
Explicitly declare that a callable node accepts the LangChain config, avoiding runtime parameter inspection overhead.
python
copy
from langgraph.utils.runnable import RunnableCallable
def my_node(state, config):
# config is available here
return {"result": config["configurable"].get("user_id")}
node = RunnableCallable(my_node, func_accepts_config=True)
Attach a subgraph directly to a PregelNode without wrapping it in a bound runnable — useful when composing graphs programmatically.
python
copy
from langgraph.pregel.read import PregelNode
child_graph = build_child_graph() # returns a compiled Pregel
node = PregelNode(
channels=["input"],
triggers=["input"],
mapper=None,
subgraphs=[child_graph],
)
Adds dependency-aware node scheduling: only nodes whose trigger channels were updated in the previous step are evaluated, reducing unnecessary work in large graphs. Not checked yet Adds trigger_to_nodes property on Pregel to expose the mapping from channel triggers to dependent nodes. Not checked yet Adds subgraphs parameter on PregelNode to directly specify subgraphs instead of extracting them from a bound runnable. Not checked yet Adds func_accepts_config parameter on RunnableCallable to explicitly control whether a wrapped function receives the LangChain config argument. Not checked yet Switches task ID generation to the XXH3 hash algorithm (via _xxhash_str) for newer checkpoint versions, replacing the slower SHA-1 SHA-1 A cryptographic hash function standardized by NIST that produces a 160-bit digest; tools use it for file integrity checks, though it is now considered cryptographically broken and unsuitable for collision-resistant applications. implementation. Not checked yet
5 details in Everything
LangGraph CLI dev command gains --studio_url option to connect to custom Studio instances.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.78 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.78
└──▷ TRY IT
Point the local dev server at a self-hosted or staging LangGraph Studio instance instead of the default smith.langchain.com.
copy
$ langgraph dev --studio_url https://studio.internal.example.com
LangGraph SDK 0.1.58 adds supersteps and graph_id parameters to thread creation for cross-deployment thread copying.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.58 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.58
└──▷ USE IT
Copy a thread from one deployment to another by replaying its supersteps at creation time.
python
copy
thread = await client.threads.create(
supersteps=source_supersteps,
graph_id="my-graph",
metadata={"copied_from": source_thread_id}
)
Adds supersteps parameter to sync and async ThreadsClient.create() , enabling a sequence of state updates to be applied at thread creation — useful for copying threads between deployments. Not checked yet Adds graph_id parameter to ThreadsClient.create() to associate a new thread with a specific graph at creation time. Not checked yet
2 details in Everything
LangGraph 0.3.17 adds bulk state update methods for efficient sequential graph state mutations.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.17 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.17
└──▷ USE IT
Apply several state patches at once during human-in-the-loop human-in-the-loop Human in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. correction instead of calling update_state repeatedly.
python
copy
from langgraph.types import StateUpdate
# graph is a compiled Pregel graph, config identifies the thread
updates = [
StateUpdate(values={"status": "reviewed"}, as_node="reviewer"),
StateUpdate(values={"score": 0.95}, as_node="scorer"),
]
graph.bulk_update_state(config, updates)
Same workflow in an async context — use abulk_update_state inside an async agent loop to batch corrections without blocking.
python
copy
from langgraph.types import StateUpdate
updates = [
StateUpdate(values={"approved": True}, as_node="approver"),
StateUpdate(values={"notes": "LGTM"}, as_node="annotator"),
]
await graph.abulk_update_state(config, updates)
Adds bulk_update_state and abulk_update_state methods to Pregel for applying multiple state updates to a graph in a single sequential operation. Not checked yet Introduces StateUpdate NamedTuple (fields: values, as_node) as a structured type for representing individual state updates passed to bulk operations. Not checked yet
2 details in Everything
LangGraph 0.3.15 adds is_available() channel introspection and improves Pregel task execution performance.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.15 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.15
└──▷ USE IT
Check whether a channel holds a value before reading it, avoiding try/except boilerplate in custom channel logic.
python
copy
if channel.is_available():
value = channel.get()
Adds is_available() method to all channel types (AnyValue, BinaryOperatorAggregate, DynamicBarrierValue, EphemeralValue, LastValue, NamedBarrierValue, Topic , UntrackedValue) for exception-free channel state checks. Not checked yet Changes PregelExecutableTask.triggers type from list[str] to Sequence[str] for more flexible and performant trigger handling. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The return_exception parameter is removed from read_channel() in langgraph.pregel.io; code passing that argument will break.
LangGraph 0.3.13 adds RemoteGraph visualization support and improves handling of multiple concurrent interrupts.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.13 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.13
└──▷ USE IT
Visualize a graph that includes RemoteGraph nodes — now renders correctly instead of being skipped.
python
copy
await compiled_graph.aget_graph(xray=True)
Adds support for visualizing RemoteGraph instances in both sync and async graph drawing methods. Not checked yet Enables parallel traversal of subgraphs during async graph visualization via asyncio.gather() , speeding up rendering of complex graphs. Not checked yet Enhances multiple concurrent interrupt handling by collecting and combining them into a single interrupt for cleaner propagation. Not checked yet
3 details in Everything
LangGraph checkpoint adds EncryptedSerializer and CipherProtocol for at-rest encryption of checkpoint data.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.21 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.21
└──▷ USE IT
Encrypt all checkpoint data at rest using AES AES A symmetric block cipher standardized by NIST that encrypts data in 128-bit blocks using 128-, 192-, or 256-bit keys; tools use it because hardware acceleration makes it fast enough for bulk encryption. — useful when storing sensitive agent state in a shared or cloud-backed checkpointer.
python
copy
from langgraph.checkpoint.serde.encrypted import EncryptedSerializer
# Key can also be supplied via LANGGRAPH_AES_KEY env var
serializer = EncryptedSerializer.from_pycryptodome_aes(key=b"your-32-byte-aes-key-here!!!!!")
# Pass the serializer to your checkpointer of choice
from langgraph.checkpoint.memory import MemorySaver
checkpointer = MemorySaver(serde=serializer)
Implement a custom cipher (e.g., a KMS KMS A managed service that creates, stores, rotates and controls access to encryption keys, usually backed by HSMs. Applications ask it to encrypt or decrypt rather than holding keys themselves. -backed one) by conforming to CipherProtocol instead of using the built-in AES factory.
python
copy
from langgraph.checkpoint.serde.base import CipherProtocol
from langgraph.checkpoint.serde.encrypted import EncryptedSerializer
class MyKMSCipher(CipherProtocol):
def encrypt(self, plaintext: bytes) -> bytes:
... # call your KMS
def decrypt(self, ciphertext: bytes) -> bytes:
... # call your KMS
serializer = EncryptedSerializer(cipher=MyKMSCipher())
New CipherProtocol interface defines encrypt/decrypt contract for pluggable cipher implementations. Not checked yet New EncryptedSerializer class wraps any underlying serializer (defaults to JsonPlusSerializer) to transparently encrypt and decrypt checkpoint data. Not checked yet Factory method EncryptedSerializer.from_pycryptodome_aes enables AES-encrypted checkpoints via the pycryptodome library with minimal setup. Not checked yet Supports AES key supply via LANGGRAPH_AES_KEY environment variable or direct key passing, and is backward-compatible with existing unencrypted checkpoint data. Not checked yet
4 details in Everything
langgraph-checkpoint-postgres 2.0.17 adds TTL TTL Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. support for Postgres store items with automatic background expiry sweeping.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.17 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.17
└──▷ USE IT
Automatically expire agent memory store entries after 60 minutes, with a background sweeper running every 30 seconds.
python
copy
from langgraph.store.postgres import PostgresStore
store = PostgresStore.from_conn_string(
"postgresql://user:pass@localhost/mydb",
ttl={"default_ttl": 60, "sweep_interval_minutes": 0.5},
)
store.start_ttl_sweeper()
# ... use store in your LangGraph app ...
store.stop_ttl_sweeper()
Use the async store with TTL in an async LangGraph application, ensuring cleanup on shutdown.
python
copy
from langgraph.store.postgres.aio import AsyncPostgresStore
async with AsyncPostgresStore.from_conn_string(
"postgresql://user:pass@localhost/mydb",
ttl={"default_ttl": 120},
) as store:
await store.start_ttl_sweeper()
# ... use store in your async LangGraph app ...
await store.stop_ttl_sweeper()
Manually trigger a TTL sweep on demand, e.g. as part of a scheduled maintenance job.
python
copy
from langgraph.store.postgres import PostgresStore
store = PostgresStore.from_conn_string("postgresql://user:pass@localhost/mydb")
deleted_count = store.sweep_ttl()
print(f"Swept {deleted_count} expired items")
Adds ttl parameter to PostgresStore and AsyncPostgresStore constructors to configure Time To Live behavior for store items. Not checked yet Adds start_ttl_sweeper() and stop_ttl_sweeper() methods to manage a background thread/task that automatically deletes expired items. Not checked yet Adds sweep_ttl() method (sync and async) for on-demand manual deletion of expired store items. Not checked yet Supports TTL configuration via from_conn_string() for both sync and async store classes. Not checked yet Adds expires_at and ttl_minutes columns plus an index on expires_at to the store table via new database migrations. Not checked yet
+1 more
show less
Enables TTL refresh on GET and SEARCH operations so item lifetimes can be extended on access. Not checked yet
6 details in Everything
LangGraph checkpoint 2.0.20 adds configurable TTL TTL Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. sweep intervals for automatic expiry cleanup in stores.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.20 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.20
└──▷ USE IT
Enable background TTL sweeping so expired store entries are deleted automatically every N minutes without manual intervention.
python
copy
from langgraph.store.base import TTLConfig
ttl_config = TTLConfig(
sweep_interval_minutes=30
)
Adds sweep_interval_minutes field to TTLConfig to schedule automatic periodic deletion of expired store items. Not checked yet
1 detail in Everything
LangGraph CLI 0.1.77 adds automatic TTL TTL Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. sweeping via new sweep_interval_minutes config option.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.77 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.77
└──▷ USE IT
Enable automatic TTL sweeping every 10 minutes so expired store entries are cleaned up without manual intervention.
python
copy
ttl_config = TTLConfig(
sweep_interval_minutes=10
)
Adds sweep_interval_minutes to TTLConfig , enabling the store to periodically delete expired items automatically; omitting it preserves the previous no-sweep behavior. Not checked yet
1 detail in Everything
LangGraph 0.3.10 adds env-var recursion control, cached schema coercion, and flexible task return types.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.10 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.10
└──▷ TRY IT
Override the default recursion limit for all graphs in a deployment without changing application code — useful in long-chain agentic workflows.
copy
$ export LANGGRAPH_DEFAULT_RECURSION_LIMIT=100
New SchemaCoercionMapper class provides cached schema coercion supporting Pydantic v1/v2, nested lists, dicts, tuples, and unions. Not checked yet Configures graph recursion limit via the LANGGRAPH_DEFAULT_RECURSION_LIMIT environment variable (default: 25), removing the need for per-run config. Not checked yet Expands PregelTask.result field to accept Any type, enabling flexible non-dict return values from tasks. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The require_at_least_one_of parameter is removed from ChannelWrite; code that passes this parameter will break on upgrade.
LangGraph SDK adds stream_mode filtering and cancel_on_disconnect to join_stream for precise run output control.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.57 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.57
└──▷ USE IT
Filter a joined run stream to only receive graph state values and debug events, reducing noise in long-running pipelines.
python
copy
async for chunk in client.runs.join_stream(thread_id, run_id, stream_mode=["values", "debug"]):
print(chunk)
Use cancel_on_disconnect in the sync client so a stalled run is automatically cancelled when your process disconnects.
python
copy
for chunk in client.runs.join_stream(thread_id, run_id, stream_mode=["values"], cancel_on_disconnect=True):
print(chunk)
Adds stream_mode parameter to both sync and async RunClient.join_stream, enabling filtering of streamed run output by mode (e.g. "values", "debug"). Not checked yet Adds cancel_on_disconnect parameter to the sync RunClient.join_stream, reaching feature parity with the async version. Not checked yet
2 details in Everything
LangGraph prebuilt 0.1.3 adds Pydantic agent state models and Callable tool support in create_react_agent.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==0.1.3 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==0.1.3
└──▷ USE IT
Use a plain Python callable as a tool in a ReAct agent — no need to wrap it in a BaseTool subclass.
python
copy
from langgraph.prebuilt import create_react_agent
def lookup_user(user_id: str) -> str:
"""Look up a user by ID."""
return f"User {user_id}: Alice"
agent = create_react_agent(model, tools=[lookup_user])
Use Pydantic-based agent state for strict type validation and serialization in a ReAct agent.
python
copy
from langgraph.prebuilt import create_react_agent
from langgraph.prebuilt.chat_agent_executor import AgentStatePydantic
agent = create_react_agent(model, tools=[...], state_schema=AgentStatePydantic)
Adds AgentStatePydantic and AgentStateWithStructuredResponsePydantic Pydantic models for representing agent state with messages, remaining steps, and structured responses. Not checked yet Enables create_react_agent to accept plain Callable objects as tools, in addition to BaseTool instances. Not checked yet Supports both TypedDict and Pydantic models interchangeably for agent state schema via updated StateSchemaType. Not checked yet
3 details in Everything
LangGraph Checkpoint 2.0.19 adds TTL TTL Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. configuration support for stores with default TTL values and refresh-on-read control.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.19 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.19
└──▷ USE IT
Set a store-wide default TTL and enable automatic TTL refresh on reads so cached items stay alive while actively used.
python
copy
from langgraph.store.base import TTLConfig
# When constructing your store implementation
store = MyStore(
ttl_config=TTLConfig(
default_ttl=60, # minutes; applied to put/aput when no TTL is specified
refresh_on_read=True # extends TTL whenever an item is fetched
)
)
Adds TTLConfig TypedDict to configure Time-To-Live behavior at the store level, including default_ttl (in minutes) and refresh_on_read options. Not checked yet Adds ttl_config property to BaseStore so TTL policy is set once and applied automatically to get, search, put, and their async counterparts. Not checked yet Adds NotProvided sentinel class and NOT_PROVIDED constant to distinguish between explicitly passing ttl=None and omitting a TTL value entirely. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The refresh_ttl parameter on get, search, and async counterparts now defaults to None (inherit store's TTL configuration) instead of True ; stores that relied on TTLs being refreshed on every read will no longer do so unless TTLConfig(refresh_on_read=True) is set or refresh_ttl=True is passed explicitly.
LangGraph CLI 0.1.76 adds TTL TTL Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. configuration for stores, enabling automatic expiration of stored items.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.76 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.76
└──▷ USE IT
Expire store entries after 60 minutes and keep them alive as long as they're being read — useful for session-scoped memory that should age out when users go idle.
python
copy
from langgraph.config import StoreConfig, TTLConfig
store_cfg = StoreConfig(
ttl=TTLConfig(
default_ttl=60, # minutes until a new item expires
refresh_on_read=True, # reset the clock whenever the item is read
)
)
Adds TTLConfig TypedDict to control automatic expiration of store items, with per-read TTL refresh and a configurable default TTL in minutes. Not checked yet Extends StoreConfig with an optional ttl field to attach TTL settings to any store definition. Not checked yet
2 details in Everything
LangGraph 0.3.7 adds Pydantic v1/v2 model validation for graph inputs via input_model support.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.7 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.7
└──▷ USE IT
Enforce structured, validated inputs on a compiled state graph by passing a Pydantic model as input_model so invalid payloads are caught before execution begins.
python
copy
from pydantic import BaseModel
from langgraph.graph.state import StateGraph
class MyInput(BaseModel):
query: str
max_results: int = 5
builder = StateGraph(MyInput)
# ... add nodes and edges ...
graph = builder.compile()
# Pydantic validation now runs automatically on invoke
result = graph.invoke({"query": "threat actors targeting finance", "max_results": 10})
Adds input_model support to Pregel for validating graph inputs against Pydantic v1 and v2 models, using construct/model_construct respectively. Not checked yet Extends get_input_schema to prioritize the input_model when available, surfacing typed input schemas for state graphs. Not checked yet Introduces _pick_mapper function in StateGraph/CompiledStateGraph to correctly handle Pydantic and non-Pydantic schema types during state coercion. Not checked yet
3 details in Everything
LangGraph 0.3.6 adds input schema inference for conditional edges and a dedicated Branch module with a new from_path factory method.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.6 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.6
└──▷ USE IT
Use Branch.from_path to build a conditional edge with automatic input schema inference, so the router function only receives the fields it declares rather than the full graph state.
python
copy
from langgraph.graph.branch import Branch
branch = Branch.from_path(
path=my_router_fn,
path_map={"yes": "node_a", "no": "node_b"},
# input_schema is inferred automatically from my_router_fn's signature
)
graph.add_conditional_edges("entry", branch)
Adds input_schema field to Branch for automatic schema inference on conditional edges in StateGraph. Not checked yet New Branch.from_path factory method handles path_map conversion and optionally infers input schema. Not checked yet Extends StateGraph.add_conditional_edges with schema inference, improving type safety for branch routing. Not checked yet Improves type annotations on the task decorator to consistently prioritize async functions in Union types. Not checked yet
4 details in Everything
LangGraph Postgres checkpoint store exposes PLACEHOLDER and get_distance_operator as public API
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.16 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.16
└──▷ USE IT
Reference the now-public PLACEHOLDER constant when building custom batch queries against the Postgres store.
python
copy
from langgraph.store.postgres.base import PLACEHOLDER
Exposes PLACEHOLDER constant (formerly _PLACEHOLDER) as a public symbol in langgraph.store.postgres.base for use in external code. Not checked yet Exposes get_distance_operator function (formerly _get_distance_operator) as a public API in langgraph.store.postgres.base for custom vector-distance logic. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The _PLACEHOLDER constant is renamed to PLACEHOLDER; any code importing _PLACEHOLDER directly will break.! The _get_distance_operator function is renamed to get_distance_operator; any code importing or calling _get_distance_operator directly will break.
LangGraph checkpoint 2.0.18 lets BaseStore operations accept non-string keys with automatic conversion.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.18 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.18
└──▷ USE IT
Use integer or other non-string keys directly in store put/get calls without manually casting to str first.
python
copy
store.put(("namespace",), 42, {"value": "data"})
result = store.get(("namespace",), 42)
Enables non-string keys (integers, tuples, etc.) in all BaseStore operations (get, put, delete, and async variants) by automatically converting them to strings before storage. Not checked yet
1 detail in Everything
LangGraph SDK 0.1.55 adds TTL TTL Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. support to the store API, enabling automatic expiration and refresh of stored items.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.55 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.55
└──▷ USE IT
Store a short-lived session token that auto-expires after 30 minutes, so stale credentials are never returned.
python
copy
await client.store.put_item(namespace, key="session:user123", value={"token": "abc"}, ttl=30)
Retrieve a cached item and slide its expiration window forward so active users stay authenticated without a re-login.
python
copy
item = await client.store.get_item(namespace, key="session:user123", refresh_ttl=True)
Adds ttl parameter to put_item to set item expiration time (in minutes) in the store API. Not checked yet Adds refresh_ttl parameter to get_item to control whether an item's TTL is refreshed on read. Not checked yet Adds refresh_ttl parameter to search_items to control TTL refresh for items returned by search. Not checked yet
3 details in Everything
LangGraph Checkpoint 2.0.17 adds TTL TTL Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. support for store items, enabling automatic expiration of stored data.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.17 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.17
Adds TTL (time-to-live time-to-live Time to live, a limit on how long data remains valid or how far a packet can travel. Caches use a time limit; IP packets use a hop limit. ) support to BaseStore via a supports_ttl flag, letting store implementations enable automatic expiration of stored items. Not checked yet Adds ttl: Optional[float] = None parameter to PutOp to set per-item expiration time in minutes when writing to the store. Not checked yet Adds refresh_ttl: bool = True parameter to GetOp and SearchOp to control whether TTLs are refreshed on retrieval or search. Not checked yet
3 details in Everything
LangGraph CLI 0.1.75 adds IDE schema validation for langgraph.json and UI component configuration support.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.75 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.75
└──▷ USE IT
Declare UI components for an agent in langgraph.json using the new ui configuration key.
json
copy
{
"graphs": {
"my_agent": "./agent.py:graph"
},
"ui": {
"my_agent": "./ui/MyAgentComponent.tsx"
}
}
Adds JSON schema files (schema.json and schema.v0.json) referenceable in langgraph.json to enable IDE autocompletion and validation of LangGraph configuration. Not checked yet Adds a new ui configuration option to the Config class for defining UI components associated with agents. Not checked yet Supports setting the LANGGRAPH_UI environment variable in Docker deployments to configure UI components. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! StoreConfig.embed is renamed to StoreConfig.index — any langgraph.json or code referencing StoreConfig.embed will break on upgrade.
LangGraph prebuilt 0.1.2 lets create_react_agent accept a RunnableSequence as its model argument.
└──▷ GET THIS VERSION
copy
$ git clone --branch prebuilt==0.1.2 https://github.com/langchain-ai/langgraph.git
$ git checkout prebuilt==0.1.2
└──▷ USE IT
Use a prompt-plus-model RunnableSequence as the agent's model so a fixed system prompt is baked into the chain rather than managed separately.
python
copy
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langgraph.prebuilt import create_react_agent
prompt = ChatPromptTemplate.from_messages([
("system", "You are a helpful security analyst."),
("placeholder", "{messages}"),
])
llm = ChatOpenAI(model="gpt-4o")
# Pass the RunnableSequence (prompt | llm) directly as the model
agent = create_react_agent(model=prompt | llm, tools=[my_tool])
Supports passing a RunnableSequence as the model to create_react_agent, enabling prompt-chained pipelines to be used directly as the agent's LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. backbone. Not checked yet
1 detail in Everything
LangGraph 0.3.4 adds config_schema and get_config_jsonschema methods to Pregel, plus a new Pydantic-support utility.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.3.4 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.3.4
└──▷ USE IT
Expose a graph's configuration schema as JSON Schema for tooling, validation, or documentation.
python
copy
schema = graph.get_config_jsonschema()
print(schema)
Check whether a custom config type will be handled natively by Pydantic before wiring it into a Pregel graph.
python
copy
from langgraph.utils.pydantic import is_supported_by_pydantic
from typing import TypedDict
class MyConfig(TypedDict):
temperature: float
max_tokens: int
if is_supported_by_pydantic(MyConfig):
print("Safe to use as a Pregel config type")
Adds config_schema method to Pregel for proper configuration schema generation when the config type is a TypedDict, dataclass, or Pydantic model. Not checked yet Adds get_config_jsonschema method to Pregel for converting config schemas to JSON Schema format, consistent with existing get_input_jsonschema/get_output_jsonschema. Not checked yet Adds is_supported_by_pydantic utility function to detect whether a type (dataclass, Pydantic model, or TypedDict, including Python 3.12+) is directly supported by Pydantic. Not checked yet
3 details in Everything
LangGraph CLI 0.1.74 adds langgraph 0.3.x support and the new langgraph-prebuilt high-level agent API.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.74 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.74
Supports langgraph 0.3.x, enabling use of the latest core graph features in CLI-managed projects. Not checked yet Adds support for langgraph-prebuilt v0.1.1, which provides high-level APIs for creating and executing LangGraph agents and tools. Not checked yet
2 details in Everything
LangGraph 0.2.75 adds structured response support and configuration schemas to the ReAct agent executor.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.75 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.75
└──▷ USE IT
Use a typed structured response from a ReAct agent instead of free-form text — useful when you need machine-readable output from an agent loop.
python
copy
from langgraph.prebuilt.chat_agent_executor import AgentStateWithStructuredResponse
Adds AgentStateWithStructuredResponse class to support structured responses in the ReAct agent executor. Not checked yet Adds configuration schema support to the ReAct agent executor. Not checked yet Enhances StreamMessagesHandler to track message IDs nested within input dictionaries for proper deduplication. Not checked yet Adds py.typed markers to package subdirectories for improved type-checking support. Not checked yet
4 details in Everything
LangGraph SDK 0.1.53 adds store authorization via @auth.on.store and dynamic loopback transport configuration.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.53 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.53
└──▷ USE IT
Restrict store operations so each user can only read or write their own data.
python
copy
@auth.on.store
async def authorize_store(ctx, value):
# Allow access only if the namespace matches the authenticated user
if ctx.user.identity not in value.get("namespace", []):
raise Exception("Access denied")
Adds @auth.on.store decorator to authorize access to storage operations, enabling per-user data access control. Not checked yet Adds configure_loopback_transports function and _registered_transports list for dynamic server transport configuration. Not checked yet Supports deferred loopback transport setup via the __LANGGRAPH_DEFER_LOOPBACK_TRANSPORT environment variable. Not checked yet
3 details in Everything
LangGraph CLI 0.1.72 adds Docker build-context support for parent-dir deps and new HTTP server config options including CORS CORS A browser mechanism that lets a server declare which foreign origins may read its HTTP responses, enforced by the browser to block unauthorized cross-site requests from JavaScript. and custom app mounting.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.72 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.72
└──▷ USE IT
Mount a custom FastAPI/Starlette app with middleware and configure CORS — useful when you need to add auth middleware or expose the server to a browser-based client.
yaml
copy
http:
app: ./my_middleware_app.py:app
cors:
allow_origins:
- "https://my-frontend.example.com"
allow_methods:
- "GET"
- "POST"
disable_routes:
- assistants
- store
Supports Docker build contexts for local dependencies located in parent directories, enabling more flexible project layouts. Not checked yet Adds http.app config option to mount custom Starlette/FastAPI apps onto the LangGraph HTTP server. Not checked yet Adds options to disable specific API route groups (assistants, threads, runs, store) via HTTP configuration. Not checked yet Adds CORS configuration support for the LangGraph HTTP server. Not checked yet
4 details in Everything
LangGraph 0.2.74 stabilizes the Functional API and adds custom task submission via CONFIG_KEY_RUNNER_SUBMIT.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.74 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.74
└──▷ USE IT
Override how PregelRunner dispatches tasks — useful for integrating custom thread pools, tracing, or rate-limiting at the task level.
python
copy
from langgraph.constants import CONFIG_KEY_RUNNER_SUBMIT
def my_submit(fn, *args, **kwargs):
print(f"Submitting task: {fn.__name__}")
return fn(*args, **kwargs)
graph.invoke(
{"messages": [{"role": "user", "content": "Hello"}]},
config={"configurable": {CONFIG_KEY_RUNNER_SUBMIT: my_submit}},
)
Use the now-stable Functional API to define reusable async tasks without wrapping in a full StateGraph.
python
copy
from langgraph.func import task, entrypoint
@task
def fetch_data(query: str) -> str:
return f"result for {query}"
@entrypoint()
def pipeline(query: str):
return fetch_data(query).result()
Adds CONFIG_KEY_RUNNER_SUBMIT configuration key, enabling custom task submission logic in PregelRunner for flexible execution control. Not checked yet Promotes langgraph.func.task and langgraph.func.entrypoint decorators to stable (Beta label removed). Not checked yet Adds no-op fallback in get_stream_writer so callers can safely invoke the stream writer even when none is configured. Not checked yet
3 details in Everything
LangGraph checkpoint 2.0.15 adds get_checkpoint_metadata for standardized, filtered checkpoint metadata extraction.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.15 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.15
└──▷ USE IT
Standardize metadata extraction from a RunnableConfig before storing a checkpoint, ensuring only primitive-typed, non-private fields are persisted.
python
copy
from langgraph.checkpoint.base import get_checkpoint_metadata
metadata = get_checkpoint_metadata(config)
# metadata contains only string/int/bool/float fields, private keys excluded
Adds get_checkpoint_metadata function to extract and process checkpoint metadata from a RunnableConfig, filtering out private/excluded keys and non-primitive types for consistent handling across checkpoint implementations. Not checked yet
1 detail in Everything
PostgreSQL checkpoint savers now store richer metadata by merging configurable properties with existing and explicit metadata.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.14 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.14
Enriches checkpoint metadata automatically: put/aput methods on PostgresSaver, AsyncPostgresSaver, ShallowPostgresSaver, and AsyncShallowPostgresSaver now combine non-private configurable properties, existing metadata, and explicitly passed metadata into each saved checkpoint. Not checked yet
1 detail in Everything
InMemorySaver now serializes configurable options and existing metadata into checkpoint metadata
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.13 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.13
└──▷ USE IT
Attach run-time configurable context (e.g. user ID, session tags) to checkpoints so they are queryable later without extra bookkeeping.
python
copy
from langgraph.checkpoint.memory import InMemorySaver
saver = InMemorySaver()
# config["configurable"] non-private keys and config["metadata"] are now
# automatically merged into the stored checkpoint metadata by put()
config = {
"configurable": {
"thread_id": "thread-42",
"user_id": "alice",
"__private_key": "ignored", # filtered out
},
"metadata": {"session": "prod-run-1"},
}
# After graph.invoke(..., config=config), checkpoints stored by InMemorySaver
# will include thread_id, user_id, and session in their metadata.
LangGraph SQLite checkpointers now store richer metadata including configurable fields and existing checkpoint metadata.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointsqlite==2.0.4 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointsqlite==2.0.4
Enriches checkpoint metadata in SqliteSaver.put and AsyncSqliteSaver.aput with configurable fields (excluding private __-prefixed keys) and any pre-existing metadata alongside explicitly provided metadata. Not checked yet
1 detail in Everything
LangGraph 0.2.71 adds a destinations parameter to add_node() for visualizing routing in edgeless graphs.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.71 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.71
└──▷ USE IT
Annotate routing possibilities in a Command-driven edgeless graph so rendered visualizations show labeled edges between nodes.
python
copy
graph.add_node("router", router_fn, destinations={"process": "to_process", "fallback": "to_fallback"})
Declare destination nodes as a tuple when edge labels aren't needed, still enabling accurate graph visualization.
python
copy
graph.add_node("router", router_fn, destinations=("process", "fallback"))
Adds optional destinations parameter to StateGraph.add_node() , accepting a dict of target-node→edge-label pairs or a tuple of node names, to declare possible routing paths for visualization. Not checked yet Enables NodeSpec and StateNodeSpec ends field to accept either a tuple of strings or a dict mapping destination node names to edge labels, improving graph rendering fidelity for Command -based edgeless graphs. Not checked yet
2 details in Everything
LangGraph Checkpoint 2.0.12 adds provider-string embedding embedding Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. init and renames MemorySaver to InMemorySaver.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.12 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.12
└──▷ USE IT
Configure a vector store vector store A database built to store embeddings and find the nearest ones to a query quickly. It is the retrieval half of most RAG systems. index with an embedding model embedding model Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. using a provider string instead of a manually constructed embeddings embeddings Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. instance.
python
copy
from langgraph.store.base import IndexConfig
index_config = IndexConfig(
embed="openai:text-embedding-3-small",
dims=1536,
)
Supports initializing embedding models embedding models Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. via provider strings (e.g., "openai:text-embedding-3-small") in IndexConfig.embed, eliminating the need to manually instantiate an embeddings object. Not checked yet Introduces InMemorySaver as the canonical class name for the in-memory checkpoint saver, with MemorySaver retained as a backward-compatible alias. Not checked yet
2 details in Everything
LangGraph 0.2.70 adds parallel tool execution in ReAct agents and graph naming for multi-agent systems.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.70 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.70
└──▷ USE IT
Run tool calls in parallel across multiple ToolNode instances to speed up multi-tool ReAct agents.
python
copy
from langgraph.prebuilt import create_react_agent
agent = create_react_agent(
model=model,
tools=[search, calculator, lookup],
version="v2", # distributes tool calls via the Send API
)
result = agent.invoke({"messages": [{"role": "user", "content": "Compare prices and specs for X and Y"}]})
Name a compiled subgraph so it is identifiable in traces and multi-agent orchestration.
python
copy
from langgraph.graph import StateGraph
builder = StateGraph(MyState)
# ... add nodes and edges ...
graph = builder.compile(name="research-agent")
Name a ReAct agent used as a subgraph so its AIMessages carry an identifiable agent name.
python
copy
from langgraph.prebuilt import create_react_agent
agent = create_react_agent(
model=model,
tools=[search],
name="web-search-agent",
)
Adds version parameter to create_react_agent() enabling parallel tool execution via the Send API (v2) or single-node processing (v1, default). Not checked yet Adds name parameter to Graph.compile() , StateGraph.compile() , and create_react_agent() to identify graphs when used as subgraphs. Not checked yet Automatically attaches agent name to AIMessages generated by the ReAct agent for easier identification in multi-agent workflows. Not checked yet Enables ToolNode to accept direct tool calls as a list of ToolCall dicts. Not checked yet Promotes _inject_tool_args to public method inject_tool_args on ToolNode. Not checked yet
+1 more
show less
Extends RunnableLike type to support injected kwargs such as writer and store via Concatenate and ParamSpec. Not checked yet
6 details in Everything
LangGraph 0.2.69 adds context utilities (get_config, get_store, get_stream_writer), tag support for streamed LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. messages, and optional store in ToolNode.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.69 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.69
└──▷ USE IT
Emit custom progress events from inside a node during streaming without threading store/config through function signatures.
python
copy
from langgraph.config import get_stream_writer
def my_node(state):
writer = get_stream_writer()
writer({"status": "starting scan", "targets": state["targets"]})
# ... do work ...
writer({"status": "complete", "findings": 42})
return state
Access the LangGraph store inside a node to read or write persistent data without passing it explicitly through the graph.
python
copy
from langgraph.config import get_store
def enrich_node(state):
store = get_store()
record = store.get("threat-intel", state["ioc"])
state["intel"] = record.value if record else {}
return state
Give a ToolNode access to the store for lookups during tool execution without making it a required parameter.
python
copy
from langgraph.prebuilt import ToolNode
from langgraph.store.memory import InMemoryStore
store = InMemoryStore()
tool_node = ToolNode(tools=[my_tool], store=store)
Adds get_config() , get_store() , and get_stream_writer() utilities in the new langgraph.config module to access runtime context (config, store, and custom stream writer) from inside any node or task. Not checked yet Adds optional store parameter support in ToolNode, enabling tools to access the LangGraph store without requiring it as a mandatory dependency. Not checked yet Adds tag support in StreamMessagesHandler so streamed LLM messages carry filtered tag metadata (excluding internal sequence-step tags). Not checked yet Adds subgraphs property to PregelNode and subgraphs field to PregelExecutableTask for direct tracking and caching of nested graph references. Not checked yet
4 details in Everything
LangGraph CLI now supports auth configuration in langgraph.json with path validation and Docker container handling.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.70 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.70
└──▷ USE IT
Wire a custom auth handler into your LangGraph deployment so it is validated locally and resolved correctly inside the Docker container.
json
copy
{
"graphs": {
"my_agent": "./agent.py:graph"
},
"auth": {
"path": "./auth/handler.py:auth"
}
}
Supports auth configuration block in langgraph.json, with validation that auth.path follows the required ./path/to/file.py:attribute_name format. Not checked yet Enables auth path resolution in Docker environments via new _update_auth_path function, so auth handlers are correctly wired when deploying containers. Not checked yet
2 details in Everything
LangGraph 0.2.68 promotes the Functional API to Beta and adds a name parameter to the task decorator.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.68 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.68
└──▷ USE IT
Assign a human-readable display name to a task that wraps a lambda or method where the default __name__ would be unhelpful.
python
copy
from langgraph.func import task
@task(name="fetch_user_profile")
def _t(user_id: str) -> dict:
# your implementation
return {"id": user_id}
future = _t("u-123")
result = future.result()
Use the new prompt parameter name in create_react_agent instead of the deprecated state_modifier.
python
copy
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
agent = create_react_agent(
model=ChatOpenAI(model="gpt-4o"),
tools=[...],
prompt="You are a concise security analyst. Answer in bullet points.",
)
result = agent.invoke({"messages": [{"role": "user", "content": "Summarize CVE-2024-1234"}]})
Adds name parameter to the task decorator, allowing custom display names for tasks regardless of the underlying function name. Not checked yet Promotes the Functional API (@task, @entrypoint) from Experimental to Beta status with expanded documentation. Not checked yet Introduces unified SyncAsyncFuture type in langgraph.pregel.call that implements both the Future interface and the awaitable protocol for task return values. Not checked yet Renames state_modifier parameter to prompt in create_react_agent, with full backward compatibility retained. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! Generators are no longer supported in the Functional API (@entrypoint); any entrypoint using a generator function will break on upgrade.
LangGraph CLI now ships PostgreSQL with pgvector enabled for vector operations support.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.69 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.69
Upgrades the bundled PostgreSQL Docker image to pgvector/pgvector:pg16, enabling vector operations in local dev environments. Not checked yet Loads the pgvector extension automatically via shared_preload_libraries=vector in the generated Docker Compose configuration. Not checked yet
2 details in Everything
LangGraph 0.2.67 adds entrypoint.final for separating return vs. checkpointed values and async state modifiers in the chat agent executor.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.67 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.67
└──▷ USE IT
Return a clean response to the caller while persisting richer state to the checkpoint — useful when you want the graph's saved context to differ from what the user receives.
python
copy
from langgraph.func import entrypoint
@entrypoint(checkpointer=checkpointer)
def my_graph(input: str) -> entrypoint.final[str, dict]:
result = run_pipeline(input)
# Return the string to the caller; save the full dict to the checkpoint
return entrypoint.final(value=result["summary"], save=result)
Adds entrypoint.final primitive to return a value to the caller that differs from the value saved in the checkpoint. Not checked yet Supports async coroutine functions as state modifiers in the chat agent executor. Not checked yet Adds thread-safe atomic counters in PregelScratchpad for safer concurrent graph execution. Not checked yet Supports Union types in node function return annotations so add_node correctly extracts Command types. Not checked yet Enhances Command.update with automatic field extraction from type hints on dataclasses and typed objects. Not checked yet
+1 more
show less
Reduces tracing noise by applying recurse=False to internal RunnableCallable instances. Not checked yet
6 details in Everything
└──▷ BREAKING ON UPGRADE
! The CONFIG_KEY_END constant is renamed to CONFIG_KEY_PREVIOUS; any code referencing CONFIG_KEY_END will break.! PregelScratchpad is changed from a TypedDict to a dataclass; code that constructs or unpacks it as a plain dict will break.
LangGraph 0.2.66 adds run_coroutine_threadsafe, explode_args, and trace_inputs for safer async execution and richer tracing.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.66 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.66
└──▷ USE IT
Safely submit a coroutine to a running event loop from a background thread — useful when mixing sync worker threads with an async LangGraph executor.
python
copy
from langgraph.utils.future import run_coroutine_threadsafe
import asyncio
loop = asyncio.get_event_loop()
future = run_coroutine_threadsafe(my_async_task(), loop)
result = future.result(timeout=30)
Customize how inputs appear in LangSmith / callback traces for a multi-step chain without changing runtime behaviour.
python
copy
from langgraph.utils.runnable import RunnableSeq
seq = RunnableSeq(
step_a,
step_b,
trace_inputs=lambda x: {"sanitized_input": x["query"]},
)
result = seq.invoke({"query": "explain RBAC", "user_token": "s3cr3t"})
Adds explode_args parameter to RunnableCallable to unpack a tuple of (args, kwargs) instead of passing it as the first positional argument; affects both invoke and ainvoke methods. Not checked yet Adds trace_inputs parameter to RunnableSeq to customize how inputs are recorded in callbacks across invoke, ainvoke, stream, and astream. Not checked yet Adds run_coroutine_threadsafe function in langgraph.utils.future for safely running coroutines from any thread context. Not checked yet Adds CONTEXT_NOT_SUPPORTED flag in langgraph.utils.future to handle Python versions whose event loops do not support contextvars. Not checked yet Adds get_runnable_for_entrypoint and get_runnable_for_task functions in langgraph.pregel.call for targeted handling of distinct execution contexts. Not checked yet
+4 more
show less
Moves the call function from langgraph.func.__init__ to langgraph.pregel.call for better module organization. Not checked yet Adds _explode_args_trace_inputs utility in langgraph.pregel.call to flatten function arguments in traces for improved debugging. Not checked yet Enhances chain_future in langgraph.utils.future to return the destination future, enabling direct chaining. Not checked yet Removes the restriction in PregelRunner that only coroutine functions could be called in an async context, and adds context detection to return the appropriate future type (async or sync) based on the calling context. Not checked yet
9 details in Everything
LangGraph 0.2.65 adds graph visualization for entrypoint functions and a new get_store() utility for easy store access.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.65 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.65
└──▷ USE IT
Visualize an entrypoint function and all its nested tasks during development or debugging.
python
copy
from langgraph.func import entrypoint, task
@task
def fetch_data(url: str):
...
@entrypoint()
def pipeline(input: dict):
return fetch_data(input["url"]).result()
# pipeline is now an EntrypointPregel
graph = pipeline.get_graph(xray=True)
graph.print_ascii()
Access the configured store inside a node or task without threading config through manually.
python
copy
from langgraph.config import get_store
@task
def save_result(key: str, value: str):
store = get_store()
store.put(("results",), key, {"value": value})
New EntrypointPregel class exposes a get_graph() method to visualize entrypoint functions and their dependent tasks, including nested subgraphs via x-ray mode. Not checked yet New get_store() utility function retrieves the BaseStore from the current config context without manual extraction. Not checked yet Tasks decorated with @task now carry a _is_pregel_task attribute, making them automatically discoverable for graph visualization. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The entrypoint decorator now returns an EntrypointPregel instance instead of a Pregel instance; code that type-checks or depends on the exact return type being Pregel will break.
LangGraph CLI 0.1.68 adds Bun package manager support and clearer JS-graph error guidance.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.68 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.68
Supports Bun as a detected package manager: detects bun.lockb and runs bun i automatically for Bun-based projects. Not checked yet Adds a clear error message when users attempt to run JS graphs with the Python CLI, directing them to use npx @langchain/langgraph-cli instead. Not checked yet
2 details in Everything
LangGraph 0.2.64 adds config schema validation and previous state access to the entrypoint decorator.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.64 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.64
└──▷ USE IT
Enforce a typed config schema on a workflow so callers get validation errors when they pass unexpected config keys.
python
copy
from langgraph.func import entrypoint
from pydantic import BaseModel
class MyConfig(BaseModel):
temperature: float = 0.7
max_tokens: int = 256
@entrypoint(config_schema=MyConfig)
def my_workflow(inputs: dict) -> str:
# config is validated against MyConfig before execution
...
Accumulate state across invocations by reading the last return value via previous — useful for iterative, stateful agent loops.
python
copy
from langgraph.func import entrypoint
@entrypoint()
def my_workflow(inputs: dict, previous: list | None = None) -> list:
history = previous or []
history.append(inputs["message"])
return history
Adds config_schema parameter to the entrypoint decorator, enabling schema validation for workflow configuration. Not checked yet Adds support for an optional previous parameter in entrypoint-decorated functions to access the prior return value in stateful Pregel graphs. Not checked yet Adds automatic input/output type detection from function signatures in the entrypoint decorator, removing the need for manual type annotation wiring. Not checked yet
3 details in Everything
LangGraph 0.2.63 adds subgraph checkpointing, string model IDs in create_react_agent, human-interrupt types, and eager streaming.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.63 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.63
└──▷ USE IT
Enable persistent checkpointing for a subgraph without wiring up a full checkpointer object.
python
copy
subgraph = subgraph_builder.compile(checkpointer=True)
parent = parent_builder.compile(checkpointer=memory_checkpointer)
parent.add_node("sub", subgraph)
Spin up a ReAct agent by referencing a model by string instead of instantiating a model object.
python
copy
from langgraph.prebuilt import create_react_agent
agent = create_react_agent("openai:gpt-4", tools)
Supports checkpointer=True on subgraphs to enable persistent checkpointing without passing a full checkpointer object. Not checked yet Accepts string model identifiers in create_react_agent, e.g. create_react_agent("openai:gpt-4", tools) . Not checked yet Adds structured type definitions for human-in-the-loop human-in-the-loop Human in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. interactions: HumanInterruptConfig, ActionRequest, HumanInterrupt, and HumanResponse in langgraph.prebuilt.interrupt. Not checked yet Adds stream_eager option to langgraph.pregel to force stream events to emit eagerly. Not checked yet Enables method chaining on add_node, add_edge, add_sequence, add_conditional_edges, set_entry_point, set_conditional_entry_point, and set_finish_point via updated Self return types. Not checked yet
+1 more
show less
Allows mixed Command and non-Command types in list commands, removing the requirement that all list items be Command objects. Not checked yet
6 details in Everything
└──▷ BREAKING ON UPGRADE
! get_configurable in langgraph.utils.config is renamed to get_config; any code calling get_configurable will break.
langgraph-checkpoint-postgres 2.0.12 adds task_path tracking to checkpoint writes for better data organization.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.12 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.12
└──▷ USE IT
Tag checkpoint writes with a task path so you can trace which graph node produced each write.
python
copy
await saver.aput_writes(config, writes, task_id, task_path="agent/subgraph")
Adds task_path parameter to put_writes() and aput_writes() on all saver classes (PostgresSaver, AsyncPostgresSaver, ShallowPostgresSaver, AsyncShallowPostgresSaver) to tag checkpoint writes with their originating task path. Not checked yet Extends the checkpoint_writes table schema with a task_path column, enabling path-based ordering and querying of checkpoint write records. Not checked yet
2 details in Everything
LangGraph SQLite checkpointer adds task_path parameter to write-tracking methods for improved task traceability.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointsqlite==2.0.3 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointsqlite==2.0.3
└──▷ USE IT
Tag writes with the originating task path so checkpoint records can be traced back to a specific graph node or subgraph.
python
copy
saver.put_writes(config, writes, task_id, task_path="agent:tool_call")
Do the same in async workflows using the async saver.
python
copy
await async_saver.aput_writes(config, writes, task_id, task_path="agent:tool_call")
Adds optional task_path parameter to SqliteSaver.put_writes() for tracking which task path created a given set of writes. Not checked yet Adds optional task_path parameter to AsyncSqliteSaver.put_writes() and AsyncSqliteSaver.aput_writes() for async task traceability. Not checked yet
2 details in Everything
LangGraph checkpoint 2.0.10 adds task path tracking to put_writes/aput_writes for consistent ordering in nested task graphs.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.10 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.10
└──▷ USE IT
Pass the nested task path when writing checkpoint data so that sends are retrieved in a consistent, hierarchical order in complex subgraph workflows.
python
copy
saver.put_writes(config, writes, task_id, task_path="parent_task/child_task")
Adds task_path parameter to put_writes and aput_writes on BaseCheckpointSaver and InMemorySaver to track the nested path of tasks creating checkpoint writes. Not checked yet Enables deterministic, consistent ordering of pending sends by sorting on task path, task ID, and sequence number during checkpoint retrieval. Not checked yet
2 details in Everything
LangGraph DuckDB checkpointer adds in-memory vector search support
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointduckdb==2.0.2 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointduckdb==2.0.2
LangGraph 0.2.62 adds a response_format parameter to create_react_agent for structured, schema-validated agent outputs.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.62 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.62
└──▷ USE IT
Enforce a typed output schema on a ReAct agent so downstream code can rely on structured data instead of free-form text.
python
copy
from pydantic import BaseModel
from langgraph.prebuilt import create_react_agent
class AgentAnswer(BaseModel):
answer: str
confidence: float
agent = create_react_agent(
model,
tools=[...],
response_format=AgentAnswer,
)
result = agent.invoke({"messages": [("user", "What is the capital of France?")]})
print(result["structured_response"]) # AgentAnswer(answer='Paris', confidence=0.99)
Supply a custom extraction prompt alongside the schema when the default structured-output prompt doesn't fit your domain.
python
copy
from typing import TypedDict
from langgraph.prebuilt import create_react_agent
class Summary(TypedDict):
key_findings: list[str]
risk_level: str
agent = create_react_agent(
model,
tools=[...],
response_format=(
"Extract the security findings and risk level from the conversation.",
Summary,
),
)
result = agent.invoke({"messages": [("user", "Analyze this log: ...")]})
print(result["structured_response"])
Adds response_format parameter to create_react_agent to enforce a schema on final agent output, returned in the structured_response state key. Not checked yet Supports OpenAI function/tool schemas, JSON Schema, TypedDict classes, and Pydantic models as the response schema. Not checked yet Accepts a (prompt, schema) tuple for response_format to supply a custom prompt when generating structured output structured output Forcing a model's response to match a given format or JSON schema, so software can parse it reliably instead of hoping the text is well formed. . Not checked yet
3 details in Everything
LangGraph SDK 0.1.50 adds store authorization handlers and expands Command.update to accept tuple sequences.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.50 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.50
└──▷ USE IT
Use tuple sequences in Command.update when state keys contain ordering semantics or you're building updates dynamically.
python
copy
from langgraph.types import Command
updates = [("messages", new_message), ("turn_count", 5)]
cmd = Command(update=updates)
Adds auth.on.store decorators to authorize store operations (put, get, search, list_namespaces, delete) at the handler level. Not checked yet Introduces new TypedDict classes — StoreGet, StoreSearch, StoreListNamespaces, StorePut, StoreDelete — for typed store operation authorization. Not checked yet Expands Command.update to accept sequences of tuples in addition to dictionaries, enabling more flexible graph state updates. Not checked yet
3 details in Everything
LangGraph 0.2.61 adds OpenAI-format message conversion to add_messages and a more flexible task decorator with async support.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.61 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.61
└──▷ USE IT
Ensure all messages stored in a graph state channel are automatically normalized to OpenAI format (string, text , image_url blocks) before passing to an OpenAI-compatible LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. .
python
copy
from langgraph.graph.message import add_messages
from typing import Annotated
from typing_extensions import TypedDict
class State(TypedDict):
messages: Annotated[list, add_messages(format="langchain-openai")]
Wrap an async function as a LangGraph task using the decorator directly without parentheses — useful for fire-and-forget subtasks in a functional graph.
python
copy
from langgraph.func import task
@task
async def fetch_data(url: str, timeout: int = 30) -> dict:
# async I/O here
...
Adds format="langchain-openai" parameter to add_messages to automatically convert message content (strings, text blocks, image_url blocks) to OpenAI-compatible format. Not checked yet Enables add_messages as a partial function when called without arguments, improving flexibility in type annotations. Not checked yet Rewrites the task decorator to support both direct (@task) and parameterized (@task(...) ) usage, with proper coroutine detection and wrapping for async functions. Not checked yet Expands task decorator function signature to accept *args and **kwargs and adds overloads for better IDE type inference. Not checked yet
4 details in Everything
LangGraph Postgres checkpointer adds ShallowPostgresSaver and AsyncShallowPostgresSaver for lightweight, history-free checkpoint storage.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.9 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.9
Adds ShallowPostgresSaver, a drop-in replacement for PostgresSaver that stores only the most recent checkpoint, reducing storage when time travel is not needed. Not checked yet Adds AsyncShallowPostgresSaver, the async counterpart to ShallowPostgresSaver, with the same lightweight storage semantics and a full async interface. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The batch method has been removed from AsyncPostgresStore; callers must switch to abatch instead.
LangGraph SDK 0.1.48 adds StudioUser class for fine-grained authorization control over LangGraph Studio UI access.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.48 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.48
└──▷ USE IT
Gate a resource to non-Studio users only — useful when you want to block Studio UI access to sensitive operations in production.
python
copy
from langgraph_sdk.auth.types import StudioUser
def my_auth_handler(user, action, resource):
if isinstance(user, StudioUser):
raise PermissionError("Studio users cannot access this resource")
return True
Disable Studio authentication entirely for environments where Studio UI access should be unrestricted.
json
copy
{
"disable_studio_auth": true
}
Adds StudioUser class in langgraph_sdk/auth/types.py representing authenticated users from the LangGraph Studio UI, exposing properties for username, display name, identity, permissions, and auth status. Not checked yet Enables custom authorization handlers to branch on Studio vs. non-Studio users via isinstance(user, StudioUser) checks. Not checked yet Supports disabling Studio authentication entirely via disable_studio_auth: true in langgraph.json. Not checked yet
3 details in Everything
LangGraph 0.2.60 makes Command.update accept any type and relaxes tool node validation for multi-message responses.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.60 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.60
└──▷ USE IT
Pass a custom non-dict value (e.g. a string or dataclass) through Command.update when routing between nodes — previously impossible without wrapping in a dict.
python
copy
from langgraph.types import Command
# Now valid: update can be any type, including None or a plain string
cmd = Command(goto="next_node", update="my_custom_payload")
Return multiple tool messages from a tool node (e.g. for logging + result) without triggering a validation error, as long as one message matches the tool call ID.
python
copy
from langchain_core.messages import ToolMessage
from langgraph.types import Command
# Both messages returned; validation passes because one has the matching tool_call_id
cmd = Command(
update={
"messages": [
ToolMessage(content="debug info", tool_call_id="other-id"),
ToolMessage(content="actual result", tool_call_id="call-123"),
]
}
)
Extends Command.update to accept any type of value (not just dicts or sequences of tuples), including None , enabling more diverse node-to-node command patterns. Not checked yet Relaxes prebuilt tool_node validation to allow multiple tool messages in a command update, requiring only that at least one message matches the tool call ID. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The default value of Command.update changed from () (empty tuple) to None ; code that checks if command.update == () or relies on the empty-tuple default will behave differently.
LangGraph SDK 0.1.47 simplifies auth handlers and renames scopes to permissions in the Auth module.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.47 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.47
└──▷ USE IT
Return a user object directly from an auth handler instead of the old (scopes, user) tuple pattern.
python
copy
from langgraph_sdk.auth import Auth
auth = Auth()
@auth.authenticate
async def authenticate(authorization: str) -> dict:
user_id = verify_token(authorization) # your token logic
return {"identity": user_id, "permissions": ["runs:create", "threads:read"]}
Simplifies authentication handler return type: handlers now return a user representation directly (string, dict, or object) instead of a (scopes, user) tuple. Not checked yet Adds permissions field to MinimalUserDict and permissions property to the BaseUser interface in Auth.types. Not checked yet Updates Authenticator type signature to reflect the new single-object return format. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The scopes field/property is renamed to permissions throughout the Auth module — any code referencing scopes on auth objects or MinimalUserDict will break.! Authentication handlers must now return a single user representation (string, dict with identity/permissions, or compatible object) instead of a tuple of (scopes, user).
LangGraph CLI now validates dependencies in configuration, with graceful fallback when the field is absent.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.64 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.64
Adds dependencies field validation to validate_config, ensuring dependency declarations are checked and included during config processing. Not checked yet
1 detail in Everything
LangGraph SDK 0.1.46 adds HTTPException to auth handlers for precise HTTP error control
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.46 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.46
└──▷ USE IT
Return a 403 with a custom message from an auth handler instead of the default 401 Unauthorized.
python
copy
from langgraph_sdk import Auth
auth = Auth()
@auth.authenticate
async def my_auth_handler(token: str):
if not is_valid(token):
raise auth.exceptions.HTTPException(
status_code=403,
detail="You do not have permission to access this resource."
)
return {"user": decode(token)}
Adds HTTPException class to Auth.exceptions, letting auth handlers return custom HTTP status codes, error messages, and headers instead of generic failures. Not checked yet Exposes exceptions module on the Auth class for clean, importable access to auth-related exception types. Not checked yet
2 details in Everything
LangGraph CLI 0.1.63 adds OpenAPI OpenAPI A vendor-neutral specification for describing REST APIs in a machine-readable format, maintained by the OpenAPI Initiative. Cyber tools use it to auto-generate clients, documentation, and validation from a single source of truth. security scheme configuration to AuthConfig for customizing API auth settings.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.63 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.63
Adds SecurityConfig TypedDict class for defining OpenAPI security schemes and requirements in authentication config. Not checked yet Extends AuthConfig with a new openapi field of type SecurityConfig, enabling customization of API security settings such as OAuth2 OAuth2 An open authorization framework (RFC 6749) that lets a service grant limited access to a user's resources on another service without exposing credentials, giving cyber tools a standard way to authenticate against third-party APIs. scopes and token endpoints. Not checked yet
2 details in Everything
LangGraph CLI 0.1.62 adds auth configuration support for LangGraph Studio with a new AuthConfig type.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.62 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.62
└──▷ USE IT
Disable Studio's built-in auth and point to a custom auth handler when running the dev server locally.
json
copy
# langgraph.json
{
"auth": {
"path": "./my_auth.py:handler",
"disable_studio_auth": true
}
}
New AuthConfig TypedDict with path and disable_studio_auth fields enables custom authentication configuration for LangGraph Studio. Not checked yet New auth field on the main Config TypedDict wires auth settings into config validation and Docker environment generation. Not checked yet The dev command now accepts auth configuration, allowing Studio auth to be controlled at dev-server launch time. Not checked yet
3 details in Everything
LangGraph SDK 0.1.45 adds an Auth class with decorator-based authentication and fine-grained per-resource authorization.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.45 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.45
└──▷ USE IT
Protect all LangGraph resources with a global auth handler that validates a bearer token bearer token A credential that grants access to whoever presents it, without a separate proof of possession. Protecting the token matters because a stolen copy can be used by someone else. and returns user scopes.
python
copy
from langgraph_sdk import Auth
auth = Auth()
@auth.authenticate
async def verify_token(token: str):
# validate token and return user scopes
user = await my_token_validator(token)
return {"id": user.id, "scopes": user.scopes}
@auth.on
async def global_handler(ctx, value):
# allow only requests where the resource owner matches the caller
if ctx.user.id != value.get("owner"):
raise Auth.exceptions.HTTPException(status_code=403)
Apply a resource-specific rule so only thread owners can read their own threads, while leaving other resources on the global handler.
python
copy
from langgraph_sdk import Auth
auth = Auth()
@auth.on.threads.read
async def restrict_thread_reads(ctx, value):
# inject a filter so the query only returns threads owned by the caller
return {"owner": ctx.user.id}
Adds Auth class providing a unified authentication and authorization system for LangGraph applications. Not checked yet Supports decorator-based auth handlers to verify credentials and return user scopes. Not checked yet Enables fine-grained access control per resource (threads, assistants, crons) and per action (create, read, update, delete, search). Not checked yet Implements a hierarchical handler system supporting global fallback handlers alongside specific per-action handlers. Not checked yet Introduces a new types module with typed dictionaries (e.g., ThreadsCreate, AssistantsRead), protocol definitions for user objects and auth handlers, and strongly-typed context objects. Not checked yet
5 details in Everything
LangGraph 0.2.59 enables config-aware tool execution by passing configuration to prebuilt tool node invocations.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.59 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.59
LangGraph 0.2.58 adds string node names in Command.goto and richer config metadata with defaults and descriptions.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.58 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.58
└──▷ USE IT
Route to a node by name directly in Command.goto instead of wrapping it in a Send object.
python
copy
from langgraph.types import Command
# Previously required Send; now a plain string works
def my_node(state):
return Command(goto="approval_node")
Inspect richer config metadata — including defaults and descriptions — for a compiled graph.
python
copy
from langgraph.utils.fields import get_enhanced_type_hints
# Get type hints plus defaults and descriptions for a config schema
hints = get_enhanced_type_hints(MyConfigSchema)
print(hints)
Supports string values in Command.goto, enabling direct node-name references instead of requiring Send objects for state transitions. Not checked yet Adds get_enhanced_type_hints utility to extract type hints along with default values and descriptions, covering Pydantic models, TypedDict, and dataclasses. Not checked yet Enriches Pregel.config_specs output with default values and descriptions for configuration fields via get_enhanced_type_hints. Not checked yet
3 details in Everything
LangGraph 0.2.57 adds a functional API with @task/@entrypoint decorators and lets tools return Command objects.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.57 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.57
└──▷ USE IT
Run two LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. calls in parallel inside a functional-API workflow — use @task so both futures resolve concurrently, then collect results in the @entrypoint.
python
copy
from langgraph.func import task, entrypoint
@task
def call_model_a(prompt: str) -> str:
return llm_a.invoke(prompt)
@task
def call_model_b(prompt: str) -> str:
return llm_b.invoke(prompt)
@entrypoint()
def compare_models(prompt: str) -> dict:
future_a = call_model_a(prompt)
future_b = call_model_b(prompt)
return {"a": future_a.result(), "b": future_b.result()}
result = compare_models.invoke("Explain quantum entanglement")
Return a Command from a tool to redirect graph control flow — now supported directly in ToolNode without extra wiring.
python
copy
from langchain_core.tools import tool
from langgraph.types import Command
@tool
def escalate_to_human(reason: str) -> Command:
"""Escalate the conversation to a human agent."""
return Command(goto="human_node", update={"escalation_reason": reason})
# Register with ToolNode as usual — Command routing is handled automatically
from langgraph.prebuilt import ToolNode
tool_node = ToolNode([escalate_to_human])
Adds @task decorator (langgraph.func.task) for creating parallel async tasks that return futures, with optional retry policies. Not checked yet Adds @entrypoint decorator (langgraph.func.entrypoint) to wrap regular or generator functions into Pregel graphs as callable entry points. Not checked yet Enables Command objects to be returned directly from LangChain tools via ToolOutputMixin compatibility and ToolNode support. Not checked yet Adds StateGraph support for lists of Command objects and tuple-based state updates in node outputs. Not checked yet Adds _repr_mimebundle_ to Graph for inline Mermaid diagram visualization in Jupyter notebooks. Not checked yet
5 details in Everything
LangGraph SDK 0.1.43 adds query-param streaming and expands Command routing flexibility
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.43 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.43
└──▷ USE IT
Filter a streaming run by passing query parameters directly on the stream call, avoiding manual URL construction.
python
copy
async for chunk in client.stream(
assistant_id,
thread_id,
input=input_data,
params={"my_filter": "value", "limit": 10},
):
print(chunk)
Route a command to multiple destinations using the expanded goto field that now accepts a sequence of Send objects or node-name strings.
python
copy
from langgraph.types import Command, Send
cmd = Command(goto=[Send("node_a", {"x": 1}), "node_b"])
Adds optional params argument to HttpClient.stream() (async and sync) so query parameters can be passed with streaming requests. Not checked yet Expands Command TypedDict's goto field to accept Send , str, or a sequence of either, enabling richer graph routing in command structures. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The Command TypedDict field send is renamed to goto; any code referencing Command(send=...) will break on upgrade.
LangGraph 0.2.55 overhauls interrupt/resume with scratchpad tracking and consolidates Send into the goto field
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.55 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.55
└──▷ USE IT
Pass both a static node name and a dynamic Send object in a single Command, now that goto accepts both types.
python
copy
from langgraph.types import Command, Send
# Route to a named node and dynamically send a message to another node
cmd = Command(goto=["review_node", Send("process_node", {"input": data})])
Handle multiple sequential interrupts inside one node reliably — the rewritten interrupt function tracks counts so each resume value is matched correctly.
python
copy
from langgraph.types import interrupt
def my_node(state):
first_answer = interrupt("Please provide your name")
second_answer = interrupt("Please provide your role")
return {"name": first_answer, "role": second_answer}
Adds CONFIG_KEY_WRITES constant exposing a read-only list of existing task writes to task configuration Not checked yet Adds CONFIG_KEY_SCRATCHPAD constant providing temporary storage scoped to the current task Not checked yet Rewrites the interrupt function with interrupt-count tracking to correctly handle multiple interrupts within the same node Not checked yet Enables goto field on Command to accept both string node names and Send objects, unifying send/goto into one API Not checked yet Deduplicates writes to special channels in PregelLoop.put_writes (last write wins) Not checked yet
5 details in Everything
└──▷ BREAKING ON UPGRADE
! The send field is removed from the Command class; any code passing send= to Command will break — use goto instead.! The CONFIG_KEY_RESUME_VALUE constant is removed; code referencing it directly will break — use CONFIG_KEY_WRITES and CONFIG_KEY_SCRATCHPAD instead.
LangGraph 0.2.54 adds parent-graph command routing, empty-tool ReAct agents, and Command input support for RemoteGraph.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.54 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.54
└──▷ USE IT
Send a command from a subgraph node up to the parent graph to update parent state or redirect control flow.
python
copy
from langgraph.types import Command
def subgraph_node(state):
# Direct this command at the parent graph instead of the current one
return Command(goto="some_parent_node", update={"status": "delegated"}, graph=Command.PARENT)
Build a zero-tool ReAct agent for pure LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. reasoning tasks where no external tools are needed.
python
copy
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
agent = create_react_agent(ChatOpenAI(model="gpt-4o"), tools=[])
result = agent.invoke({"messages": [{"role": "user", "content": "Summarise the history of cryptography."}]})
Pass a Command object directly into a RemoteGraph to resume or redirect a running remote workflow.
python
copy
from langgraph.pregel.remote import RemoteGraph
from langgraph.types import Command
remote = RemoteGraph("my-deployed-graph", url="https://my-langgraph-server")
for chunk in remote.stream(Command(goto="review_node", update={"approved": True}), config={"thread_id": "abc123"}):
print(chunk)
Adds Command.PARENT constant ("__parent__") and a graph field on Command so nodes in a subgraph can route commands up to the parent graph. Not checked yet Adds GraphBubbleUp base exception class and new ParentCommand exception to propagate parent-directed commands cleanly through the graph hierarchy. Not checked yet Enables create_react_agent to accept an empty tools list, producing a simple LLM-only graph without tool-calling tool-calling A model's ability to answer with a structured request to run a named function or API, which the application executes and returns. It is how agents take actions. plumbing. Not checked yet Enables RemoteGraph.stream and RemoteGraph.invoke to accept Command objects directly as input, with pass-through of additional client kwargs. Not checked yet Graph validation now only requires at least one edge from START; unreachable nodes no longer cause a validation error. Not checked yet
+1 more
show less
Adds Python 3.11+ exception notes in retry mechanisms for richer error diagnostics when tasks fail. Not checked yet
6 details in Everything
LangGraph SDK 0.1.42 adds run status filtering, cancel-on-disconnect streaming, and command support in assistant APIs.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.42 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.42
└──▷ USE IT
List only runs that are currently pending or running — useful for building dashboards or cleanup scripts that act on in-progress work.
python
copy
runs = await client.runs.list(thread_id="<thread_id>", status="pending")
Stream a run and ensure it is automatically cancelled server-side if your client drops the connection, preventing orphaned background work.
python
copy
async for chunk in client.runs.join_stream(thread_id="<thread_id>", run_id="<run_id>", cancel_on_disconnect=True):
print(chunk)
Pass a command to an assistant stream to steer execution dynamically at invocation time.
python
copy
async for chunk in client.assistants.stream(assistant_id="<assistant_id>", command=<command>):
print(chunk)
Adds status parameter to RunsAPI.list() to filter runs by execution status. Not checked yet Adds cancel_on_disconnect parameter to RunsAPI.join_stream() to automatically cancel a run when the client disconnects from the stream. Not checked yet Adds command parameter to AssistantAPI.stream() , .create() , and .wait() for finer control over assistant execution. Not checked yet Adds Interrupt type definition and exposes interrupt information on the Thread schema for improved interrupt handling. Not checked yet
4 details in Everything
langgraph-checkpoint-postgres 2.0.7 adds configurable vector indices (HNSW HNSW Hierarchical Navigable Small World, a graph index that finds approximate nearest neighbours among millions of vectors in milliseconds. Most vector databases use it by default. , IVFFlat, flat) and improved vector search ordering.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.7 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.7
└──▷ USE IT
Use an IVFFlat index with a custom cluster count when you have a large embedding embedding Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. dataset and want to trade recall for speed.
python
copy
from langgraph.store.postgres.base import ANNIndexConfig, IVFFlatConfig
index_config = ANNIndexConfig(
kind="ivfflat",
ann_index_config=IVFFlatConfig(nlist=256),
)
Adds ANNIndexConfig with a kind field to select vector index type: 'hnsw', 'ivfflat', or 'flat'. Not checked yet Adds HNSWConfig class for tuning HNSW indices via m (max connections per layer) and ef_construction (dynamic candidate list size). Not checked yet Adds IVFFlatConfig class for tuning IVFFlat indices via nlist (number of inverted lists/clusters). Not checked yet Adds automatic vector index creation in BasePostgresStore based on the supplied index configuration. Not checked yet Adds condition field to Migration to support conditional migration execution based on store configuration. Not checked yet
5 details in Everything
LangGraph CLI adds --wait-for-client flag for blocking debug startup and isolates store config into LANGGRAPH_STORE.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.61 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.61
└──▷ TRY IT
Pause the dev server at startup until your IDE debugger attaches, so you can set breakpoints before any graph code runs.
copy
$ langgraph dev --debug-port 5678 --wait-for-client
Adds --wait-for-client flag to the dev command that, combined with --debug-port, pauses server startup until a debugger client connects. Not checked yet Introduces dedicated LANGGRAPH_STORE environment variable for store configuration in Docker environments, replacing the previous embedding embedding Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. inside LANGGRAPH_CONFIG. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! Store configuration in Docker environments is now passed via LANGGRAPH_STORE instead of LANGGRAPH_CONFIG; any tooling or scripts that read store config from LANGGRAPH_CONFIG will no longer receive it there.
langgraph-checkpoint-postgres 2.0.5 adds pgvector-powered semantic search semantic search Searching by meaning rather than requiring the same words. It commonly compares vector representations to find related content, even when the wording differs. to PostgreSQL-backed LangGraph stores.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.5 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.5
Adds PostgresIndexConfig class to configure pgvector-backed vector search with configurable dimensions, distance metrics (l2, inner_product, cosine), and vector types (vector, halfvec). Not checked yet Enables vector similarity search and embedding embedding Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. -based document indexing and retrieval in BasePostgresStore. Not checked yet Adds async embedding and vector search support to AsyncPostgresStore for non-blocking document indexing and retrieval. Not checked yet Introduces _row_to_search_item to surface similarity scores as float values alongside search results. Not checked yet
4 details in Everything
LangGraph CLI 0.1.60 adds vector store vector store A database built to store embeddings and find the nearest ones to a query quickly. It is the retrieval half of most RAG systems. configuration with embedding embedding Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. specs, enabling semantic search semantic search Searching by meaning rather than requiring the same words. It commonly compares vector representations to find related content, even when the wording differs. in LangGraph projects.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.60 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.60
└──▷ USE IT
Configure a vector store with an embedding model embedding model Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. in your LangGraph project config to enable semantic search over stored data.
python
copy
from langgraph_cli.config import IndexConfig, StoreConfig
store = StoreConfig(
index=IndexConfig(
dims=1536,
embed="openai:text-embedding-3-small",
fields=["text", "description"],
)
)
Adds IndexConfig and StoreConfig configuration types to specify vector embedding dimensions (dims), model selection (embed), and custom field extraction (fields) for semantic search. Not checked yet Enables the dev command to pass store configuration from config.json to the LangGraph server at runtime. Not checked yet Supports store settings in Docker container deployments via environment variable pass-through. Not checked yet Adds python-dotenv as an optional dependency for environment variable management. Not checked yet
4 details in Everything
LangGraph SDK 0.1.40 adds natural language search to the store with relevance scoring and fine-grained index control.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.40 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.40
└──▷ USE IT
Run a natural language query against the store and inspect relevance scores to surface the most pertinent items.
python
copy
results = await client.store.search_items(namespace, query="latest customer complaints about billing")
for item in results.items:
print(item.score, item.key, item.value)
Store an item while limiting indexing to specific fields, reducing noise in semantic search semantic search Searching by meaning rather than requiring the same words. It commonly compares vector representations to find related content, even when the wording differs. results.
python
copy
await client.store.put_item(namespace, key="user-42", value={"name": "Alice", "notes": "VIP customer", "internal_id": 99}, index=["name", "notes"])
Exclude a sensitive item from search indexing entirely so it cannot be surfaced via natural language queries.
python
copy
await client.store.put_item(namespace, key="secret-config", value={"api_key": "s3cr3t"}, index=False)
Adds query parameter to search_items (sync and async) enabling natural language search over stored items. Not checked yet Introduces SearchItem class extending Item with an optional score field, so callers can rank results by relevance. Not checked yet Updates SearchItemsResponse to return list[SearchItem] instead of list[Item], surfacing relevance scores in all search results. Not checked yet Adds index parameter to put_item (sync and async) to control per-item indexing: None for default, False to skip indexing, or a list[str] of field paths to index selectively. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! SearchItemsResponse now returns list[SearchItem] instead of list[Item]; code that type-checks or pattern-matches on Item from search results will need updating.
LangGraph checkpoint 2.0.7 adds vector/semantic search semantic search Searching by meaning rather than requiring the same words. It commonly compares vector representations to find related content, even when the wording differs. to stores, richer query filters, and embedding embedding Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. utilities.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.7 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.7
└──▷ USE IT
Enable semantic search on an in-memory store so an agent can retrieve memories by meaning rather than exact key.
python
copy
from langgraph.store.memory import InMemoryStore
from langgraph.store.base import IndexConfig
from langchain_openai import OpenAIEmbeddings
store = InMemoryStore(
index=IndexConfig(
dims=1536,
embed=OpenAIEmbeddings(model="text-embedding-3-small"),
fields=["text", "summary"],
)
)
# Store an item (indexed by default)
await store.aput(("users", "alice"), "mem-1", {"text": "Alice prefers dark mode."})
# Retrieve semantically similar items
results = await store.asearch(("users", "alice"), query="UI preferences", limit=5)
for item in results:
print(item.key, item.score, item.value)
Wrap a custom embedding function (e.g. a local model) into LangChain's interface so it works with IndexConfig.
python
copy
from langgraph.store.base.embed import ensure_embeddings
import numpy as np
def my_embed(texts: list[str]) -> list[list[float]]:
# Replace with your local model call
return [np.random.rand(768).tolist() for _ in texts]
embeddings = ensure_embeddings(my_embed)
from langgraph.store.base import IndexConfig
config = IndexConfig(dims=768, embed=embeddings)
Use comparison-operator filters alongside a semantic query to narrow store search results to recent, high-relevance items.
python
copy
results = await store.asearch(
("projects", "sec-team"),
query="privilege escalation techniques",
filter={"severity": {"$gt": 7}, "status": {"$eq": "open"}},
limit=10,
)
for item in results:
print(item.key, item.score, item.value["severity"])
Adds semantic similarity search to BaseStore via an updated search/asearch interface that returns ranked SearchItem instances with a score field. Not checked yet Introduces IndexConfig class to configure vector search settings — embedding dimensions, embedding function, and which fields to index — per store. Not checked yet Adds index parameter to put/aput (and PutOp) to control per-item vector indexing: use default indexing, disable with False , or specify custom field paths. Not checked yet Adds query parameter to SearchOp for natural-language semantic search alongside existing namespace/filter queries. Not checked yet Enhances query filtering in SearchOp with comparison operators ($eq, $gt, $lt, and others) including support for nested fields and array path expressions. Not checked yet
+3 more
show less
Adds ensure_embeddings utility to wrap any sync or async embedding function into LangChain's Embeddings Embeddings Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. interface, plus EmbeddingsFunc/AEmbeddingsFunc type definitions. Not checked yet Adds get_text_at_path and tokenize_path utilities for extracting text from nested objects using path expressions with support for wildcards, array indexing, and multi-field selection. Not checked yet Rewrites InMemoryStore with full vector search support and optional NumPy acceleration for vector operations. Not checked yet
8 details in Everything
└──▷ BREAKING ON UPGRADE
! NameSpacePath is renamed to NamespacePath; code importing or referencing NameSpacePath will break.! search and asearch on BaseStore now return SearchItem instances instead of plain Item instances; code that expects Item objects from these methods may break.
langgraph-checkpoint-postgres 2.0.4 adds connection pooling, pipeline optimization, and last-write-wins deduplication for Postgres stores.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.4 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.4
New PoolConfig TypedDict in langgraph.store.postgres.base lets you configure min/max connections and extra connection parameters for PostgreSQL connection pools. Not checked yet Adds connection pooling support to both PostgresStore and AsyncPostgresStore for improved throughput under high concurrency. Not checked yet Adds pipelined database operations to PostgresStore and AsyncPostgresStore, batching queries for higher throughput. Not checked yet Adds last-write-wins deduplication semantics for concurrent operations on the same key in PostgresStore. Not checked yet Adds thread locking (PostgresStore) and async locks (AsyncPostgresStore) for safe concurrent access. Not checked yet
+1 more
show less
Improves inheritance support in PostgresSaver and AsyncPostgresSaver by using cls instead of hardcoded class names, enabling reliable subclassing. Not checked yet
6 details in Everything
LangGraph checkpoint 2.0.6 adds async namespace listing and batch operation deduplication to AsyncBatchedBaseStore.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.6 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.6
└──▷ USE IT
Discover which namespaces exist in your store, filtered by prefix and bounded by depth — useful for auditing or scoping operations in multi-tenant graphs.
python
copy
namespaces = await store.alist_namespaces(prefix=("user", "alice"), depth=3, limit=50)
Adds alist_namespaces method to AsyncBatchedBaseStore for querying namespaces with filtering by prefix, suffix, depth, and pagination. Not checked yet Improves batch performance in AsyncBatchedBaseStore via a new _dedupe_ops function that deduplicates identical get/search operations and consolidates multiple puts to the same key. Not checked yet Extends CheckpointMetadata.source to accept "fork" as a valid value, identifying checkpoints created as copies of other checkpoints. Not checked yet
3 details in Everything
LangGraph CLI dev command now auto-loads config-file dependencies onto Python's path
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.59 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.59
Enables the dev command to read the dependencies field from the config file and add those directories to Python's path automatically. Not checked yet Automatically adds the current working directory to Python's path when running the dev command, allowing seamless local module imports. Not checked yet
2 details in Everything
LangGraph CLI 0.1.58 adds env parameter to pass environment variables from config file to the dev server.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.58 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.58
└──▷ USE IT
Set environment variables in your LangGraph config so they are automatically available when running the dev server — no need to export them separately in your shell.
yaml
copy
env:
OPENAI_API_KEY: "sk-..."
MY_CUSTOM_VAR: "value"
LangGraph CLI 0.1.56 adds Python 3.13 support and Node.js/package.json compatibility validation.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.56 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.56
└──▷ USE IT
Programmatically load and validate a langgraph config file (replaces separate load + validate calls).
python
copy
from langgraph_cli.config import validate_config_file
config = validate_config_file("langgraph.json")
Supports Python 3.13 as a valid runtime in langgraph-cli config. Not checked yet Adds validate_config_file() function that loads and validates config files in a single call. Not checked yet Validates Node.js version compatibility against package.json when present in a project. Not checked yet Introduces MIN_NODE_VERSION and MIN_PYTHON_VERSION constants for centralized version requirement enforcement. Not checked yet
4 details in Everything
LangGraph CLI gains a langgraph dev command for running the API server in development mode with hot reloading.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.55 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.55
└──▷ TRY IT
Spin up a hot-reloading local LangGraph API server during development without launching a browser, binding to a custom port.
copy
$ langgraph dev --port 8123 --no-browser --config langgraph.json
Install the CLI with in-memory API support to run langgraph dev without a full backend dependency.
copy
$ pip install "langgraph-cli[inmem]"
New langgraph dev command runs the LangGraph API server in development mode with hot reloading and options for --host, --port, --no-reload, --config, --n-jobs-per-worker, --no-browser, and --debug-port. Not checked yet New inmem extras entry enables lightweight in-memory API support via pip install "langgraph-cli[inmem]". Not checked yet
2 details in Everything
LangGraph 0.2.51 adds checkpoint forking to Pregel via a new __copy__ node.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.51 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.51
LangGraph checkpoint 2.0.5 adds disk-persistent checkpoints via PersistentDict and a configurable MemorySaver storage backend.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.5 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.5
└──▷ USE IT
Persist agent checkpoints to disk across process restarts instead of losing state when the process exits.
python
copy
from langgraph.checkpoint.memory import MemorySaver, PersistentDict
with MemorySaver(factory=lambda: PersistentDict("/tmp/checkpoints.pkl")) as saver:
# compile and run your graph with `saver` as the checkpointer
graph = my_graph.compile(checkpointer=saver)
graph.invoke({"messages": []}, config={"configurable": {"thread_id": "session-1"}})
New PersistentDict class provides dictionary-like checkpoint storage backed by disk, using atomic writes for data safety. Not checked yet Adds a factory parameter to MemorySaver to swap in custom storage backends, including the new PersistentDict. Not checked yet
2 details in Everything
LangGraph 0.2.50 adds the ability to create snapshot checkpoints without modifying graph state.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.50 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.50
└──▷ USE IT
Capture a mid-execution snapshot of a running graph without altering its state, useful for audit trails or rollback points.
python
copy
await graph.aupdate_state(config, values=None, as_node=None)
Enables creating checkpoint snapshots mid-execution via aupdate_state without applying any state changes (pass values=None, as_node=None). Not checked yet
1 detail in Everything
LangGraph 0.2.49 adds checkpoint copying and a debug parameter to graph execution loops.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.49 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.49
└──▷ USE IT
Snapshot the current graph checkpoint without modifying state — useful before a risky branch of execution.
python
copy
graph.update_state(config, values=None, as_node=None)
Supports copying the current checkpoint by calling update_state with both values=None and as_node=None. Not checked yet Adds a debug parameter to loop creation in Pregel for improved visibility into graph execution. Not checked yet
2 details in Everything
LangGraph CLI gains a new project scaffolding command, Docker Compose generation, and five built-in agent templates.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.54 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.54
└──▷ TRY IT
Bootstrap a new ReAct-style agent project without writing boilerplate — pick a template interactively and start coding immediately.
copy
$ langgraph new my-agent-project
Generate a full local-dev stack (Dockerfile + docker-compose.yml + .env + .dockerignore) in one shot so you can docker compose up right away.
copy
$ langgraph dockerfile --add-docker-compose langgraph.json
Adds new command to scaffold LangGraph projects interactively from five built-in templates (minimal chatbot, ReAct Agent, Memory Agent, Retrieval Agent, Data-enrichment Agent). Not checked yet Adds --add-docker-compose flag to the dockerfile command, generating a docker-compose.yml, .env, and .dockerignore alongside the Dockerfile. Not checked yet Adds --version flag to display the installed CLI version. Not checked yet
3 details in Everything
langgraph-checkpoint 2.0.4 adds INTERRUPT and RESUME constants to support graph execution interruption and resumption.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.4 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.4
└──▷ USE IT
Reference the new constants when inspecting or filtering checkpoint writes for interrupt/resume events.
python
copy
from langgraph.checkpoint.serde.types import INTERRUPT, RESUME
# Check whether a checkpoint write corresponds to an interrupt or resume
def is_interrupt_write(write):
return write.channel in (INTERRUPT, RESUME)
Adds INTERRUPT and RESUME constants to langgraph.checkpoint.serde.types, enabling interrupt and resume operations in graph execution checkpointing. Not checked yet Reserves checkpoint write index values -3 and -4 for interrupt and resume operation types in WRITES_IDX_MAP. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The CommandProtocol class has been removed from langgraph.checkpoint.serde.types and its serialization handling dropped from JsonPlusSerializer; any code referencing CommandProtocol will break on upgrade.
LangGraph SDK 0.1.36 adds Command-based graph control, rollback cancellation, and a new messages-tuple stream mode.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.36 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.36
└──▷ USE IT
Resume a paused run at a specific node or inject a value mid-graph without supplying new top-level input.
python
copy
async for chunk in client.runs.stream(
thread_id,
assistant_id,
command={"resume": "user_approved"},
stream_mode="messages-tuple",
):
print(chunk)
Roll back all side-effects of a run when cancelling, rather than just interrupting it in place.
python
copy
await client.runs.cancel(thread_id, run_id, action="rollback")
Adds command parameter to stream() , create() , and wait() run methods, enabling direct node interaction and state manipulation without requiring input. Not checked yet Adds new Command type with send, update, and resume operations for fine-grained graph execution control. Not checked yet Adds Send typed dictionary to support direct node targeting during runs. Not checked yet Enhances cancel() with a new action parameter supporting "interrupt" (default) or "rollback" modes to control cancellation behavior. Not checked yet Adds CancelAction type to the schema to back the new cancellation modes. Not checked yet
+1 more
show less
Adds "messages-tuple" as a new StreamMode literal option. Not checked yet
6 details in Everything
└──▷ BREAKING ON UPGRADE
! running has been removed from RunStatus literals, which will break any code that checks for or matches against that status value.
LangGraph 0.2.47 adds resumable interrupts via a new interrupt() function and Command(resume=…) parameter.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.47 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.47
└──▷ USE IT
Pause a node mid-graph for human-in-the-loop human-in-the-loop Human in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. approval, then resume it with the reviewer's decision.
python
copy
from langgraph.types import interrupt, Command
def review_node(state):
# Pause execution and surface data to the caller
decision = interrupt({"payload": state["draft"], "prompt": "Approve this draft?"})
# Execution resumes here once Command(resume=...) is issued
return {"approved": decision}
# From outside the graph, resume after the interrupt:
graph.invoke(Command(resume=True), config=config)
Adds interrupt() function in langgraph.types enabling nodes to pause and later resume with specific values, with namespace tracking for accurate resumption. Not checked yet Adds a resume parameter to the Command class to control resumption of graph execution after an interrupt. Not checked yet Adds RESUME constant in langgraph.constants to identify values used to resume a node after an interrupt. Not checked yet Adds NULL_TASK_ID constant in langgraph.constants to handle writes not associated with any specific task, enabling global writes independent of task execution. Not checked yet Supports pushing new tasks during graph execution, improving dynamic task scheduling. Not checked yet
5 details in Everything
LangGraph 0.2.46 adds add_sequence for linear node chains, GraphCommand class, and explicit checkpointing opt-out.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.46 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.46
└──▷ USE IT
Chain several processing nodes in order without manually adding edges between each pair.
python
copy
graph = StateGraph(MyState)
graph.add_sequence([
("ingest", ingest_node),
("analyze", analyze_node),
("summarize", summarize_node),
])
app = graph.compile()
Compile a subgraph with checkpointing explicitly disabled so it inherits no checkpointer from the parent.
python
copy
subgraph = StateGraph(SubState)
subgraph.add_node("step", step_node)
subgraph.set_entry_point("step")
compiled_sub = subgraph.compile(checkpointer=False)
Use GraphCommand with goto to conditionally redirect graph execution to a named node.
python
copy
from langgraph.graph.state import GraphCommand
def router_node(state):
if state["needs_review"]:
return GraphCommand(goto="human_review", update={"routed": True})
return GraphCommand(goto="auto_approve")
Adds add_sequence() method to StateGraph for declaratively building a linear chain of nodes with edges auto-wired between them. Not checked yet Introduces GraphCommand class (replacing deprecated Control ) with a goto parameter for directing graph flow and updating state. Not checked yet Supports passing False to StateGraph.compile(checkpointer=False) to explicitly disable checkpointing in a graph or subgraph. Not checked yet
3 details in Everything
LangGraph Checkpoint 2.0.3 adds CommandProtocol serialization support in JSON and MessagePack formats.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==2.0.3 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==2.0.3
New CommandProtocol interface in langgraph.checkpoint.serde.types enables serialization of command objects (including update and send operations) that mirror the Command type from LangGraph. Not checked yet Extends JsonPlusSerializer to serialize CommandProtocol objects in both JSON and MessagePack formats by encoding their attributes. Not checked yet
2 details in Everything
LangGraph 0.2.45 adds a Control class so node functions can steer graph flow and send values to destination nodes directly.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.45 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.45
└──▷ USE IT
Route to different nodes from within a single node function based on runtime state, without wiring separate conditional edges.
python
copy
from langgraph.types import Control
def router_node(state: dict) -> Control:
if state["score"] > 0.9:
return Control(goto="high_confidence_node", update={"routed": True})
else:
return Control(goto="low_confidence_node", update={"routed": True})
New Control class lets node functions simultaneously update state and direct graph flow — including triggering specific next nodes or sending values to them. Not checked yet Nodes can now declare their potential destination nodes via type annotations on their return type, enabling static graph validation of routing paths. Not checked yet New SELF constant represents the implicit branch created to handle Control return values. Not checked yet Metadata is now preserved across update_state / aupdate_state calls, so checkpoint metadata survives incremental updates. Not checked yet
4 details in Everything
LangGraph CLI 0.1.53 adds JavaScript/TypeScript project templates and arbitrary Docker build argument passthrough.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.53 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.53
Adds a JavaScript/TypeScript project template for scaffolding LangGraph.js applications, including TypeScript config, ESLint, Jest, and sample StateAnnotation-based graph. Not checked yet Enables passing arbitrary Docker build arguments directly to the Docker build process in the build command. Not checked yet Adds automatic Node.js package manager detection (npm, yarn, pnpm) based on lock files, selecting the correct install and build commands automatically. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The --platform option has been removed from the build command; use Docker's native passthrough parameters instead.! The deprecated test command has been removed; use the run command instead.
LangGraph 0.2.44 adds chat history validation for ReAct agents and messages-tuple stream mode for remote graphs.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.44 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.44
└──▷ USE IT
Catch incomplete ReAct chat histories early — the agent now raises INVALID_CHAT_HISTORY if any AIMessage tool call lacks a matching ToolMessage, surfacing the bad call before it hits the LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. .
python
copy
from langgraph.errors import ErrorCode
# The validation runs automatically inside create_react_agent;
# catch it explicitly to handle incomplete histories gracefully.
try:
result = agent.invoke({"messages": chat_history})
except ValueError as e:
if ErrorCode.INVALID_CHAT_HISTORY in str(e):
print("Chat history has unmatched tool calls:", e)
Stream a remote LangGraph deployment using the messages-tuple format, now transparently supported by RemoteGraph.
python
copy
from langgraph.pregel.remote import RemoteGraph
remote = RemoteGraph(graph_id="my-graph", url="https://my-deployment.example.com")
for chunk in remote.stream({"messages": []}, stream_mode="messages-tuple"):
print(chunk)
Adds INVALID_CHAT_HISTORY error code and _validate_chat_history function to catch mismatched tool call / tool response pairs in chat history before they reach the LLM. Not checked yet Supports messages-tuple stream mode format for RemoteGraph, automatically mapping it to the messages mode. Not checked yet Improves RemoteGraph visualization by resolving meaningful node names from node data instead of falling back to an empty string. Not checked yet
3 details in Everything
LangGraph 0.2.42 improves nested streaming in RemoteGraph with proper parent-graph stream mode propagation.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.42 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.42
└──▷ USE IT
Stream a remote subgraph from a parent graph, letting the parent's stream modes flow through to the RemoteGraph automatically.
python
copy
from langgraph.pregel.remote import RemoteGraph
remote = RemoteGraph("my-remote-graph", url="http://localhost:8000")
# When invoked as a subgraph, RemoteGraph now inherits and propagates
# the parent graph's stream modes and namespace context automatically.
async for chunk in remote.astream(
{"input": "hello"},
config={"configurable": {"thread_id": "abc"}},
stream_mode="updates",
):
print(chunk)
Enables RemoteGraph to accept stream-mode configuration from parent graphs and propagate it correctly through nested graph hierarchies. Not checked yet Supports namespace information propagation between parent and child graphs during streaming sessions. Not checked yet Removes events stream mode support in Pregel, as it was never functional. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The events stream mode is explicitly no longer supported in Pregel; any working setup that requested events as a stream mode will no longer function.
LangGraph 0.2.40 adds DuckDB checkpointing, richer ToolNode error handling, and concurrency limiting for async executors.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.40 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.40
└──▷ USE IT
Use a different state key for messages when your graph stores messages under a non-default key (e.g., chat_history).
python
copy
tool_node = ToolNode(tools, messages_key="chat_history")
condition = tools_condition(messages_key="chat_history")
Apply fine-grained ToolNode error handling: catch only specific exception types and format the error dynamically.
python
copy
from langgraph.prebuilt import ToolNode
tool_node = ToolNode(
tools,
handle_tool_errors=(ValueError, KeyError), # only catch these types
)
# — or use a callable for dynamic formatting —
tool_node = ToolNode(
tools,
handle_tool_errors=lambda exc: f"Tool failed: {type(exc).__name__}: {exc}",
)
Adds DuckDB checkpointing support via the new langgraph-checkpoint-duckdb package. Not checked yet Adds messages_key parameter to ToolNode and tools_condition for flexible integration with non-standard state schemas. Not checked yet Enhances ToolNode error handling: accepts a boolean, custom string, callable, or tuple of exception types to selectively catch and format errors, and attaches status="error" to error tool messages. Not checked yet Adds concurrency limiting to AsyncBackgroundExecutor via max_concurrency config parameter and semaphore-based gated utility. Not checked yet Adds node_finished callback parameter to PregelRunner via CONFIG_KEY_NODE_FINISHED for node-completion hooks. Not checked yet
+1 more
show less
Improves schema inference in StateGraph for class method node functions via the extracted _get_input_schema_from_type_hint helper. Not checked yet
6 details in Everything
LangGraph SDK 0.1.35 adds error-handling control to wait and raises default timeouts to 300 s
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.35 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.35
└──▷ USE IT
Poll a long-running graph run without crashing your process on error — inspect the result yourself instead of catching an exception.
python
copy
result = await client.wait(thread_id, run_id, raise_error=False)
if "__error__" in result:
print("Run failed:", result["__error__"])
Adds raise_error parameter to LangGraphClient.wait and SyncLangGraphClient.wait, letting callers suppress exception raising and inspect error objects directly. Not checked yet Increases default read/write timeouts from 60 s to 300 s in get_client and get_sync_client, enabling reliable use with long-running graph operations. Not checked yet
2 details in Everything
LangGraph SDK 0.1.34 adds if_not_exists parameter and new "error" thread status for safer run handling.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.34 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.34
└──▷ USE IT
Auto-provision a thread on first run so a new user session starts without a separate thread-creation step.
python
copy
async for chunk in client.runs.stream(
thread_id=user_thread_id,
assistant_id="my-assistant",
input={"messages": [{"role": "user", "content": "Hello"}]},
if_not_exists="create",
):
print(chunk)
Gate on thread existence explicitly — raise fast if the thread ID supplied by a client is stale or invalid.
python
copy
result = await client.runs.wait(
thread_id=incoming_thread_id,
assistant_id="my-assistant",
input={"messages": [{"role": "user", "content": "Continue"}]},
if_not_exists="reject", # raises if thread_id not found
)
Adds if_not_exists parameter to stream, create, and wait client methods, letting callers auto-create a missing thread ("create") or reject the operation ("reject") instead of always raising. Not checked yet Adds "error" as a valid ThreadStatus value, surfacing when an exception occurred during task processing. Not checked yet Widens type annotations for stream_mode, interrupt_before, interrupt_after, and feedback_keys from list to Sequence , accepting tuples and other sequences without casting. Not checked yet
3 details in Everything
LangGraph 0.2.39 adds TAG_NOSTREAM constant, structured error codes, and finer streaming control.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.39 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.39
└──▷ USE IT
Suppress a cost-tracking or internal chat model call from appearing in the user-facing stream.
python
copy
from langgraph.constants import TAG_NOSTREAM
# When binding or invoking a chat model you want kept off the stream,
# pass TAG_NOSTREAM as a tag so StreamMessagesHandler skips it.
silent_model = llm.with_config({"tags": [TAG_NOSTREAM]})
# Use silent_model inside a node as normal — its tokens won't be streamed.
def my_node(state):
result = silent_model.invoke(state["messages"])
return {"messages": [result]}
Catch and branch on specific LangGraph error categories in production error handlers.
python
copy
from langgraph.errors import ErrorCode
from langgraph.errors import GraphRecursionError
try:
graph.invoke(inputs)
except GraphRecursionError as e:
if ErrorCode.GRAPH_RECURSION_LIMIT.value in str(e):
# surface a user-friendly message or increase recursion_limit
print("Graph hit recursion limit — consider increasing recursion_limit or breaking cycles.")
New TAG_NOSTREAM constant in langgraph.constants lets you tag chat models to suppress their output from the stream. Not checked yet New ErrorCode enum in langgraph.errors provides standardized codes (GRAPH_RECURSION_LIMIT, INVALID_CONCURRENT_GRAPH_UPDATE, INVALID_GRAPH_NODE_RETURN_VALUE, MULTIPLE_SUBGRAPHS) for programmatic error handling. Not checked yet New create_error_message helper in langgraph.errors generates consistent error messages with links to troubleshooting documentation. Not checked yet StreamMessagesHandler now respects TAG_NOSTREAM on chat model starts and TAG_HIDDEN on chain starts for fine-grained control over what gets streamed. Not checked yet
4 details in Everything
LangGraph 0.2.37 adds RemainingSteps managed value and LoopProtocol for finer-grained loop termination control.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.37 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.37
└──▷ USE IT
Guard an agent node against runaway tool calls by checking how many steps remain — useful when you want to abort gracefully before hitting the recursion limit.
python
copy
from langgraph.managed import RemainingSteps
def agent_node(state, remaining_steps: RemainingSteps):
if remaining_steps < 2:
# Not enough headroom — return a safe fallback instead of calling tools
return {"messages": [AIMessage(content="Stopping early: too few steps remaining.")]}
# ... normal tool-calling logic
return model_with_tools.invoke(state["messages"])
Adds RemainingSteps managed value to expose the number of remaining steps during loop execution, usable alongside IsLastStep for precise loop control. Not checked yet Introduces LoopProtocol interface, giving managed values and channels structured access to loop execution context (config, store, stream, step, stop). Not checked yet Improves checkpointing in nested loops with proper parent configuration propagation via updated patch_checkpoint_map. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The ManagedValue.__call__ signature no longer accepts a step parameter; callers that passed step explicitly will break.
LangGraph 0.2.36 adds RemoteGraph for interacting with hosted LangGraph deployments via the LangGraph API.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.36 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.36
└──▷ USE IT
Connect to a remotely hosted LangGraph deployment and stream results — useful when your graph runs in production and you want to interact with it programmatically from a client.
python
copy
from langgraph.pregel.remote import RemoteGraph
remote_graph = RemoteGraph(
url="https://my-deployment.langgraph.app",
api_key="<your-api-key>",
graph_id="my-graph"
)
async for chunk in remote_graph.astream({"input": "Hello"}):
print(chunk)
New RemoteGraph class enables invoking, streaming, and inspecting state on remote LangGraph deployments through the LangGraph API. Not checked yet New PregelProtocol defines a standard interface for interacting with graphs, providing both sync and async methods for state management, visualization, subgraph traversal, and execution. Not checked yet Adds a result field to PregelTask to store and access structured task execution results in state snapshots. Not checked yet
3 details in Everything
LangGraph SDK 0.1.33 adds wildcard node interrupts, custom stream mode, and richer update_state returns.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.33 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.33
└──▷ USE IT
Inspect the checkpoint produced after patching thread state, so you can resume from or verify the exact saved point.
python
copy
response = await client.threads.update_state(
thread_id=thread_id,
values={"messages": [{"role": "assistant", "content": "Corrected reply"}]},
)
print(response) # ThreadUpdateStateResponse with checkpoint info
Consume custom stream events alongside standard ones to handle application-defined data emitted during a run.
python
copy
async for chunk in client.runs.stream(
thread_id=thread_id,
assistant_id=assistant_id,
input={"messages": [{"role": "user", "content": "Hello"}]},
stream_mode=["messages", "custom"],
):
print(chunk)
Supports passing "*" to interrupt_before/interrupt_after parameters in RunsClient and CronClient to interrupt all nodes without listing them individually. Not checked yet Adds "custom" option to StreamMode, giving more flexibility in how streams are handled. Not checked yet update_state now returns a ThreadUpdateStateResponse containing checkpoint information instead of None . Not checked yet Expands update_state values parameter to accept Sequence[dict] in addition to a single dict, enabling multi-dictionary state updates. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! update_state on ThreadsClient and SyncThreadsClient now returns ThreadUpdateStateResponse instead of None — code that assumes a None return (e.g., ignores or asserts on the return value) will behave differently.
LangGraph 0.2.35 adds cross-thread memory for agents and a new find_subgraph_pregel utility for nested graph introspection.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.35 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.35
└──▷ USE IT
Inspect a compiled runnable to find whether it contains a Pregel subgraph, useful before attaching a checkpointer to a nested graph.
python
copy
from langgraph.pregel.utils import find_subgraph_pregel
subgraph = find_subgraph_pregel(my_runnable)
if subgraph:
print("Found Pregel subgraph:", subgraph)
Adds cross-thread memory support in agent executors, enabling agents to retain information across separate conversation threads. Not checked yet Introduces find_subgraph_pregel utility to recursively locate Pregel subgraphs within runnable components — useful for checkpoint handling and graph introspection. Not checked yet Enhances map_debug_checkpoint to include task state information and properly maintain checkpoint namespaces for nested subgraph debugging. Not checked yet
3 details in Everything
AsyncPostgresStore now inherits from AsyncBatchedBaseStore, enabling efficient batched async operations.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==2.0.1 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==2.0.1
Enables batched async operations in AsyncPostgresStore via AsyncBatchedBaseStore inheritance, reducing round-trips for high-throughput workloads. Not checked yet Adds explicit ORDER BY updated_at DESC to search queries in PostgresStore, providing consistent, deterministic result ordering. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! BasePostgresStore is no longer a direct subclass of BaseStore; code that relied on that inheritance chain (e.g., isinstance checks or super() calls through BasePostgresStore) will break.! _deserializer is now a class attribute on BasePostgresStore rather than an instance attribute set in __init__; subclasses that override or reference self._deserializer set during __init__ may behave differently.
LangGraph 0.2.34 adds a store parameter to create_react_agent for cross-thread persistence.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.34 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.34
└──▷ USE IT
Persist memory across multiple user conversations by wiring a store into a ReAct agent at creation time.
python
copy
from langgraph.prebuilt import create_react_agent
agent = create_react_agent(
model=llm,
tools=tools,
checkpointer=checkpointer, # single-thread (per-conversation) state
store=store, # cross-thread (multi-user) persistence
)
Adds store parameter to create_react_agent, enabling data persistence across multiple threads (e.g., different users or conversations) alongside the existing checkpointer parameter. Not checked yet Adds a warning when InjectedStore annotation is used without langchain-core >= 0.3.8, surfacing the dependency requirement at runtime. Not checked yet
2 details in Everything
LangGraph 0.2.33 adds InjectedStore annotation so tools can read/write the LangGraph store without exposing it to the model.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.33 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.33
└──▷ USE IT
Give a tool direct access to the LangGraph store (e.g. to look up or persist memory) without surfacing the store parameter to the LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. .
python
copy
from typing import Annotated
from langgraph.prebuilt.tool_node import InjectedStore
from langgraph.store.base import BaseStore
def save_note(note: str, store: Annotated[BaseStore, InjectedStore()]) -> str:
"""Save a note to the store."""
store.put(("notes",), "latest", {"text": note})
return "Saved."
Adds InjectedStore annotation to inject LangGraph store objects directly into tool arguments, hiding them from the tool-calling tool-calling A model's ability to answer with a structured request to run a named function or API, which the application executes and returns. It is how agents take actions. model (similar to InjectedState). Not checked yet Enhances ToolNode to automatically detect and inject the store for tools annotated with InjectedStore, with precomputed caching of state and store arguments for efficiency. Not checked yet Enables RunnableCallable keyword arguments to override config values in invoke and ainvoke, giving callers finer control over execution. Not checked yet
3 details in Everything
LangGraph SDK 0.1.32 adds a key-value Store API with namespaced put, get, delete, search, and list operations for both async and sync clients.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.32 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.32
└──▷ USE IT
Persist and retrieve agent memory across runs by storing key-value data in a user-scoped namespace.
python
copy
from langgraph_sdk import get_client
client = get_client()
# Store a user preference
await client.store.put_item(
namespace=("users", "alice"),
key="preferences",
value={"theme": "dark", "language": "en"}
)
# Retrieve it later
item = await client.store.get_item(
namespace=("users", "alice"),
key="preferences"
)
print(item["value"])
Search stored items within a namespace prefix to find relevant context for an agent, with filtering.
python
copy
from langgraph_sdk import get_client
client = get_client()
results = await client.store.search_items(
namespace_prefix=("users",),
filter={"language": "en"}
)
for item in results["items"]:
print(item["namespace"], item["key"], item["value"])
Use the synchronous client in a non-async script to list all namespaces under a given prefix.
python
copy
from langgraph_sdk import get_sync_client
client = get_sync_client()
namespaces = client.store.list_namespaces(prefix=("users",))
for ns in namespaces["namespaces"]:
print(ns)
New StoreClient and SyncStoreClient classes provide async and sync key-value storage with put_item, get_item, delete_item, search_items, and list_namespaces methods. Not checked yet Adds store property to LangGraphClient and SyncLangGraphClient for direct access to the new store API. Not checked yet Exposes get_sync_client in module exports for easier access to the synchronous client. Not checked yet New Item , ListNamespaceResponse, and SearchItemsResponse TypedDicts formalize storage operation schemas. Not checked yet Adds output_schema field to the GraphSchema TypedDict. Not checked yet
+1 more
show less
HttpClient and SyncHttpClient now support JSON payloads in DELETE requests. Not checked yet
6 details in Everything
LangGraph Postgres store now accepts a custom deserializer parameter for user-controlled JSON loading.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==1.0.11 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==1.0.11
└──▷ USE IT
Supply a custom deserializer to handle non-standard JSON types (e.g., dates, decimals) stored in Postgres.
python
copy
import json
from decimal import Decimal
from langgraph.store.postgres import PostgresStore
def my_deserializer(data: str):
return json.loads(data, parse_float=Decimal)
store = PostgresStore(conn_string="postgresql://user:pass@localhost/db", deserializer=my_deserializer)
Use a custom deserializer with the async store in an async LangGraph workflow.
python
copy
import json
from langgraph.store.postgres.aio import AsyncPostgresStore
def my_deserializer(data: str):
return json.loads(data, object_hook=lambda d: {k: v.upper() if isinstance(v, str) else v for k, v in d.items()})
store = AsyncPostgresStore(conn_string="postgresql://user:pass@localhost/db", deserializer=my_deserializer)
Adds optional deserializer parameter to PostgresStore and AsyncPostgresStore (via BasePostgresStore), enabling custom JSON deserialization deserialization Turning stored or transmitted data back into objects a program can use. Unsafe handling of untrusted data can allow unexpected behavior or code execution. when loading values from the database. Not checked yet
1 detail in Everything
langgraph-checkpoint-postgres 1.0.10 adds sync and async PostgreSQL store implementations with batch ops, namespace listing, and schema migration.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==1.0.10 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==1.0.10
└──▷ USE IT
Initialize the PostgreSQL store schema and persist/retrieve agent state in a synchronous workflow.
python
copy
from langgraph.store.postgres import PostgresStore
with PostgresStore.from_conn_string("postgresql://user:pass@localhost/mydb") as store:
store.setup() # create tables and run migrations
store.put(("agents", "session-42"), "state", {"step": 1, "status": "running"})
item = store.get(("agents", "session-42"), "state")
print(item)
Use the async store in an asyncio-based LangGraph agent to avoid blocking the event loop on database calls.
python
copy
import asyncio
from langgraph.store.postgres.aio import AsyncPostgresStore
async def main():
async with AsyncPostgresStore.from_conn_string("postgresql://user:pass@localhost/mydb") as store:
await store.setup()
await store.put(("sessions", "user-99"), "context", {"history": []})
results = await store.search(("sessions",))
print(results)
asyncio.run(main())
New PostgresStore class provides a synchronous PostgreSQL-backed store with get, put, search, and namespace-listing operations. Not checked yet New AsyncPostgresStore class mirrors PostgresStore with full async/await support via asyncio for non-blocking database access. Not checked yet Both stores expose a from_conn_string() context manager for ergonomic connection management. Not checked yet Both stores include a setup() method to initialize the database schema and run migrations automatically. Not checked yet Explicit __all__ exports added to the postgres store modules for cleaner programmatic imports. Not checked yet
5 details in Everything
LangGraph 0.2.29 expands create_react_agent to accept any LanguageModelLike and adds custom store support via configuration.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.29 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.29
└──▷ USE IT
Use a non-BaseChatModel language model (any LanguageModelLike) directly with create_react_agent — useful when wrapping custom or third-party models.
python
copy
from langgraph.prebuilt import create_react_agent
# model_like is any LanguageModelLike, not necessarily a BaseChatModel
agent = create_react_agent(model=model_like, tools=[my_tool])
result = agent.invoke({"messages": [{"role": "user", "content": "Search for X"}]})
Expands create_react_agent to accept LanguageModelLike instead of only BaseChatModel, enabling use with a broader range of model types. Not checked yet Adds support for custom stores via configuration in Pregel , with store parameter propagation through the execution stack. Not checked yet Migrates store implementation to langgraph-checkpoint, updating namespace representation from strings to tuples and switching methods from list/put to search/batch. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The store namespace representation in SharedValue changed from strings to tuples; any code relying on string namespaces will need to be updated.! Store method calls changed from list/put to search/batch; code calling the old store methods directly will break.
LangGraph Checkpoint 1.0.13 introduces a namespaced key-value store API with sync/async ops and an in-memory implementation.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==1.0.13 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==1.0.13
└──▷ USE IT
Persist and retrieve cross-session user facts in a namespaced store during graph execution.
python
copy
from langgraph.store.memory import InMemoryStore
store = InMemoryStore()
# Store a user fact under a namespaced key
store.put(("users", "alice"), "preference", {"theme": "dark"})
# Retrieve it later
item = store.get(("users", "alice"), "preference")
print(item.value) # {"theme": "dark"}
Search across a namespace prefix to find all items matching a filter — useful for multi-tenant or multi-session lookups.
python
copy
from langgraph.store.memory import InMemoryStore
store = InMemoryStore()
store.put(("sessions", "s1"), "summary", {"turns": 5})
store.put(("sessions", "s2"), "summary", {"turns": 12})
results = store.search(("sessions",))
for item in results:
print(item.namespace, item.key, item.value)
Adds BaseStore abstract base class with sync and async CRUD CRUD The four basic database operations — Create, Read, Update, Delete — used as shorthand for any system that manages persistent data records, giving cyber tools a standard model for interacting with stored information. operations (get/aget, put/aput, delete/adelete, search/asearch, list_namespaces/alist_namespaces, batch/abatch) for persistent, namespaced key-value storage. Not checked yet Introduces Item as the core storage unit, carrying value data, key, namespace path, and timestamp metadata with equality comparison and dict conversion support. Not checked yet Ships InMemoryStore, a fully-featured in-memory BaseStore implementation backed by Python dicts for prototyping and testing without external dependencies. Not checked yet Adds AsyncBatchedBaseStore, which automatically coalesces async store operations into batches via a background task for higher throughput. Not checked yet Extends JsonPlusSerializer to serialize Item objects, enabling store items to round-trip correctly through checkpoint persistence. Not checked yet
5 details in Everything
LangGraph checkpoint 1.0.12 adds secret-value serialization support in JsonPlusSerializer.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==1.0.12 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==1.0.12
Supports serializing objects that implement get_secret_value() in JsonPlusSerializer, enabling proper handling of secure/secret values during checkpoint serialization and deserialization deserialization Turning stored or transmitted data back into objects a program can use. Unsafe handling of untrusted data can allow unexpected behavior or code execution. . Not checked yet
1 detail in Everything
LangGraph 0.2.27 adds namespace filtering to subgraph traversal and broadens BaseStore value types.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.27 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.27
└──▷ USE IT
Retrieve only the subgraph matching a specific namespace when inspecting a deeply nested graph, avoiding a full traversal.
python
copy
subgraphs = list(graph.get_subgraphs(namespace="my_agent"))
Adds optional namespace parameter to get_subgraphs and aget_subgraphs for filtering subgraphs by name, improving performance in nested-subgraph graphs. Not checked yet Automatically excludes subgraphs with checkpointing disabled (checkpointer is False) from subgraph enumeration. Not checked yet Broadens BaseStore value type (V) from dict[str, Any] to Any , enabling storage of arbitrary value types. Not checked yet
3 details in Everything
LangGraph's ToolNode now supports multimodal multimodal Able to work with more than one type of input or output, such as text, images and audio. A multimodal model can combine information across those formats. tool responses, letting tools return images and structured data alongside text.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.25 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.25
└──▷ USE IT
Return an image from a tool so the LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. receives it as a structured content block rather than a stringified blob.
python
copy
from langgraph.prebuilt import ToolNode
from langchain_core.tools import tool
@tool
def capture_screenshot(url: str) -> list:
"""Capture a screenshot and return it as image content."""
image_bytes = fetch_screenshot(url) # your existing logic
return [{"type": "image", "source": {"type": "base64", "media_type": "image/png", "data": image_bytes}}]
node = ToolNode([capture_screenshot])
Enhances ToolNode to handle multimodal content in tool responses, preserving image, image_url, text, and json content blocks instead of converting everything to strings. Not checked yet
1 detail in Everything
LangGraph SDK 0.1.31 adds assistant versioning, subgraph streaming, future run scheduling, and a richer Checkpoint type.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.31 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.31
└──▷ USE IT
Pin a specific assistant version to active after testing a new prompt configuration in staging.
python
copy
await client.assistants.set_latest(assistant_id="asst_abc123", version=3)
Audit all deployed versions of an assistant to understand what changed between releases.
python
copy
versions = await client.assistants.get_versions(assistant_id="asst_abc123")
for v in versions:
print(v.version, v.config)
Schedule a background run to execute 60 seconds in the future, e.g. for deferred processing after an external webhook.
python
copy
await client.runs.create(thread_id="thread_xyz", assistant_id="asst_abc123", after_seconds=60)
Adds name parameter to assistant create and update methods for human-readable assistant identification. Not checked yet Adds get_versions method to retrieve the full version history of an assistant. Not checked yet Adds set_latest method to promote a specific assistant version to active. Not checked yet Adds subgraphs parameter to get_state to include subgraph state in thread state responses. Not checked yet Adds stream_subgraphs parameter to run methods to stream outputs from subgraphs. Not checked yet
+3 more
show less
Adds after_seconds parameter to schedule runs for future execution. Not checked yet Introduces new Checkpoint type for richer checkpoint representation across thread and run APIs. Not checked yet Adds AssistantVersion class and ThreadTask model to the schema for version history and per-thread task tracking. Not checked yet
8 details in Everything
└──▷ BREAKING ON UPGRADE
! The patch_state method has been removed from the Thread client in favor of updated state management via update_state.! The config field in thread state responses has been replaced by checkpoint (using the new Checkpoint type).! The checkpoint_id parameter is deprecated in get_state and run methods; the replacement is the new checkpoint parameter.
LangGraph 0.2.24 adds a new langgraph.types module and error detection for multiple subgraphs inside a single node.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.24 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.24
└──▷ USE IT
Import Send and Interrupt from the new canonical module instead of constants in new code.
python
copy
from langgraph.types import Send, Interrupt
Introduces langgraph.types module as the new canonical home for core data types including Send and Interrupt . Not checked yet Adds MultipleSubgraphsError to detect and prevent multiple subgraphs from being invoked inside the same node. Not checked yet
2 details in Everything
LangGraph 0.2.23 adds token-by-token message streaming and custom node output streaming via two new stream modes.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.23 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.23
└──▷ USE IT
Surface LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. tokens as they are generated so a UI can display streamed responses without waiting for the full reply.
python
copy
for chunk in graph.stream(inputs, stream_mode="messages"):
print(chunk)
Emit structured intermediate results from a node (e.g. progress updates) that consumers can act on before the graph finishes.
python
copy
# Inside a node definition:
def my_node(state, *, write):
write({"status": "halfway done"})
return state
# Consuming the stream:
for chunk in graph.stream(inputs, stream_mode="custom"):
print(chunk)
Adds stream_mode="messages" to stream LLM output token-by-token in real time. Not checked yet Adds stream_mode="custom" to emit arbitrary output from nodes via a write parameter. Not checked yet Enhances chat_agent_executor with route_tool_responses to support tools configured with return_direct, bypassing the agent on return. Not checked yet Introduces AsyncQueue and SyncQueue utilities for higher-performance concurrent streaming. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! In chat_agent_executor, should_continue now returns "tools" instead of "continue" and "__end__" instead of "end" — code that matches on those string values will break.
LangGraph checkpoint 1.0.10 adds MessagePack serialization, scheduled-task tracking, and namedtuple support.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==1.0.10 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==1.0.10
Adds MessagePack integration to JsonPlusSerializer as a faster alternative to JSON serialization, with pooled encoders for throughput. Not checked yet Adds a SCHEDULED special channel constant (value -2) in WRITES_IDX_MAP on BaseCheckpointSaver to track scheduled task status in the checkpoint system. Not checked yet Adds get_next_version method to InMemorySaver to generate consistent, unique version identifiers for channels. Not checked yet Extends JsonPlusSerializer to serialize objects exposing _asdict() (e.g., namedtuples). Not checked yet
4 details in Everything
LangGraph Postgres checkpointer gains custom serializer support and smarter SQL write strategies in v1.0.7
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==1.0.7 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==1.0.7
└──▷ USE IT
Plug in a custom serializer when opening an async Postgres checkpoint connection — useful when your graph state contains types the default serializer can't handle.
python
copy
from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
from my_project.serializers import MyCustomSerde
async with AsyncPostgresSaver.from_conn_string(
"postgresql://user:pass@localhost/mydb",
serde=MyCustomSerde(),
) as saver:
await saver.setup()
# attach saver to your compiled graph
graph = workflow.compile(checkpointer=saver)
Adds optional serde parameter to AsyncPostgresSaver.from_conn_string() for injecting custom serializers. Not checked yet Introduces dynamic SQL query selection for checkpoint writes, choosing between upsert and insert-only operations based on channel types in both PostgresSaver and AsyncPostgresSaver. Not checked yet Adds new INSERT_CHECKPOINT_WRITES_SQL constant enabling insert-only checkpoint write operations alongside the existing upsert path. Not checked yet
3 details in Everything
LangGraph 0.2.22 adds create_model Pydantic utility and improved subgraph retry resumption.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.22 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.22
└──▷ USE IT
Use create_model to build a Pydantic state schema that works across langchain-core versions when defining a StateGraph.
python
copy
from langgraph.utils.pydantic import create_model
from langgraph.graph import StateGraph
MyState = create_model('MyState', messages=(list, []), step=(int, 0))
graph = StateGraph(state_schema=MyState)
Adds langgraph.utils.pydantic.create_model, a new utility function that creates Pydantic models compatible with both older and newer versions of langchain-core, supporting normal field definitions and root models through a consistent interface. Not checked yet Adds a deprecation warning when StateGraph is initialized without an explicit state_schema parameter, prompting users to supply one explicitly. Not checked yet
2 details in Everything
LangGraph 0.2.20 adds dataclass schema support, ToolNode naming, and reduced dependency on langchain-core for config handling.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.20 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.20
└──▷ USE IT
Use a dataclass as a StateGraph schema so field defaults are automatically resolved without manual annotation workarounds.
python
copy
from dataclasses import dataclass, field
from langgraph.graph import StateGraph
@dataclass
class AgentState:
messages: list = field(default_factory=list)
step: int = 0
graph = StateGraph(AgentState)
Identify a ToolNode by name when inspecting or logging graph structure.
python
copy
from langgraph.prebuilt import ToolNode
node = ToolNode(tools=[my_tool])
print(node.name) # "ToolNode"
Adds dataclass support in get_field_default, enabling field defaults (including default factories) to be retrieved from dataclass-based state schemas. Not checked yet Adds a name attribute (default "ToolNode") to ToolNode for better graph node identification. Not checked yet Adds local ensure_config, get_callback_manager_for_config, and get_async_callback_manager_for_config in langgraph.utils.config, removing the dependency on langchain-core for config handling. Not checked yet Adds __slots__ to BaseChannel and all channel subclasses, reducing per-instance memory overhead at scale. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! The from_checkpoint API on all channel classes now returns instances directly instead of using a context manager pattern — code that used with channel.from_checkpoint(...) as ch: will break.
LangGraph 0.2.19 adds Pydantic BaseModel support to ToolNode and improves async/sync runner responsiveness.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.19 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.19
└──▷ USE IT
Use a Pydantic model as your graph state so ToolNode can extract typed fields directly — no dict conversion needed.
python
copy
from pydantic import BaseModel
from langgraph.prebuilt import ToolNode
from langchain_core.tools import tool
class AgentState(BaseModel):
messages: list
user_id: str
@tool
def lookup_user(user_id: str) -> str:
"""Look up a user by ID."""
return f"User: {user_id}"
node = ToolNode([lookup_user])
# AgentState instance is now passed directly — ToolNode reads fields via getattr
result = node.invoke(AgentState(messages=[...], user_id="u-123"))
Supports Pydantic BaseModel as an input type in ToolNode, alongside existing list and dict inputs, for stronger type safety in tool-calling tool-calling A model's ability to answer with a structured request to run a named function or API, which the application executes and returns. It is how agents take actions. graphs. Not checked yet Enables ToolNode to detect nested tool injections inside Union and Annotated types. Not checked yet Improves ToolNode state extraction to work with object attributes via getattr, enabling object-like states alongside dictionaries. Not checked yet Yields control back to the caller immediately at the start of PregelRunner.tick and atick, improving responsiveness in async and sync applications. Not checked yet
4 details in Everything
LangGraph 0.2.18 adds scheduled-task tracking, a TaskNotFound exception, and a Pregel.copy() method for cleaner graph customization.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.18 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.18
└──▷ USE IT
Catch the new TaskNotFound exception when manually driving task execution to handle missing-task edge cases gracefully.
python
copy
from langgraph.errors import TaskNotFound
try:
result = await pregel_loop.execute_task(task_id)
except TaskNotFound:
print(f"Task {task_id} no longer exists in the execution graph")
Adds SCHEDULED constant ("__scheduled__") to represent scheduled tasks, included in the RESERVED set of special keys. Not checked yet Introduces TaskNotFound exception for explicit error handling when the executor cannot locate a task. Not checked yet Adds Pregel.copy(update) method to create modified Pregel instances without mutating the original graph. Not checked yet Adds path: tuple[str, ...] field to PregelExecutableTask to track a task's execution path through the graph. Not checked yet Adds scheduled: bool field to PregelExecutableTask to indicate whether a task has been scheduled. Not checked yet
+1 more
show less
Changes prepare_next_tasks to return a dict[str, PregelExecutableTask] keyed by task ID, enabling O(1) task lookup in execution loops. Not checked yet
6 details in Everything
└──▷ BREAKING ON UPGRADE
! The tasks attribute of PregelLoop changed from Sequence[PregelExecutableTask] to dict[str, PregelExecutableTask]; code that iterates or indexes tasks as a list will break.! prepare_next_tasks now returns a dict[str, PregelExecutableTask] instead of a list; callers that treat the return value as a sequence will break.
LangGraph 0.2.17 adds Pydantic v2 support, a new get_field_default utility, and a new SUBSCRIPTIONS constant for channel management.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.17 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.17
└──▷ USE IT
Inspect the default value for a field in a state schema, e.g. to check whether an optional field has a factory default before graph compilation.
python
copy
from langgraph.utils.fields import get_field_default
from typing import Optional
from pydantic import BaseModel
class MyState(BaseModel):
messages: list = []
user_id: Optional[str] = None
default = get_field_default(MyState.model_fields["messages"])
print(default) # []
Adds Pydantic v2 support across the library while maintaining Pydantic v1 compatibility, including in ValidationNode which now selects the correct validation method (model_validate/model_dump_json for v2, validate/json for v1) automatically. Not checked yet Adds new get_field_default utility in langgraph.utils.fields for reliably resolving default values for state schema fields, with improved handling of optional fields, Required /NotRequired annotations, and type hints. Not checked yet Adds new SUBSCRIPTIONS constant to langgraph.constants, included in the RESERVED set for channel management. Not checked yet Expands langchain-core dependency range to allow versions up to v0.4.x. Not checked yet
4 details in Everything
AsyncPostgresSaver gains synchronous wrapper methods for use in mixed sync/async contexts.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==1.0.6 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==1.0.6
└──▷ USE IT
Use AsyncPostgresSaver from a synchronous function — e.g. inside a Django view or a sync test — without spinning up a separate async runtime.
python
copy
from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
async def setup():
saver = await AsyncPostgresSaver.from_conn_string("postgresql://user:pass@localhost/db")
return saver
# In a synchronous context:
import asyncio
saver = asyncio.run(setup())
# Now call sync wrappers directly from sync code:
checkpoint_tuple = saver.get_tuple(config)
all_checkpoints = list(saver.list(config))
saver.put(config, checkpoint, metadata, new_versions)
Adds synchronous list() , get_tuple() , put() , and put_writes() methods to AsyncPostgresSaver, backed by asyncio.run_coroutine_threadsafe() , enabling use from synchronous code without restructuring the async saver. Not checked yet Stores the running event loop on AsyncPostgresSaver instances via self.loop to support the new synchronous dispatch methods. Not checked yet
2 details in Everything
AsyncSqliteSaver gains synchronous get_tuple, list, put, and put_writes methods for mixed async/sync use.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointsqlite==1.0.2 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointsqlite==1.0.2
└──▷ USE IT
Call AsyncSqliteSaver synchronously from a non-async context — useful when integrating with sync frameworks or threads that share an async event loop.
python
copy
from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
saver = AsyncSqliteSaver.from_conn_string("checkpoints.db")
# Synchronous put now works without wrapping in asyncio.run()
saver.put(config, checkpoint, metadata, new_versions)
# Synchronous put_writes also available
saver.put_writes(config, writes, task_id)
Adds synchronous get_tuple, list, and put methods to AsyncSqliteSaver, running async equivalents via asyncio.run_coroutine_threadsafe for mixed-context use. Not checked yet Adds new synchronous put_writes method to AsyncSqliteSaver. Not checked yet
2 details in Everything
LangGraph 0.2.16 improves nested subgraph detection for accurate visualization of complex graph structures.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.16 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.16
Enhances get_graph with pre-computed subgraph resolution when using the xray parameter, enabling accurate visualization of complex nested graph structures. Not checked yet Expands get_subgraphs to discover nested Pregel instances inside RunnableSequence steps, RunnableLambda dependencies, and RunnableCallable function nonlocals. Not checked yet
2 details in Everything
create_react_agent now accepts a ToolNode instance directly, enabling reuse of tool configurations across agents.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.15 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.15
└──▷ USE IT
Reuse a pre-configured ToolNode across two agents to share tool setup (e.g., auth, retries) without duplicating it.
python
copy
from langgraph.prebuilt import ToolNode, create_react_agent
shared_tool_node = ToolNode([search_tool, calculator_tool])
agent_a = create_react_agent(model_a, shared_tool_node)
agent_b = create_react_agent(model_b, shared_tool_node)
Wire a StateGraph node directly to END without a prior add_node(END) call, reducing boilerplate in graph definitions.
python
copy
from langgraph.graph import StateGraph, END
builder = StateGraph(MyState)
builder.add_node("analyze", analyze_fn)
builder.add_edge("analyze", END) # No explicit add_node(END) needed
graph = builder.compile()
Enables passing a ToolNode instance directly to create_react_agent, so existing tool configurations can be reused across multiple agents without duplication. Not checked yet Supports connecting StateGraph edges directly to the END node without explicitly adding it first, making graph construction more concise. Not checked yet
2 details in Everything
LangGraph SDK 0.1.30 adds state-value filtering for thread search and makes runs.join() return final thread state.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.30 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.30
└──▷ USE IT
Filter threads to only those whose state contains a specific value — useful for finding active conversations in a given topic or stage.
python
copy
threads = await client.threads.search(values={"topic": "billing", "status": "open"})
Block until a run completes and immediately inspect the final thread state without a separate fetch call.
python
copy
final_state = await client.runs.join(thread_id, run_id)
print(final_state)
Adds values parameter to client.threads.search() for filtering threads by their state values. Not checked yet Changes client.runs.join() to return a dictionary containing the final thread state instead of None . Not checked yet Introduces Json type as a replacement for the Metadata type to better reflect its semantic purpose. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The Metadata type is renamed to Json ; code importing or referencing Metadata will break.! client.runs.join() now returns a dictionary containing the final thread state instead of None ; code that assumes a None return value will break.
LangGraph Checkpoint 1.0.7 adds parent checkpoint references and pending-send tracking across checkpoint operations.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==1.0.7 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==1.0.7
Adds parents field to CheckpointMetadata, mapping checkpoint namespace to checkpoint ID for relationship tracking between checkpoints. Not checked yet Adds pending-send tracking in InMemorySaver: get_tuple now includes pending_sends from parent checkpoints, and list gains improved namespace filtering. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The score field in CheckpointMetadata is replaced by the parents field — any code reading or writing score will break.
LangGraph CLI 0.1.52 adds Node.js/LangGraphJS deployment support with dedicated Docker configuration.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.52 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.52
└──▷ USE IT
Configure a LangGraphJS project for deployment by specifying the Node.js version in your langgraph config file.
json
copy
{
"node_version": "20",
"graphs": {
"my_graph": "./src/graph.ts:graph"
}
}
Adds node_version field to the LangGraph config TypedDict, enabling Node.js (LangGraphJS) project deployments alongside existing Python support. Not checked yet Adds node_config_to_docker function to generate Docker configurations for Node.js projects, automatically selecting the langchain/langgraphjs-api base image. Not checked yet Adds validation for the node_version config field (currently enforces version "20") to catch misconfigured Node.js projects early. Not checked yet Updates build, prepare, and deployment CLI commands to operate correctly against both Python and Node.js environments. Not checked yet
4 details in Everything
LangGraph Postgres checkpointer now accepts connection pools for high-concurrency deployments.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==1.0.4 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==1.0.4
└──▷ USE IT
Use a connection pool with PostgresSaver to handle many concurrent LangGraph checkpoints without exhausting database connections.
python
copy
from psycopg_pool import ConnectionPool
from langgraph.checkpoint.postgres import PostgresSaver
pool = ConnectionPool("postgresql://user:password@localhost/db", min_size=2, max_size=10)
saver = PostgresSaver(pool)
Use an async connection pool with AsyncPostgresSaver for high-concurrency async LangGraph applications.
python
copy
from psycopg_pool import AsyncConnectionPool
from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
pool = AsyncConnectionPool("postgresql://user:password@localhost/db", min_size=2, max_size=10)
saver = AsyncPostgresSaver(pool)
Adds ConnectionPool support to PostgresSaver, enabling psycopg connection pool usage alongside direct connections for high-concurrency scenarios. Not checked yet Adds AsyncConnectionPool support to AsyncPostgresSaver for async workflows requiring pooled database connections. Not checked yet Enhances list() and alist() methods to include pending writes in returned checkpoint tuples. Not checked yet
3 details in Everything
LangGraph SDK 0.1.29 adds disconnect/completion lifecycle controls and a new join_stream() method for live run output.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.29 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.29
└──▷ USE IT
Attach to an in-progress run mid-flight to tail its output in real time — useful when a run was started in the background and you want to surface results to a user later.
python
copy
async for chunk in client.runs.join_stream(thread_id, run_id):
print(chunk)
Start a streaming run that auto-cancels if the user closes the connection, and deletes resources once it completes — keeps infra clean in high-volume deployments.
python
copy
async for chunk in client.runs.stream(
thread_id,
assistant_id,
input=input_data,
on_disconnect="cancel",
on_completion="delete",
):
print(chunk)
Create a background run that retains its output after completion so you can inspect results later.
python
copy
run = await client.runs.create(
thread_id,
assistant_id,
input=input_data,
on_completion="keep",
)
Adds on_disconnect parameter to stream() and wait() — set to "cancel" or "continue" to control what happens to a run when the client disconnects. Not checked yet Adds on_completion parameter to stream() , create() , and wait() — set to "delete" or "keep" to control resource cleanup after a run finishes. Not checked yet Adds join_stream() method to attach to an already-running run and receive its real-time output without buffering prior output. Not checked yet Adds DisconnectMode and OnCompletionBehavior types for structured lifecycle control in typed clients. Not checked yet
4 details in Everything
LangGraph 0.2.13 adds runtime-only managed values and reimplements Context to skip unnecessary serialization.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.13 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.13
└──▷ USE IT
Declare a runtime-only managed value to inject a context manager into your graph without it being serialized to checkpoints.
python
copy
from langgraph.managed.base import ManagedValue
class MyRuntimeValue(ManagedValue, runtime=True):
...
Adds a runtime flag to ManagedValue that marks values as created at runtime and excluded from serialization/deserialization deserialization Turning stored or transmitted data back into objects a program can use. Unsafe handling of untrusted data can allow unexpected behavior or code execution. . Not checked yet Adds replace_runtime_values and replace_runtime_placeholders methods to ManagedValueMapping for safe handling of runtime placeholders during graph serialization. Not checked yet Reimplements Context as a managed value (langgraph.managed.context.ContextManagedValue) with runtime=True, integrating it with the managed value system instead of the channel system. Not checked yet
3 details in Everything
LangGraph CLI 0.1.51 adds Redis 6 to Docker Compose for caching and message queuing.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.51 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.51
Adds Redis 6 as a managed Docker Compose service with health-check gating, so langgraph-api only starts after Redis is healthy. Not checked yet Injects REDIS_URI environment variable (redis://langgraph-redis:6379) automatically into the langgraph-api service. Not checked yet
2 details in Everything
LangGraph Checkpoint 1.0.4 adds error-write support, an ERROR constant, and exception serialization in JsonPlusSerializer.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==1.0.4 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==1.0.4
└──▷ USE IT
Capture and persist a node error into a checkpoint write so downstream nodes or retry logic can inspect it.
python
copy
from langgraph.checkpoint.serde.types import ERROR
# In a custom checkpointer's put_writes, tag a failed write with the ERROR sentinel
writes = [(ERROR, exception_value)]
await checkpointer.put_writes(config, writes, task_id)
Adds ERROR = "__error__" constant in langgraph.checkpoint.serde.types to represent error types in checkpoint writes. Not checked yet Supports special write types including error handling via WRITES_IDX_MAP in InMemorySaver.put_writes. Not checked yet Enables JsonPlusSerializer to serialize BaseException objects by encoding them using their constructor arguments. Not checked yet Includes pending writes in checkpoint list output from InMemorySaver. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! The current_tasks field is removed from the Checkpoint TypedDict; any code reading or writing checkpoint["current_tasks"] will break.! empty_checkpoint, copy_checkpoint, and create_checkpoint no longer include current_tasks in their returned dictionaries.
LangGraph 0.2.10 adds error and interrupt fields to debug task result payloads for richer execution tracing.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.10 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.10
└──▷ USE IT
Inspect task-level errors and interrupts during a graph run by reading the enriched debug stream.
python
copy
for chunk in graph.stream(inputs, stream_mode="debug"):
if chunk["type"] == "task_result":
payload = chunk["payload"]
if payload["error"]:
print("Task error:", payload["error"])
if payload["interrupts"]:
print("Interrupts:", payload["interrupts"])
Adds error: Optional[str] and interrupts: list[dict] fields to TaskResultPayload for capturing task-level errors and interrupts in debug output. Not checked yet Enhances put_writes on PregelLoop to automatically stream updates and debug information without manual wiring. Not checked yet Adds stream_keys as a class attribute on PregelLoop for explicit management of streaming outputs. Not checked yet Updates map_debug_task_results to accept task-writes pairs and support both string and sequence stream key formats. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! The map_debug_task_results function signature now accepts task-writes pairs instead of just tasks — callers passing tasks alone will break.! The tick method on PregelLoop has had parameters removed — code passing those now-removed parameters will break.! The SyncPregelLoop and AsyncPregelLoop constructor signatures have changed to support the new streaming architecture — existing instantiation code may break.! map_output_updates now expects the new task-writes tuple format — callers using the old format will break.! ERROR and INTERRUPT keys are now filtered out of regular output streams by map_output_updates — code relying on seeing those keys in regular output will no longer receive them.
LangGraph SDK 0.1.28 adds custom HTTP headers support and checkpoint namespace field for state configs.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.28 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.28
└──▷ USE IT
Attach a tenant ID or trace header to every SDK request when operating in a multi-tenant or instrumented environment.
python
copy
from langgraph_sdk import get_client
client = get_client(
url="https://your-langgraph-endpoint",
headers={"x-tenant-id": "acme-corp", "x-trace-id": "abc123"},
)
Retrieve a checkpoint scoped to a specific namespace to isolate state across parallel graph executions.
python
copy
state = await client.threads.get_state(
thread_id="<thread_id>",
checkpoint_id="<checkpoint_id>",
checkpoint_ns="pipeline-a",
)
Adds a headers parameter to get_client for injecting custom HTTP headers into all API requests, with validation blocking reserved headers like x-api-key. Not checked yet Adds a checkpoint_ns field to state configurations in get_state and create for namespace-scoped checkpoint lookups. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The thread_ts field is renamed to checkpoint_id in state configurations for LangGraphClient.get_state and LangGraphClient.create — any code referencing thread_ts will break.
LangGraph 0.2.7 adds SharedValue and a pluggable store system for persisting state across graph nodes.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.7 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.7
└──▷ USE IT
Persist shared state across nodes in a compiled graph using the built-in in-memory store.
python
copy
from langgraph.graph.state import StateGraph
from langgraph.managed.shared_value import SharedValue
from langgraph.store.memory import MemoryStore
store = MemoryStore()
graph = StateGraph(...)
# SharedValue field is accessible and writable by all nodes
graph.add_node("node_a", node_a_fn)
graph.add_node("node_b", node_b_fn)
app = graph.compile(store=store)
Batch async store operations to reduce round-trips when many nodes read/write shared state concurrently.
python
copy
from langgraph.store.memory import MemoryStore
from langgraph.store.batch import AsyncBatchedStore
batched_store = AsyncBatchedStore(MemoryStore())
app = graph.compile(store=batched_store)
Check at runtime whether a managed value can be mutated before attempting an update.
python
copy
from langgraph.managed.base import is_writable_managed_value, is_readonly_managed_value
if is_writable_managed_value(my_value):
await my_value.aupdate(new_data)
elif is_readonly_managed_value(my_value):
print("This value cannot be updated")
New SharedValue class enables shared, writable state across graph nodes with optional scoping by configuration. Not checked yet New WritableManagedValue abstract class extends the managed values system with update() and aupdate() methods for sync/async mutations. Not checked yet New store parameter on StateGraph.compile() wires a persistent storage backend into the graph. Not checked yet New BaseStore abstract class defines a standard interface (list/update, sync and async) for pluggable storage engines. Not checked yet New MemoryStore provides a ready-to-use in-memory implementation of BaseStore. Not checked yet
+3 more
show less
New AsyncBatchedStore wraps any BaseStore to batch async operations for higher-throughput workloads. Not checked yet New utility functions is_readonly_managed_value and is_writable_managed_value allow runtime inspection of managed value types. Not checked yet New ChannelKeyPlaceholder and ChannelTypePlaceholder objects support dynamic injection of channel key and type metadata. Not checked yet
8 details in Everything
LangGraph 0.2.6 adds structured graph interrupts with timing context and a new NodeInterrupt exception for in-node signaling.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.6 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.6
└──▷ USE IT
Pause a node mid-execution (e.g., to await human approval) and surface structured timing context to the caller.
python
copy
from langgraph.errors import NodeInterrupt
def review_node(state):
if state["needs_approval"]:
raise NodeInterrupt("Waiting for human approval before proceeding")
return state
Inspect which interrupts fired and when after catching a GraphInterrupt to decide how to resume.
python
copy
from langgraph.errors import GraphInterrupt
try:
result = graph.invoke(inputs)
except GraphInterrupt as e:
for interrupt in e.interrupts:
print(f"Interrupted {interrupt.when}: {interrupt.value}")
New Interrupt dataclass captures structured interruption events with a when field ("before", "during", "after") and an optional value. Not checked yet New NodeInterrupt exception lets node logic explicitly signal a mid-execution interrupt without raising a generic error. Not checked yet Enhanced GraphInterrupt now stores a list of Interrupt objects, giving full context on when and how many interrupts occurred. Not checked yet Adds interrupts field to PregelTask for per-task interrupt visibility useful in debugging and flow control. Not checked yet Adds CONFIG_KEY_TASK_ID constant to track task identifiers through the configuration system. Not checked yet
+1 more
show less
should_interrupt now returns the list of executable tasks to be interrupted instead of a boolean, enabling precise per-task interrupt control. Not checked yet
6 details in Everything
└──▷ BREAKING ON UPGRADE
! langgraph.pregel.algo.should_interrupt return type changed from bool to a list of executable tasks — any code that checks the return value as a boolean will behave incorrectly.
LangGraph 0.2.5 adds task-level error tracking in state snapshots and a new ERROR constant for consistent failure visibility.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.5 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.5
└──▷ USE IT
Inspect task-level errors after a graph run to understand which node failed and why.
python
copy
snapshot = await graph.aget_state(config)
for task in snapshot.tasks:
if task.error is not None:
print(f"Task {task.id} failed with: {task.error}")
Adds ERROR = "__error__" constant (reserved key) for consistent error tracking and propagation across graph execution. Not checked yet Enhances StateSnapshot with a new tasks field that surfaces task-level error details in state history. Not checked yet Introduces enhanced PregelTask class with id and optional error fields to uniquely identify tasks and capture exceptions. Not checked yet Adds tasks_w_writes debug function to associate tasks with their writes and any errors for richer checkpoint debug output. Not checked yet Extends get_state / aget_state on Pregel to include proper step numbers and task error information in returned snapshots. Not checked yet
5 details in Everything
└──▷ BREAKING ON UPGRADE
! The __call__ method of ManagedValue has its signature changed from __call__(self, step: int, task: PregelTaskDescription) to __call__(self, step: int) — any custom ManagedValue subclass that accepts a task parameter will break.! The __call__ method of IsLastStepManager has its signature changed from __call__(self, step: int, task: PregelExecutableTask) to __call__(self, step: int) — any code calling this with a task argument will break.! PregelTaskDescription is replaced by the new PregelTask class — code that references or type-hints PregelTaskDescription directly will break.
JsonPlusSerializer gains native support for pathlib, regex, decimal, deque, IP address, and time types.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==1.0.3 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==1.0.3
Supports serialization of pathlib.Path, re.Pattern, decimal.Decimal, deque, IPv4/IPv6 IPv6 The current version of the Internet Protocol, standardized by the IETF, using 128-bit addresses to replace the exhausted IPv4 space. Cyber tools target it because modern networks run dual-stack or IPv6-only. address types, date, time, and ZoneInfo in JsonPlusSerializer. Not checked yet Deserialization Deserialization Turning stored or transmitted data back into objects a program can use. Unsafe handling of untrusted data can allow unexpected behavior or code execution. now returns None gracefully when a module or attribute is missing, instead of raising an exception. Not checked yet
2 details in Everything
LangGraph PostgreSQL checkpointer gains versioned schema migrations and JSON+Plus metadata serialization.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpointpostgres==1.0.1 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpointpostgres==1.0.1
└──▷ USE IT
Run versioned schema migrations on an existing PostgreSQL checkpoint database so it stays in sync after upgrading.
python
copy
from langgraph.checkpoint.postgres import PostgresSaver
with PostgresSaver.from_conn_string("postgresql://user:pass@localhost/db") as saver:
saver.setup() # applies all pending MIGRATIONS instead of recreating tables
Use the async saver with the same versioned migration support in an async workflow.
python
copy
from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
async with AsyncPostgresSaver.from_conn_string("postgresql://user:pass@localhost/db") as saver:
await saver.setup() # applies MIGRATIONS for the async variant
Adds versioned database migrations (MIGRATIONS list) for both PostgresSaver and AsyncPostgresSaver, replacing one-shot static table creation. Not checked yet Introduces JsonPlusSerializer-backed _load_metadata and _dump_metadata methods for consistent, richer metadata serialization across sync and async savers. Not checked yet
2 details in Everything
└──▷ BREAKING ON UPGRADE
! The is_setup flag has been removed from PostgresSaver and AsyncPostgresSaver in favor of the new versioned setup method; any code that reads or sets is_setup will break.
LangGraph 0.2 ships dedicated checkpointer libraries for SQLite and Postgres, including the previously cloud-only PostgresSaver.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.2.0 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.2.0
└──▷ USE IT
Use the SQLite checkpointer for local development with persistent state across runs without standing up a database server.
python
copy
from langgraph.checkpoint.sqlite import SqliteSaver
with SqliteSaver.from_conn_string("./local_state.db") as checkpointer:
graph = app.compile(checkpointer=checkpointer)
result = graph.invoke(
{"messages": ["Hello"]},
config={"configurable": {"thread_id": "dev-session-1"}}
)
New langgraph-checkpoint package exposes BaseCheckpointSaver, SerializationProtocol, and MemorySaver as a standalone base library. Not checked yet New langgraph-checkpoint-sqlite package provides SqliteSaver / AsyncSqliteSaver for local and experimental workflows. Not checked yet New langgraph-checkpoint-postgres package open-sources the production-grade PostgresSaver previously available only in LangGraph Cloud. Not checked yet New new_versions parameter in BaseCheckpointSaver.put enables further optimization of custom checkpointer implementations. Not checked yet Graph stream output now includes outputs from all nodes, including nodes that return no state writes (previously silent nodes were omitted). Not checked yet
5 details in Everything
└──▷ BREAKING ON UPGRADE
! thread_ts and parent_ts are renamed to checkpoint_id and parent_checkpoint_id respectively (via langgraph_checkpoint==1.0.0).! Re-exported imports like from langgraph.checkpoint import BaseCheckpointSaver no longer work; use from langgraph.checkpoint.base import BaseCheckpointSaver instead.! SQLite checkpointers have been moved to a separate library — pip install langgraph-checkpoint-sqlite is now required to use them.! The .from_conn_string method of SqliteSaver / AsyncSqliteSaver is now a context manager.! Graph stream output now emits {'node_1': None} for nodes that return no state writes, changing the shape of streamed output for graphs with such nodes.
LangGraph checkpoint 1.0.1 adds binary serialization, channel-version API, and context-manager support for MemorySaver.
└──▷ GET THIS VERSION
copy
$ git clone --branch checkpoint==1.0.1 https://github.com/langchain-ai/langgraph.git
$ git checkout checkpoint==1.0.1
└──▷ USE IT
Use MemorySaver as a context manager to ensure clean resource teardown in tests or short-lived scripts.
python
copy
from langgraph.checkpoint.memory import MemorySaver
with MemorySaver() as saver:
# saver is fully initialised; resources released on exit
checkpoints = list(saver.list(config))
Persist raw binary blobs (e.g. embeddings embeddings Lists of numbers a model produces to represent the meaning of text, images or code, so similar items sit close together. They power semantic search and RAG. or serialised models) directly in checkpoint state — now round-trippable through JsonPlusSerializer.
python
copy
from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
serde = JsonPlusSerializer()
type_tag, encoded = serde.dumps_typed(b"\x89PNG\r\n")
restored = serde.loads_typed((type_tag, encoded))
assert isinstance(restored, bytes)
Adds bytes and bytearray serialization support to JsonPlusSerializer, enabling binary data in checkpointed state. Not checked yet Introduces ChannelVersions type alias (dict[str, Union[str, int, float]]) for type-safe channel version handling. Not checked yet Extends BaseCheckpointSaver.put and aput with a new new_versions: ChannelVersions parameter exposing channel version info at write time. Not checked yet Implements sync and async context manager interfaces (__enter__/__exit__/__aenter__/__aexit__) on MemorySaver for explicit resource management. Not checked yet
4 details in Everything
└──▷ BREAKING ON UPGRADE
! The put and aput methods on BaseCheckpointSaver (and MemorySaver) now require a new_versions: ChannelVersions parameter — any custom subclass that overrides these methods without the new parameter will break.
LangGraph SDK 0.1.27 adds optional URL client init, ASGI ASGI A Python async web server interface specification that defines how servers and applications exchange HTTP and WebSocket messages; cyber tools use it to serve high-concurrency APIs without blocking on I/O. transport support, thread copy, and assistant if_exists dedup control.
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.27 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.27
└──▷ USE IT
Connect to a local LangGraph server without specifying a URL — useful in dev environments where defaults are sufficient.
python
copy
from langgraph_sdk import get_client
client = get_client() # url is now optional
Create an assistant idempotently — safe to run in setup scripts without worrying about duplicate errors.
python
copy
assistant = await client.assistants.create(
graph_id="my_graph",
config={"configurable": {"model": "gpt-4o"}},
if_exists="return_existing",
)
Duplicate a thread to branch off a conversation without modifying the original.
python
copy
new_thread = await client.threads.copy(thread_id="<thread_id>")
Makes the url parameter optional in get_client, with intelligent defaults so local dev requires no explicit URL. Not checked yet Adds ASGI transport support in get_client with correct root path configuration. Not checked yet Adds if_exists parameter to AssistantsAPI.create for controlling behavior on duplicate assistant creation. Not checked yet Adds a new ThreadsAPI.copy method for duplicating existing threads. Not checked yet Makes GraphSchema fields (input_schema, state_schema, config_schema) optional for better TypeScript interoperability. Not checked yet
5 details in Everything
LangGraph 0.1.17 lets update_state() accept None values to preserve configuration without changing state.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.1.17 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.1.17
└──▷ USE IT
Preserve checkpoint configuration between steps without overwriting any state values — useful when you need to advance step count or merge configurable fields mid-graph.
python
copy
graph.update_state(config, values=None)
Supports None as a valid values argument in Pregel.update_state() , enabling configuration-only state updates that leave channel values unchanged. Not checked yet
1 detail in Everything
LangGraph 0.1.10 adds InjectedState for automatic graph-state injection into tools and improves parallel tool execution in ToolNode.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.1.10 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.1.10
└──▷ USE IT
Give a tool access to the current graph state (e.g., conversation history) without asking the LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. to supply it — useful for retrieval or policy tools that need context the model shouldn't fabricate.
python
copy
from typing import Annotated
from langgraph.prebuilt.tool_node import InjectedState
from langchain_core.tools import tool
class AgentState(TypedDict):
messages: list
user_id: str
@tool
def lookup_policy(
topic: str,
state: Annotated[AgentState, InjectedState()],
) -> str:
"""Look up company policy, scoped to the current user."""
user_id = state["user_id"] # injected automatically; model never sees it
return fetch_policy(topic, user_id)
Adds InjectedState annotation to automatically inject graph state into tool arguments inside ToolNode, so tools can access state fields without the model generating them. Not checked yet Improves parallel execution of tools in ToolNode using config lists via get_config_list from langchain-core. Not checked yet Adds GraphInterrupt error class for structured handling of interruptions in nested graphs. Not checked yet Adds EmptyInputError error class for clearer reporting when graphs receive empty inputs. Not checked yet Enhances checkpoint parent-child relationship tracking and includes parent configuration data in checkpoint tuples, improving support for nested graphs. Not checked yet
5 details in Everything
LangGraph 0.1.9 adds state_modifier to create_react_agent, custom state schemas, retry policies, and new background executor classes.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.1.9 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.1.9
└──▷ USE IT
Use state_modifier to prepend a system prompt from the full agent state, giving you access to state fields beyond just messages.
python
copy
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
def modify_state(state):
# state is the full graph state, not just messages
return [{"role": "system", "content": "You are a helpful security analyst."}] + state["messages"]
agent = create_react_agent(
model=ChatOpenAI(model="gpt-4o"),
tools=[...],
state_modifier=modify_state,
)
Define a custom state schema with extra fields so the agent graph carries domain-specific context alongside messages.
python
copy
from typing import TypedDict, Annotated
from langgraph.prebuilt import create_react_agent
from langchain_openai import ChatOpenAI
import operator
class MyAgentState(TypedDict):
messages: Annotated[list, operator.add]
user_role: str # custom field
session_id: str # custom field
agent = create_react_agent(
model=ChatOpenAI(model="gpt-4o"),
tools=[...],
state_schema=MyAgentState,
)
Adds state_modifier parameter to create_react_agent for finer control over LLM LLM A large language model, a neural network trained on large amounts of text to recognize patterns and generate language. Applications use it for tasks such as answering, summarizing and writing code. inputs, replacing the now-deprecated messages_modifier. Not checked yet Adds state_schema parameter to create_react_agent, enabling custom graph state definitions beyond the default AgentState. Not checked yet Adds BackgroundExecutor and AsyncBackgroundExecutor classes in langgraph.pregel for structured background task management and cancellation. Not checked yet Adds retry policies for nodes in StateGraph. Not checked yet Adds custom input and output type support to StateGraph. Not checked yet
+3 more
show less
Adds equality comparison (__eq__) to all channel classes (AnyValue, LastValue, Topic , and others), enabling channel state comparisons. Not checked yet Improves graph visualization to include type-hint hints for conditional edges and to create END nodes only when needed. Not checked yet Adds node-existence validation in update_state, surfacing clear errors when a nonexistent node is targeted. Not checked yet
8 details in Everything
└──▷ BREAKING ON UPGRADE
! The messages_modifier parameter of create_react_agent is deprecated; migrate to state_modifier.
LangGraph CLI 0.1.49 adds a dockerfile command to generate customized Dockerfiles for the LangGraph API server.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.49 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.49
└──▷ TRY IT
Generate a ready-to-build Dockerfile from your LangGraph config so you can version-control or customize it before pushing to a registry.
copy
$ langgraph dockerfile --config langgraph.json --output Dockerfile
New dockerfile CLI command generates a Dockerfile for the LangGraph API server, accepting a save path and configuration file for customization. Not checked yet Docker image generation now sets PYTHONDONTWRITEBYTECODE=1 and passes --no-cache-dir to pip installs, producing smaller images. Not checked yet
2 details in Everything
LangGraph SDK 0.1.26 adds batch run creation, cron job scheduling, and thread conflict handling
└──▷ GET THIS VERSION
copy
$ git clone --branch sdk==0.1.26 https://github.com/langchain-ai/langgraph.git
$ git checkout sdk==0.1.26
└──▷ USE IT
List all scheduled cron jobs for a specific assistant to audit or manage recurring runs.
python
copy
crons = await client.crons.search(assistant_id="asst-abc", limit=20, offset=0)
New RunCreate TypedDict enables structured background run creation with fields for thread_id, assistant_id, input, metadata, and run configuration options. Not checked yet New create_batch method on LangGraphClient submits multiple runs in a single API call for more efficient batch operations. Not checked yet New Cron class and search method support scheduled job management, with filtering by assistant_id and thread_id and pagination. Not checked yet New OnConflictBehavior type ("raise" or "do_nothing") controls what happens when a thread is created that already exists, via the new if_exists parameter on Threads.create. Not checked yet
4 details in Everything
LangGraph 0.1.8 adds node-level metadata support via add_node's new metadata parameter and the NodeSpec class.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.1.8 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.1.8
└──▷ USE IT
Tag a node with metadata (e.g. owner or risk label) so it appears in graph visualisations and downstream tooling.
python
copy
graph.add_node("my_agent", my_runnable, metadata={"team": "red-team", "criticality": "high"})
Adds an optional metadata parameter to Graph.add_node to attach arbitrary metadata to graph nodes, surfaced through NodeSpec instances. Not checked yet Introduces langgraph.graph.graph.NodeSpec, a new class that stores a runnable alongside optional metadata for a node. Not checked yet Propagates node metadata through PregelNode.__init__ into the node's configuration. Not checked yet Exposes node metadata in graph visualizations via the updated CompiledGraph.get_graph method. Not checked yet
4 details in Everything
LangGraph 0.1.7 adds persistent task-write checkpointing via new put_writes/aput_writes methods, enabling resilient interrupted-workflow recovery.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.1.7 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.1.7
└──▷ USE IT
Persist mid-run task writes so that an interrupted graph can resume without re-executing completed tasks.
python
copy
from langgraph.checkpoint.sqlite import SqliteSaver
checkpointer = SqliteSaver.from_conn_string('checkpoints.db')
# During a custom checkpointer integration, flush task writes explicitly:
checkpointer.put_writes(config, writes, task_id)
Adds put_writes and aput_writes methods to BaseCheckpointer (implemented across Memory , SQLite , and AioSQLite checkpointers) for storing task-specific writes mid-execution. Not checked yet Adds pending_writes field to CheckpointTuple to carry per-task write state that is restored when a checkpoint is reloaded. Not checked yet Tasks with pre-loaded pending_writes are skipped on restart, avoiding redundant re-execution when resuming interrupted workflows. Not checked yet
3 details in Everything
LangGraph 0.1.6 adds RemoveMessage support for message deletion by ID and handle_tool_errors parameter in ToolNode.
└──▷ GET THIS VERSION
copy
$ git clone --branch 0.1.6 https://github.com/langchain-ai/langgraph.git
$ git checkout 0.1.6
└──▷ USE IT
Disable automatic tool-error suppression in a ToolNode so exceptions propagate directly — useful when you want strict failure semantics in CI or testing.
python
copy
from langgraph.prebuilt import ToolNode
tool_node = ToolNode(tools=[my_tool], handle_tool_errors=False)
Prune a specific message from a running message graph by its ID — handy for trimming context or removing a malformed turn mid-conversation.
python
copy
from langchain_core.messages import RemoveMessage
# Return a RemoveMessage from a node to delete the message with the given ID
def cleanup_node(state):
return {"messages": [RemoveMessage(id="msg-abc123")]}
Adds handle_tool_errors parameter (defaults to True ) to ToolNode in langgraph.prebuilt.tool_node, returning a friendly error message instead of raising an exception when a tool fails, so agents can continue the conversation after tool errors. Not checked yet Adds support for RemoveMessage from langchain-core in langgraph.graph.message.add_messages, enabling deletion of specific messages by ID from message graphs, with validation that raises an error if the target message ID does not exist. Not checked yet
2 details in Everything
LangGraph CLI 0.1.48 adds --debugger-base-url to point the debugger at a custom LangGraph API URL
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.48 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.48
└──▷ TRY IT
Point the LangGraph debugger at a remotely accessible API URL so teammates on other machines can use the Studio UI against your local server.
copy
$ langgraph dev --debugger-base-url https://my-dev-server.example.com:8123
Adds --debugger-base-url CLI option to specify a custom URL for the debugger to access the LangGraph API, overriding the default http://127.0.0.1:[PORT]; also sets VITE_STUDIO_LOCAL_GRAPH_URL in the debugger container when the option is used. Not checked yet Makes Docker base image pulls verbose during build to provide better visibility into the build process. Not checked yet
2 details in Everything
LangGraph CLI 0.1.45 adds a test command to validate graphs locally before deploying to LangGraph Cloud.
└──▷ GET THIS VERSION
copy
$ git clone --branch cli==0.1.45 https://github.com/langchain-ai/langgraph.git
$ git checkout cli==0.1.45
└──▷ TRY IT
Validate that your graph works with the LangGraph API server before pushing to LangGraph Cloud.
Adds langgraph test subcommand to start a local test server that validates graph compatibility with the LangGraph API server before deploying to LangGraph Cloud. Not checked yet Improves environment variable handling in config.config_to_compose to support both string (env file) and dictionary formats, with proper quoting of values in Docker Compose configuration. Not checked yet Enhances watch functionality in config.config_to_compose for better dependency tracking during development. Not checked yet
3 details in Everything
└──▷ BREAKING ON UPGRADE
! The langgraph-api-path option has been removed from CLI commands.