◆ AI Agent Frameworks

LangGraph

sdk==0.4.4 open-source

LangGraph is a framework for building stateful, multi-actor applications using language models with cyclic computational graphs.

source ↗ rss ↗ last repo push Aug 19, 2026

graph.add_node("my_node", my_node_fn, trace_policy=<policy>)
graph.add_node('my_node', my_node_fn, trace_policy=TracePolicy(...))
graph.add_node('my_node', my_node_fn, trace_policy=TracePolicy(...))
crons = await client.crons.search(metadata={"env": "production", "team": "infra"})
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)
client.threads.update(thread_id, return_minimal=True)
history = await saver.get_writes_history(config)
# (Python) — stream_events v3
async for event in graph.astream_events(input, version='v3'):
    print(event)
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])
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])
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])
result = await client.runs.create(
    thread_id=thread_id,
    assistant_id=assistant_id,
    input={"messages": [{"role": "user", "content": "hello"}]},
    langsmith_tracing=False,
)
langgraph deploy revisions list
langgraph deploy logs <deployment-id>
langgraph deploy list
langgraph deploy delete <deployment-id>
result = graph.invoke({"input": "hello"}, version="v2")
result.value       # your output state
result.interrupts  # tuple[Interrupt, ...], empty if none
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]
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)
langgraph deploy
from langgraph_sdk import get_client, SKIP_LOAD_API_KEY

client = get_client(url="http://localhost:8123", api_key=SKIP_LOAD_API_KEY)
assistants = await client.assistants.search(name="my-assistant")
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
graph.invoke(input, durability="ephemeral")
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')
)
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']))
thread_state = await client.threads.get_state(thread_id)
interrupts = thread_state.interrupts
for event in graph.stream(input, stream_mode="tasks"):
    print(event)
from langgraph.graph import StateGraph

graph = StateGraph(
    state_schema=MyState,
    input_schema=UserQuery,
    output_schema=AssistantResponse,
)
async for chunk in graph.astream(inputs, stream_mode=["tasks", "checkpoints"]):
    print(chunk)
from langgraph.store.sqlite import SqliteStore

store = SqliteStore("./my_app.db")
results = store.list_namespaces(max_depth=2)
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,
)
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)
store = SqliteStore("./agent_state.db")
# ... populate store ...
store.clear()  # deletes all entries when called without arguments
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"})
from langgraph_sdk import get_client

client = get_client(url="http://localhost:8123", timeout=30)
checkpointer.delete_thread(thread_id)
async for chunk in client.runs.stream(
    thread_id,
    assistant_id,
    input=input_data,
    checkpoint_during=False,
):
    print(chunk)
run = await client.runs.create(
    thread_id,
    assistant_id,
    input=input_data,
    checkpoint_during=True,
)
results = await client.assistants.search(sort_by="updated_at", sort_order="desc")
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)
graph.invoke(Command(resume={interrupt.interrupt_id: "approved"}), config)
snapshot = graph.get_state(config)
for interrupt in snapshot.interrupts:
    print(interrupt.interrupt_id, interrupt.value)
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")
from langgraph.pregel.draw import draw_graph

draw_graph(compiled_graph)
langgraph up --image my-custom-langgraph-image:latest
langgraph dev --tunnel
threads = await client.threads.search(
    sort_by="updated_at",
    sort_order="desc"
)
saver = PostgresSaver(conn)
saver.delete_thread(thread_id="thread-abc123")
saver = AsyncPostgresSaver(conn)
await saver.adelete_thread(thread_id="thread-abc123")
{
  "_INTERNAL_docker_tag": "3.11-slim-bookworm"
}
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
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])
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):
    ...
result = graph.invoke({"messages": messages}, config=config, checkpoint_during=False)
async for chunk in graph.astream({"messages": messages}, config=config, checkpoint_during=False):
    process(chunk)
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
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]
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,
)
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,
)
assistant = await client.assistants.create(
    graph_id="my-graph",
    description="Triages incoming support tickets and routes to the correct queue."
)
await client.assistants.update(
    assistant_id="asst_abc123",
    description="Revised: handles both support tickets and billing inquiries."
)
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
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)]}
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",
    )
)
langgraph dev --allow-blocking
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])
run = await client.runs.create(
    thread_id="<thread_id>",
    assistant_id="<assistant_id>",
    headers={"X-Tenant-ID": "org-42", "X-Request-ID": "req-abc123"}
)
async for chunk in client.runs.stream(
    thread_id="<thread_id>",
    assistant_id="<assistant_id>",
    headers={"Authorization": "Bearer <ephemeral_token>"}
):
    print(chunk)
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)
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],
)
langgraph dev --studio_url https://studio.internal.example.com
thread = await client.threads.create(
    supersteps=source_supersteps,
    graph_id="my-graph",
    metadata={"copied_from": source_thread_id}
)
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)
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)
if channel.is_available():
    value = channel.get()
await compiled_graph.aget_graph(xray=True)
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)
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())
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()
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()
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")
from langgraph.store.base import TTLConfig

ttl_config = TTLConfig(
    sweep_interval_minutes=30
)
ttl_config = TTLConfig(
    sweep_interval_minutes=10
)
export LANGGRAPH_DEFAULT_RECURSION_LIMIT=100
async for chunk in client.runs.join_stream(thread_id, run_id, stream_mode=["values", "debug"]):
    print(chunk)
for chunk in client.runs.join_stream(thread_id, run_id, stream_mode=["values"], cancel_on_disconnect=True):
    print(chunk)
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])
from langgraph.prebuilt import create_react_agent
from langgraph.prebuilt.chat_agent_executor import AgentStatePydantic

agent = create_react_agent(model, tools=[...], state_schema=AgentStatePydantic)
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
    )
)
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
    )
)
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})
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)
from langgraph.store.postgres.base import PLACEHOLDER
store.put(("namespace",), 42, {"value": "data"})
result = store.get(("namespace",), 42)
await client.store.put_item(namespace, key="session:user123", value={"token": "abc"}, ttl=30)
item = await client.store.get_item(namespace, key="session:user123", refresh_ttl=True)
{
  "graphs": {
    "my_agent": "./agent.py:graph"
  },
  "ui": {
    "my_agent": "./ui/MyAgentComponent.tsx"
  }
}
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])
schema = graph.get_config_jsonschema()
print(schema)
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")
from langgraph.prebuilt.chat_agent_executor import AgentStateWithStructuredResponse
@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")
http:
  app: ./my_middleware_app.py:app
  cors:
    allow_origins:
      - "https://my-frontend.example.com"
    allow_methods:
      - "GET"
      - "POST"
  disable_routes:
    - assistants
    - store
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}},
)
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()
from langgraph.checkpoint.base import get_checkpoint_metadata

metadata = get_checkpoint_metadata(config)
# metadata contains only string/int/bool/float fields, private keys excluded
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.
graph.add_node("router", router_fn, destinations={"process": "to_process", "fallback": "to_fallback"})
graph.add_node("router", router_fn, destinations=("process", "fallback"))
from langgraph.store.base import IndexConfig

index_config = IndexConfig(
    embed="openai:text-embedding-3-small",
    dims=1536,
)
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"}]})
from langgraph.graph import StateGraph

builder = StateGraph(MyState)
# ... add nodes and edges ...
graph = builder.compile(name="research-agent")
from langgraph.prebuilt import create_react_agent

agent = create_react_agent(
    model=model,
    tools=[search],
    name="web-search-agent",
)
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
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
from langgraph.prebuilt import ToolNode
from langgraph.store.memory import InMemoryStore

store = InMemoryStore()
tool_node = ToolNode(tools=[my_tool], store=store)
{
  "graphs": {
    "my_agent": "./agent.py:graph"
  },
  "auth": {
    "path": "./auth/handler.py:auth"
  }
}
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()
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"}]})
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)
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)
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"})
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()
from langgraph.config import get_store

@task
def save_result(key: str, value: str):
    store = get_store()
    store.put(("results",), key, {"value": value})
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
    ...
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
subgraph = subgraph_builder.compile(checkpointer=True)
parent = parent_builder.compile(checkpointer=memory_checkpointer)
parent.add_node("sub", subgraph)
from langgraph.prebuilt import create_react_agent

agent = create_react_agent("openai:gpt-4", tools)
await saver.aput_writes(config, writes, task_id, task_path="agent/subgraph")
saver.put_writes(config, writes, task_id, task_path="agent:tool_call")
await async_saver.aput_writes(config, writes, task_id, task_path="agent:tool_call")
saver.put_writes(config, writes, task_id, task_path="parent_task/child_task")
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)
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"])
from langgraph.types import Command

updates = [("messages", new_message), ("turn_count", 5)]
cmd = Command(update=updates)
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")]
from langgraph.func import task

@task
async def fetch_data(url: str, timeout: int = 30) -> dict:
    # async I/O here
    ...
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_auth": true
}
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")
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"),
        ]
    }
)
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"]}
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)}
# langgraph.json
{
  "auth": {
    "path": "./my_auth.py:handler",
    "disable_studio_auth": true
  }
}
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)
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}
from langgraph.types import Command

# Previously required Send; now a plain string works
def my_node(state):
    return Command(goto="approval_node")
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)
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")
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])
async for chunk in client.stream(
    assistant_id,
    thread_id,
    input=input_data,
    params={"my_filter": "value", "limit": 10},
):
    print(chunk)
from langgraph.types import Command, Send

cmd = Command(goto=[Send("node_a", {"x": 1}), "node_b"])
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})])
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}
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)
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."}]})
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)
runs = await client.runs.list(thread_id="<thread_id>", status="pending")
async for chunk in client.runs.join_stream(thread_id="<thread_id>", run_id="<run_id>", cancel_on_disconnect=True):
    print(chunk)
async for chunk in client.assistants.stream(assistant_id="<assistant_id>", command=<command>):
    print(chunk)
from langgraph.store.postgres.base import ANNIndexConfig, IVFFlatConfig

index_config = ANNIndexConfig(
    kind="ivfflat",
    ann_index_config=IVFFlatConfig(nlist=256),
)
langgraph dev --debug-port 5678 --wait-for-client
from langgraph_cli.config import IndexConfig, StoreConfig

store = StoreConfig(
    index=IndexConfig(
        dims=1536,
        embed="openai:text-embedding-3-small",
        fields=["text", "description"],
    )
)
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)
await client.store.put_item(namespace, key="user-42", value={"name": "Alice", "notes": "VIP customer", "internal_id": 99}, index=["name", "notes"])
await client.store.put_item(namespace, key="secret-config", value={"api_key": "s3cr3t"}, index=False)
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)
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)
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"])
namespaces = await store.alist_namespaces(prefix=("user", "alice"), depth=3, limit=50)
env:
  OPENAI_API_KEY: "sk-..."
  MY_CUSTOM_VAR: "value"
from langgraph_cli.config import validate_config_file

config = validate_config_file("langgraph.json")
langgraph dev --port 8123 --no-browser --config langgraph.json
pip install "langgraph-cli[inmem]"
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"}})
await graph.aupdate_state(config, values=None, as_node=None)
graph.update_state(config, values=None, as_node=None)
langgraph new my-agent-project
langgraph dockerfile --add-docker-compose langgraph.json
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)
async for chunk in client.runs.stream(
    thread_id,
    assistant_id,
    command={"resume": "user_approved"},
    stream_mode="messages-tuple",
):
    print(chunk)
await client.runs.cancel(thread_id, run_id, action="rollback")
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)
graph = StateGraph(MyState)
graph.add_sequence([
    ("ingest", ingest_node),
    ("analyze", analyze_node),
    ("summarize", summarize_node),
])
app = graph.compile()
subgraph = StateGraph(SubState)
subgraph.add_node("step", step_node)
subgraph.set_entry_point("step")
compiled_sub = subgraph.compile(checkpointer=False)
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")
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})
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)
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)
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)
tool_node = ToolNode(tools, messages_key="chat_history")
condition   = tools_condition(messages_key="chat_history")
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}",
)
result = await client.wait(thread_id, run_id, raise_error=False)
if "__error__" in result:
    print("Run failed:", result["__error__"])
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)
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
)
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]}
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.")
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"])
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)
response = await client.threads.update_state(
    thread_id=thread_id,
    values={"messages": [{"role": "assistant", "content": "Corrected reply"}]},
)
print(response)  # ThreadUpdateStateResponse with checkpoint info
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)
from langgraph.pregel.utils import find_subgraph_pregel

subgraph = find_subgraph_pregel(my_runnable)
if subgraph:
    print("Found Pregel subgraph:", subgraph)
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
)
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."
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"])
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"])
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)
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)
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)
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)
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())
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"}]})
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"}
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)
subgraphs = list(graph.get_subgraphs(namespace="my_agent"))
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])
await client.assistants.set_latest(assistant_id="asst_abc123", version=3)
versions = await client.assistants.get_versions(assistant_id="asst_abc123")
for v in versions:
    print(v.version, v.config)
await client.runs.create(thread_id="thread_xyz", assistant_id="asst_abc123", after_seconds=60)
from langgraph.types import Send, Interrupt
for chunk in graph.stream(inputs, stream_mode="messages"):
    print(chunk)
# 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)
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)
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)
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)
from langgraph.prebuilt import ToolNode

node = ToolNode(tools=[my_tool])
print(node.name)  # "ToolNode"
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"))
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")
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)  # []
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)
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)
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)
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()
threads = await client.threads.search(values={"topic": "billing", "status": "open"})
final_state = await client.runs.join(thread_id, run_id)
print(final_state)
{
  "node_version": "20",
  "graphs": {
    "my_graph": "./src/graph.ts:graph"
  }
}
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)
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)
async for chunk in client.runs.join_stream(thread_id, run_id):
    print(chunk)
async for chunk in client.runs.stream(
    thread_id,
    assistant_id,
    input=input_data,
    on_disconnect="cancel",
    on_completion="delete",
):
    print(chunk)
run = await client.runs.create(
    thread_id,
    assistant_id,
    input=input_data,
    on_completion="keep",
)
from langgraph.managed.base import ManagedValue

class MyRuntimeValue(ManagedValue, runtime=True):
    ...
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)
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"])
from langgraph_sdk import get_client

client = get_client(
    url="https://your-langgraph-endpoint",
    headers={"x-tenant-id": "acme-corp", "x-trace-id": "abc123"},
)
state = await client.threads.get_state(
    thread_id="<thread_id>",
    checkpoint_id="<checkpoint_id>",
    checkpoint_ns="pipeline-a",
)
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)
from langgraph.store.memory import MemoryStore
from langgraph.store.batch import AsyncBatchedStore

batched_store = AsyncBatchedStore(MemoryStore())
app = graph.compile(store=batched_store)
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")
from langgraph.errors import NodeInterrupt

def review_node(state):
    if state["needs_approval"]:
        raise NodeInterrupt("Waiting for human approval before proceeding")
    return state
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}")
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}")
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
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
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"}}
    )
from langgraph.checkpoint.memory import MemorySaver

with MemorySaver() as saver:
    # saver is fully initialised; resources released on exit
    checkpoints = list(saver.list(config))
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)
from langgraph_sdk import get_client

client = get_client()  # url is now optional
assistant = await client.assistants.create(
    graph_id="my_graph",
    config={"configurable": {"model": "gpt-4o"}},
    if_exists="return_existing",
)
new_thread = await client.threads.copy(thread_id="<thread_id>")
graph.update_state(config, values=None)
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)
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,
)
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,
)
langgraph dockerfile --config langgraph.json --output Dockerfile
crons = await client.crons.search(assistant_id="asst-abc", limit=20, offset=0)
graph.add_node("my_agent", my_runnable, metadata={"team": "red-team", "criticality": "high"})
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)
from langgraph.prebuilt import ToolNode

tool_node = ToolNode(tools=[my_tool], handle_tool_errors=False)
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")]}
langgraph dev --debugger-base-url https://my-dev-server.example.com:8123
langgraph test

Summary

LangGraph is an open-source, MIT-licensed orchestration framework for building stateful, long-running agents, distributed as a Python library (with a JS/TS equivalent) that you install with pip and import directly into application code rather than run as a standalone service. It handles durable execution, letting agents persist through failures and resume where they left off, and supports human-in-the-loop steps for inspecting or modifying agent state mid-run, plus checkpointed state history and streaming APIs for observability. It's aimed at developers building agentic applications rather than end users, and the README points to Deep Agents as a higher-level package built on top of it for those wanting more scaffolding out of the box. Backed by LangChain, it has 320 contributors, over 1,700 commits in the past year, and a release 22 days ago, indicating active development.

LangGraph is a framework for building stateful, multi-actor applications using language models with cyclic computational graphs.

What LangGraph answers

What happens to a long-running agent if the process crashes partway through?

node-level error handlers catch failures where they occur, and execution can resume from the last checkpoint after a host crash instead of restarting the whole run

Do I need to run a separate server to use this?

no — it is a library you install and import into application code, though a CLI can deploy graphs to a hosted studio if you want that later

How do I watch what an agent is doing while it runs?

streaming APIs expose node-level events, message and tool-call output, and full write-history retrieval for a thread, over either SSE or WebSocket

Will checkpoint storage keep growing as an agent runs for a long time?

state is stored as incremental deltas rather than full snapshots at every step, with periodic forced snapshots so replay never has an unbounded gap

Can I connect an agent's execution to a system outside the process it runs in?

remote graph execution supports the same streaming protocol as local runs, so a graph invoked over the network still gives real-time output

all 11 features, with the evidence for each →

Features

11 capabilities across 6 areas · 2 backed by code, an API document or a real run

Built from everything we hold on LangGraph — every release we have summarised, its product documentation and how that documentation has changed, its README, its command-line surface and API, and runs we performed ourselves. Dates are when we first saw a capability, not when the vendor introduced it.

Capability area

Streaming and Remote Graph Execution 4 capabilities LangGraph provides multiple transport options and protocol controls for streaming the output of graph runs to remote callers. Users can tune how events are delivered, filtered, and identified across SSE and WebSocket connections.

v3 streaming protocol support shipped Enables remote graph runs to stream events using an updated protocol with typed events and more precise filtering options. 4 releases · first seen Jun 2026

release

Adds typed return for v3 stream_events and supports native projections for more precise event filtering. 1.2.10 · Jul 2026 · source · release history
Enables v3 streaming protocol support in RemoteGraph, allowing remote graphs to leverage the latest streaming features. sdk==0.4.1 · Jun 2026 · source · release history
Adds v3 streaming primitives and SSE transport to the Python SDK, aligning the client with the updated server-side streaming protocol. 1.2.3 · Jun 2026 · source · release history
Adds v3 streaming support to RemoteGraph, enabling the latest streaming protocol for remote graph execution. 1.2.3 · Jun 2026 · source · release history

Streamed output projections shipped Lets callers narrow streamed output to specific views, such as messages or tool-call events, rather than receiving everything. 3 releases · 1 other source · first seen Jun 2026

release

Adds interleave_projections capability via extracted stream decoders in the Python SDK, enabling finer control over streamed output projection. sdk==0.4.1 · Jun 2026 · source · release history
Adds messages and tool call projections to the Python SDK, enabling filtered views of streamed agent output. 1.2.3 · Jun 2026 · source · release history
Wires RemoteGraph.interleave_projections to the SDK's interleave_projections, allowing interleaved stream projection control from the client. 1.2.3 · Jun 2026 · source · release history

example

Use interleave_projections on a RemoteGraph to merge streamed message and tool-call events into a single ordered sequence. $ 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",… 1.2.3 · Jun 2026 · source

WebSocket stream transport shipped Allows graph runs to be streamed over a persistent WebSocket connection as an alternative to HTTP server-sent events. 1 release · 1 other source · first seen Jun 2026

release

Adds WebSocket stream transport to the Python SDK for persistent, low-latency streaming connections. 1.2.3 · Jun 2026 · source · release history

example

Stream a remote graph run over WebSocket for low-latency, persistent connections instead of HTTP SSE. $ 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",… 1.2.3 · Jun 2026 · source

Wire-format field alignment in streaming protocol shipped Keeps the SDK's streaming event field names consistent with what is actually sent over the wire, reducing confusion when inspecting raw output. 1 release · first seen Jun 2026

release

The ProtocolEvent.eventId field is renamed to event_id to match the wire field 1.2.3 · Jun 2026 · source · release history

Deployment and Local Development 3 capabilities LangGraph covers the path from local testing to production deployment, including HTTPS support for dev servers and faster build pipelines. These capabilities reduce friction when moving a graph from a developer machine to a hosted environment.

TLS/HTTPS for local development server verified Lets the local development server run over HTTPS so it can be tested with clients that require secure connections. 1 release · 3 other sources · first seen Jun 2026

release

Adds --certfile and cert key options to langgraph dev so the local development server can be served over HTTPS. cli==0.4.29 · Jun 2026 · source · release history

command line

--ssl-keyfile — Path to an SSL key file for serving the development server over HTTPS. 1.2.5 · Jun 2026 · command-line history
--ssl-certfile — Path to an SSL certificate file for serving the development server over HTTPS. 1.2.5 · Jun 2026 · command-line history

example

Run the local dev server with TLS when your agent client or browser requires HTTPS endpoints during development. $ langgraph dev --certfile cert.pem --keyfile key.pem cli==0.4.29 · Jun 2026 · source

Prebuild image support for deployment shipped Allows deployments to start from a pre-built Docker image, cutting the time needed to deploy a graph. 1 release · first seen Jul 2026

release

Supports prebuild images when running langgraph deploy, enabling faster deployments using pre-built Docker images. cli==0.4.31 · Jul 2026 · source · release history

CLI–server API version negotiation shipped Lets the CLI work with a range of server API versions rather than being locked to one, reducing compatibility breakage during upgrades. 1 release · first seen Jun 2026

release

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. cli==0.4.30 · Jun 2026 · source · release history

Automation and Scripted Workflows 1 capability The CLI can operate without human interaction and emit machine-readable output, making LangGraph usable inside scripts, pipelines, and CI systems. This area covers the interfaces through which LangGraph is driven programmatically rather than interactively.

CLI non-interactive and structured output modes verified Runs the CLI without prompts and outputs structured JSON lines so it can be called reliably from scripts and automated pipelines. 2 other sources · first seen May 2026

command line

--no-input — Never prompt for input; fail with an error if a required value is missing. 1.2.0 · May 2026 · command-line history
--json — Emit structured JSON-lines to stdout instead of human-readable text. 1.2.0 · May 2026 · command-line history

Multi-Agent Graph Behaviour 1 capability LangGraph supports graphs where nodes spawn or coordinate with subagents, and provides controls over how those agents are identified during a run. These capabilities help users understand and manage what is happening across a graph with multiple active agents.

Subagent identity in multi-agent graphs shipped Lets subagents spawned by tool calls be given a name so they can be clearly identified within a multi-agent graph run. 1 release · first seen Jun 2026

release

Names tool-dispatched subagents via lc_agent_name, giving clearer identity to dynamically spawned subagents in multi-agent graphs. 1.2.3 · Jun 2026 · source · release history

State Management and Checkpointing 1 capability LangGraph persists graph state through checkpoints and gives users control over which stored states are visible during a run. Filtering expired checkpoints prevents outdated state from affecting long-running workflows.

Expired checkpoint row filtering shipped Lets checkpoint reads skip expired rows so that stale saved state does not surface during long-running workflow execution. 2 releases · first seen Jul 2026

release

Adds opt-in omit_expired parameter to checkpoint reads (supported in checkpoint and checkpoint-postgres) to skip expired rows, preventing stale state from surfacing in long-running workflows. checkpoint==4.2.0 · Aug 2026 · source · release history
Adds opt-in omit_expired parameter to checkpoint reads, allowing callers to skip expired rows and avoid processing stale state. checkpointpostgres==3.1.1 · Jul 2026 · source · release history

Observability and Tracing 1 capability LangGraph allows tracing behaviour to be configured at the level of individual nodes rather than applied uniformly across a graph. This gives operators control over what is recorded, including the ability to reduce tracing on nodes that handle sensitive data.

Per-node trace policy shipped Lets users set tracing behaviour per node when registering it, so sensitive nodes can be excluded or treated differently from the rest of the graph. 3 releases · 1 other source · first seen Jul 2026

release

Adds trace_policy parameter to add_node to control tracing behaviour on a per-node basis. 1.2.11 · Aug 2026 · source · release history
Removes tags from TracePolicy, simplifying the tracing configuration surface. 1.2.10 · Jul 2026 · source · release history
Exposes trace_policy parameter on add_node, enabling per-node control over tracing behaviour. 1.2.10 · Jul 2026 · source · release history

example

Restrict tracing on a sensitive node by setting a custom trace policy at node registration time. $ graph.add_node("sensitive_step", sensitive_fn, trace_policy=my_trace_policy) 1.2.10 · Jul 2026 · source

Capability

Evidence

Lines in monospace are the tool's own words — help text parsed from its source, or an endpoint from its API document. Everything else is our summary of a dated release or documentation change, linked back to the source it came from.

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

sdk==0.4.4 Aug 27, 2026 · issue 009

LangGraph SDK 0.4.4 routes LangSmith traces from thread streams for deeper agent observability.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.4.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.4.4
```
- ›Routes LangSmith traces from thread streams, enabling trace visibility for streaming thread operations.
sdk==0.4.3 Aug 19, 2026 · issue 002

LangGraph SDK 0.4.3 adds decrypted replacement results and clears cron end_time via update(end_time=None).
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.4.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.4.3
```
- ›Supports clearing a cron job's end_time by calling update(end_time=None) on the cron client.
- ›Adds decrypt replacement result support to the Python SDK.
1.2.11 Aug 11, 2026 · issue -008

LangGraph 1.2.11 exposes trace_policy on add_node for per-node tracing control.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.11 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.2.11
```
└──▷ USE IT
Suppress or customize tracing for a specific node without affecting the rest of the graph.
python
```
graph.add_node("my_node", my_node_fn, trace_policy=<policy>)
```
- ›Adds trace_policy parameter to add_node, letting callers control tracing behavior on a per-node basis.
1.2.11 Aug 11, 2026 · issue 001

LangGraph 1.2.11 exposes trace_policy on add_node for per-node tracing control.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.11 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.2.11
```
- ›Adds trace_policy parameter to add_node to control tracing behaviour on a per-node basis.
checkpoint==4.2.0 Aug 7, 2026 · issue -012

LangGraph checkpoint 4.2.0 adds opt-in omit_expired flag to skip expired rows on checkpoint reads.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==4.2.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==4.2.0
```
- ›Adds omit_expired opt-in parameter to checkpoint and checkpoint-postgres read operations to skip expired rows, enabling cleaner state retrieval without stale data.
checkpoint==4.2.0 Aug 7, 2026 · issue 001

LangGraph checkpoint 4.2.0 adds opt-in omit_expired flag to skip expired checkpoint rows on read.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==4.2.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==4.2.0
```
- ›Adds opt-in omit_expired parameter to checkpoint and checkpoint-postgres readers to skip expired rows when reading checkpoint history, reducing noise and improving read performance in long-running workflows.
checkpoint==4.2.0 Aug 7, 2026 · issue -012

LangGraph checkpoint 4.2.0 adds opt-in omit_expired flag to skip expired checkpoint rows on read.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==4.2.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==4.2.0
```
- ›Adds opt-in omit_expired parameter to checkpoint and checkpoint-postgres readers to skip expired rows when reading checkpoint history, reducing noise and improving read performance in long-running workflows.
checkpointpostgres==3.1.1 Jul 30, 2026 · issue -020

LangGraph checkpoint-postgres 3.1.1 adds opt-in omit_expired flag to skip expired checkpoint rows on read.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==3.1.1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==3.1.1
```
- ›Adds omit_expired opt-in parameter to checkpoint reads, allowing callers to skip expired rows instead of returning them.
checkpointpostgres==3.1.1 Jul 30, 2026 · issue 001

checkpoint-postgres 3.1.1 adds opt-in omit_expired flag to skip expired checkpoint rows on read.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==3.1.1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==3.1.1
```
- ›Adds opt-in omit_expired parameter to checkpoint read operations, allowing callers to skip expired rows and avoid processing stale state.
checkpointpostgres==3.1.1 Jul 30, 2026 · issue -020

checkpoint-postgres 3.1.1 adds opt-in omit_expired flag to skip expired checkpoint rows on read.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==3.1.1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==3.1.1
```
- ›Adds opt-in omit_expired parameter to checkpoint read operations, allowing callers to skip expired rows and avoid processing stale state.
1.2.10 Jul 28, 2026 · issue -022

LangGraph 1.2.10 adds trace_policy on add_node and typed v3 stream_events return with native projections.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.2.10
```
└──▷ USE IT
Attach a trace_policy to a specific node to control how that node's execution is traced, without affecting the rest of the graph.
python
```
graph.add_node('my_node', my_node_fn, trace_policy=TracePolicy(...))
```
- ›Exposes trace_policy parameter on add_node, letting you control tracing behavior per node when building graphs.
- ›Types the v3 stream_events return value and adds native projections, enabling strongly-typed streaming event handling.
1.2.10 Jul 28, 2026 · issue 001

LangGraph 1.2.10 exposes trace_policy on add_node and drops tags from TracePolicy for cleaner tracing control.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.2.10
```
└──▷ USE IT
Attach a per-node trace policy at graph construction time to control which nodes are traced in production.
python
```
graph.add_node('my_node', my_node_fn, trace_policy=TracePolicy(...))
```
- ›Exposes trace_policy parameter on add_node, letting callers set per-node tracing behavior directly when wiring the graph.
- ›Drops tags from TracePolicy, narrowing the tracing configuration surface.
- ›Adds typed return for v3 stream_events and native projections support.
└──▷ BREAKING ON UPGRADE
- !The tags field has been removed from TracePolicy; any code that sets tags on a TracePolicy instance will break.
cli==0.4.31 Jul 10, 2026 · issue -040

LangGraph CLI now supports prebuild images for langgraph deploy.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.4.31 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.4.31
```
- ›Supports prebuild images for langgraph deploy, enabling faster deployments by skipping the image build step.
1.2.3 Jun 1, 2026 · issue -079

LangGraph 1.2.3 adds v3 streaming support, WebSocket transport, and tool-dispatched subagent naming to RemoteGraph.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.2.3
```
- ›Adds v3 streaming support to RemoteGraph, enabling the latest streaming protocol for remote graph execution.
- ›Wires RemoteGraph.interleave to sdk-py interleave_projections for interleaved stream output.
- ›Names tool-dispatched subagents via lc_agent_name for clearer agent identification in multi-agent graphs.
- ›Adds WebSocket stream transport to the Python SDK (sdk-py) as an alternative to SSE.
- ›Adds messages and tool call projections to sdk-py for structured stream consumption.
+1 moreshow less
- ›Adds v3 streaming primitives and SSE transport to sdk-py.
sdk==0.4.1 Jun 1, 2026 · issue -079

LangGraph SDK 0.4.1 adds interleave_projections stream decoder and v3 streaming support for RemoteGraph.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.4.1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.4.1
```
- ›Extracts stream decoders into a reusable module and adds interleave_projections stream decoder.
- ›Adds v3 streaming protocol support to RemoteGraph, enabling richer real-time output from remote graph execution.
sdk==0.4.0 May 28, 2026 · issue -083

LangGraph SDK 0.4.0 adds WebSocket streaming, reconnect resilience, scoped subgraph handles, and sync/async thread stream helpers.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.4.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.4.0
```
- ›Adds WebSocket stream transport support, enabling lower-latency bidirectional streaming as an alternative to SSE.
- ›Adds SSE transport and v3 streaming primitives as a foundational streaming layer.
- ›Adds WebSocket stream selection wiring so clients can choose between SSE and WebSocket transports.
- ›Adds async stream reconnect support with hardened reconnect logic for resilient long-running streams.
- ›Adds async and sync thread stream helpers for high-level, ergonomic consumption of streamed thread output.
+4 moreshow less
- ›Adds scoped subgraph handles (async and sync) for targeting and streaming specific subgraph execution.
- ›Adds messages and tool call projections to extract structured message and tool-call data from stream events.
- ›Adds output, values, and controller extraction from stream lifecycle state.
- ›Adds shared stream subscriptions for multiplexing a single stream across multiple consumers.
sdk==0.3.15 May 22, 2026 · issue -089

LangGraph SDK 0.3.15 adds metadata filtering for cron job search and count operations.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.3.15 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.3.15
```
└──▷ USE IT
Filter cron job searches by metadata to find only crons matching specific labels or properties.
python
```
crons = await client.crons.search(metadata={"env": "production", "team": "infra"})
```
- ›Supports metadata filter parameter when searching and counting cron jobs via the SDK.
1.2.1 May 21, 2026 · issue -090

LangGraph 1.2.1 adds before_builtins opt-in for stream transformers.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.2.1
```
- ›Adds before_builtins opt-in option for stream transformers, enabling custom transformation logic to run before built-in stream processing.
1.2.0 May 12, 2026 · issue -099

LangGraph 1.2.0 adds node defaults, durable error-handler resume, and delta-channel snapshot guarantees.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Enables durable error-handler resume so graph execution can recover across host crashes.
- ›Forces a delta channel snapshot after a configurable max number of supersteps since the last snapshot, preventing unbounded replay.
- ›Overrides get_delta_channel_history in the SQLite checkpoint backend with a streaming walk for more efficient history retrieval.
checkpoint==4.1.0 May 12, 2026 · issue -099

LangGraph checkpoint 4.1.0 forces delta channel snapshots after max supersteps to ensure durability.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==4.1.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
cli==0.4.25 May 7, 2026 · issue -104

LangGraph CLI gains Studio deploy support for pushing graphs directly to LangGraph Studio.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.4.25 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.4.25
```
- ›Adds studio deploy command to the LangGraph CLI, enabling direct deployment to LangGraph Studio.
checkpointsqlite==3.1.0a1 May 5, 2026 · issue -106

LangGraph SQLite checkpointer gains a public get_writes_history API and streaming delta channel history.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointsqlite==3.1.0a1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointsqlite==3.1.0a1
```
- ›Adds public get_writes_history saver API for retrieving write history with reworked delta cadence.
- ›Overrides get_delta_channel_history with a streaming walk implementation for more efficient history retrieval.
sdk==0.3.14 May 5, 2026 · issue -106

LangGraph SDK 0.3.14 adds return_minimal to thread updates, trimming response payload size.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.3.14 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
checkpointpostgres==3.1.0a4 May 4, 2026 · issue -107

langgraph-checkpoint-postgres 3.1.0a4 exposes a public get_writes_history saver API with reworked delta cadence.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==3.1.0a4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Reworks delta cadence logic for checkpoint writes, enabling finer-grained control over how incremental state changes are persisted.
prebuilt==1.1.0a1 May 1, 2026 · issue -110

LangGraph prebuilt 1.1.0a1 adds stream_events v3 dispatch and streaming transformer infrastructure.
└──▷ GET THIS VERSION
```
$ git clone --branch prebuilt==1.1.0a1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout prebuilt==1.1.0a1
```
- ›Dispatches stream_events(version='v3') on Pregel, enabling finer-grained streaming event visibility.
- ›Adds streaming transformer infrastructure, providing a new layer for composing and testing stream transformations in the graph runtime.
1.2.0a3 May 1, 2026 · issue -110

LangGraph 1.2.0a3 adds node-level error handlers, graceful shutdown/drain, stream_events v3, and richer streaming infrastructure.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.0a3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.2.0a3
```
└──▷ USE IT
Subscribe to v3 stream events from a Pregel graph for fine-grained observability of node execution.
python
```
# (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.
python
```
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.
- ›Supports graceful graph shutdown/drain on request, allowing in-flight work to complete cleanly before termination.
- ›Dispatches stream_events(version='v3') on Pregel graphs, enabling richer event streaming for observability pipelines.
- ›Introduces DeltaChannel for storing sentinels in blobs and reconstructing state from checkpoint writes.
- ›Adds native v2 projections for custom, updates, checkpoints, debug, and tasks stream modes.
+2 moreshow less
- ›Introduces streaming transformer infrastructure for composable, testable stream processing.
- ›Allows ToolNode tools to return list[Command | ToolMessage], enabling richer tool output patterns.
checkpoint==4.1.0a3 May 1, 2026 · issue -110

LangGraph checkpoint 4.1.0a3 introduces DeltaChannel with sentinel storage and checkpoint_writes reconstruction.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==4.1.0a3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==4.1.0a3
```
- ›Adds DeltaChannel: stores sentinels in blobs and reconstructs state from checkpoint_writes, enabling more efficient incremental state tracking.
1.2.0a2 Apr 30, 2026 · issue -111

LangGraph 1.2.0a2 adds node-level error handlers for fine-grained fault control in graphs.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.0a2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.2.0a2
```
- ›Adds node-level error handlers, enabling per-node fault handling logic directly in graph definitions.
checkpointpostgres==3.1.0a1 Apr 30, 2026 · issue -111

checkpoint-postgres 3.1.0a1 adds DeltaChannel sentinel storage in blobs with checkpoint_writes reconstruction.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==3.1.0a1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==3.1.0a1
```
- ›Adds DeltaChannel support: stores sentinel values in blobs and reconstructs state from checkpoint_writes, enabling more efficient incremental checkpointing.
prebuilt==1.0.13 Apr 30, 2026 · issue -111

LangGraph prebuilt 1.0.13 adds alpha timer support and streaming transformer infrastructure.
└──▷ GET THIS VERSION
```
$ git clone --branch prebuilt==1.0.13 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout prebuilt==1.0.13
```
- ›Introduces alpha timer support for scheduling and time-based graph behaviors.
- ›Adds streaming transformer infrastructure enabling new streaming pipeline patterns in graphs.
checkpoint==4.1.0a1 Apr 29, 2026 · issue -112

LangGraph checkpoint 4.1.0a1 adds timer support (alpha) and a new DeltaChannel for efficient checkpoint reconstruction.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==4.1.0a1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==4.1.0a1
```
- ›Adds alpha timer support for checkpoint-based workflows.
- ›Introduces DeltaChannel: stores sentinel values in blobs and reconstructs state from checkpoint_writes rather than full snapshots.
1.2.0a1 Apr 29, 2026 · issue -112

LangGraph 1.2.0a1 adds graceful shutdown/drain, timer support, DeltaChannel checkpointing, and native v2 streaming projections.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.2.0a1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.2.0a1
```
- ›Adds graceful shutdown/drain support, allowing graphs to finish in-flight work before stopping on request.
- ›Introduces alpha timer primitives for scheduling time-based graph behavior.
- ›New DeltaChannel stores sentinel values in blobs and reconstructs state from checkpoint writes.
- ›Adds native v2 projections for custom, updates, checkpoints, debug, and tasks streams.
- ›Adds streaming transformer infrastructure enabling richer, composable stream processing pipelines.

1.1.10 Apr 27, 2026 · issue -114

LangGraph 1.1.10 lets ToolNode tools return mixed lists of Command and ToolMessage objects.

└──▷ GET THIS VERSION

$ git clone --branch 1.1.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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

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.

prebuilt==1.0.11 Apr 24, 2026 · issue -117

LangGraph prebuilt 1.0.11 lets ToolNode return mixed Command/ToolMessage lists and exposes available tools on ToolRuntime.
└──▷ GET THIS VERSION
```
$ git clone --branch prebuilt==1.0.11 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Exposes the set of available tools on ToolRuntime, making it possible to inspect or enumerate registered tools at runtime.
checkpoint==4.0.2 Apr 15, 2026 · issue -126

LangGraph checkpoint 4.0.2 documents LANGGRAPH_STRICT_MSGPACK environment variable for checkpoint security hardening.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==4.0.2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==4.0.2
```
- ›Documents LANGGRAPH_STRICT_MSGPACK environment variable to control strict MessagePack deserialization security for checkpoints.
1.1.7a1 Apr 10, 2026 · issue -131

LangGraph 1.1.7a1 adds graph lifecycle callback handlers for hooking into graph execution events.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.1.7a1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.1.7a1
```
- ›Adds graph lifecycle callback handlers, enabling hooks into key stages of graph execution.
cli==0.4.20 Apr 8, 2026 · issue -133

LangGraph CLI gains remote build support for langgraph deploy
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.4.20 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.4.20
```
- ›Adds remote build support for langgraph deploy, enabling builds to run on remote infrastructure instead of locally.
sdk==0.3.13 Apr 7, 2026 · issue -134

LangGraph SDK adds langsmith_tracing parameter to runs.create/stream/wait for per-call tracing control.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.3.13 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.3.13
```
└──▷ USE IT
Disable LangSmith tracing for a specific run invocation to avoid logging sensitive payloads.
python
```
result = await client.runs.create(
    thread_id=thread_id,
    assistant_id=assistant_id,
    input={"messages": [{"role": "user", "content": "hello"}]},
    langsmith_tracing=False,
)
```
- ›Adds langsmith_tracing parameter to runs.create, runs.stream, and runs.wait to enable or disable LangSmith tracing on a per-call basis.
1.1.5 Apr 3, 2026 · issue -138

LangGraph 1.1.5 adds remote build support for langgraph deploy and richer runtime execution information.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.1.5 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.1.5
```
- ›Adds remote build support to langgraph deploy in the CLI.
- ›Enhances the runtime with more execution information.
prebuilt==1.0.9 Apr 3, 2026 · issue -138

LangGraph prebuilt 1.0.9 exposes richer execution information at runtime for agent observability.
└──▷ GET THIS VERSION
```
$ git clone --branch prebuilt==1.0.9 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
1.1.4 Mar 31, 2026 · issue -141

LangGraph 1.1.4 adds LangSmith integration metadata to graph runs.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.1.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.1.4
```
- ›Adds LangSmith integration metadata to LangGraph, enabling richer tracing and observability linkage between graph runs and LangSmith.
cli==0.4.19 Mar 20, 2026 · issue -152

LangGraph CLI 0.4.19 adds deploy revisions list command to inspect deployment revisions.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.4.19 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.4.19
```
└──▷ TRY IT
List all revisions for a deployed LangGraph app to audit deployment history or roll back.
```
$ langgraph deploy revisions list
```
- ›Adds deploy revisions list subcommand to list revisions of a LangGraph deployment.
1.1.3 Mar 18, 2026 · issue -154

LangGraph 1.1.3 adds execution info to the runtime context.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.1.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.1.3
```
- ›Adds execution info to the LangGraph runtime, exposing contextual metadata during graph execution.
cli==0.4.16 Mar 12, 2026 · issue -159

LangGraph CLI gains deploy logs, list, delete subcommands and distributed runtime support.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.4.16 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.4.16
```
└──▷ TRY IT
Tail logs from a running LangGraph deployment to debug production agent behavior.
```
$ langgraph deploy logs <deployment-id>
```
List all active deployments to audit or identify targets for cleanup.
```
$ langgraph deploy list
```
Delete a specific deployment to decommission a retired agent service.
```
$ langgraph deploy delete <deployment-id>
```
- ›Adds langgraph deploy logs subcommand to stream or retrieve logs from a deployment.
- ›Adds langgraph deploy list subcommand to enumerate active deployments.
- ›Adds langgraph deploy delete subcommand to remove a deployment.
- ›Adds distributed runtime support to the LangGraph CLI for scalable deployment configurations.
1.1.2 Mar 12, 2026 · issue -159

LangGraph 1.1.2 adds context support for remote graph API calls.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.1.2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.1.2
```
- ›Adds context parameter support for remote graph API interactions.
1.1.0 Mar 10, 2026 · issue -161

LangGraph 1.1 adds opt-in version="v2" for type-safe streaming and invoke with Pydantic/dataclass output coercion.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.1.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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
```
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.
- ›New GraphOutput return type from invoke(..., version="v2") exposes .value and .interrupts attributes, cleanly separating state from interrupt signals.
- ›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.
- ›Automatic output coercion to Pydantic models or dataclasses when the graph's state schema is declared as one — no manual parsing needed.
- ›Non-"values" stream modes with version="v2" return list[StreamPart] from invoke() instead of list[tuple].
cli==0.4.15 Mar 10, 2026 · issue -161

LangGraph CLI gains a langgraph deploy command for direct deployment from the CLI.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.4.15 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.4.15
```
└──▷ TRY IT
Deploy a LangGraph application to LangGraph Cloud without leaving the terminal.
```
$ langgraph deploy
```
- ›Adds langgraph deploy command to deploy LangGraph applications directly from the CLI.
sdk==0.3.10 Mar 9, 2026 · issue -162

LangGraph SDK 0.3.10 adds type-safe stream/invoke with proper output type coercion
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.3.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.3.10
```
- ›Adds type-safe stream/invoke calls with proper output type coercion, enabling strongly-typed responses from graph runs
cli==0.4.14 Mar 2, 2026 · issue -169

LangGraph CLI gains a keep_latest prune strategy for ThreadTTLConfig and checkpointer config passthrough.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.4.14 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.4.14
```
- ›Adds keep_latest prune strategy to ThreadTTLConfig, giving finer control over which threads are retained when TTL cleanup runs.
- ›Passes checkpointer config through to the CLI, enabling checkpointer settings to be applied via CLI invocation.
sdk==0.3.8 Feb 19, 2026 · issue -179

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
```
$ git clone --branch sdk==0.3.8 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.3.8
```
- ›Adds stream_mode, stream_subgraphs, stream_resumable, and durability parameters to cron job creation in the Python SDK.
- ›Improves type safety and docstrings for store auth in the Python SDK.
sdk==0.3.4 Feb 6, 2026 · issue -192

LangGraph Python SDK gains cron job update, enable, and disable methods in the crons client.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.3.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.3.4
```
- ›Adds update method to the crons client for modifying existing cron jobs.
- ›Supports enabling and disabling cron jobs via the crons client.
prebuilt==1.0.7 Jan 22, 2026 · issue -207

LangGraph prebuilt 1.0.7 adds dynamic tool calling via a tool override in wrap_model_call.
└──▷ GET THIS VERSION
```
$ git clone --branch prebuilt==1.0.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout prebuilt==1.0.7
```
- ›Supports dynamic tool calling by accepting a tool override parameter in wrap_model_call.
1.0.6 Jan 12, 2026 · issue -217

LangGraph 1.0.6 adds compile-time checkpointer type validation to catch configuration errors early.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.6 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.0.6
```
- ›Validates checkpointer type at compile time, surfacing misconfigured checkpointers before runtime.
prebuilt==1.0.6 Jan 12, 2026 · issue -217

LangGraph prebuilt 1.0.6 adds compile-time checkpointer validation, custom encryption at rest, and paginated assistant search.
└──▷ GET THIS VERSION
```
$ git clone --branch prebuilt==1.0.6 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout prebuilt==1.0.6
```
- ›Validates checkpointer type at compile time, catching misconfiguration before runtime.
- ›Supports custom encryption at rest for checkpoint data.
- ›Includes pagination in assistants search responses.
1.0.5 Dec 12, 2025 · issue -248

LangGraph 1.0.5 adds custom encryption at rest, stream event IDs, and pagination for assistants search.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.5 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 1.0.5
```
- ›Adds custom encryption at rest for persisted graph state.
- ›Emits id as part of stream events in the Python SDK.
- ›Includes pagination in assistants search responses.
cli==0.4.8 Dec 9, 2025 · issue -251

LangGraph CLI 0.4.8 adds webhook configuration and custom encryption at rest.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.4.8 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.4.8
```
- ›Adds webhook configuration support to the CLI.
- ›Supports custom encryption at rest for stored data.
sdk==0.2.12 Dec 2, 2025 · issue -258

LangGraph SDK 0.2.12 adds pagination to assistants search and a sentinel to skip auto-loading API keys.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.2.12 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Introduces a sentinel value to skip automatic API key loading when instantiating the SDK client, allowing explicit credential control.
sdk==0.2.10 Nov 24, 2025 · issue -266

LangGraph Python SDK 0.2.10 adds name filtering to Assistants search and cursory Python 3.14 support.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.2.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.2.10
```
└──▷ USE IT
Filter the Assistants search results to a specific assistant name instead of iterating all assistants.
python
```
assistants = await client.assistants.search(name="my-assistant")
```
- ›Adds name parameter to the Assistants search API, enabling filtering assistants by name.
- ›Adds cursory Python 3.14 support.
└──▷ BREAKING ON UPGRADE
- !Python 3.9 is no longer supported; projects running on Python 3.9 must upgrade their runtime.
1.0.2 Oct 29, 2025 · issue -292

LangGraph 1.0.2 adds Overwrite reducer bypass, Python 3.14 support, and ships Checkpointers 3.0.
└──▷ GET THIS VERSION
```
$ git clone --branch 1.0.2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds cursory Python 3.14 support.
- ›Ships Checkpointers 3.0 release.
└──▷ BREAKING ON UPGRADE
- !Python 3.9 is no longer supported; the minimum supported Python version has been raised.
prebuilt==1.0.2 Oct 29, 2025 · issue -292

LangGraph prebuilt 1.0.2 adds Python 3.14 support and drops Python 3.9.
└──▷ GET THIS VERSION
```
$ git clone --branch prebuilt==1.0.2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout prebuilt==1.0.2
```
- ›Adds cursory Python 3.14 support for prebuilt components.
- ›Un-deprecates ToolNode, restoring it as a supported API.
└──▷ BREAKING ON UPGRADE
- !Python 3.9 is no longer supported; setups running on Python 3.9 will break on upgrade.
prebuilt==0.6.5 Oct 21, 2025 · issue -300

LangGraph prebuilt 0.6.5 adds Redis node-level caching and SDK client query-parameter support.
└──▷ GET THIS VERSION
```
$ git clone --branch prebuilt==0.6.5 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›Adds query-parameter support to the Python SDK client (feat(sdk-py): client qparams), allowing callers to pass arbitrary query parameters through SDK calls.
checkpointpostgres==3.0.0 Oct 20, 2025 · issue -301

langgraph-checkpoint-postgres 3.0 adds cursory Python 3.14 support.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==3.0.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==3.0.0
```
- ›Adds cursory Python 3.14 support, enabling use of the Postgres checkpointer on the latest Python release.
└──▷ BREAKING ON UPGRADE
- !Python 3.9 is no longer supported; setups running langgraph-checkpoint-postgres on Python 3.9 will break on upgrade.
checkpointsqlite==3.0.0 Oct 20, 2025 · issue -301

LangGraph checkpointsqlite 3.0 adds Python 3.14 support and drops Python 3.9.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointsqlite==3.0.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointsqlite==3.0.0
```
- ›Adds cursory Python 3.14 support, keeping the library compatible with the upcoming CPython release.
- ›Drops Python 3.9 support; minimum supported Python version is now 3.10 or higher.
└──▷ BREAKING ON UPGRADE
- !Python 3.9 is no longer supported; running checkpointsqlite on Python 3.9 will break after upgrading to 3.0.0.
checkpoint==3.0.0 Oct 20, 2025 · issue -301

LangGraph checkpoint 3.0 drops Python 3.9 and adds cursory Python 3.14 support.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==3.0.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==3.0.0
```
- ›Adds cursory Python 3.14 support to the checkpointers library.
- ›Restricts 'json' type deserialization for tighter serialization safety.
└──▷ BREAKING ON UPGRADE
- !Python 3.9 is no longer supported; upgrade to Python 3.10 or later before upgrading to checkpoint 3.0.0.
cli==0.4.3 Oct 8, 2025 · issue -313

LangGraph CLI 0.4.3 adds auth control on custom routes and server customization ordering.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.4.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.4.3
```
- ›Adds auth flag in HttpConfig to enable or disable authentication on custom routes.
- ›Adds configuration for controlling the ordering of server customization (middleware/routers).
0.6.8 Sep 29, 2025 · issue -321

LangGraph 0.6.8 adds guardrails that prevent arbitrary resumes when multiple interrupts are pending.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.6.8 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.6.8
```
- ›Adds enforcement that prevents arbitrary graph resumes when multiple pending interrupts exist, ensuring interrupt handling is ordered and intentional.
0.6.7 Sep 7, 2025 · issue -343

LangGraph CLI gains monorepo support for managing multi-package LangGraph projects.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.6.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.6.7
```
- ›Adds monorepo support in the LangGraph CLI, enabling multi-package project structures to be managed from a single repository.
0.6.3 Aug 3, 2025 · issue -363

LangGraph 0.6.3 adds a durability mode to invoke and ainvoke for controlling checkpoint persistence.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.6.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
graph.invoke(input, durability="ephemeral")
```
- ›Adds durability mode parameter to invoke and ainvoke for controlling checkpoint persistence behavior.
0.6.0 Jul 28, 2025 · issue -364

LangGraph 0.6 introduces a typed Context/Runtime API, durability modes, dynamic model/tool selection, and a solidified public API surface.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.6.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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 provider and toolset per-invocation in a ReAct agent based on runtime context.
python
```
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.
- ›Introduces context_schema argument on StateGraph as the successor to config_schema, enabling typed context definitions via dataclasses.
- ›Adds durability argument with three modes — "exit", "async", and "sync" — giving fine-grained control over checkpoint persistence behavior.
- ›Enables create_react_agent to dynamically select model and tools at runtime via a custom context object.
- ›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.
+3 moreshow less
- ›Refines the Interrupt interface: adds id (unique identifier encoding namespace) and value attributes as the canonical surface.
- ›Centralizes all error classes under langgraph.errors; moves Send and Interrupt imports to langgraph.types.
- ›Adds get_context_jsonschema for graph introspection, superseding get_config_jsonschema.
└──▷ 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.
prebuilt==0.6.0 Jul 28, 2025 · issue -364

LangGraph prebuilt 0.6.0 adds dynamic model selection in create_react_agent and a new context API replacing config['configurable'].
└──▷ GET THIS VERSION
```
$ git clone --branch prebuilt==0.6.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout prebuilt==0.6.0
```
- ›Adds dynamic model support to create_react_agent, allowing the LLM to be swapped at runtime per invocation.
- ›Introduces a new context API as a cleaner replacement for config['configurable'] and config_schema patterns.
└──▷ BREAKING ON UPGRADE
- !Public/private differentiations have been solidified — previously accessible private symbols may no longer be importable from their old paths.
cli==0.3.6 Jul 23, 2025 · issue -364

LangGraph CLI 0.3.6 introduces an api-version option and a new context API replacing config['configurable'] and config_schema.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.3.6 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.3.6
```
- ›Adds api-version option for explicit API version control.
- ›Introduces new context API as a replacement for config['configurable'] and config_schema for passing configuration to graph nodes.
└──▷ BREAKING ON UPGRADE
- !The new context API replaces config['configurable'] and config_schema; existing code relying on these patterns will need to be migrated.
sdk==0.2.0 Jul 22, 2025 · issue -364

LangGraph Python SDK 0.2.0 adds context API support and exposes interrupts in thread state
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.2.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.2.0
```
└──▷ USE IT
Inspect interrupts on a thread after a run is suspended, to determine why execution paused.
python
```
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.
- ›Adds interrupts field to thread state, making interrupt information accessible when inspecting thread state.
- ›Cleans up the Interrupt interface for v1, refining the interrupt contract.
└──▷ 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.
0.5.4 Jul 21, 2025 · issue -364

LangGraph 0.5.4 adds ParentCommand handling in RemoteGraph for cross-graph command propagation.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.5.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.5.4
```
- ›Supports ParentCommand in RemoteGraph, enabling commands issued inside a remote graph to propagate up to the parent graph.
sdk==0.1.73 Jul 14, 2025 · issue -364

LangGraph SDK 0.1.73 exposes is_studio_user flag to identify Studio-originated requests.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.73 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.73
```
- ›Adds is_studio_user attribute to identify whether the current user is a LangGraph Studio user.
checkpointpostgres==2.0.22 Jul 10, 2025 · issue -364

LangGraph checkpoint-postgres 2.0.22 adds numpy array serialization and pandas pickle fallback in JsonPlusSerializer.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.22 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==2.0.22
```
- ›Supports numpy array serialization in JsonPlusSerializer, enabling checkpoint storage of numpy arrays without manual conversion.
- ›Adds pickle fallback for pandas objects in JsonPlusSerializer via serialize/deserialize path, so DataFrames and Series round-trip through checkpoints reliably.
- ›Extends pipeline mode in checkpoint-postgres to use the same lock used in non-pipeline mode, improving consistency under concurrent writes.
- ›Centralizes CheckpointTuple creation into a shared helper function within checkpoint_postgres, reducing duplication across sync and async paths.
└──▷ 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.
cli==0.3.4 Jul 8, 2025 · issue -364

LangGraph CLI 0.3.4 adds a flag to retain build dependencies (setuptools, pip, wheel) in container builds.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.3.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.3.4
```
- ›Adds a CLI argument to retain build dependencies (setuptools, pip, wheel) in the build output instead of pruning them.
0.5.0 Jun 26, 2025 · issue -365

LangGraph 0.5 adds NodeBuilder, granular streaming modes, NumPy serialization, and a stricter StateGraph API ahead of 1.0.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.5.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Introduces stream_mode="tasks" and stream_mode="checkpoints" as individually selectable streaming modes (and "debug" becomes an alias for both).
- ›Adds print_mode= argument to invoke/stream for controlling output printing.
- ›StateGraph now accepts input_schema and output_schema parameters (replacing input/output).
- ›JsonPlusSerializer now natively handles NumPy arrays (including Fortran-ordered) without pickle fallback.
+3 moreshow less
- ›Checkpoints are leaner: redundant keys dropped, per-task writes stored directly, and legacy pending_sends data is auto-migrated on first load.
- ›Allows same-name channels and nodes in StateGraph.
- ›Task masquerading with update_state is now supported.
└──▷ 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.
0.4.10 Jun 25, 2025 · issue -365

LangGraph 0.4.10 adds 'tasks' and 'checkpoints' stream modes and numpy/pandas serialization support.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Supports numpy array serialization in JsonPlusSerializer, enabling numpy data in graph state.
- ›Adds pickle fallback for pandas serialization/deserialization via JsonPlusSerializer.
- ›Allows same-name channels and nodes in StateGraph, removing a previous naming constraint.
- ›Skips saving checkpoints for subgraphs when checkpoint_during=False, reducing unnecessary checkpoint overhead.
checkpoint==2.1.0 Jun 16, 2025 · issue -365

langgraph-checkpoint 2.1.0 adds NumPy array and pandas serialization support to JsonPlusSerializer
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.1.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==2.1.0
```
- ›Supports NumPy array serialization in JsonPlusSerializer, enabling checkpoint storage of array-heavy state.
- ›Adds pickle fallback for pandas serialization, allowing DataFrames and Series to round-trip through the checkpoint layer.
└──▷ BREAKING ON UPGRADE
- !Checkpoint.writes has been removed.
- !Checkpoint.pending_sends has been removed.
cli==0.2.11 Jun 4, 2025 · issue -365

LangGraph CLI 0.2.11 adds image_distro config support and warns when distro is not set to Wolfi.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.2.11 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›Adds a warning when the image distro is not configured as Wolfi, nudging users toward the recommended distro.
0.4.8 Jun 2, 2025 · issue -365

LangGraph 0.4.8 adds NodeBuilder to replace Channel.subscribe_to and flips the default for checkpoint_during.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.8 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.4.8
```
- ›Adds NodeBuilder class as the new way to define node subscriptions, replacing Channel.subscribe_to.
- ›Flips the default value for checkpoint_during, changing checkpoint behavior out of the box.
- ›Stream modes messages and custom now respect subgraphs=False, giving finer control over subgraph output filtering.
- ›Requires state_schema in StateGraph.__init__, enforcing explicit schema declaration at graph construction.
└──▷ 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.
0.4.6 May 23, 2025 · issue -366

LangGraph 0.4.6 adds push_message() for manual stream writes, SQLiteStore, and smarter stream_mode=values emission.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.6 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.4.6
```
└──▷ USE IT
Use SqliteStore as a persistence backend for checkpointing or memory in a LangGraph application.
python
```
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.
- ›Introduces SqliteStore as a new built-in store backend.
- ›Optimizes stream_mode=values to emit chunks only when output channels have actually changed, reducing noise in high-frequency graphs.
- ›Prints output for cached @task functions, making task caching observable in the stream.
- ›Updates list_namespaces in SQLite with max_depth support for scoped namespace queries.
prebuilt==0.2.0 May 22, 2025 · issue -366

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
```
$ git clone --branch prebuilt==0.2.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout prebuilt==0.2.0
```
└──▷ USE IT
Inject a post-model validation or logging step into a ReAct agent without subclassing.
python
```
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
```
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.
- ›Introduces HumanInterruptNode for structured human-in-the-loop interruption handling in prebuilt agents.
- ›Switches parallel tool call execution to use Send by default, enabling concurrent tool dispatch in the ReAct agent.
- ›Releases SqliteStore as a persistent key-value store backend with namespace search and list_namespaces supporting max_depth filtering.
└──▷ BREAKING ON UPGRADE
- !The state_modifier parameter has been removed from create_react_agent; existing code passing state_modifier will break on upgrade.
checkpointsqlite==2.0.8 May 18, 2025 · issue -366

LangGraph SQLite checkpoint adds SqliteStore and InMemoryCache for persistent and in-memory state storage.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointsqlite==2.0.8 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›New InMemoryCache (moved into the sqlite package alongside FileCache) enables fast, non-persistent caching without a database.
- ›Adds SqliteStore release as the official sqlite store integration for LangGraph checkpointing.
- ›Overloaded clear() method on the store now deletes all entries when called without arguments.
checkpoint==2.0.26 May 15, 2025 · issue -366

LangGraph checkpoint 2.0.26 adds InMemoryCache, namespace-scoped cache keys, TTL support, and pickle fallback for the JSON serializer.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.26 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==2.0.26
```
- ›Adds InMemoryCache as a new cache backend alongside the existing file-based cache.
- ›Moves FileCache to the sqlite package and re-implements it using SQLite for more reliable storage.
- ›Adds namespace support to cache keys, enabling isolated cache spaces across different workloads.
- ›Implements TTL (time-to-live) expiry in FileCache, allowing automatic cache entry invalidation.
- ›Overloads the clear method so calling it without arguments deletes all cache entries.
+2 moreshow less
- ›Adds pickle_fallback option to the JSON-plus serializer, enabling serialization of objects that are not natively JSON-serializable.
- ›Removes Python version upper bounds, allowing installation on future Python releases without constraint conflicts.
0.4.4 May 15, 2025 · issue -366

LangGraph 0.4.4 adds update_state for the functional API, a caching layer with InMemoryCache, and deferred node execution.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Introduces a cache interface with InMemoryCache and FileCache (moved to sqlite package), including clear methods and namespace-scoped cache keys.
- ›Adds cache_policy acceptance on graph, entrypoint, and pregel for default caching configuration.
- ›Adds support for Deferred Nodes, enabling nodes whose execution can be deferred within a graph.
- ›Adds ability to start the dev server externally.
sdk==0.1.69 May 13, 2025 · issue -366

LangGraph Python SDK adds customizable client timeouts, loop-safe ASGI transport, and a new 'running' RunStatus.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.69 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.69
```
└──▷ USE IT
Set per-request timeouts when initializing the LangGraph client to avoid hung calls in production.
python
```
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.
- ›Adds optional loop-safe ASGI transport to avoid event-loop conflicts in async environments.
- ›Adds missing 'running' value to RunStatus enum, enabling accurate status checks on in-progress runs.
└──▷ BREAKING ON UPGRADE
- !Private SDK functions are now prefixed with _; any code calling these functions by their former unprefixed names will break.
0.4.3 May 8, 2025 · issue -366

LangGraph 0.4.3 uses tuples for streamed message events in RemoteGraph and adds a draw limit to Pregel graphs.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.4.3
```
- ›Uses tuples for streamed message events in RemoteGraph, aligning remote streaming with local graph conventions.
- ›Adds a node limit to Pregel.draw to prevent rendering failures on very large graphs.
0.4.2 May 7, 2025 · issue -366

LangGraph 0.4.2 decouples RemoteGraph name from assistant ID and executes parallel tool calls via Send by default.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.4.2
```
- ›Decouples the graph name from the assistant ID in RemoteGraph, allowing them to be set independently.
- ›Switches prebuilt parallel tool calls to execute via Send by default, enabling more controlled parallel tool dispatch.
checkpointsqlite==2.0.7 May 2, 2025 · issue -366

LangGraph checkpoint-sqlite 2.0.7 adds a delete_thread method to the Checkpointer class.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointsqlite==2.0.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointsqlite==2.0.7
```
└──▷ USE IT
Delete all checkpoint state for a specific thread to free storage or reset a conversation.
python
```
checkpointer.delete_thread(thread_id)
```
- ›Adds delete_thread method to the Checkpointer class for removing thread state from SQLite checkpoints.
cli==0.2.8 May 2, 2025 · issue -366

LangGraph CLI 0.2.8 adds custom base image support and configurable headers schema for Docker workflows.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.2.8 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.2.8
```
- ›Supports specifying a custom base image in Docker commands.
- ›Adds schema updates for configurable headers.
sdk==0.1.66 Apr 30, 2025 · issue -367

LangGraph SDK 0.1.66 adds checkpoint_during parameter to control mid-execution checkpointing in graph runs.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.66 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
run = await client.runs.create(
    thread_id,
    assistant_id,
    input=input_data,
    checkpoint_during=True,
)
```
- ›Adds optional checkpoint_during: Optional[bool] parameter to stream, create, wait, and create_for_thread client methods, letting callers control whether checkpoints are written during graph execution or only at the end/interruption.
sdk==0.1.65 Apr 30, 2025 · issue -367

LangGraph SDK 0.1.65 adds sorting support to assistants search with new sort_by and sort_order parameters.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.65 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Introduces new type aliases AssistantSortBy, ThreadSortBy, and SortOrder for strongly-typed sort parameter hints across assistant and thread searches.
0.4.1 Apr 30, 2025 · issue -367

LangGraph 0.4.1 adds incremental UI message merging and drops Pydantic V1 support.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Drops Pydantic V1 support — SchemaCoercionMapper and langgraph.utils.pydantic now exclusively use Pydantic V2 APIs.
└──▷ 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).
0.4.0 Apr 29, 2025 · issue -367

LangGraph 0.4.0 adds targeted interrupt resumption by ID and exposes pending interrupts on StateSnapshot
└──▷ GET THIS VERSION
```
$ git clone --branch 0.4.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Enhances Command.resume to accept a mapping of interrupt IDs to resume values, allowing targeted resumption of specific interrupts rather than all-or-nothing.
- ›Adds interrupts field to StateSnapshot to track interrupts that occurred in a step and are pending resolution.
- ›Propagates interrupts in "values" stream mode so invoke/ainvoke and streaming consumers now see interrupts emitted during graph execution.
- ›Adds add_edge utility in graph visualization to prevent duplicate edges when rendering graphs with END nodes.
checkpoint==2.0.25 Apr 26, 2025 · issue -367

LangGraph checkpoint savers gain delete_thread and adelete_thread methods to remove all data for a given thread ID.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.25 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
0.3.32 Apr 23, 2025 · issue -367

LangGraph 0.3.32 adds draw_graph for graph visualization and get_static_writes for static analysis of conditional edges.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.32 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.3.32
```
└──▷ USE IT
Visualize a compiled graph including subgraphs and conditional edges using the new dedicated draw_graph function.
python
```
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.
- ›Extends ChannelWrite.register_writer to accept static declarations for writers, with a new static field on ChannelWriteTupleEntry to declare writes for static analysis.
- ›Adds new langgraph.pregel.draw module with a draw_graph function that simulates execution to discover edges, correctly handling subgraphs and conditional edges.
cli==0.2.7 Apr 23, 2025 · issue -367

LangGraph CLI gains --image option to deploy pre-built Docker images without a rebuild step.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.2.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
```
$ 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.
cli==0.2.6 Apr 22, 2025 · issue -367

LangGraph CLI 0.2.6 adds --tunnel flag to expose local dev server publicly via Cloudflare.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.2.6 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
```
$ langgraph dev --tunnel
```
- ›Adds --tunnel flag to the dev command to expose the local LangGraph API server through a public Cloudflare tunnel, enabling remote frontend access without localhost restrictions.
sdk==0.1.62 Apr 21, 2025 · issue -367

LangGraph SDK 0.1.62 adds sort_by and sort_order parameters to thread search for ordered result retrieval.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.62 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.62
```
└──▷ USE IT
Retrieve the most recently updated threads first — useful when triaging active or stalled agent runs.
python
```
threads = await client.threads.search(
    sort_by="updated_at",
    sort_order="desc"
)
```
- ›Adds sort_by and sort_order parameters to Client.search for sorting thread results by id, status, created_at, or updated_at in ascending or descending order.
checkpointpostgres==2.0.20 Apr 17, 2025 · issue -367

LangGraph Postgres checkpoint library adds thread deletion and tightens search method signatures.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.20 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==2.0.20
```
└──▷ USE IT
Purge all checkpoint data for a completed or abandoned thread to reclaim storage.
python
```
saver = PostgresSaver(conn)
saver.delete_thread(thread_id="thread-abc123")
```
Purge thread data in an async workflow without blocking the event loop.
python
```
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.
- ›Adds adelete_thread (async) and delete_thread (sync, with main-thread safety checks) to AsyncPostgresSaver for the same capability in async workflows.
- ›Updates search on PostgresStore and asearch on AsyncPostgresStore to require query as an explicit keyword argument rather than a positional parameter.
└──▷ 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.
cli==0.2.5 Apr 17, 2025 · issue -367

LangGraph CLI 0.2.5 adds internal config option to override Docker tags in generated Dockerfiles.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.2.5 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
{
  "_INTERNAL_docker_tag": "3.11-slim-bookworm"
}
```
- ›Adds _INTERNAL_docker_tag configuration option to override the default Docker tag used in generated Dockerfiles, falling back to the Python or Node.js version when not set.
0.3.31 Apr 17, 2025 · issue -367

LangGraph 0.3.31 adds CONFIG_KEY_THREAD_ID constant for tracking thread IDs in concurrent graph invocations.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.31 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
- ›New langgraph.constants.CONFIG_KEY_THREAD_ID constant enables explicit tracking of thread IDs for current invocations in checkpointing and state management.
0.3.28 Apr 11, 2025 · issue -367

LangGraph 0.3.28 adds support for multiple retry policies per node or task, applying the first matching policy on exception.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.28 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Improves SchemaCoercionMapper performance with functools.lru_cache caching, fast paths for basic types, and better handling of tuple, set, and other collection types.
- ›Adds compatibility with both Pydantic v1 and v2 in schema coercion via SchemaCoercionMapper.
cli==0.2.2 Apr 10, 2025 · issue -367

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
```
$ git clone --branch cli==0.2.2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.2.2
```
- ›Automatically detects Python and JavaScript graphs by file extension, eliminating manual language configuration.
- ›Selects the appropriate Docker base image automatically based on project composition via new default_base_image logic.
- ›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.
- ›New docker_tag utility generates correct Docker image tags based on project configuration.
0.3.27 Apr 8, 2025 · issue -367

LangGraph 0.3.27 adds checkpoint_during parameter to skip per-step checkpointing and boost large-graph performance.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.27 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
└──▷ BREAKING ON UPGRADE
- !checkpoint_every_step is renamed to checkpoint_during in PregelLoop — any code referencing the old name will break.
cli==0.1.89 Apr 4, 2025 · issue -367

LangGraph CLI now accepts dictionary-format graph definitions with a 'path' key in addition to plain import-path strings.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.89 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.89
```
- ›Supports dictionary-format graph definitions (with a 'path' key) in the configuration file, alongside the existing plain import-path string format, enabling additional metadata to be co-located with graph paths.
0.3.25 Apr 3, 2025 · issue -367

LangGraph 0.3.25 adds a UI messaging system to push, remove, and reduce UI component updates during graph execution.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.25 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›New RemoveUIMessage TypedDict enables removal of UI components from the current graph state.
- ›New AnyUIMessage Union type combines UIMessage and RemoveUIMessage for flexible type annotations.
- ›New push_ui_message() function creates and sends UI messages to render components mid-execution.
- ›New delete_ui_message() function removes a UI component from state by ID.
+1 moreshow less
- ›New ui_message_reducer() function merges UI message lists, handling both additions and deletions.

prebuilt==0.1.8 Apr 3, 2025 · issue -367

LangGraph prebuilt 0.1.8 adds a pre_model_hook to create_react_agent for trimming or summarizing long message histories before LLM calls.

└──▷ GET THIS VERSION

$ git clone --branch prebuilt==0.1.8 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.

python

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

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.
›Hook can return messages to update agent state or llm_input_messages to reshape only what the LLM sees, leaving persisted state untouched.

cli==0.1.84 Apr 3, 2025 · issue -367

LangGraph CLI 0.1.84 adds custom UI configuration support for dev server and Docker builds.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.84 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.84
```
- ›Supports ui and ui_config options in config files for customized UI when running langgraph dev.
- ›Docker image builds now automatically detect and install UI dependencies (npm, yarn, pnpm, bun) when UI is configured.
- ›Docker images now include LANGGRAPH_UI and LANGGRAPH_UI_CONFIG environment variables when UI is configured.
sdk==0.1.61 Apr 3, 2025 · issue -367

LangGraph SDK 0.1.61 adds description support to assistant create and update methods.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.61 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds description parameter to create and update methods (async and sync) on the assistants client.
checkpoint==2.0.24 Apr 2, 2025 · issue -367

LangGraph checkpoint 2.0.24 adds explicit None serialization support in JsonPlusSerializer.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.24 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
0.3.23 Apr 2, 2025 · issue -367

LangGraph 0.3.23 adds REMOVE_ALL_MESSAGES to clear entire conversation histories in one operation.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.23 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
cli==0.1.83 Apr 2, 2025 · issue -367

LangGraph CLI 0.1.83 adds TTL-based checkpointer config for automatic thread data cleanup in deployments.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.83 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds ThreadTTLConfig class to set default TTL (in minutes), sweep interval, and expiry strategy ("delete") for automatic cleanup of thread checkpoints.
- ›Supports passing checkpointer configuration to Docker environments via the LANGGRAPH_CHECKPOINTER environment variable automatically.
- ›Switches from msgpack to ormsgpack for improved serialization performance.
cli==0.1.82 Apr 1, 2025 · issue -367

LangGraph CLI dev command gains --allow-blocking flag to suppress synchronous I/O blocking errors
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.82 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
```
$ langgraph dev --allow-blocking
```
- ›Adds --allow-blocking flag to the dev command, allowing the server to run without raising errors when synchronous I/O blocking operations are detected.
cli==0.1.81 Mar 28, 2025 · issue -368

LangGraph CLI 0.1.81 adds ui_config parameter to customize the LangGraph UI via configuration.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.81 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.81
```
- ›Adds ui_config parameter to the LangGraph configuration for customizing the LangGraph UI.
- ›Exposes LANGGRAPH_UI_CONFIG Docker environment variable when UI configurations are provided, enabling container-level UI customization.
sdk==0.1.60 Mar 27, 2025 · issue -368

LangGraph SDK 0.1.60 adds dictionary-like access to the auth user object — index, check, and iterate over user properties.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.60 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.60
```
└──▷ USE IT
Access, check, and iterate over user properties inside a LangGraph auth handler without calling getattr.
python
```
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"]).
- ›Adds __contains__ to the auth user object so you can check property existence with the in operator.
- ›Adds __iter__ to the auth user object, allowing iteration over all user properties in auth handlers.
cli==0.1.80 Mar 25, 2025 · issue -368

LangGraph CLI now reads package.json metadata to auto-detect Yarn, pnpm, or Bun when no lock file is present.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.80 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.80
```
- ›Adds get_pkg_manager_name() helper that reads packageManager or devEngines.packageManager.name from package.json to detect the correct package manager (Yarn, pnpm, Bun, or npm) even when no lock file exists.
sdk==0.1.59 Mar 25, 2025 · issue -368

LangGraph SDK 0.1.59 adds per-request custom HTTP headers across all API client methods.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.59 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds optional headers parameter to all methods on AssistantsClient and SyncAssistantsClient (including get, create, update, delete, search).
- ›Adds optional headers parameter to all thread-related methods on ThreadsClient and SyncThreadsClient, including state management, history, and creation.
- ›Adds optional headers parameter to all run methods on RunsClient and SyncRunsClient, covering create, stream, wait, and management operations.
- ›Adds optional headers parameter to all cron job methods on CronClient and SyncCronClient (create, search, delete).
+1 moreshow less
- ›Adds optional headers parameter to all store operations on StoreClient and SyncStoreClient, including item storage, retrieval, and namespace management.
checkpoint==2.0.22 Mar 24, 2025 · issue -368

langgraph-checkpoint 2.0.22 adds blob storage for InMemorySaver, upgrades to ormsgpack, and supports custom serialization hooks.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.22 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›Bumps checkpoint format to LATEST_VERSION = 2, adopted by empty_checkpoint() and create_checkpoint(), to support the new storage layout.
- ›Replaces msgpack with ormsgpack in JsonPlusSerializer for faster serialization, including new bytearray support and optimized serialization options.
- ›Adds customizable JsonPlusSerializer.__init__ accepting an optional custom unpacking hook, plus _msgpack_ext_hook_to_json for better MessagePack-to-JSON type translation.
0.3.19 Mar 24, 2025 · issue -368

LangGraph 0.3.19 adds dependency-aware node scheduling and XXH3-based task ID hashing for faster graph execution.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.19 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.3.19
```
└──▷ USE IT
Explicitly declare that a callable node accepts the LangChain config, avoiding runtime parameter inspection overhead.
python
```
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
```
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.
- ›Adds trigger_to_nodes property on Pregel to expose the mapping from channel triggers to dependent nodes.
- ›Adds subgraphs parameter on PregelNode to directly specify subgraphs instead of extracting them from a bound runnable.
- ›Adds func_accepts_config parameter on RunnableCallable to explicitly control whether a wrapped function receives the LangChain config argument.
- ›Switches task ID generation to the XXH3 hash algorithm (via _xxhash_str) for newer checkpoint versions, replacing the slower SHA-1 implementation.
cli==0.1.78 Mar 21, 2025 · issue -368

LangGraph CLI dev command gains --studio_url option to connect to custom Studio instances.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.78 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
```
$ langgraph dev --studio_url https://studio.internal.example.com
```
- ›Adds --studio_url option to the dev command, enabling connection to a custom LangGraph Studio instance instead of the default https://smith.langchain.com.
sdk==0.1.58 Mar 19, 2025 · issue -368

LangGraph SDK 0.1.58 adds supersteps and graph_id parameters to thread creation for cross-deployment thread copying.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.58 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.58
```
└──▷ USE IT
Copy a thread from one deployment to another by replaying its supersteps at creation time.
python
```
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.
- ›Adds graph_id parameter to ThreadsClient.create() to associate a new thread with a specific graph at creation time.
0.3.17 Mar 19, 2025 · issue -368

LangGraph 0.3.17 adds bulk state update methods for efficient sequential graph state mutations.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.17 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.3.17
```
└──▷ USE IT
Apply several state patches at once during human-in-the-loop correction instead of calling update_state repeatedly.
python
```
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
```
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.
- ›Introduces StateUpdate NamedTuple (fields: values, as_node) as a structured type for representing individual state updates passed to bulk operations.
0.3.15 Mar 18, 2025 · issue -368

LangGraph 0.3.15 adds is_available() channel introspection and improves Pregel task execution performance.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.15 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Changes PregelExecutableTask.triggers type from list[str] to Sequence[str] for more flexible and performant trigger handling.
└──▷ BREAKING ON UPGRADE
- !The return_exception parameter is removed from read_channel() in langgraph.pregel.io; code passing that argument will break.
0.3.13 Mar 18, 2025 · issue -368

LangGraph 0.3.13 adds RemoteGraph visualization support and improves handling of multiple concurrent interrupts.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.13 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.3.13
```
└──▷ USE IT
Visualize a graph that includes RemoteGraph nodes — now renders correctly instead of being skipped.
python
```
await compiled_graph.aget_graph(xray=True)
```
- ›Adds support for visualizing RemoteGraph instances in both sync and async graph drawing methods.
- ›Enables parallel traversal of subgraphs during async graph visualization via asyncio.gather(), speeding up rendering of complex graphs.
- ›Enhances multiple concurrent interrupt handling by collecting and combining them into a single interrupt for cleaner propagation.
checkpoint==2.0.21 Mar 17, 2025 · issue -368

LangGraph checkpoint adds EncryptedSerializer and CipherProtocol for at-rest encryption of checkpoint data.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.21 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==2.0.21
```
└──▷ USE IT
Encrypt all checkpoint data at rest using AES — useful when storing sensitive agent state in a shared or cloud-backed checkpointer.
python
```
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-backed one) by conforming to CipherProtocol instead of using the built-in AES factory.
python
```
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.
- ›New EncryptedSerializer class wraps any underlying serializer (defaults to JsonPlusSerializer) to transparently encrypt and decrypt checkpoint data.
- ›Factory method EncryptedSerializer.from_pycryptodome_aes enables AES-encrypted checkpoints via the pycryptodome library with minimal setup.
- ›Supports AES key supply via LANGGRAPH_AES_KEY environment variable or direct key passing, and is backward-compatible with existing unencrypted checkpoint data.
checkpointpostgres==2.0.17 Mar 14, 2025 · issue -368

langgraph-checkpoint-postgres 2.0.17 adds TTL support for Postgres store items with automatic background expiry sweeping.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.17 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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
```
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.
- ›Adds start_ttl_sweeper() and stop_ttl_sweeper() methods to manage a background thread/task that automatically deletes expired items.
- ›Adds sweep_ttl() method (sync and async) for on-demand manual deletion of expired store items.
- ›Supports TTL configuration via from_conn_string() for both sync and async store classes.
- ›Adds expires_at and ttl_minutes columns plus an index on expires_at to the store table via new database migrations.
+1 moreshow less
- ›Enables TTL refresh on GET and SEARCH operations so item lifetimes can be extended on access.
checkpoint==2.0.20 Mar 14, 2025 · issue -368

LangGraph checkpoint 2.0.20 adds configurable TTL sweep intervals for automatic expiry cleanup in stores.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.20 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
cli==0.1.77 Mar 14, 2025 · issue -368

LangGraph CLI 0.1.77 adds automatic TTL sweeping via new sweep_interval_minutes config option.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.77 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
0.3.10 Mar 14, 2025 · issue -368

LangGraph 0.3.10 adds env-var recursion control, cached schema coercion, and flexible task return types.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
```
$ export LANGGRAPH_DEFAULT_RECURSION_LIMIT=100
```
- ›New SchemaCoercionMapper class provides cached schema coercion supporting Pydantic v1/v2, nested lists, dicts, tuples, and unions.
- ›Configures graph recursion limit via the LANGGRAPH_DEFAULT_RECURSION_LIMIT environment variable (default: 25), removing the need for per-run config.
- ›Expands PregelTask.result field to accept Any type, enabling flexible non-dict return values from tasks.
└──▷ BREAKING ON UPGRADE
- !The require_at_least_one_of parameter is removed from ChannelWrite; code that passes this parameter will break on upgrade.
sdk==0.1.57 Mar 13, 2025 · issue -368

LangGraph SDK adds stream_mode filtering and cancel_on_disconnect to join_stream for precise run output control.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.57 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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").
- ›Adds cancel_on_disconnect parameter to the sync RunClient.join_stream, reaching feature parity with the async version.
prebuilt==0.1.3 Mar 13, 2025 · issue -368

LangGraph prebuilt 0.1.3 adds Pydantic agent state models and Callable tool support in create_react_agent.
└──▷ GET THIS VERSION
```
$ git clone --branch prebuilt==0.1.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Enables create_react_agent to accept plain Callable objects as tools, in addition to BaseTool instances.
- ›Supports both TypedDict and Pydantic models interchangeably for agent state schema via updated StateSchemaType.
checkpoint==2.0.19 Mar 12, 2025 · issue -368

LangGraph Checkpoint 2.0.19 adds TTL configuration support for stores with default TTL values and refresh-on-read control.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.19 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds ttl_config property to BaseStore so TTL policy is set once and applied automatically to get, search, put, and their async counterparts.
- ›Adds NotProvided sentinel class and NOT_PROVIDED constant to distinguish between explicitly passing ttl=None and omitting a TTL value entirely.
└──▷ 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.
cli==0.1.76 Mar 12, 2025 · issue -368

LangGraph CLI 0.1.76 adds TTL configuration for stores, enabling automatic expiration of stored items.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.76 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Extends StoreConfig with an optional ttl field to attach TTL settings to any store definition.
0.3.7 Mar 12, 2025 · issue -368

LangGraph 0.3.7 adds Pydantic v1/v2 model validation for graph inputs via input_model support.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Extends get_input_schema to prioritize the input_model when available, surfacing typed input schemas for state graphs.
- ›Introduces _pick_mapper function in StateGraph/CompiledStateGraph to correctly handle Pydantic and non-Pydantic schema types during state coercion.
0.3.6 Mar 11, 2025 · issue -368

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
```
$ git clone --branch 0.3.6 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›New Branch.from_path factory method handles path_map conversion and optionally infers input schema.
- ›Extends StateGraph.add_conditional_edges with schema inference, improving type safety for branch routing.
- ›Improves type annotations on the task decorator to consistently prioritize async functions in Union types.
checkpointpostgres==2.0.16 Mar 7, 2025 · issue -368

LangGraph Postgres checkpoint store exposes PLACEHOLDER and get_distance_operator as public API
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.16 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==2.0.16
```
└──▷ USE IT
Reference the now-public PLACEHOLDER constant when building custom batch queries against the Postgres store.
python
```
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.
- ›Exposes get_distance_operator function (formerly _get_distance_operator) as a public API in langgraph.store.postgres.base for custom vector-distance logic.
└──▷ 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.
checkpoint==2.0.18 Mar 7, 2025 · issue -368

LangGraph checkpoint 2.0.18 lets BaseStore operations accept non-string keys with automatic conversion.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.18 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
sdk==0.1.55 Mar 6, 2025 · issue -368

LangGraph SDK 0.1.55 adds TTL support to the store API, enabling automatic expiration and refresh of stored items.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.55 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds refresh_ttl parameter to get_item to control whether an item's TTL is refreshed on read.
- ›Adds refresh_ttl parameter to search_items to control TTL refresh for items returned by search.
checkpoint==2.0.17 Mar 6, 2025 · issue -368

LangGraph Checkpoint 2.0.17 adds TTL support for store items, enabling automatic expiration of stored data.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.17 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==2.0.17
```
- ›Adds TTL (time-to-live) support to BaseStore via a supports_ttl flag, letting store implementations enable automatic expiration of stored items.
- ›Adds ttl: Optional[float] = None parameter to PutOp to set per-item expiration time in minutes when writing to the store.
- ›Adds refresh_ttl: bool = True parameter to GetOp and SearchOp to control whether TTLs are refreshed on retrieval or search.
cli==0.1.75 Mar 6, 2025 · issue -368

LangGraph CLI 0.1.75 adds IDE schema validation for langgraph.json and UI component configuration support.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.75 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.75
```
└──▷ USE IT
Declare UI components for an agent in langgraph.json using the new ui configuration key.
json
```
{
  "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.
- ›Adds a new ui configuration option to the Config class for defining UI components associated with agents.
- ›Supports setting the LANGGRAPH_UI environment variable in Docker deployments to configure UI components.
└──▷ BREAKING ON UPGRADE
- !StoreConfig.embed is renamed to StoreConfig.index — any langgraph.json or code referencing StoreConfig.embed will break on upgrade.

prebuilt==0.1.2 Mar 6, 2025 · issue -368

LangGraph prebuilt 0.1.2 lets create_react_agent accept a RunnableSequence as its model argument.

└──▷ GET THIS VERSION

$ git clone --branch prebuilt==0.1.2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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

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 backbone.

0.3.4 Mar 4, 2025 · issue -368

LangGraph 0.3.4 adds config_schema and get_config_jsonschema methods to Pregel, plus a new Pydantic-support utility.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.3.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.3.4
```
└──▷ USE IT
Expose a graph's configuration schema as JSON Schema for tooling, validation, or documentation.
python
```
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
```
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.
- ›Adds get_config_jsonschema method to Pregel for converting config schemas to JSON Schema format, consistent with existing get_input_jsonschema/get_output_jsonschema.
- ›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.
cli==0.1.74 Feb 27, 2025 · issue -369

LangGraph CLI 0.1.74 adds langgraph 0.3.x support and the new langgraph-prebuilt high-level agent API.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.74 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.74
```
- ›Supports langgraph 0.3.x, enabling use of the latest core graph features in CLI-managed projects.
- ›Adds support for langgraph-prebuilt v0.1.1, which provides high-level APIs for creating and executing LangGraph agents and tools.
0.2.75 Feb 26, 2025 · issue -369

LangGraph 0.2.75 adds structured response support and configuration schemas to the ReAct agent executor.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.75 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
from langgraph.prebuilt.chat_agent_executor import AgentStateWithStructuredResponse
```
- ›Adds AgentStateWithStructuredResponse class to support structured responses in the ReAct agent executor.
- ›Adds configuration schema support to the ReAct agent executor.
- ›Enhances StreamMessagesHandler to track message IDs nested within input dictionaries for proper deduplication.
- ›Adds py.typed markers to package subdirectories for improved type-checking support.
sdk==0.1.53 Feb 20, 2025 · issue -369

LangGraph SDK 0.1.53 adds store authorization via @auth.on.store and dynamic loopback transport configuration.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.53 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.53
```
└──▷ USE IT
Restrict store operations so each user can only read or write their own data.
python
```
@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.
- ›Adds configure_loopback_transports function and _registered_transports list for dynamic server transport configuration.
- ›Supports deferred loopback transport setup via the __LANGGRAPH_DEFER_LOOPBACK_TRANSPORT environment variable.
cli==0.1.72 Feb 19, 2025 · issue -369

LangGraph CLI 0.1.72 adds Docker build-context support for parent-dir deps and new HTTP server config options including CORS and custom app mounting.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.72 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds http.app config option to mount custom Starlette/FastAPI apps onto the LangGraph HTTP server.
- ›Adds options to disable specific API route groups (assistants, threads, runs, store) via HTTP configuration.
- ›Adds CORS configuration support for the LangGraph HTTP server.
0.2.74 Feb 19, 2025 · issue -369

LangGraph 0.2.74 stabilizes the Functional API and adds custom task submission via CONFIG_KEY_RUNNER_SUBMIT.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.74 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Promotes langgraph.func.task and langgraph.func.entrypoint decorators to stable (Beta label removed).
- ›Adds no-op fallback in get_stream_writer so callers can safely invoke the stream writer even when none is configured.
checkpoint==2.0.15 Feb 15, 2025 · issue -369

LangGraph checkpoint 2.0.15 adds get_checkpoint_metadata for standardized, filtered checkpoint metadata extraction.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.15 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
checkpointpostgres==2.0.14 Feb 13, 2025 · issue -369

PostgreSQL checkpoint savers now store richer metadata by merging configurable properties with existing and explicit metadata.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.14 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.

checkpoint==2.0.13 Feb 13, 2025 · issue -369

InMemorySaver now serializes configurable options and existing metadata into checkpoint metadata

└──▷ GET THIS VERSION

$ git clone --branch checkpoint==2.0.13 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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

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.

›Enriches InMemorySaver.put checkpoint metadata with non-private config["configurable"] entries (keys not prefixed with __) and any existing config["metadata"] values

checkpointsqlite==2.0.4 Feb 13, 2025 · issue -369

LangGraph SQLite checkpointers now store richer metadata including configurable fields and existing checkpoint metadata.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointsqlite==2.0.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
0.2.71 Feb 11, 2025 · issue -369

LangGraph 0.2.71 adds a destinations parameter to add_node() for visualizing routing in edgeless graphs.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.71 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›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.
checkpoint==2.0.12 Feb 9, 2025 · issue -369

LangGraph Checkpoint 2.0.12 adds provider-string embedding init and renames MemorySaver to InMemorySaver.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.12 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==2.0.12
```
└──▷ USE IT
Configure a vector store index with an embedding model using a provider string instead of a manually constructed embeddings instance.
python
```
from langgraph.store.base import IndexConfig

index_config = IndexConfig(
    embed="openai:text-embedding-3-small",
    dims=1536,
)
```
- ›Supports initializing embedding models via provider strings (e.g., "openai:text-embedding-3-small") in IndexConfig.embed, eliminating the need to manually instantiate an embeddings object.
- ›Introduces InMemorySaver as the canonical class name for the in-memory checkpoint saver, with MemorySaver retained as a backward-compatible alias.
0.2.70 Feb 6, 2025 · issue -369

LangGraph 0.2.70 adds parallel tool execution in ReAct agents and graph naming for multi-agent systems.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.70 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.70
```
└──▷ USE IT
Run tool calls in parallel across multiple ToolNode instances to speed up multi-tool ReAct agents.
python
```
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
```
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
```
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).
- ›Adds name parameter to Graph.compile(), StateGraph.compile(), and create_react_agent() to identify graphs when used as subgraphs.
- ›Automatically attaches agent name to AIMessages generated by the ReAct agent for easier identification in multi-agent workflows.
- ›Enables ToolNode to accept direct tool calls as a list of ToolCall dicts.
- ›Promotes _inject_tool_args to public method inject_tool_args on ToolNode.
+1 moreshow less
- ›Extends RunnableLike type to support injected kwargs such as writer and store via Concatenate and ParamSpec.
0.2.69 Jan 31, 2025 · issue -370

LangGraph 0.2.69 adds context utilities (get_config, get_store, get_stream_writer), tag support for streamed LLM messages, and optional store in ToolNode.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.69 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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
```
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.
- ›Adds optional store parameter support in ToolNode, enabling tools to access the LangGraph store without requiring it as a mandatory dependency.
- ›Adds tag support in StreamMessagesHandler so streamed LLM messages carry filtered tag metadata (excluding internal sequence-step tags).
- ›Adds subgraphs property to PregelNode and subgraphs field to PregelExecutableTask for direct tracking and caching of nested graph references.
cli==0.1.70 Jan 29, 2025 · issue -370

LangGraph CLI now supports auth configuration in langgraph.json with path validation and Docker container handling.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.70 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
{
  "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.
- ›Enables auth path resolution in Docker environments via new _update_auth_path function, so auth handlers are correctly wired when deploying containers.
0.2.68 Jan 28, 2025 · issue -370

LangGraph 0.2.68 promotes the Functional API to Beta and adds a name parameter to the task decorator.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.68 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Promotes the Functional API (@task, @entrypoint) from Experimental to Beta status with expanded documentation.
- ›Introduces unified SyncAsyncFuture type in langgraph.pregel.call that implements both the Future interface and the awaitable protocol for task return values.
- ›Renames state_modifier parameter to prompt in create_react_agent, with full backward compatibility retained.
└──▷ BREAKING ON UPGRADE
- !Generators are no longer supported in the Functional API (@entrypoint); any entrypoint using a generator function will break on upgrade.
cli==0.1.69 Jan 25, 2025 · issue -370

LangGraph CLI now ships PostgreSQL with pgvector enabled for vector operations support.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.69 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.69
```
- ›Upgrades the bundled PostgreSQL Docker image to pgvector/pgvector:pg16, enabling vector operations in local dev environments.
- ›Loads the pgvector extension automatically via shared_preload_libraries=vector in the generated Docker Compose configuration.
0.2.67 Jan 23, 2025 · issue -370

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
```
$ git clone --branch 0.2.67 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Supports async coroutine functions as state modifiers in the chat agent executor.
- ›Adds thread-safe atomic counters in PregelScratchpad for safer concurrent graph execution.
- ›Supports Union types in node function return annotations so add_node correctly extracts Command types.
- ›Enhances Command.update with automatic field extraction from type hints on dataclasses and typed objects.
+1 moreshow less
- ›Reduces tracing noise by applying recurse=False to internal RunnableCallable instances.
└──▷ 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.
0.2.66 Jan 21, 2025 · issue -370

LangGraph 0.2.66 adds run_coroutine_threadsafe, explode_args, and trace_inputs for safer async execution and richer tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.66 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds trace_inputs parameter to RunnableSeq to customize how inputs are recorded in callbacks across invoke, ainvoke, stream, and astream.
- ›Adds run_coroutine_threadsafe function in langgraph.utils.future for safely running coroutines from any thread context.
- ›Adds CONTEXT_NOT_SUPPORTED flag in langgraph.utils.future to handle Python versions whose event loops do not support contextvars.
- ›Adds get_runnable_for_entrypoint and get_runnable_for_task functions in langgraph.pregel.call for targeted handling of distinct execution contexts.
+4 moreshow less
- ›Moves the call function from langgraph.func.__init__ to langgraph.pregel.call for better module organization.
- ›Adds _explode_args_trace_inputs utility in langgraph.pregel.call to flatten function arguments in traces for improved debugging.
- ›Enhances chain_future in langgraph.utils.future to return the destination future, enabling direct chaining.
- ›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.
0.2.65 Jan 21, 2025 · issue -370

LangGraph 0.2.65 adds graph visualization for entrypoint functions and a new get_store() utility for easy store access.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.65 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.65
```
└──▷ USE IT
Visualize an entrypoint function and all its nested tasks during development or debugging.
python
```
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
```
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.
- ›New get_store() utility function retrieves the BaseStore from the current config context without manual extraction.
- ›Tasks decorated with @task now carry a _is_pregel_task attribute, making them automatically discoverable for graph visualization.
└──▷ 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.
cli==0.1.68 Jan 20, 2025 · issue -370

LangGraph CLI 0.1.68 adds Bun package manager support and clearer JS-graph error guidance.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.68 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›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.
0.2.64 Jan 17, 2025 · issue -370

LangGraph 0.2.64 adds config schema validation and previous state access to the entrypoint decorator.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.64 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds support for an optional previous parameter in entrypoint-decorated functions to access the prior return value in stateful Pregel graphs.
- ›Adds automatic input/output type detection from function signatures in the entrypoint decorator, removing the need for manual type annotation wiring.
0.2.63 Jan 16, 2025 · issue -370

LangGraph 0.2.63 adds subgraph checkpointing, string model IDs in create_react_agent, human-interrupt types, and eager streaming.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.63 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.63
```
└──▷ USE IT
Enable persistent checkpointing for a subgraph without wiring up a full checkpointer object.
python
```
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
```
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.
- ›Accepts string model identifiers in create_react_agent, e.g. create_react_agent("openai:gpt-4", tools).
- ›Adds structured type definitions for human-in-the-loop interactions: HumanInterruptConfig, ActionRequest, HumanInterrupt, and HumanResponse in langgraph.prebuilt.interrupt.
- ›Adds stream_eager option to langgraph.pregel to force stream events to emit eagerly.
- ›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.
+1 moreshow less
- ›Allows mixed Command and non-Command types in list commands, removing the requirement that all list items be Command objects.
└──▷ BREAKING ON UPGRADE
- !get_configurable in langgraph.utils.config is renamed to get_config; any code calling get_configurable will break.
checkpointpostgres==2.0.12 Jan 15, 2025 · issue -370

langgraph-checkpoint-postgres 2.0.12 adds task_path tracking to checkpoint writes for better data organization.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.12 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Extends the checkpoint_writes table schema with a task_path column, enabling path-based ordering and querying of checkpoint write records.
checkpointsqlite==2.0.3 Jan 15, 2025 · issue -370

LangGraph SQLite checkpointer adds task_path parameter to write-tracking methods for improved task traceability.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointsqlite==2.0.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
saver.put_writes(config, writes, task_id, task_path="agent:tool_call")
```
Do the same in async workflows using the async saver.
python
```
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.
- ›Adds optional task_path parameter to AsyncSqliteSaver.put_writes() and AsyncSqliteSaver.aput_writes() for async task traceability.
checkpoint==2.0.10 Jan 15, 2025 · issue -370

LangGraph checkpoint 2.0.10 adds task path tracking to put_writes/aput_writes for consistent ordering in nested task graphs.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Enables deterministic, consistent ordering of pending sends by sorting on task path, task ID, and sequence number during checkpoint retrieval.
checkpointduckdb==2.0.2 Jan 14, 2025 · issue -370

LangGraph DuckDB checkpointer adds in-memory vector search support
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointduckdb==2.0.2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointduckdb==2.0.2
```
- ›Adds in-memory vector search capability to the DuckDB checkpointer

0.2.62 Jan 10, 2025 · issue -370

LangGraph 0.2.62 adds a response_format parameter to create_react_agent for structured, schema-validated agent outputs.

└──▷ GET THIS VERSION

$ git clone --branch 0.2.62 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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

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

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.
›Supports OpenAI function/tool schemas, JSON Schema, TypedDict classes, and Pydantic models as the response schema.
›Accepts a (prompt, schema) tuple for response_format to supply a custom prompt when generating structured output.

sdk==0.1.50 Jan 9, 2025 · issue -370

LangGraph SDK 0.1.50 adds store authorization handlers and expands Command.update to accept tuple sequences.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.50 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Introduces new TypedDict classes — StoreGet, StoreSearch, StoreListNamespaces, StorePut, StoreDelete — for typed store operation authorization.
- ›Expands Command.update to accept sequences of tuples in addition to dictionaries, enabling more flexible graph state updates.
0.2.61 Jan 5, 2025 · issue -370

LangGraph 0.2.61 adds OpenAI-format message conversion to add_messages and a more flexible task decorator with async support.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.61 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
python
```
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
```
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.
- ›Enables add_messages as a partial function when called without arguments, improving flexibility in type annotations.
- ›Rewrites the task decorator to support both direct (@task) and parameterized (@task(...)) usage, with proper coroutine detection and wrapping for async functions.
- ›Expands task decorator function signature to accept *args and **kwargs and adds overloads for better IDE type inference.
checkpointpostgres==2.0.9 Dec 20, 2024 · issue -371

LangGraph Postgres checkpointer adds ShallowPostgresSaver and AsyncShallowPostgresSaver for lightweight, history-free checkpoint storage.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.9 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›Adds AsyncShallowPostgresSaver, the async counterpart to ShallowPostgresSaver, with the same lightweight storage semantics and a full async interface.
└──▷ BREAKING ON UPGRADE
- !The batch method has been removed from AsyncPostgresStore; callers must switch to abatch instead.
sdk==0.1.48 Dec 18, 2024 · issue -371

LangGraph SDK 0.1.48 adds StudioUser class for fine-grained authorization control over LangGraph Studio UI access.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.48 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
{
  "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.
- ›Enables custom authorization handlers to branch on Studio vs. non-Studio users via isinstance(user, StudioUser) checks.
- ›Supports disabling Studio authentication entirely via disable_studio_auth: true in langgraph.json.
0.2.60 Dec 18, 2024 · issue -371

LangGraph 0.2.60 makes Command.update accept any type and relaxes tool node validation for multi-message responses.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.60 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›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.
└──▷ 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.
sdk==0.1.47 Dec 17, 2024 · issue -371

LangGraph SDK 0.1.47 simplifies auth handlers and renames scopes to permissions in the Auth module.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.47 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds permissions field to MinimalUserDict and permissions property to the BaseUser interface in Auth.types.
- ›Updates Authenticator type signature to reflect the new single-object return format.
└──▷ 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).
cli==0.1.64 Dec 17, 2024 · issue -371

LangGraph CLI now validates dependencies in configuration, with graceful fallback when the field is absent.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.64 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.64
```
- ›Adds dependencies field validation to validate_config, ensuring dependency declarations are checked and included during config processing.
sdk==0.1.46 Dec 16, 2024 · issue -371

LangGraph SDK 0.1.46 adds HTTPException to auth handlers for precise HTTP error control
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.46 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Exposes exceptions module on the Auth class for clean, importable access to auth-related exception types.
cli==0.1.63 Dec 14, 2024 · issue -371

LangGraph CLI 0.1.63 adds OpenAPI security scheme configuration to AuthConfig for customizing API auth settings.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.63 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.63
```
- ›Adds SecurityConfig TypedDict class for defining OpenAPI security schemes and requirements in authentication config.
- ›Extends AuthConfig with a new openapi field of type SecurityConfig, enabling customization of API security settings such as OAuth2 scopes and token endpoints.
cli==0.1.62 Dec 14, 2024 · issue -371

LangGraph CLI 0.1.62 adds auth configuration support for LangGraph Studio with a new AuthConfig type.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.62 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
# 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.
- ›New auth field on the main Config TypedDict wires auth settings into config validation and Docker environment generation.
- ›The dev command now accepts auth configuration, allowing Studio auth to be controlled at dev-server launch time.
sdk==0.1.45 Dec 14, 2024 · issue -371

LangGraph SDK 0.1.45 adds an Auth class with decorator-based authentication and fine-grained per-resource authorization.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.45 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.45
```
└──▷ USE IT
Protect all LangGraph resources with a global auth handler that validates a bearer token and returns user scopes.
python
```
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
```
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.
- ›Supports decorator-based auth handlers to verify credentials and return user scopes.
- ›Enables fine-grained access control per resource (threads, assistants, crons) and per action (create, read, update, delete, search).
- ›Implements a hierarchical handler system supporting global fallback handlers alongside specific per-action handlers.
- ›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.
0.2.59 Dec 11, 2024 · issue -371

LangGraph 0.2.59 enables config-aware tool execution by passing configuration to prebuilt tool node invocations.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.59 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.59
```
- ›Enables prebuilt tool node to pass the configuration object to tools during both synchronous (invoke) and asynchronous (ainvoke) execution, allowing tools to access runtime configuration parameters.
0.2.58 Dec 10, 2024 · issue -371

LangGraph 0.2.58 adds string node names in Command.goto and richer config metadata with defaults and descriptions.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.58 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds get_enhanced_type_hints utility to extract type hints along with default values and descriptions, covering Pydantic models, TypedDict, and dataclasses.
- ›Enriches Pregel.config_specs output with default values and descriptions for configuration fields via get_enhanced_type_hints.
0.2.57 Dec 10, 2024 · issue -371

LangGraph 0.2.57 adds a functional API with @task/@entrypoint decorators and lets tools return Command objects.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.57 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.57
```
└──▷ USE IT
Run two LLM calls in parallel inside a functional-API workflow — use @task so both futures resolve concurrently, then collect results in the @entrypoint.
python
```
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
```
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.
- ›Adds @entrypoint decorator (langgraph.func.entrypoint) to wrap regular or generator functions into Pregel graphs as callable entry points.
- ›Enables Command objects to be returned directly from LangChain tools via ToolOutputMixin compatibility and ToolNode support.
- ›Adds StateGraph support for lists of Command objects and tuple-based state updates in node outputs.
- ›Adds _repr_mimebundle_ to Graph for inline Mermaid diagram visualization in Jupyter notebooks.
sdk==0.1.43 Dec 5, 2024 · issue -371

LangGraph SDK 0.1.43 adds query-param streaming and expands Command routing flexibility
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.43 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Expands Command TypedDict's goto field to accept Send, str, or a sequence of either, enabling richer graph routing in command structures.
└──▷ BREAKING ON UPGRADE
- !The Command TypedDict field send is renamed to goto; any code referencing Command(send=...) will break on upgrade.
0.2.55 Dec 5, 2024 · issue -371

LangGraph 0.2.55 overhauls interrupt/resume with scratchpad tracking and consolidates Send into the goto field
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.55 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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
- ›Adds CONFIG_KEY_SCRATCHPAD constant providing temporary storage scoped to the current task
- ›Rewrites the interrupt function with interrupt-count tracking to correctly handle multiple interrupts within the same node
- ›Enables goto field on Command to accept both string node names and Send objects, unifying send/goto into one API
- ›Deduplicates writes to special channels in PregelLoop.put_writes (last write wins)
└──▷ 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.
0.2.54 Dec 3, 2024 · issue -371

LangGraph 0.2.54 adds parent-graph command routing, empty-tool ReAct agents, and Command input support for RemoteGraph.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.54 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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 reasoning tasks where no external tools are needed.
python
```
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
```
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.
- ›Adds GraphBubbleUp base exception class and new ParentCommand exception to propagate parent-directed commands cleanly through the graph hierarchy.
- ›Enables create_react_agent to accept an empty tools list, producing a simple LLM-only graph without tool-calling plumbing.
- ›Enables RemoteGraph.stream and RemoteGraph.invoke to accept Command objects directly as input, with pass-through of additional client kwargs.
- ›Graph validation now only requires at least one edge from START; unreachable nodes no longer cause a validation error.
+1 moreshow less
- ›Adds Python 3.11+ exception notes in retry mechanisms for richer error diagnostics when tasks fail.
sdk==0.1.42 Dec 3, 2024 · issue -371

LangGraph SDK 0.1.42 adds run status filtering, cancel-on-disconnect streaming, and command support in assistant APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.42 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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
```
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.
- ›Adds cancel_on_disconnect parameter to RunsAPI.join_stream() to automatically cancel a run when the client disconnects from the stream.
- ›Adds command parameter to AssistantAPI.stream(), .create(), and .wait() for finer control over assistant execution.
- ›Adds Interrupt type definition and exposes interrupt information on the Thread schema for improved interrupt handling.
checkpointpostgres==2.0.7 Dec 3, 2024 · issue -371

langgraph-checkpoint-postgres 2.0.7 adds configurable vector indices (HNSW, IVFFlat, flat) and improved vector search ordering.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==2.0.7
```
└──▷ USE IT
Use an IVFFlat index with a custom cluster count when you have a large embedding dataset and want to trade recall for speed.
python
```
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'.
- ›Adds HNSWConfig class for tuning HNSW indices via m (max connections per layer) and ef_construction (dynamic candidate list size).
- ›Adds IVFFlatConfig class for tuning IVFFlat indices via nlist (number of inverted lists/clusters).
- ›Adds automatic vector index creation in BasePostgresStore based on the supplied index configuration.
- ›Adds condition field to Migration to support conditional migration execution based on store configuration.
cli==0.1.61 Nov 28, 2024 · issue -372

LangGraph CLI adds --wait-for-client flag for blocking debug startup and isolates store config into LANGGRAPH_STORE.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.61 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
```
$ 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.
- ›Introduces dedicated LANGGRAPH_STORE environment variable for store configuration in Docker environments, replacing the previous embedding inside LANGGRAPH_CONFIG.
└──▷ 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.
checkpointpostgres==2.0.5 Nov 28, 2024 · issue -372

langgraph-checkpoint-postgres 2.0.5 adds pgvector-powered semantic search to PostgreSQL-backed LangGraph stores.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.5 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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).
- ›Enables vector similarity search and embedding-based document indexing and retrieval in BasePostgresStore.
- ›Adds async embedding and vector search support to AsyncPostgresStore for non-blocking document indexing and retrieval.
- ›Introduces _row_to_search_item to surface similarity scores as float values alongside search results.
cli==0.1.60 Nov 28, 2024 · issue -372

LangGraph CLI 0.1.60 adds vector store configuration with embedding specs, enabling semantic search in LangGraph projects.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.60 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.60
```
└──▷ USE IT
Configure a vector store with an embedding model in your LangGraph project config to enable semantic search over stored data.
python
```
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.
- ›Enables the dev command to pass store configuration from config.json to the LangGraph server at runtime.
- ›Supports store settings in Docker container deployments via environment variable pass-through.
- ›Adds python-dotenv as an optional dependency for environment variable management.
sdk==0.1.40 Nov 28, 2024 · issue -372

LangGraph SDK 0.1.40 adds natural language search to the store with relevance scoring and fine-grained index control.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.40 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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 results.
python
```
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
```
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.
- ›Introduces SearchItem class extending Item with an optional score field, so callers can rank results by relevance.
- ›Updates SearchItemsResponse to return list[SearchItem] instead of list[Item], surfacing relevance scores in all search results.
- ›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.
└──▷ 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.
checkpoint==2.0.7 Nov 28, 2024 · issue -372

LangGraph checkpoint 2.0.7 adds vector/semantic search to stores, richer query filters, and embedding utilities.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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
```
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.
- ›Introduces IndexConfig class to configure vector search settings — embedding dimensions, embedding function, and which fields to index — per store.
- ›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.
- ›Adds query parameter to SearchOp for natural-language semantic search alongside existing namespace/filter queries.
- ›Enhances query filtering in SearchOp with comparison operators ($eq, $gt, $lt, and others) including support for nested fields and array path expressions.
+3 moreshow less
- ›Adds ensure_embeddings utility to wrap any sync or async embedding function into LangChain's Embeddings interface, plus EmbeddingsFunc/AEmbeddingsFunc type definitions.
- ›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.
- ›Rewrites InMemoryStore with full vector search support and optional NumPy acceleration for vector operations.
└──▷ 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.
checkpointpostgres==2.0.4 Nov 26, 2024 · issue -372

langgraph-checkpoint-postgres 2.0.4 adds connection pooling, pipeline optimization, and last-write-wins deduplication for Postgres stores.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›Adds connection pooling support to both PostgresStore and AsyncPostgresStore for improved throughput under high concurrency.
- ›Adds pipelined database operations to PostgresStore and AsyncPostgresStore, batching queries for higher throughput.
- ›Adds last-write-wins deduplication semantics for concurrent operations on the same key in PostgresStore.
- ›Adds thread locking (PostgresStore) and async locks (AsyncPostgresStore) for safe concurrent access.
+1 moreshow less
- ›Improves inheritance support in PostgresSaver and AsyncPostgresSaver by using cls instead of hardcoded class names, enabling reliable subclassing.
checkpoint==2.0.6 Nov 26, 2024 · issue -372

LangGraph checkpoint 2.0.6 adds async namespace listing and batch operation deduplication to AsyncBatchedBaseStore.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.6 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›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.
- ›Extends CheckpointMetadata.source to accept "fork" as a valid value, identifying checkpoints created as copies of other checkpoints.
cli==0.1.59 Nov 25, 2024 · issue -372

LangGraph CLI dev command now auto-loads config-file dependencies onto Python's path
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.59 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›Automatically adds the current working directory to Python's path when running the dev command, allowing seamless local module imports.
cli==0.1.58 Nov 21, 2024 · issue -372

LangGraph CLI 0.1.58 adds env parameter to pass environment variables from config file to the dev server.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.58 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
env:
  OPENAI_API_KEY: "sk-..."
  MY_CUSTOM_VAR: "value"
```
- ›Supports passing environment variables from the configuration file to the development server via a new env parameter.
cli==0.1.56 Nov 21, 2024 · issue -372

LangGraph CLI 0.1.56 adds Python 3.13 support and Node.js/package.json compatibility validation.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.56 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.56
```
└──▷ USE IT
Programmatically load and validate a langgraph config file (replaces separate load + validate calls).
python
```
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.
- ›Adds validate_config_file() function that loads and validates config files in a single call.
- ›Validates Node.js version compatibility against package.json when present in a project.
- ›Introduces MIN_NODE_VERSION and MIN_PYTHON_VERSION constants for centralized version requirement enforcement.
cli==0.1.55 Nov 19, 2024 · issue -372

LangGraph CLI gains a langgraph dev command for running the API server in development mode with hot reloading.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.55 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
```
$ 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.
```
$ 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.
- ›New inmem extras entry enables lightweight in-memory API support via pip install "langgraph-cli[inmem]".
0.2.51 Nov 19, 2024 · issue -372

LangGraph 0.2.51 adds checkpoint forking to Pregel via a new __copy__ node.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.51 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.51
```
- ›Adds checkpoint forking in Pregel via a new __copy__ special node: when as_node="__copy__" and values=None, creates a copy of the checkpoint with a "fork" source marker and preserved parent metadata.
checkpoint==2.0.5 Nov 18, 2024 · issue -372

LangGraph checkpoint 2.0.5 adds disk-persistent checkpoints via PersistentDict and a configurable MemorySaver storage backend.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.5 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds a factory parameter to MemorySaver to swap in custom storage backends, including the new PersistentDict.
0.2.50 Nov 15, 2024 · issue -372

LangGraph 0.2.50 adds the ability to create snapshot checkpoints without modifying graph state.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.50 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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).
0.2.49 Nov 15, 2024 · issue -372

LangGraph 0.2.49 adds checkpoint copying and a debug parameter to graph execution loops.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.49 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.49
```
└──▷ USE IT
Snapshot the current graph checkpoint without modifying state — useful before a risky branch of execution.
python
```
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.
- ›Adds a debug parameter to loop creation in Pregel for improved visibility into graph execution.
cli==0.1.54 Nov 15, 2024 · issue -372

LangGraph CLI gains a new project scaffolding command, Docker Compose generation, and five built-in agent templates.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.54 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
```
$ 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.
```
$ 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).
- ›Adds --add-docker-compose flag to the dockerfile command, generating a docker-compose.yml, .env, and .dockerignore alongside the Dockerfile.
- ›Adds --version flag to display the installed CLI version.
checkpoint==2.0.4 Nov 14, 2024 · issue -372

langgraph-checkpoint 2.0.4 adds INTERRUPT and RESUME constants to support graph execution interruption and resumption.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==2.0.4
```
└──▷ USE IT
Reference the new constants when inspecting or filtering checkpoint writes for interrupt/resume events.
python
```
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.
- ›Reserves checkpoint write index values -3 and -4 for interrupt and resume operation types in WRITES_IDX_MAP.
└──▷ 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.
sdk==0.1.36 Nov 14, 2024 · issue -372

LangGraph SDK 0.1.36 adds Command-based graph control, rollback cancellation, and a new messages-tuple stream mode.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.36 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds new Command type with send, update, and resume operations for fine-grained graph execution control.
- ›Adds Send typed dictionary to support direct node targeting during runs.
- ›Enhances cancel() with a new action parameter supporting "interrupt" (default) or "rollback" modes to control cancellation behavior.
- ›Adds CancelAction type to the schema to back the new cancellation modes.
+1 moreshow less
- ›Adds "messages-tuple" as a new StreamMode literal option.
└──▷ BREAKING ON UPGRADE
- !"running" has been removed from RunStatus literals, which will break any code that checks for or matches against that status value.
0.2.47 Nov 13, 2024 · issue -372

LangGraph 0.2.47 adds resumable interrupts via a new interrupt() function and Command(resume=…) parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.47 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.47
```
└──▷ USE IT
Pause a node mid-graph for human-in-the-loop approval, then resume it with the reviewer's decision.
python
```
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.
- ›Adds a resume parameter to the Command class to control resumption of graph execution after an interrupt.
- ›Adds RESUME constant in langgraph.constants to identify values used to resume a node after an interrupt.
- ›Adds NULL_TASK_ID constant in langgraph.constants to handle writes not associated with any specific task, enabling global writes independent of task execution.
- ›Supports pushing new tasks during graph execution, improving dynamic task scheduling.
0.2.46 Nov 13, 2024 · issue -372

LangGraph 0.2.46 adds add_sequence for linear node chains, GraphCommand class, and explicit checkpointing opt-out.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.46 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.46
```
└──▷ USE IT
Chain several processing nodes in order without manually adding edges between each pair.
python
```
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
```
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
```
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.
- ›Introduces GraphCommand class (replacing deprecated Control) with a goto parameter for directing graph flow and updating state.
- ›Supports passing False to StateGraph.compile(checkpointer=False) to explicitly disable checkpointing in a graph or subgraph.
checkpoint==2.0.3 Nov 13, 2024 · issue -372

LangGraph Checkpoint 2.0.3 adds CommandProtocol serialization support in JSON and MessagePack formats.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==2.0.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›Extends JsonPlusSerializer to serialize CommandProtocol objects in both JSON and MessagePack formats by encoding their attributes.
0.2.45 Nov 4, 2024 · issue -372

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
```
$ git clone --branch 0.2.45 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Nodes can now declare their potential destination nodes via type annotations on their return type, enabling static graph validation of routing paths.
- ›New SELF constant represents the implicit branch created to handle Control return values.
- ›Metadata is now preserved across update_state / aupdate_state calls, so checkpoint metadata survives incremental updates.
cli==0.1.53 Nov 4, 2024 · issue -372

LangGraph CLI 0.1.53 adds JavaScript/TypeScript project templates and arbitrary Docker build argument passthrough.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.53 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›Enables passing arbitrary Docker build arguments directly to the Docker build process in the build command.
- ›Adds automatic Node.js package manager detection (npm, yarn, pnpm) based on lock files, selecting the correct install and build commands automatically.
└──▷ 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.
0.2.44 Nov 2, 2024 · issue -372

LangGraph 0.2.44 adds chat history validation for ReAct agents and messages-tuple stream mode for remote graphs.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.44 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
python
```
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
```
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.
- ›Supports messages-tuple stream mode format for RemoteGraph, automatically mapping it to the messages mode.
- ›Improves RemoteGraph visualization by resolving meaningful node names from node data instead of falling back to an empty string.
0.2.42 Oct 31, 2024 · issue -373

LangGraph 0.2.42 improves nested streaming in RemoteGraph with proper parent-graph stream mode propagation.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.42 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Supports namespace information propagation between parent and child graphs during streaming sessions.
- ›Removes events stream mode support in Pregel, as it was never functional.
└──▷ 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.
0.2.40 Oct 31, 2024 · issue -373

LangGraph 0.2.40 adds DuckDB checkpointing, richer ToolNode error handling, and concurrency limiting for async executors.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.40 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds messages_key parameter to ToolNode and tools_condition for flexible integration with non-standard state schemas.
- ›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.
- ›Adds concurrency limiting to AsyncBackgroundExecutor via max_concurrency config parameter and semaphore-based gated utility.
- ›Adds node_finished callback parameter to PregelRunner via CONFIG_KEY_NODE_FINISHED for node-completion hooks.
+1 moreshow less
- ›Improves schema inference in StateGraph for class method node functions via the extracted _get_input_schema_from_type_hint helper.
sdk==0.1.35 Oct 28, 2024 · issue -373

LangGraph SDK 0.1.35 adds error-handling control to wait and raises default timeouts to 300 s
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.35 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›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.
sdk==0.1.34 Oct 25, 2024 · issue -373

LangGraph SDK 0.1.34 adds if_not_exists parameter and new "error" thread status for safer run handling.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.34 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds "error" as a valid ThreadStatus value, surfacing when an exception occurred during task processing.
- ›Widens type annotations for stream_mode, interrupt_before, interrupt_after, and feedback_keys from list to Sequence, accepting tuples and other sequences without casting.
0.2.39 Oct 18, 2024 · issue -373

LangGraph 0.2.39 adds TAG_NOSTREAM constant, structured error codes, and finer streaming control.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.39 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.39
```
└──▷ USE IT
Suppress a cost-tracking or internal chat model call from appearing in the user-facing stream.
python
```
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
```
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.
- ›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.
- ›New create_error_message helper in langgraph.errors generates consistent error messages with links to troubleshooting documentation.
- ›StreamMessagesHandler now respects TAG_NOSTREAM on chat model starts and TAG_HIDDEN on chain starts for fine-grained control over what gets streamed.
0.2.37 Oct 15, 2024 · issue -373

LangGraph 0.2.37 adds RemainingSteps managed value and LoopProtocol for finer-grained loop termination control.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.37 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Introduces LoopProtocol interface, giving managed values and channels structured access to loop execution context (config, store, stream, step, stop).
- ›Improves checkpointing in nested loops with proper parent configuration propagation via updated patch_checkpoint_map.
└──▷ BREAKING ON UPGRADE
- !The ManagedValue.__call__ signature no longer accepts a step parameter; callers that passed step explicitly will break.
0.2.36 Oct 14, 2024 · issue -373

LangGraph 0.2.36 adds RemoteGraph for interacting with hosted LangGraph deployments via the LangGraph API.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.36 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›New PregelProtocol defines a standard interface for interacting with graphs, providing both sync and async methods for state management, visualization, subgraph traversal, and execution.
- ›Adds a result field to PregelTask to store and access structured task execution results in state snapshots.
sdk==0.1.33 Oct 14, 2024 · issue -373

LangGraph SDK 0.1.33 adds wildcard node interrupts, custom stream mode, and richer update_state returns.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.33 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds "custom" option to StreamMode, giving more flexibility in how streams are handled.
- ›update_state now returns a ThreadUpdateStateResponse containing checkpoint information instead of None.
- ›Expands update_state values parameter to accept Sequence[dict] in addition to a single dict, enabling multi-dictionary state updates.
└──▷ 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.
0.2.35 Oct 9, 2024 · issue -373

LangGraph 0.2.35 adds cross-thread memory for agents and a new find_subgraph_pregel utility for nested graph introspection.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.35 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Introduces find_subgraph_pregel utility to recursively locate Pregel subgraphs within runnable components — useful for checkpoint handling and graph introspection.
- ›Enhances map_debug_checkpoint to include task state information and properly maintain checkpoint namespaces for nested subgraph debugging.
checkpointpostgres==2.0.1 Oct 8, 2024 · issue -373

AsyncPostgresStore now inherits from AsyncBatchedBaseStore, enabling efficient batched async operations.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==2.0.1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==2.0.1
```
- ›Enables batched async operations in AsyncPostgresStore via AsyncBatchedBaseStore inheritance, reducing round-trips for high-throughput workloads.
- ›Adds explicit ORDER BY updated_at DESC to search queries in PostgresStore, providing consistent, deterministic result ordering.
└──▷ 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.
0.2.34 Oct 2, 2024 · issue -373

LangGraph 0.2.34 adds a store parameter to create_react_agent for cross-thread persistence.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.34 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds a warning when InjectedStore annotation is used without langchain-core >= 0.3.8, surfacing the dependency requirement at runtime.
0.2.33 Oct 2, 2024 · issue -373

LangGraph 0.2.33 adds InjectedStore annotation so tools can read/write the LangGraph store without exposing it to the model.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.33 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
python
```
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 model (similar to InjectedState).
- ›Enhances ToolNode to automatically detect and inject the store for tools annotated with InjectedStore, with precomputed caching of state and store arguments for efficiency.
- ›Enables RunnableCallable keyword arguments to override config values in invoke and ainvoke, giving callers finer control over execution.
sdk==0.1.32 Oct 1, 2024 · issue -373

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
```
$ git clone --branch sdk==0.1.32 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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
```
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.
- ›Adds store property to LangGraphClient and SyncLangGraphClient for direct access to the new store API.
- ›Exposes get_sync_client in module exports for easier access to the synchronous client.
- ›New Item, ListNamespaceResponse, and SearchItemsResponse TypedDicts formalize storage operation schemas.
- ›Adds output_schema field to the GraphSchema TypedDict.
+1 moreshow less
- ›HttpClient and SyncHttpClient now support JSON payloads in DELETE requests.

checkpointpostgres==1.0.11 Sep 30, 2024 · issue -374

LangGraph Postgres store now accepts a custom deserializer parameter for user-controlled JSON loading.

└──▷ GET THIS VERSION

$ git clone --branch checkpointpostgres==1.0.11 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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

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

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 when loading values from the database.

checkpointpostgres==1.0.10 Sep 30, 2024 · issue -374

langgraph-checkpoint-postgres 1.0.10 adds sync and async PostgreSQL store implementations with batch ops, namespace listing, and schema migration.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==1.0.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpointpostgres==1.0.10
```
└──▷ USE IT
Initialize the PostgreSQL store schema and persist/retrieve agent state in a synchronous workflow.
python
```
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
```
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.
- ›New AsyncPostgresStore class mirrors PostgresStore with full async/await support via asyncio for non-blocking database access.
- ›Both stores expose a from_conn_string() context manager for ergonomic connection management.
- ›Both stores include a setup() method to initialize the database schema and run migrations automatically.
- ›Explicit __all__ exports added to the postgres store modules for cleaner programmatic imports.
0.2.29 Sep 30, 2024 · issue -374

LangGraph 0.2.29 expands create_react_agent to accept any LanguageModelLike and adds custom store support via configuration.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.29 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds support for custom stores via configuration in Pregel, with store parameter propagation through the execution stack.
- ›Migrates store implementation to langgraph-checkpoint, updating namespace representation from strings to tuples and switching methods from list/put to search/batch.
└──▷ 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.
checkpoint==1.0.13 Sep 30, 2024 · issue -374

LangGraph Checkpoint 1.0.13 introduces a namespaced key-value store API with sync/async ops and an in-memory implementation.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==1.0.13 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==1.0.13
```
└──▷ USE IT
Persist and retrieve cross-session user facts in a namespaced store during graph execution.
python
```
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
```
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 operations (get/aget, put/aput, delete/adelete, search/asearch, list_namespaces/alist_namespaces, batch/abatch) for persistent, namespaced key-value storage.
- ›Introduces Item as the core storage unit, carrying value data, key, namespace path, and timestamp metadata with equality comparison and dict conversion support.
- ›Ships InMemoryStore, a fully-featured in-memory BaseStore implementation backed by Python dicts for prototyping and testing without external dependencies.
- ›Adds AsyncBatchedBaseStore, which automatically coalesces async store operations into batches via a background task for higher throughput.
- ›Extends JsonPlusSerializer to serialize Item objects, enabling store items to round-trip correctly through checkpoint persistence.
checkpoint==1.0.12 Sep 27, 2024 · issue -374

LangGraph checkpoint 1.0.12 adds secret-value serialization support in JsonPlusSerializer.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==1.0.12 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
0.2.27 Sep 24, 2024 · issue -374

LangGraph 0.2.27 adds namespace filtering to subgraph traversal and broadens BaseStore value types.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.27 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Automatically excludes subgraphs with checkpointing disabled (checkpointer is False) from subgraph enumeration.
- ›Broadens BaseStore value type (V) from dict[str, Any] to Any, enabling storage of arbitrary value types.

0.2.25 Sep 23, 2024 · issue -374

LangGraph's ToolNode now supports multimodal tool responses, letting tools return images and structured data alongside text.

└──▷ GET THIS VERSION

$ git clone --branch 0.2.25 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.25

└──▷ USE IT

Return an image from a tool so the LLM receives it as a structured content block rather than a stringified blob.

python

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.

sdk==0.1.31 Sep 23, 2024 · issue -374

LangGraph SDK 0.1.31 adds assistant versioning, subgraph streaming, future run scheduling, and a richer Checkpoint type.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.31 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.31
```
└──▷ USE IT
Pin a specific assistant version to active after testing a new prompt configuration in staging.
python
```
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
```
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
```
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.
- ›Adds get_versions method to retrieve the full version history of an assistant.
- ›Adds set_latest method to promote a specific assistant version to active.
- ›Adds subgraphs parameter to get_state to include subgraph state in thread state responses.
- ›Adds stream_subgraphs parameter to run methods to stream outputs from subgraphs.
+3 moreshow less
- ›Adds after_seconds parameter to schedule runs for future execution.
- ›Introduces new Checkpoint type for richer checkpoint representation across thread and run APIs.
- ›Adds AssistantVersion class and ThreadTask model to the schema for version history and per-thread task tracking.
└──▷ 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.
0.2.24 Sep 23, 2024 · issue -374

LangGraph 0.2.24 adds a new langgraph.types module and error detection for multiple subgraphs inside a single node.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.24 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.24
```
└──▷ USE IT
Import Send and Interrupt from the new canonical module instead of constants in new code.
python
```
from langgraph.types import Send, Interrupt
```
- ›Introduces langgraph.types module as the new canonical home for core data types including Send and Interrupt.
- ›Adds MultipleSubgraphsError to detect and prevent multiple subgraphs from being invoked inside the same node.
0.2.23 Sep 20, 2024 · issue -374

LangGraph 0.2.23 adds token-by-token message streaming and custom node output streaming via two new stream modes.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.23 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.23
```
└──▷ USE IT
Surface LLM tokens as they are generated so a UI can display streamed responses without waiting for the full reply.
python
```
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
```
# 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.
- ›Adds stream_mode="custom" to emit arbitrary output from nodes via a write parameter.
- ›Enhances chat_agent_executor with route_tool_responses to support tools configured with return_direct, bypassing the agent on return.
- ›Introduces AsyncQueue and SyncQueue utilities for higher-performance concurrent streaming.
└──▷ 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.
checkpoint==1.0.10 Sep 16, 2024 · issue -374

LangGraph checkpoint 1.0.10 adds MessagePack serialization, scheduled-task tracking, and namedtuple support.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==1.0.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==1.0.10
```
- ›Adds MessagePack integration to JsonPlusSerializer as a faster alternative to JSON serialization, with pooled encoders for throughput.
- ›Adds a SCHEDULED special channel constant (value -2) in WRITES_IDX_MAP on BaseCheckpointSaver to track scheduled task status in the checkpoint system.
- ›Adds get_next_version method to InMemorySaver to generate consistent, unique version identifiers for channels.
- ›Extends JsonPlusSerializer to serialize objects exposing _asdict() (e.g., namedtuples).
checkpointpostgres==1.0.7 Sep 16, 2024 · issue -374

LangGraph Postgres checkpointer gains custom serializer support and smarter SQL write strategies in v1.0.7
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==1.0.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Introduces dynamic SQL query selection for checkpoint writes, choosing between upsert and insert-only operations based on channel types in both PostgresSaver and AsyncPostgresSaver.
- ›Adds new INSERT_CHECKPOINT_WRITES_SQL constant enabling insert-only checkpoint write operations alongside the existing upsert path.
0.2.22 Sep 16, 2024 · issue -374

LangGraph 0.2.22 adds create_model Pydantic utility and improved subgraph retry resumption.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.22 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds a deprecation warning when StateGraph is initialized without an explicit state_schema parameter, prompting users to supply one explicitly.
0.2.20 Sep 13, 2024 · issue -374

LangGraph 0.2.20 adds dataclass schema support, ToolNode naming, and reduced dependency on langchain-core for config handling.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.20 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds a name attribute (default "ToolNode") to ToolNode for better graph node identification.
- ›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.
- ›Adds __slots__ to BaseChannel and all channel subclasses, reducing per-instance memory overhead at scale.
└──▷ 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.
0.2.19 Sep 6, 2024 · issue -374

LangGraph 0.2.19 adds Pydantic BaseModel support to ToolNode and improves async/sync runner responsiveness.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.19 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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 graphs.
- ›Enables ToolNode to detect nested tool injections inside Union and Annotated types.
- ›Improves ToolNode state extraction to work with object attributes via getattr, enabling object-like states alongside dictionaries.
- ›Yields control back to the caller immediately at the start of PregelRunner.tick and atick, improving responsiveness in async and sync applications.
0.2.18 Sep 6, 2024 · issue -374

LangGraph 0.2.18 adds scheduled-task tracking, a TaskNotFound exception, and a Pregel.copy() method for cleaner graph customization.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.18 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Introduces TaskNotFound exception for explicit error handling when the executor cannot locate a task.
- ›Adds Pregel.copy(update) method to create modified Pregel instances without mutating the original graph.
- ›Adds path: tuple[str, ...] field to PregelExecutableTask to track a task's execution path through the graph.
- ›Adds scheduled: bool field to PregelExecutableTask to indicate whether a task has been scheduled.
+1 moreshow less
- ›Changes prepare_next_tasks to return a dict[str, PregelExecutableTask] keyed by task ID, enabling O(1) task lookup in execution loops.
└──▷ 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.
0.2.17 Sep 5, 2024 · issue -374

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
```
$ git clone --branch 0.2.17 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›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.
- ›Adds new SUBSCRIPTIONS constant to langgraph.constants, included in the RESERVED set for channel management.
- ›Expands langchain-core dependency range to allow versions up to v0.4.x.
checkpointpostgres==1.0.6 Sep 3, 2024 · issue -374

AsyncPostgresSaver gains synchronous wrapper methods for use in mixed sync/async contexts.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==1.0.6 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Stores the running event loop on AsyncPostgresSaver instances via self.loop to support the new synchronous dispatch methods.
checkpointsqlite==1.0.2 Sep 3, 2024 · issue -374

AsyncSqliteSaver gains synchronous get_tuple, list, put, and put_writes methods for mixed async/sync use.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointsqlite==1.0.2 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds new synchronous put_writes method to AsyncSqliteSaver.
0.2.16 Sep 1, 2024 · issue -374

LangGraph 0.2.16 improves nested subgraph detection for accurate visualization of complex graph structures.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.16 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›Expands get_subgraphs to discover nested Pregel instances inside RunnableSequence steps, RunnableLambda dependencies, and RunnableCallable function nonlocals.
0.2.15 Aug 30, 2024 · issue -375

create_react_agent now accepts a ToolNode instance directly, enabling reuse of tool configurations across agents.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.15 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Supports connecting StateGraph edges directly to the END node without explicitly adding it first, making graph construction more concise.
sdk==0.1.30 Aug 30, 2024 · issue -375

LangGraph SDK 0.1.30 adds state-value filtering for thread search and makes runs.join() return final thread state.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.30 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Changes client.runs.join() to return a dictionary containing the final thread state instead of None.
- ›Introduces Json type as a replacement for the Metadata type to better reflect its semantic purpose.
└──▷ 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.
checkpoint==1.0.7 Aug 30, 2024 · issue -375

LangGraph Checkpoint 1.0.7 adds parent checkpoint references and pending-send tracking across checkpoint operations.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==1.0.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==1.0.7
```
- ›Adds parents field to CheckpointMetadata, mapping checkpoint namespace to checkpoint ID for relationship tracking between checkpoints.
- ›Adds pending-send tracking in InMemorySaver: get_tuple now includes pending_sends from parent checkpoints, and list gains improved namespace filtering.
└──▷ BREAKING ON UPGRADE
- !The score field in CheckpointMetadata is replaced by the parents field — any code reading or writing score will break.
cli==0.1.52 Aug 28, 2024 · issue -375

LangGraph CLI 0.1.52 adds Node.js/LangGraphJS deployment support with dedicated Docker configuration.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.52 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
{
  "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.
- ›Adds node_config_to_docker function to generate Docker configurations for Node.js projects, automatically selecting the langchain/langgraphjs-api base image.
- ›Adds validation for the node_version config field (currently enforces version "20") to catch misconfigured Node.js projects early.
- ›Updates build, prepare, and deployment CLI commands to operate correctly against both Python and Node.js environments.
checkpointpostgres==1.0.4 Aug 27, 2024 · issue -375

LangGraph Postgres checkpointer now accepts connection pools for high-concurrency deployments.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==1.0.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds AsyncConnectionPool support to AsyncPostgresSaver for async workflows requiring pooled database connections.
- ›Enhances list() and alist() methods to include pending writes in returned checkpoint tuples.
sdk==0.1.29 Aug 26, 2024 · issue -375

LangGraph SDK 0.1.29 adds disconnect/completion lifecycle controls and a new join_stream() method for live run output.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.29 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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
```
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.
- ›Adds on_completion parameter to stream(), create(), and wait() — set to "delete" or "keep" to control resource cleanup after a run finishes.
- ›Adds join_stream() method to attach to an already-running run and receive its real-time output without buffering prior output.
- ›Adds DisconnectMode and OnCompletionBehavior types for structured lifecycle control in typed clients.
0.2.13 Aug 23, 2024 · issue -375

LangGraph 0.2.13 adds runtime-only managed values and reimplements Context to skip unnecessary serialization.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.13 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds replace_runtime_values and replace_runtime_placeholders methods to ManagedValueMapping for safe handling of runtime placeholders during graph serialization.
- ›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.
cli==0.1.51 Aug 22, 2024 · issue -375

LangGraph CLI 0.1.51 adds Redis 6 to Docker Compose for caching and message queuing.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.51 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
- ›Injects REDIS_URI environment variable (redis://langgraph-redis:6379) automatically into the langgraph-api service.
checkpoint==1.0.4 Aug 22, 2024 · issue -375

LangGraph Checkpoint 1.0.4 adds error-write support, an ERROR constant, and exception serialization in JsonPlusSerializer.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==1.0.4 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Supports special write types including error handling via WRITES_IDX_MAP in InMemorySaver.put_writes.
- ›Enables JsonPlusSerializer to serialize BaseException objects by encoding them using their constructor arguments.
- ›Includes pending writes in checkpoint list output from InMemorySaver.
└──▷ 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.
0.2.10 Aug 21, 2024 · issue -375

LangGraph 0.2.10 adds error and interrupt fields to debug task result payloads for richer execution tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.10
```
└──▷ USE IT
Inspect task-level errors and interrupts during a graph run by reading the enriched debug stream.
python
```
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.
- ›Enhances put_writes on PregelLoop to automatically stream updates and debug information without manual wiring.
- ›Adds stream_keys as a class attribute on PregelLoop for explicit management of streaming outputs.
- ›Updates map_debug_task_results to accept task-writes pairs and support both string and sequence stream key formats.
└──▷ 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.
sdk==0.1.28 Aug 21, 2024 · issue -375

LangGraph SDK 0.1.28 adds custom HTTP headers support and checkpoint namespace field for state configs.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.28 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Adds a checkpoint_ns field to state configurations in get_state and create for namespace-scoped checkpoint lookups.
└──▷ 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.
0.2.7 Aug 21, 2024 · issue -375

LangGraph 0.2.7 adds SharedValue and a pluggable store system for persisting state across graph nodes.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.7
```
└──▷ USE IT
Persist shared state across nodes in a compiled graph using the built-in in-memory store.
python
```
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
```
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
```
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.
- ›New WritableManagedValue abstract class extends the managed values system with update() and aupdate() methods for sync/async mutations.
- ›New store parameter on StateGraph.compile() wires a persistent storage backend into the graph.
- ›New BaseStore abstract class defines a standard interface (list/update, sync and async) for pluggable storage engines.
- ›New MemoryStore provides a ready-to-use in-memory implementation of BaseStore.
+3 moreshow less
- ›New AsyncBatchedStore wraps any BaseStore to batch async operations for higher-throughput workloads.
- ›New utility functions is_readonly_managed_value and is_writable_managed_value allow runtime inspection of managed value types.
- ›New ChannelKeyPlaceholder and ChannelTypePlaceholder objects support dynamic injection of channel key and type metadata.
0.2.6 Aug 21, 2024 · issue -375

LangGraph 0.2.6 adds structured graph interrupts with timing context and a new NodeInterrupt exception for in-node signaling.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.6 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›New NodeInterrupt exception lets node logic explicitly signal a mid-execution interrupt without raising a generic error.
- ›Enhanced GraphInterrupt now stores a list of Interrupt objects, giving full context on when and how many interrupts occurred.
- ›Adds interrupts field to PregelTask for per-task interrupt visibility useful in debugging and flow control.
- ›Adds CONFIG_KEY_TASK_ID constant to track task identifiers through the configuration system.
+1 moreshow less
- ›should_interrupt now returns the list of executable tasks to be interrupted instead of a boolean, enabling precise per-task interrupt control.
└──▷ 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.
0.2.5 Aug 21, 2024 · issue -375

LangGraph 0.2.5 adds task-level error tracking in state snapshots and a new ERROR constant for consistent failure visibility.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.5 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.2.5
```
└──▷ USE IT
Inspect task-level errors after a graph run to understand which node failed and why.
python
```
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.
- ›Enhances StateSnapshot with a new tasks field that surfaces task-level error details in state history.
- ›Introduces enhanced PregelTask class with id and optional error fields to uniquely identify tasks and capture exceptions.
- ›Adds tasks_w_writes debug function to associate tasks with their writes and any errors for richer checkpoint debug output.
- ›Extends get_state / aget_state on Pregel to include proper step numbers and task error information in returned snapshots.
└──▷ 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.
checkpoint==1.0.3 Aug 15, 2024 · issue -375

JsonPlusSerializer gains native support for pathlib, regex, decimal, deque, IP address, and time types.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==1.0.3 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout checkpoint==1.0.3
```
- ›Supports serialization of pathlib.Path, re.Pattern, decimal.Decimal, deque, IPv4/IPv6 address types, date, time, and ZoneInfo in JsonPlusSerializer.
- ›Deserialization now returns None gracefully when a module or attribute is missing, instead of raising an exception.
checkpointpostgres==1.0.1 Aug 7, 2024 · issue -375

LangGraph PostgreSQL checkpointer gains versioned schema migrations and JSON+Plus metadata serialization.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpointpostgres==1.0.1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›Introduces JsonPlusSerializer-backed _load_metadata and _dump_metadata methods for consistent, richer metadata serialization across sync and async savers.
└──▷ 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.
0.2.0 Aug 7, 2024 · issue -375

LangGraph 0.2 ships dedicated checkpointer libraries for SQLite and Postgres, including the previously cloud-only PostgresSaver.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.2.0 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›New langgraph-checkpoint-sqlite package provides SqliteSaver / AsyncSqliteSaver for local and experimental workflows.
- ›New langgraph-checkpoint-postgres package open-sources the production-grade PostgresSaver previously available only in LangGraph Cloud.
- ›New new_versions parameter in BaseCheckpointSaver.put enables further optimization of custom checkpointer implementations.
- ›Graph stream output now includes outputs from all nodes, including nodes that return no state writes (previously silent nodes were omitted).
└──▷ 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.
checkpoint==1.0.1 Aug 7, 2024 · issue -375

LangGraph checkpoint 1.0.1 adds binary serialization, channel-version API, and context-manager support for MemorySaver.
└──▷ GET THIS VERSION
```
$ git clone --branch checkpoint==1.0.1 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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 or serialised models) directly in checkpoint state — now round-trippable through JsonPlusSerializer.
python
```
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.
- ›Introduces ChannelVersions type alias (dict[str, Union[str, int, float]]) for type-safe channel version handling.
- ›Extends BaseCheckpointSaver.put and aput with a new new_versions: ChannelVersions parameter exposing channel version info at write time.
- ›Implements sync and async context manager interfaces (__enter__/__exit__/__aenter__/__aexit__) on MemorySaver for explicit resource management.
└──▷ 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.
sdk==0.1.27 Aug 3, 2024 · issue -375

LangGraph SDK 0.1.27 adds optional URL client init, ASGI transport support, thread copy, and assistant if_exists dedup control.
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.27 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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
```
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.
- ›Adds ASGI transport support in get_client with correct root path configuration.
- ›Adds if_exists parameter to AssistantsAPI.create for controlling behavior on duplicate assistant creation.
- ›Adds a new ThreadsAPI.copy method for duplicating existing threads.
- ›Makes GraphSchema fields (input_schema, state_schema, config_schema) optional for better TypeScript interoperability.
0.1.17 Jul 31, 2024 · issue -376

LangGraph 0.1.17 lets update_state() accept None values to preserve configuration without changing state.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.1.17 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
0.1.10 Jul 23, 2024 · issue -376

LangGraph 0.1.10 adds InjectedState for automatic graph-state injection into tools and improves parallel tool execution in ToolNode.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.1.10 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout 0.1.10
```
└──▷ USE IT
Give a tool access to the current graph state (e.g., conversation history) without asking the LLM to supply it — useful for retrieval or policy tools that need context the model shouldn't fabricate.
python
```
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.
- ›Improves parallel execution of tools in ToolNode using config lists via get_config_list from langchain-core.
- ›Adds GraphInterrupt error class for structured handling of interruptions in nested graphs.
- ›Adds EmptyInputError error class for clearer reporting when graphs receive empty inputs.
- ›Enhances checkpoint parent-child relationship tracking and includes parent configuration data in checkpoint tuples, improving support for nested graphs.
0.1.9 Jul 18, 2024 · issue -376

LangGraph 0.1.9 adds state_modifier to create_react_agent, custom state schemas, retry policies, and new background executor classes.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.1.9 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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 inputs, replacing the now-deprecated messages_modifier.
- ›Adds state_schema parameter to create_react_agent, enabling custom graph state definitions beyond the default AgentState.
- ›Adds BackgroundExecutor and AsyncBackgroundExecutor classes in langgraph.pregel for structured background task management and cancellation.
- ›Adds retry policies for nodes in StateGraph.
- ›Adds custom input and output type support to StateGraph.
+3 moreshow less
- ›Adds equality comparison (__eq__) to all channel classes (AnyValue, LastValue, Topic, and others), enabling channel state comparisons.
- ›Improves graph visualization to include type-hint hints for conditional edges and to create END nodes only when needed.
- ›Adds node-existence validation in update_state, surfacing clear errors when a nonexistent node is targeted.
└──▷ BREAKING ON UPGRADE
- !The messages_modifier parameter of create_react_agent is deprecated; migrate to state_modifier.
cli==0.1.49 Jul 18, 2024 · issue -376

LangGraph CLI 0.1.49 adds a dockerfile command to generate customized Dockerfiles for the LangGraph API server.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.49 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
```
$ 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.
- ›Docker image generation now sets PYTHONDONTWRITEBYTECODE=1 and passes --no-cache-dir to pip installs, producing smaller images.
sdk==0.1.26 Jul 15, 2024 · issue -376

LangGraph SDK 0.1.26 adds batch run creation, cron job scheduling, and thread conflict handling
└──▷ GET THIS VERSION
```
$ git clone --branch sdk==0.1.26 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout sdk==0.1.26
```
└──▷ USE IT
List all scheduled cron jobs for a specific assistant to audit or manage recurring runs.
python
```
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.
- ›New create_batch method on LangGraphClient submits multiple runs in a single API call for more efficient batch operations.
- ›New Cron class and search method support scheduled job management, with filtering by assistant_id and thread_id and pagination.
- ›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.
0.1.8 Jul 12, 2024 · issue -376

LangGraph 0.1.8 adds node-level metadata support via add_node's new metadata parameter and the NodeSpec class.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.1.8 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Introduces langgraph.graph.graph.NodeSpec, a new class that stores a runnable alongside optional metadata for a node.
- ›Propagates node metadata through PregelNode.__init__ into the node's configuration.
- ›Exposes node metadata in graph visualizations via the updated CompiledGraph.get_graph method.
0.1.7 Jul 10, 2024 · issue -376

LangGraph 0.1.7 adds persistent task-write checkpointing via new put_writes/aput_writes methods, enabling resilient interrupted-workflow recovery.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.1.7 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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.
- ›Adds pending_writes field to CheckpointTuple to carry per-task write state that is restored when a checkpoint is reloaded.
- ›Tasks with pre-loaded pending_writes are skipped on restart, avoiding redundant re-execution when resuming interrupted workflows.
0.1.6 Jul 9, 2024 · issue -376

LangGraph 0.1.6 adds RemoveMessage support for message deletion by ID and handle_tool_errors parameter in ToolNode.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.1.6 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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
```
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
```
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.
- ›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.
cli==0.1.48 Jul 9, 2024 · issue -376

LangGraph CLI 0.1.48 adds --debugger-base-url to point the debugger at a custom LangGraph API URL
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.48 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ 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.
```
$ 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.
- ›Makes Docker base image pulls verbose during build to provide better visibility into the build process.
cli==0.1.45 Jun 27, 2024 · issue -377

LangGraph CLI 0.1.45 adds a test command to validate graphs locally before deploying to LangGraph Cloud.
└──▷ GET THIS VERSION
```
$ git clone --branch cli==0.1.45 https://github.com/langchain-ai/langgraph.git
# already have the repo? check out this version:
$ git checkout cli==0.1.45
```
└──▷ TRY IT
Validate that your graph works with the LangGraph API server before pushing to LangGraph Cloud.
```
$ langgraph test
```
- ›Adds langgraph test subcommand to start a local test server that validates graph compatibility with the LangGraph API server before deploying to LangGraph Cloud.
- ›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.
- ›Enhances watch functionality in config.config_to_compose for better dependency tracking during development.
└──▷ BREAKING ON UPGRADE
- !The langgraph-api-path option has been removed from CLI commands.

LangGraph

Summary

What LangGraph answers

Features

release

release

example

release

example

release

release

command line

example

release

release

command line

release

release

release

example

Examples

Command line

Release history