langgraph deploy --image-uri my-custom-registry.io/langgraph-agent:v1.2
langgraph deploy --agent-id my-agent-uuid --environment production
interrupt(
...,
response_schema={"type": "object", "properties": {"key": {"type": "string"}}}
)
graph.add_node("sensitive_step", sensitive_fn, trace_policy=my_trace_policy)
langgraph dev --certfile cert.pem --keyfile key.pem
from langgraph_sdk import get_client
client = get_client(url="https://my-deployment.example.com")
async for chunk in client.runs.stream(
thread_id,
assistant_id,
input={"messages": [{"role": "user", "content": "Hello"}]},
stream_mode="messages",
transport="websocket",
):
print(chunk)
from langgraph.pregel.remote import RemoteGraph
remote = RemoteGraph(
"my-agent",
url="https://my-deployment.example.com",
)
async for chunk in remote.astream(
{"messages": [{"role": "user", "content": "Plan a trip"}]},
stream_mode="messages",
interleave_projections=True,
):
print(chunk)
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-loophuman-in-the-loopHuman in the loop, involving a person in an otherwise automated workflow. The person can review, approve, correct or supply information before work continues. 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.
Will an agent pick up where it left off after a crash or restart?
persists state through checkpoints and resumes execution from the last completed step rather than starting over
How do I let a person review or edit what an agent is about to do mid-task?
exposes the agent's current state for inspection and modification at any point during a run, so a human can interrupt before it continues
Can I see what an agent's nodes are doing while a long task is still running?
streams events from individual node executions as they happen, including tool calls and state updates, instead of only returning a final result
Which step in a multi-step agent run actually changed the state, and when?
records the write history for each thread so state transitions can be audited or replayed after the fact
What happens to the rest of an agent's work when one step throws an error?
lets individual nodes catch and handle their own errors so a failure doesn't automatically propagate and kill the whole graph
How much storage does a long-running agent's conversation history consume over time?
stores only the incremental change at each step rather than the full accumulated state, keeping checkpoint size from growing unbounded as a thread continues
110 capabilities
across 7 areas
· 3 backed by code, an API document or a real run
Built from LangGraph's releases, docs, README and our own runs.
“Seen” marks the month we first spotted a release the vendor didn't date.
Group names and tags are our labels.
＋Streaming and Remote Graph Execution4 capabilitiesLangGraph 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 supportshippedEnables remote graph runs to stream events using an updated protocol with typed events and more precise filtering options.19 releases · 3 other sources · first seen Oct 2024▸
Also counts toward: Client SDKs
release
19 total
Adds v3 streaming primitives and SSE (Server-Sent Events) transport to the Python SDK (sdk-py).
prebuilt==1.1.1 · Oct 2026
· source
· release history
Adds typed return for v3 stream_events and supports native projections for more precise event filtering.
1.2.10 · Jul 2026
· source
· release history
Adds typed return for v3 stream_events and native projections support.
1.2.10 · Jul 2026
· source
· release history
Adds v3 streaming protocol support to RemoteGraph, enabling richer real-time output from remote graph execution.
sdk==0.4.1 · Jun 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
example
Stream both task-level and checkpoint events to observe exactly when each node runs and when state is persisted.$ async for chunk in graph.astream(inputs, stream_mode=["tasks", "checkpoints"]): print(chunk)
0.4.10 · Jun 2025
· source
Stream a remote LangGraph deployment using the messages-tuple format, now transparently supported by RemoteGraph.$ from langgraph.pregel.remote import RemoteGraph remote = RemoteGraph(graph_id="my-graph", url="https://my-deployment.example.com") for chunk in remote.stream({"messages": []},…
0.2.44 · Nov 2024
· source
Stream a remote subgraph from a parent graph, letting the parent's stream modes flow through to the RemoteGraph automatically.$ 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…
0.2.42 · Oct 2024
· source
＋Streamed output projectionsshippedLets callers narrow streamed output to specific views, such as messages or tool-call events, rather than receiving everything.16 releases · 4 other sources · first seen Aug 2024▸
Also counts toward: Client SDKs
release
16 total
Adds messages and tool call projections to the Python SDK (sdk-py) for filtered views of streamed output.
prebuilt==1.1.1 · Oct 2026
· source
· release history
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
Wires RemoteGraph.interleave to sdk-pyinterleave_projections for interleaved stream output.
1.2.3 · 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
Extracts stream decoders into a reusable module and adds interleave_projections stream decoder.
sdk==0.4.1 · 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
Filter a joined run stream to only receive graph state values and debug events, reducing noise in long-running pipelines.$ async for chunk in client.runs.join_stream(thread_id, run_id, stream_mode=["values", "debug"]): print(chunk)
sdk==0.1.57 · Mar 2025
· source
Filter a streaming run by passing query parameters directly on the stream call, avoiding manual URL construction.$ async for chunk in client.stream( assistant_id, thread_id, input=input_data, params={"my_filter": "value", "limit": 10}, ): print(chunk)
sdk==0.1.43 · Dec 2024
· source
Emit structured intermediate results from a node (e.g. progress updates) that consumers can act on before the graph finishes.$ # 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)
0.2.23 · Sep 2024
· source
＋WebSocket stream transportshippedAllows graph runs to be streamed over a persistent WebSocket connection as an alternative to HTTP server-sent events.10 releases · 2 other sources · first seen Sep 2024▸
Also counts toward: Client SDKs
release
10 total
Adds WebSocket stream transports to the Python SDK (sdk-py) for streaming agent output over WebSocket connections.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
prebuilt==1.1.1 · Oct 2026
· source
· release history
Adds WebSocket stream transport to the Python SDK (sdk-py) as an alternative to SSE.
1.2.3 · Jun 2026
· source
· release history
Adds WebSocket stream transport to the Python SDK for persistent, low-latency streaming connections.
1.2.3 · Jun 2026
· source
· release history
Adds WebSocket stream transport support, enabling lower-latency bidirectional streaming as an alternative to SSE.
sdk==0.4.0 · May 2026
· source
· release history
Adds WebSocket stream selection wiring so clients can choose between SSE and WebSocket transports.
sdk==0.4.0 · May 2026
· source
· release history
Adds a merge parameter to push_ui_message enabling incremental/partial updates to existing UI messages without replacing them wholesale.
0.4.1 · Apr 2025
· 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
Stream incremental prop updates to a UI message (e.g. progressively reveal content) instead of replacing the whole message on each update.$ 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…
0.4.1 · Apr 2025
· source
＋Wire-format field alignment in streaming protocolshippedKeeps 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 Development3 capabilitiesLangGraph 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.▸
＋Prebuild image support for deploymentshippedAllows deployments to start from a pre-built Docker image, cutting the time needed to deploy a graph.5 releases · 5 other sources · first seen Jul 2024▸
Also counts toward: Command-line interface
release
Adds --image-uri flag to langgraph deploy to deploy an already-pushed container image without rebuilding.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
cli==0.4.33 · Oct 2026
· source
· release history
Adds --image-uri flag to the CLI for specifying a container image URI in self-hosted deployments.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
cli==0.4.32 · Sep 2026
· source
· release history
Supports prebuild images for langgraph deploy, enabling faster deployments by skipping the image build step.
cli==0.4.31 · Jul 2026
· source
· release history
Supports prebuild images when running langgraph deploy, enabling faster deployments using pre-built Docker images.
cli==0.4.31 · Jul 2026
· source
· release history
New dockerfile CLI command generates a Dockerfile for the LangGraph API server, accepting a save path and configuration file for customization.
cli==0.1.49 · Jul 2024
· source
· release history
example
Deploy a container image you have already built and pushed to a registry, skipping the build step entirely.$ langgraph deploy --image-uri <your-registry>/my-agent:v1.2.3
cli==0.4.33 · Oct 2026
· source
Deploy a self-hosted LangGraph agent using a pre-built container image rather than building one locally.$ langgraph deploy --image-uri my-registry.example.com/my-agent:latest
cli==0.4.32 · Sep 2026
· source
Deploy a self-hosted LangGraph instance using a custom container image specified by the new flag.$ langgraph deploy --image-uri my-custom-registry.io/langgraph-agent:v1.2
cli==0.4.32 · Sep 2026
· source
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
cli==0.2.7 · Apr 2025
· source
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
cli==0.1.49 · Jul 2024
· source
＋TLS/HTTPS for local development serververifiedLets the local development server run over HTTPS so it can be tested with clients that require secure connections.4 releases · 5 other sources · first seen Jul 2024▸
Also counts toward: Command-line interface
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
The dev command now accepts auth configuration, allowing Studio auth to be controlled at dev-server launch time.
cli==0.1.62 · Dec 2024
· source
· release history
Supports passing environment variables from the configuration file to the development server via a new env parameter.
cli==0.1.58 · Nov 2024
· source
· release history
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.
0.1.6 · Jul 2024
· 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
--ssl-certfile — Path to an SSL certificate file for serving the development server over HTTPS.
1.2.5 · Jun 2026
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
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
cli==0.1.61 · Nov 2024
· source
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
cli==0.1.55 · Nov 2024
· source
＋CLI–server API version negotiationshippedLets the CLI work with a range of server API versions rather than being locked to one, reducing compatibility breakage during upgrades.3 releases · first seen Jul 2024▸
Also counts toward: Command-line interface
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
Adds context parameter support for remote graph API interactions.
1.1.2 · Mar 2026
· source
· release history
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.
cli==0.1.48 · Jul 2024
· source
· release history
＋Automation and Scripted Workflows1 capabilityThe 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 modesverifiedRuns the CLI without prompts and outputs structured JSON lines so it can be called reliably from scripts and automated pipelines.5 releases · 5 other sources · first seen Jun 2024▸
Also counts toward: Command-line interface, JSON data export
release
Adds optional deserializer parameter to PostgresStore and AsyncPostgresStore (via BasePostgresStore), enabling custom JSON deserialization when loading values from the database.
checkpointpostgres==1.0.11 · Sep 2024
· source
· release history
The store namespace representation in SharedValue changed from strings to tuples; any code relying on string namespaces will need to be updated.
0.2.29 · Sep 2024
· source
· release history
Supports serializing objects that implement get_secret_value() in JsonPlusSerializer, enabling proper handling of secure/secret values during checkpoint serialization and deserialization.
checkpoint==1.0.12 · Sep 2024
· source
· release history
Supports serialization of pathlib.Path, re.Pattern, decimal.Decimal, deque, IPv4/IPv6 address types, date, time, and ZoneInfo in JsonPlusSerializer.
checkpoint==1.0.3 · Aug 2024
· source
· release history
The langgraph-api-path option has been removed from CLI commands.
cli==0.1.45 · Jun 2024
· source
· release history
docs
Low-level orchestration framework for building, managing, and deploying long-running, stateful AI agents.
command line
--no-input — Never prompt for input; fail with an error if a required value is missing.
1.2.0 · May 2026
--json — Emit structured JSON-lines to stdout instead of human-readable text.
1.2.0 · May 2026
example
Pipe deployment listings into jq or other tooling for scripted inspection of active deployments.$ langgraph deploy list --json
cli==0.4.39 · Oct 2026
· source
Pipe deployment listener data into jq or other tooling by requesting JSON output from the CLI.$ langgraph deploy listeners list --json | jq '.[].name'
cli==0.4.34 · Oct 2026
· source
＋Multi-Agent Graph Behaviour1 capabilityLangGraph 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 graphsshippedLets subagents spawned by tool calls be given a name so they can be clearly identified within a multi-agent graph run.4 releases · 1 other source · first seen Jul 2024▸
release
Names tool-dispatched subagents via lc_agent_name for clearer agent identification in multi-agent graphs.
1.2.3 · Jun 2026
· source
· release history
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
Automatically attaches agent name to AIMessages generated by the ReAct agent for easier identification in multi-agent workflows.
0.2.70 · Feb 2025
· source
· release history
Adds InjectedState annotation to automatically inject graph state into tool arguments inside ToolNode, so tools can access state fields without the model generating them.
0.1.10 · Jul 2024
· source
· release history
example
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.$ 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…
0.1.10 · Jul 2024
· source
＋State Management and Checkpointing1 capabilityLangGraph 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 filteringshippedLets checkpoint reads skip expired rows so that stale saved state does not surface during long-running workflow execution.10 releases · first seen Jul 2024▸
release
10 total
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 2026
· source
· release history
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 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 2026
· source
· release history
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 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
Adds omit_expired opt-in parameter to checkpoint reads, allowing callers to skip expired rows instead of returning them.
checkpointpostgres==3.1.1 · Jul 2026
· source
· release history
＋Observability and Tracing1 capabilityLangGraph 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 policyshippedLets users set tracing behaviour per node when registering it, so sensitive nodes can be excluded or treated differently from the rest of the graph.8 releases · 4 other sources · first seen Jul 2024▸
release
8 total
Adds trace_policy parameter to add_node, letting callers control tracing behavior on a per-node basis.
1.2.11 · Aug 2026
· source
· release history
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, letting callers set per-node tracing behavior directly when wiring the graph.
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
Drops tags from TracePolicy, narrowing the tracing configuration surface.
1.2.10 · Jul 2026
· source
· release history
example
Suppress or customize tracing for a specific node without affecting the rest of the graph.$ graph.add_node("my_node", my_node_fn, trace_policy=<policy>)
1.2.11 · Aug 2026
· source
Attach a per-node trace policy at graph construction time to control which nodes are traced in production.$ graph.add_node('my_node', my_node_fn, trace_policy=TracePolicy(...))
1.2.10 · Jul 2026
· source
Attach a trace_policy to a specific node to control how that node's execution is traced, without affecting the rest of the graph.$ graph.add_node('my_node', my_node_fn, trace_policy=TracePolicy(...))
1.2.10 · Jul 2026
· source
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
＋Other99 capabilities▸
＋Persistent key-value store APIshippedProvides a `BaseStore` abstract base class with CRUD and search operations for persistent, namespaced key-value storage.51 releases · 7 other sources · first seen Aug 2024▸
release
51 total
Improves type safety and docstrings for store auth in the Python SDK.
sdk==0.3.8 · Feb 2026
· source
· release history
Releases SqliteStore as a persistent key-value store backend with namespace search and list_namespaces supporting max_depth filtering.
prebuilt==0.2.0 · May 2025
· source
· release history
Adds optional headers parameter to all store operations on StoreClient and SyncStoreClient, including item storage, retrieval, and namespace management.
sdk==0.1.59 · Mar 2025
· source
· release history
Adds ttl parameter to PostgresStore and AsyncPostgresStore constructors to configure Time To Live behavior for store items.
checkpointpostgres==2.0.17 · Mar 2025
· source
· release history
Adds sweep_interval_minutes field to TTLConfig to schedule automatic periodic deletion of expired store items.
checkpoint==2.0.20 · Mar 2025
· source
· release history
Adds sweep_interval_minutes to TTLConfig, enabling the store to periodically delete expired items automatically; omitting it preserves the previous no-sweep behavior.
cli==0.1.77 · Mar 2025
· source
· release history
example
7 total
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.$ 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…
cli==0.1.76 · Mar 2025
· source
Use integer or other non-string keys directly in store put/get calls without manually casting to str first.$ store.put(("namespace",), 42, {"value": "data"}) result = store.get(("namespace",), 42)
checkpoint==2.0.18 · Mar 2025
· source
Use an IVFFlat index with a custom cluster count when you have a large embedding dataset and want to trade recall for speed.$ from langgraph.store.postgres.base import ANNIndexConfig, IVFFlatConfig index_config = ANNIndexConfig( kind="ivfflat", ann_index_config=IVFFlatConfig(nlist=256), )
checkpointpostgres==2.0.7 · Dec 2024
· source
Use comparison-operator filters alongside a semantic query to narrow store search results to recent, high-relevance items.$ results = await store.asearch( ("projects", "sec-team"), query="privilege escalation techniques", filter={"severity": {"$gt": 7}, "status": {"$eq": "open"}}, limit=10, ) for item in results:…
checkpoint==2.0.7 · Nov 2024
· source
Configure a vector store with an embedding model in your LangGraph project config to enable semantic search over stored data.$ from langgraph_cli.config import IndexConfig, StoreConfig store = StoreConfig( index=IndexConfig( dims=1536, embed="openai:text-embedding-3-small", fields=["text", "description"], ) )
cli==0.1.60 · Nov 2024
· source
Search across a namespace prefix to find all items matching a filter — useful for multi-tenant or multi-session lookups.$ from langgraph.store.memory import InMemoryStore store = InMemoryStore() store.put(("sessions", "s1"), "summary", {"turns": 5}) store.put(("sessions", "s2"), "summary", {"turns": 12}) results =…
checkpoint==1.0.13 · Sep 2024
· source
＋Checkpoint & state update operationsshippedEnables batched, mid-execution, and source-tracked state updates alongside configurable checkpoint metadata management for fine-grained runtime control.30 releases · 15 other sources · first seen Jul 2024▸
release
30 total
Adds prune to PostgresSaver and AsyncPostgresSaver to clean up old checkpoints stored in Postgres.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
checkpointpostgres==3.2.0 · Oct 2026
· source
· release history
Adds durability argument with three modes — "exit", "async", and "sync" — giving fine-grained control over checkpoint persistence behavior.
0.6.0 · Jul 2025
· source
· release history
Extends pipeline mode in checkpoint-postgres to use the same lock used in non-pipeline mode, improving consistency under concurrent writes.
checkpointpostgres==2.0.22 · Jul 2025
· source
· release history
Skips saving checkpoints for subgraphs when checkpoint_during=False, reducing unnecessary checkpoint overhead.
0.4.10 · Jun 2025
· source
· release history
Implements update_state for the functional API, enabling state updates mid-graph in entrypoint-based workflows.
0.4.4 · May 2025
· source
· release history
New langgraph.constants.CONFIG_KEY_THREAD_ID constant enables explicit tracking of thread IDs for current invocations in checkpointing and state management.
0.3.31 · Apr 2025
· source
· release history
example
15 total
Use Overwrite on a state field when you want the latest value to always win instead of being merged by a reducer.$ from langgraph.types import Overwrite from typing import Annotated from typing_extensions import TypedDict class State(TypedDict): messages: Annotated[list, Overwrite()] # latest assignment replaces,…
1.0.2 · Oct 2025
· source
Disable mid-run checkpointing for a streaming run to reduce storage overhead when you only need a final checkpoint on completion or interruption.$ async for chunk in client.runs.stream( thread_id, assistant_id, input=input_data, checkpoint_during=False, ): print(chunk)
sdk==0.1.66 · Apr 2025
· source
Purge all checkpoint data for a completed or abandoned thread to free storage and enforce data-retention policies.$ 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")
checkpoint==2.0.25 · Apr 2025
· source
Serialize and deserialize a None value in checkpoint state without errors — useful when graph state fields are legitimately null.$ 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,…
checkpoint==2.0.24 · Apr 2025
· source
Same workflow in an async context — use abulk_update_state inside an async agent loop to batch corrections without blocking.$ from langgraph.types import StateUpdate updates = [ StateUpdate(values={"approved": True}, as_node="approver"), StateUpdate(values={"notes": "LGTM"}, as_node="annotator"), ] await…
0.3.17 · Mar 2025
· source
Apply several state patches at once during human-in-the-loop correction instead of calling update_state repeatedly.$ from langgraph.types import StateUpdate # graph is a compiled Pregel graph, config identifies the thread updates = [ StateUpdate(values={"status": "reviewed"}, as_node="reviewer"),…
0.3.17 · Mar 2025
· source
＋Graph construction and execution optimizationshippedImproves graph definition conciseness, execution loop performance, task scheduling efficiency, and tool error handling semantics.28 releases · 11 other sources · first seen Jul 2024▸
release
28 total
Introduces alpha timer support for scheduling and time-based graph behaviors.
prebuilt==1.0.13 · Apr 2026
· source
· release history
Introduces alpha timer primitives for scheduling time-based graph behavior.
1.2.0a1 · Apr 2026
· source
· release history
Adds Redis node-level cache via feat(langgraph): implement redis node level cache, enabling per-node result caching backed by Redis.
prebuilt==0.6.5 · Oct 2025
· source
· release history
New NodeBuilder utility provides a declarative way to create nodes and attach them to channels, replacing Channel.subscribe_to.
0.5.0 · Jun 2025
· source
· release history
Checkpoints are leaner: redundant keys dropped, per-task writes stored directly, and legacy pending_sends data is auto-migrated on first load.
0.5.0 · Jun 2025
· source
· release history
Optimizes stream_mode=values to emit chunks only when output channels have actually changed, reducing noise in high-frequency graphs.
0.4.6 · May 2025
· source
· release history
example
11 total
Assign different retry policies per exception type on a node — e.g., retry rate-limit errors aggressively and network errors conservatively.$ 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 =…
0.3.28 · Apr 2025
· source
Attach a subgraph directly to a PregelNode without wrapping it in a bound runnable — useful when composing graphs programmatically.$ from langgraph.pregel.read import PregelNode child_graph = build_child_graph() # returns a compiled Pregel node = PregelNode( channels=["input"], triggers=["input"], mapper=None,…
0.3.19 · Mar 2025
· source
Explicitly declare that a callable node accepts the LangChain config, avoiding runtime parameter inspection overhead.$ 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,…
0.3.19 · Mar 2025
· source
Check whether a channel holds a value before reading it, avoiding try/except boilerplate in custom channel logic.$ if channel.is_available(): value = channel.get()
0.3.15 · Mar 2025
· source
Override how PregelRunner dispatches tasks — useful for integrating custom thread pools, tracing, or rate-limiting at the task level.$ 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":…
0.2.74 · Feb 2025
· source
Declare destination nodes as a tuple when edge labels aren't needed, still enabling accurate graph visualization.$ graph.add_node("router", router_fn, destinations=("process", "fallback"))
0.2.71 · Feb 2025
· source
＋Agent configuration and execution controlsshippedProvides finer control over agent inputs, model compatibility, resource cleanup on completion, and structured background task management.18 releases · 6 other sources · first seen Jul 2024▸
release
18 total
Add a managed browser to an agent by exporting a browser from browser.py using define_browser from managed_deepagents, with scope set to 'thread' or 'user' and idle_ttl_seconds controlling the idle timeout.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
announced · Oct 2026
· source
· release history
Supports enabling and disabling cron jobs via the crons client.
sdk==0.3.4 · Feb 2026
· source
· release history
Introduces a new context API as a cleaner replacement for config['configurable'] and config_schema patterns.
prebuilt==0.6.0 · Jul 2025
· source
· release history
Introduces new context API as a replacement for config['configurable'] and config_schema for passing configuration to graph nodes.
cli==0.3.6 · Jul 2025
· source
· release history
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.
prebuilt==0.1.2 · Mar 2025
· source
· release history
Adds CONFIG_KEY_RUNNER_SUBMIT configuration key, enabling custom task submission logic in PregelRunner for flexible execution control.
0.2.74 · Feb 2025
· source
· release history
example
Give a Managed Deep Agent a per-thread browser with a 10-minute idle timeout so it can click through web UIs that have no API.$ # browser.py from managed_deepagents import define_browser browser = define_browser( scope="thread", idle_ttl_seconds=600, )
announced · Oct 2026
· source
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.$ from langchain_core.prompts import ChatPromptTemplate from langchain_openai import ChatOpenAI from langgraph.prebuilt import create_react_agent prompt = ChatPromptTemplate.from_messages([ ("system",…
prebuilt==0.1.2 · Mar 2025
· source
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.$ from langgraph.prebuilt.chat_agent_executor import AgentStateWithStructuredResponse
0.2.75 · Feb 2025
· source
Use a non-BaseChatModel language model (any LanguageModelLike) directly with create_react_agent — useful when wrapping custom or third-party models.$ 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 =…
0.2.29 · Sep 2024
· source
Schedule a background run to execute 60 seconds in the future, e.g. for deferred processing after an external webhook.$ await client.runs.create(thread_id="thread_xyz", assistant_id="asst_abc123", after_seconds=60)
sdk==0.1.31 · Sep 2024
· source
Use state_modifier to prepend a system prompt from the full agent state, giving you access to state fields beyond just messages.$ 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",…
0.1.9 · Jul 2024
· source
＋API security customizationshippedAdds configuration options for defining API security settings such as OAuth scopes and token endpoints.14 releases · 7 other sources · first seen Dec 2024▸
Also counts toward: Command-line interface
release
14 total
Adds --allowed-scope to cap what later authorizations may request, and --authorize-url / --token-url to support OAuth providers outside the built-in catalog.
announced · Sep 2026
· source
· release history
Introduces a sentinel value to skip automatic API key loading when instantiating the SDK client, allowing explicit credential control.
sdk==0.2.12 · Dec 2025
· source
· release history
Adds options to disable specific API route groups (assistants, threads, runs, store) via HTTP configuration.
cli==0.1.72 · Feb 2025
· source
· release history
Enables auth path resolution in Docker environments via new _update_auth_path function, so auth handlers are correctly wired when deploying containers.
cli==0.1.70 · Jan 2025
· source
· release history
Supports auth configuration block in langgraph.json, with validation that auth.path follows the required ./path/to/file.py:attribute_name format.
cli==0.1.70 · Jan 2025
· source
· release history
Enables custom authorization handlers to branch on Studio vs. non-Studio users via isinstance(user, StudioUser) checks.
sdk==0.1.48 · Dec 2024
· source
· release history
example
7 total
Register a GitHub OAuth connection scoped to repo so the agent files issues under each caller's own GitHub identity rather than a shared service account.$ uv run mda connections create github-issues \ --oauth github \ --client-id "$GITHUB_CLIENT_ID" \ --secret-from-env GITHUB_CLIENT_SECRET \ --scope repo
announced · Sep 2026
· source
Instantiate the SDK client without auto-loading the API key from the environment, supplying credentials explicitly instead.$ from langgraph_sdk import get_client, SKIP_LOAD_API_KEY client = get_client(url="http://localhost:8123", api_key=SKIP_LOAD_API_KEY)
sdk==0.2.12 · Dec 2025
· source
Inject a per-request auth token when streaming a run, e.g. for short-lived credentials that differ from the client's default.$ async for chunk in client.runs.stream( thread_id="<thread_id>", assistant_id="<assistant_id>", headers={"Authorization": "Bearer <ephemeral_token>"} ): print(chunk)
sdk==0.1.59 · Mar 2025
· source
Wire a custom auth handler into your LangGraph deployment so it is validated locally and resolved correctly inside the Docker container.$ { "graphs": { "my_agent": "./agent.py:graph" }, "auth": { "path": "./auth/handler.py:auth" } }
cli==0.1.70 · Jan 2025
· source
Gate a resource to non-Studio users only — useful when you want to block Studio UI access to sensitive operations in production.$ 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…
sdk==0.1.48 · Dec 2024
· source
Protect all LangGraph resources with a global auth handler that validates a bearer token and returns user scopes.$ 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":…
sdk==0.1.45 · Dec 2024
· source
＋Human-in-the-loop configuration typesshippedProvides structured type definitions and utilities for defining and handling human intervention points, including interrupt configs, action requests, and responses.16 releases · 3 other sources · first seen Aug 2024▸
release
16 total
Adds response_schema parameter to the interrupt() method
sdk==0.4.5 · Sep 2026
· source
· release history
Adds response_schema parameter to interrupt() to declare the expected structure of a human response when pausing graph execution.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
1.2.12 · Sep 2026
· source
· release history
Adds enforcement that prevents arbitrary graph resumes when multiple pending interrupts exist, ensuring interrupt handling is ordered and intentional.
0.6.8 · Sep 2025
· source
· release history
Refines the Interrupt interface: adds id (unique identifier encoding namespace) and value attributes as the canonical surface.
0.6.0 · Jul 2025
· source
· release history
Adds interrupts field to thread state, making interrupt information accessible when inspecting thread state.
sdk==0.2.0 · Jul 2025
· source
· release history
Introduces HumanInterruptNode for structured human-in-the-loop interruption handling in prebuilt agents.
prebuilt==0.2.0 · May 2025
· source
· release history
example
Enforce a specific JSON structure for data passed through an interruption point in a LangGraph workflow.$ interrupt( ..., response_schema={"type": "object", "properties": {"key": {"type": "string"}}} )
sdk==0.4.5 · Sep 2026
· source
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.$ graph.invoke(Command(resume={interrupt.interrupt_id: "approved"}), config)
0.4.0 · Apr 2025
· source
Handle multiple sequential interrupts inside one node reliably — the rewritten interrupt function tracks counts so each resume value is matched correctly.$ 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,…
0.2.55 · Dec 2024
· source
＋Serialization and state schema introspectionshippedOffers utilities to inspect state schema defaults, integrate MessagePack serialization for faster throughput, and serialize storage items.16 releases · 1 other source · first seen Aug 2024▸
release
16 total
Supports numpy array serialization in JsonPlusSerializer, enabling checkpoint storage of numpy arrays without manual conversion.
checkpointpostgres==2.0.22 · Jul 2025
· source
· release history
JsonPlusSerializer now natively handles NumPy arrays (including Fortran-ordered) without pickle fallback.
0.5.0 · Jun 2025
· source
· release history
Supports NumPy array serialization in JsonPlusSerializer, enabling checkpoint storage of array-heavy state.
checkpoint==2.1.0 · Jun 2025
· source
· release history
Adds pickle fallback for pandas serialization, allowing DataFrames and Series to round-trip through the checkpoint layer.
checkpoint==2.1.0 · Jun 2025
· source
· release history
Adds pickle_fallback option to the JSON-plus serializer, enabling serialization of objects that are not natively JSON-serializable.
checkpoint==2.0.26 · May 2025
· source
· release history
Supports None values in JsonPlusSerializer via a new "null" type designation, enabling round-trip serialization of null checkpoint state fields.
checkpoint==2.0.24 · Apr 2025
· source
· release history
example
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.$ 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 =…
0.2.17 · Sep 2024
· source
＋Runtime context access utilitiesshippedProvides helper functions to access runtime configuration, persistent store, and stream writers from within any node or task without explicit parameter passing.10 releases · 6 other sources · first seen Aug 2024▸
release
10 total
Introduces context_schema argument on StateGraph as the successor to config_schema, enabling typed context definitions via dataclasses.
0.6.0 · Jul 2025
· source
· release history
Adds a new Context API with Runtime[Context] parameter for type-safe, run-scoped context injection, replacing the config['configurable'] pattern.
0.6.0 · Jul 2025
· source
· release history
The new context API replaces config['configurable'] and config_schema; existing code relying on these patterns will need to be migrated.
cli==0.3.6 · Jul 2025
· source
· release history
Adds no-op fallback in get_stream_writer so callers can safely invoke the stream writer even when none is configured.
0.2.74 · Feb 2025
· source
· release history
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.
0.2.69 · Jan 2025
· source
· release history
Adds optional store parameter support in ToolNode, enabling tools to access the LangGraph store without requiring it as a mandatory dependency.
0.2.69 · Jan 2025
· source
· release history
example
Pass typed, run-scoped context (e.g. authenticated user ID and DB connection) to graph nodes without nesting values inside config['configurable'].$ 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,…
0.6.0 · Jul 2025
· source
Access the current invocation's thread ID inside a node or custom checkpointer to correlate concurrent runs.$ 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
0.3.31 · Apr 2025
· source
Access the LangGraph store inside a node to read or write persistent data without passing it explicitly through the graph.$ 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
0.2.69 · Jan 2025
· source
Give a ToolNode access to the store for lookups during tool execution without making it a required parameter.$ from langgraph.prebuilt import ToolNode from langgraph.store.memory import InMemoryStore store = InMemoryStore() tool_node = ToolNode(tools=[my_tool], store=store)
0.2.69 · Jan 2025
· source
Emit custom progress events from inside a node during streaming without threading store/config through function signatures.$ from langgraph.config import get_stream_writer def my_node(state): writer = get_stream_writer() writer({"status": "starting scan", "targets": state["targets"]}) # ... do work ...
0.2.69 · Jan 2025
· source
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.$ 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()])…
0.2.33 · Oct 2024
· source
＋Runtime command execution & routingshippedIntroduces Command and GraphCommand objects to route execution to specific nodes, handle subgraph parent routing, and pass custom state updates mid-run.11 releases · 4 other sources · first seen Nov 2024▸
release
11 total
Supports ParentCommand in RemoteGraph, enabling commands issued inside a remote graph to propagate up to the parent graph.
0.5.4 · Jul 2025
· source
· release history
Enhances Command.update with automatic field extraction from type hints on dataclasses and typed objects.
0.2.67 · Jan 2025
· source
· release history
Allows mixed Command and non-Command types in list commands, removing the requirement that all list items be Command objects.
0.2.63 · Jan 2025
· source
· release history
Enables Command objects to be returned directly from LangChain tools via ToolOutputMixin compatibility and ToolNode support.
0.2.57 · Dec 2024
· source
· release history
Enables goto field on Command to accept both string node names and Send objects, unifying send/goto into one API
0.2.55 · Dec 2024
· source
· release history
Expands Command TypedDict's goto field to accept Send, str, or a sequence of either, enabling richer graph routing in command structures.
sdk==0.1.43 · Dec 2024
· source
· release history
example
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.$ 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")
0.2.60 · Dec 2024
· source
Return a Command from a tool to redirect graph control flow — now supported directly in ToolNode without extra wiring.$ 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…
0.2.57 · Dec 2024
· source
Route a command to multiple destinations using the expanded goto field that now accepts a sequence of Send objects or node-name strings.$ from langgraph.types import Command, Send cmd = Command(goto=[Send("node_a", {"x": 1}), "node_b"])
sdk==0.1.43 · Dec 2024
· source
Route to different nodes from within a single node function based on runtime state, without wiring separate conditional edges.$ 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…
0.2.45 · Nov 2024
· source
＋OAuth connection managementshippedProvides CLI commands and SDK utilities to create, list, and resolve user-owned or agent-owned OAuth connections for MCP servers and other services, including support for catalog providers and static secrets.11 releases · 2 other sources · first seen Mar 2025▸
Also counts toward: Command-line interface
release
11 total
Adds local-development resolution: agent-owned connections resolve from MDA_DEV_<SLUG> environment variables (hyphens uppercased to underscores) in .env; user-owned connections resolve the signed-in developer as a real principal under mda dev.
announced · Sep 2026
· source
· release history
Adds mda connections create <slug> --mcp <url> to create a user-owned OAuth connection to any MCP server that self-registers its OAuth client, requiring only the server URL.
announced · Sep 2026
· source
· release history
Adds mda connections create <slug> --secret-from-env <ENV_VAR> to store agent-owned static secrets in a LangSmith workspace, keeping credentials out of .env and build artifacts.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
announced · Sep 2026
· source
· release history
Adds --authorize flag on mda connections create to pre-store a single shared OAuth grant for all callers (fourth ownership mode: deployment-level shared account).
announced · Sep 2026
· source
· release history
Adds mda connections create <slug> --oauth <catalog-service> --client-id --secret-from-env --scope to register user-owned OAuth connections from a 23-service catalog (including github) without writing authorization URLs, token URLs, or refresh logic.
announced · Sep 2026
· source
· release history
Adds mda connections create <slug> --secret-from-env <ENV_VAR> to store agent-owned static secrets in a LangSmith workspace, keeping credentials out of .env and build artifacts.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
announced · Sep 2026
· source
· release history
example
Read a user-owned OAuth token at run time inside a tool — triggering an authorization interrupt automatically if the caller has not yet granted access.$ from managed_deepagents import connections access_token = await connections.get("github-issues", {"type": "user"})
announced · Sep 2026
· source
Store a Tavily API key as an agent-owned connection so every caller shares it without embedding it in the codebase or deployment config.$ uv run mda connections create tavily-agent --secret-from-env TAVILY_API_KEY
announced · Sep 2026
· source
＋Graph construction & type validationshippedEnhances graph definition with improved schema inference for class methods, type-annotated routing declarations, and dependency validation.11 releases · 2 other sources · first seen Jul 2024▸
release
11 total
Requires state_schema in StateGraph.__init__, enforcing explicit schema declaration at graph construction.
0.4.8 · Jun 2025
· source
· release history
Extends StateGraph.add_conditional_edges with schema inference, improving type safety for branch routing.
0.3.6 · Mar 2025
· source
· release history
Adds dependencies field validation to validate_config, ensuring dependency declarations are checked and included during config processing.
cli==0.1.64 · Dec 2024
· source
· release history
Adds get_enhanced_type_hints utility to extract type hints along with default values and descriptions, covering Pydantic models, TypedDict, and dataclasses.
0.2.58 · Dec 2024
· source
· release history
Graph validation now only requires at least one edge from START; unreachable nodes no longer cause a validation error.
0.2.54 · Dec 2024
· source
· release history
Nodes can now declare their potential destination nodes via type annotations on their return type, enabling static graph validation of routing paths.
0.2.45 · Nov 2024
· source
· release history
example
Use create_model to build a Pydantic state schema that works across langchain-core versions when defining a StateGraph.$ 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)
0.2.22 · Sep 2024
· source
Use a dataclass as a StateGraph schema so field defaults are automatically resolved without manual annotation workarounds.$ 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)
0.2.20 · Sep 2024
· source
＋Synchronous access to async checkpointersshippedAdds synchronous list, get_tuple, put, and put_writes methods to `AsyncPostgresSaver` and `AsyncSqliteSaver` for use in synchronous contexts.10 releases · 2 other sources · first seen Aug 2024▸
release
10 total
Overrides get_delta_channel_history in the SQLite checkpoint backend with a streaming walk for more efficient history retrieval.
1.2.0 · May 2026
· source
· release history
Checkpoint.writes and Checkpoint.pending_sends fields have been removed.
0.5.0 · Jun 2025
· source
· release history
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.
0.3.28 · Apr 2025
· source
· release history
Adds dependency-aware node scheduling: only nodes whose trigger channels were updated in the previous step are evaluated, reducing unnecessary work in large graphs.
0.3.19 · Mar 2025
· source
· release history
The require_at_least_one_of parameter is removed from ChannelWrite; code that passes this parameter will break on upgrade.
0.3.10 · Mar 2025
· source
· release history
Rewrites the task decorator to support both direct (@task) and parameterized (@task(...)) usage, with proper coroutine detection and wrapping for async functions.
0.2.61 · Jan 2025
· source
· release history
example
Call AsyncSqliteSaver synchronously from a non-async context — useful when integrating with sync frameworks or threads that share an async event loop.$ from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver saver = AsyncSqliteSaver.from_conn_string("checkpoints.db") # Synchronous put now works without wrapping in asyncio.run()…
checkpointsqlite==1.0.2 · Sep 2024
· source
Use AsyncPostgresSaver from a synchronous function — e.g. inside a Django view or a sync test — without spinning up a separate async runtime.$ 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…
checkpointpostgres==1.0.6 · Sep 2024
· source
＋Deployment Dockerfile generation and Node.js supportshippedEnables generation of version-controlled Dockerfiles for API servers and adds configuration validation support for Node.js project deployments.11 releases · 1 other source · first seen Aug 2024▸
Also counts toward: Scripting language support
release
11 total
Adds a CLI argument to retain build dependencies (setuptools, pip, wheel) in the build output instead of pruning them.
cli==0.3.4 · Jul 2025
· source
· release history
Supports image_distro setting in the LangGraph config file for controlling the base image distribution used in Dockerfile generation.
cli==0.2.11 · Jun 2025
· source
· release history
Adds a warning when the image distro is not configured as Wolfi, nudging users toward the recommended distro.
cli==0.2.11 · Jun 2025
· source
· release history
Selects the appropriate Docker base image automatically based on project composition via new default_base_image logic.
cli==0.2.2 · Apr 2025
· source
· release history
Docker images now include LANGGRAPH_UI and LANGGRAPH_UI_CONFIG environment variables when UI is configured.
cli==0.1.84 · Apr 2025
· source
· release history
Docker image builds now automatically detect and install UI dependencies (npm, yarn, pnpm, bun) when UI is configured.
cli==0.1.84 · Apr 2025
· source
· release history
example
Pin a specific base image tag in your generated Dockerfile instead of relying on the auto-detected Python/Node.js version.$ { "_INTERNAL_docker_tag": "3.11-slim-bookworm" }
cli==0.2.5 · Apr 2025
· source
＋LangSmith tracing controlsshippedAllows enabling or disabling LangSmith tracing on a per-call basis and disabling it for specific runs to avoid logging sensitive payloads.9 releases · 2 other sources · first seen Aug 2024▸
release
9 total
Routes LangSmith traces from thread streams, enabling trace visibility for streaming thread operations.
sdk==0.4.4 · Aug 2026
· source
· release history
Adds langsmith_tracing parameter to runs.create, runs.stream, and runs.wait to enable or disable LangSmith tracing on a per-call basis.
sdk==0.3.13 · Apr 2026
· source
· release history
Enhances the runtime with more execution information.
1.1.5 · Apr 2026
· source
· release history
Adds trace_inputs parameter to RunnableSeq to customize how inputs are recorded in callbacks across invoke, ainvoke, stream, and astream.
0.2.66 · Jan 2025
· source
· release history
Adds _explode_args_trace_inputs utility in langgraph.pregel.call to flatten function arguments in traces for improved debugging.
0.2.66 · Jan 2025
· source
· release history
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.39 · Oct 2024
· source
· release history
example
Disable LangSmith tracing for a specific run invocation to avoid logging sensitive payloads.$ result = await client.runs.create( thread_id=thread_id, assistant_id=assistant_id, input={"messages": [{"role": "user", "content": "hello"}]}, langsmith_tracing=False, )
sdk==0.3.13 · Apr 2026
· source
Customize how inputs appear in LangSmith / callback traces for a multi-step chain without changing runtime behaviour.$ 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",…
0.2.66 · Jan 2025
· source
＋Structured graph input validationshippedEnforces structured, validated inputs on compiled state graphs using Pydantic models to catch invalid payloads before execution.8 releases · 3 other sources · first seen Jan 2025▸
release
8 total
Validates checkpointer type at compile time, catching misconfiguration before runtime.
prebuilt==1.0.6 · Jan 2026
· source
· release history
Validates checkpointer type at compile time, surfacing misconfigured checkpointers before runtime.
1.0.6 · Jan 2026
· source
· release history
state_schema is now required in StateGraph.__init__; existing code that omits it will raise an error.
0.4.8 · Jun 2025
· source
· release history
New SchemaCoercionMapper class provides cached schema coercion supporting Pydantic v1/v2, nested lists, dicts, tuples, and unions.
0.3.10 · Mar 2025
· source
· release history
Adds NotProvided sentinel class and NOT_PROVIDED constant to distinguish between explicitly passing ttl=None and omitting a TTL value entirely.
checkpoint==2.0.19 · Mar 2025
· source
· release history
Adds input_model support to Pregel for validating graph inputs against Pydantic v1 and v2 models, using construct/model_construct respectively.
0.3.7 · Mar 2025
· source
· release history
example
Define a typed graph with explicit input and output schemas using the new required state_schema and renamed schema parameters.$ from langgraph.graph import StateGraph graph = StateGraph( state_schema=MyState, input_schema=UserQuery, output_schema=AssistantResponse, )
0.5.0 · Jun 2025
· source
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.$ 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 ...
0.3.7 · Mar 2025
· source
Enforce a typed config schema on a workflow so callers get validation errors when they pass unexpected config keys.$ 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…
0.2.64 · Jan 2025
· source
＋Thread management operationsshippedAdds capabilities to delete entire threads and sort search results for both threads and assistants.8 releases · 2 other sources · first seen Aug 2024▸
release
8 total
Includes pagination in assistants search responses.
prebuilt==1.0.6 · Jan 2026
· source
· release history
Introduces new type aliases AssistantSortBy, ThreadSortBy, and SortOrder for strongly-typed sort parameter hints across assistant and thread searches.
sdk==0.1.65 · Apr 2025
· source
· release history
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.
sdk==0.1.65 · Apr 2025
· source
· release history
Adds delete_thread and adelete_thread methods to BaseCheckpointSaver and InMemorySaver for deleting all checkpoints and writes associated with a specific thread ID.
checkpoint==2.0.25 · Apr 2025
· source
· release history
Adds adelete_thread (async) and delete_thread (sync, with main-thread safety checks) to AsyncPostgresSaver for the same capability in async workflows.
checkpointpostgres==2.0.20 · Apr 2025
· source
· release history
Adds delete_thread method to PostgresSaver for complete removal of all checkpoints and writes tied to a specific thread ID.
checkpointpostgres==2.0.20 · Apr 2025
· source
· release history
example
Clear an entire conversation history in one step instead of removing messages one by one — useful when resetting context between sessions or tasks.$ 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 =…
0.3.23 · Apr 2025
· source
Filter threads to only those whose state contains a specific value — useful for finding active conversations in a given topic or stage.$ threads = await client.threads.search(values={"topic": "billing", "status": "open"})
sdk==0.1.30 · Aug 2024
· source
＋LangGraph Cloud CLI deploymentshippedEnables deploying, listing, deleting, and remotely building LangGraph Cloud applications directly from the command line.6 releases · 3 other sources · first seen Aug 2024▸
Also counts toward: Command-line interface, SaaS deployment
release
Sends upload headers returned by the control plane when pushing artifacts, enabling authenticated or signed upload flows.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
cli==0.4.40 · Oct 2026
· source
· release history
Adds --json flag to the langgraph deploy list command for machine-readable JSON output.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
cli==0.4.39 · Oct 2026
· source
· release history
Adds remote build support to langgraph deploy in the CLI.
1.1.5 · Apr 2026
· source
· release history
Adds langgraph deploy list subcommand to enumerate active deployments.
cli==0.4.16 · Mar 2026
· source
· release history
Adds langgraph deploy delete subcommand to remove a deployment.
cli==0.4.16 · Mar 2026
· source
· release history
Updates build, prepare, and deployment CLI commands to operate correctly against both Python and Node.js environments.
cli==0.1.52 · Aug 2024
· source
· release history
example
Delete a specific deployment to decommission a retired agent service.$ langgraph deploy delete <deployment-id>
cli==0.4.16 · Mar 2026
· source
List all active deployments to audit or identify targets for cleanup.$ langgraph deploy list
cli==0.4.16 · Mar 2026
· source
Deploy a LangGraph application to LangGraph Cloud without leaving the terminal.$ langgraph deploy
cli==0.4.15 · Mar 2026
· source
＋Auto-cancelling streaming runsshippedSupports starting streaming runs that automatically cancel and clean up resources when the user closes the connection.5 releases · 3 other sources · first seen Aug 2024▸
release
Enables durable error-handler resume so graph execution can recover across host crashes.
1.2.0 · May 2026
· source
· release history
Adds cancel_on_disconnect parameter to the sync RunClient.join_stream, reaching feature parity with the async version.
sdk==0.1.57 · Mar 2025
· source
· release history
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.
0.2.63 · Jan 2025
· source
· release history
Adds cancel_on_disconnect parameter to RunsAPI.join_stream() to automatically cancel a run when the client disconnects from the stream.
sdk==0.1.42 · Dec 2024
· source
· release history
Adds on_disconnect parameter to stream() and wait() — set to "cancel" or "continue" to control what happens to a run when the client disconnects.
sdk==0.1.29 · Aug 2024
· source
· release history
example
Use cancel_on_disconnect in the sync client so a stalled run is automatically cancelled when your process disconnects.$ for chunk in client.runs.join_stream(thread_id, run_id, stream_mode=["values"], cancel_on_disconnect=True): print(chunk)
sdk==0.1.57 · Mar 2025
· source
Stream a run and ensure it is automatically cancelled server-side if your client drops the connection, preventing orphaned background work.$ async for chunk in client.runs.join_stream(thread_id="<thread_id>", run_id="<run_id>", cancel_on_disconnect=True): print(chunk)
sdk==0.1.42 · Dec 2024
· source
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.$ async for chunk in client.runs.stream( thread_id, assistant_id, input=input_data, on_disconnect="cancel", on_completion="delete", ): print(chunk)
sdk==0.1.29 · Aug 2024
· source
＋Encrypted checkpoint storageshippedSupports AES encryption for checkpoints via environment variables or direct key supply, maintaining backward compatibility with unencrypted data.5 releases · 3 other sources · first seen Aug 2024▸
release
Supports custom encryption at rest for checkpoint data.
prebuilt==1.0.6 · Jan 2026
· source
· release history
Factory method EncryptedSerializer.from_pycryptodome_aes enables AES-encrypted checkpoints via the pycryptodome library with minimal setup.
checkpoint==2.0.21 · Mar 2025
· source
· release history
Supports AES key supply via LANGGRAPH_AES_KEY environment variable or direct key passing, and is backward-compatible with existing unencrypted checkpoint data.
checkpoint==2.0.21 · Mar 2025
· source
· release history
New EncryptedSerializer class wraps any underlying serializer (defaults to JsonPlusSerializer) to transparently encrypt and decrypt checkpoint data.
checkpoint==2.0.21 · Mar 2025
· source
· release history
Introduces JsonPlusSerializer-backed_load_metadata and _dump_metadata methods for consistent, richer metadata serialization across sync and async savers.
checkpointpostgres==1.0.1 · Aug 2024
· source
· release history
example
Implement a custom cipher (e.g., a KMS-backed one) by conforming to CipherProtocol instead of using the built-in AES factory.$ from langgraph.checkpoint.serde.base import CipherProtocol from langgraph.checkpoint.serde.encrypted import EncryptedSerializer class MyKMSCipher(CipherProtocol): def encrypt(self, plaintext: bytes)…
checkpoint==2.0.21 · Mar 2025
· source
Encrypt all checkpoint data at rest using AES — useful when storing sensitive agent state in a shared or cloud-backed checkpointer.$ from langgraph.checkpoint.serde.encrypted import EncryptedSerializer # Key can also be supplied via LANGGRAPH_AES_KEY env var serializer =…
checkpoint==2.0.21 · Mar 2025
· source
Persist raw binary blobs (e.g. embeddings or serialised models) directly in checkpoint state — now round-trippable through JsonPlusSerializer.$ 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))…
checkpoint==1.0.1 · Aug 2024
· source
＋HTTP client custom headersshippedAdds an optional headers parameter to all HTTP methods on client classes for merging custom request headers.6 releases · 2 other sources · first seen Aug 2024▸
release
Adds query-parameter support to the Python SDK client (feat(sdk-py): client qparams), allowing callers to pass arbitrary query parameters through SDK calls.
prebuilt==0.6.5 · Oct 2025
· source
· release history
Adds optional headers parameter to all methods on AssistantsClient and SyncAssistantsClient (including get, create, update, delete, search).
sdk==0.1.59 · Mar 2025
· source
· release history
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.
sdk==0.1.59 · Mar 2025
· source
· release history
Adds optional headers parameter to all thread-related methods on ThreadsClient and SyncThreadsClient, including state management, history, and creation.
sdk==0.1.59 · Mar 2025
· source
· release history
Adds optional headers parameter to all run methods on RunsClient and SyncRunsClient, covering create, stream, wait, and management operations.
sdk==0.1.59 · Mar 2025
· source
· release history
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.
sdk==0.1.28 · Aug 2024
· source
· release history
example
Pass a correlation or tenant-tracking header on a per-run basis without modifying the global client config.$ run = await client.runs.create( thread_id="<thread_id>", assistant_id="<assistant_id>", headers={"X-Tenant-ID": "org-42", "X-Request-ID": "req-abc123"} )
sdk==0.1.59 · Mar 2025
· source
Attach a tenant ID or trace header to every SDK request when operating in a multi-tenant or instrumented environment.$ from langgraph_sdk import get_client client = get_client( url="https://your-langgraph-endpoint", headers={"x-tenant-id": "acme-corp", "x-trace-id": "abc123"}, )
sdk==0.1.28 · Aug 2024
· source
＋Standardized error codesshippedIntroduces a structured enum of error codes and validation utilities for programmatic error handling.7 releases · 1 other source · first seen Oct 2024▸
release
7 total
Centralizes all error classes under langgraph.errors; moves Send and Interrupt imports to langgraph.types.
0.6.0 · Jul 2025
· source
· release history
Adds --wait-for-client flag to the dev command that, combined with --debug-port, pauses server startup until a debugger client connects.
cli==0.1.61 · Nov 2024
· source
· release history
Automatically adds the current working directory to Python's path when running the dev command, allowing seamless local module imports.
cli==0.1.59 · Nov 2024
· source
· release history
Enables the dev command to read the dependencies field from the config file and add those directories to Python's path automatically.
cli==0.1.59 · Nov 2024
· source
· release history
Adds --add-docker-compose flag to the dockerfile command, generating a docker-compose.yml, .env, and .dockerignore alongside the Dockerfile.
cli==0.1.54 · Nov 2024
· source
· release history
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.
0.2.44 · Nov 2024
· source
· release history
example
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
cli==0.1.54 · Nov 2024
· source
＋Entrypoint function visualizationshippedExposes graph visualization capabilities for entrypoint functions, their dependent tasks, and nested subgraphs.7 releases · 1 other source · first seen Jul 2024▸
release
7 total
Adds new langgraph.pregel.draw module with a draw_graph function that simulates execution to discover edges, correctly handling subgraphs and conditional edges.
0.3.32 · Apr 2025
· source
· release history
Enables parallel traversal of subgraphs during async graph visualization via asyncio.gather(), speeding up rendering of complex graphs.
0.3.13 · Mar 2025
· source
· release history
Tasks decorated with @task now carry a _is_pregel_task attribute, making them automatically discoverable for graph visualization.
0.2.65 · Jan 2025
· source
· release history
New EntrypointPregel class exposes a get_graph() method to visualize entrypoint functions and their dependent tasks, including nested subgraphs via x-ray mode.
0.2.65 · Jan 2025
· source
· release history
Improves RemoteGraph visualization by resolving meaningful node names from node data instead of falling back to an empty string.
0.2.44 · Nov 2024
· source
· release history
Enhances get_graph with pre-computed subgraph resolution when using the xray parameter, enabling accurate visualization of complex nested graph structures.
0.2.16 · Sep 2024
· source
· release history
example
Tag a node with metadata (e.g. owner or risk label) so it appears in graph visualisations and downstream tooling.$ graph.add_node("my_agent", my_runnable, metadata={"team": "red-team", "criticality": "high"})
0.1.8 · Jul 2024
· source
＋Prebuilt agent APIsshippedsuggestedProvides high-level APIs for creating and executing LangGraph agents and tools via the langgraph-prebuilt package.7 releases · first seen Jul 2024▸
Suggested capability: Model tool calling. This is our guess, not confirmed.
release
7 total
Inspect which tools a ToolNode exposes by reading tool names from graph node metadata.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
1.2.19 · Oct 2026
· source
· release history
Adds dynamic model support to create_react_agent, allowing the LLM to be swapped at runtime per invocation.
prebuilt==0.6.0 · Jul 2025
· source
· release history
Enables create_react_agent to accept plain Callable objects as tools, in addition to BaseTool instances.
prebuilt==0.1.3 · Mar 2025
· source
· release history
Adds support for langgraph-prebuilt v0.1.1, which provides high-level APIs for creating and executing LangGraph agents and tools.
cli==0.1.74 · Feb 2025
· source
· release history
Renames state_modifier parameter to prompt in create_react_agent, with full backward compatibility retained.
0.2.68 · Jan 2025
· source
· release history
Enables create_react_agent to accept an empty tools list, producing a simple LLM-only graph without tool-calling plumbing.
0.2.54 · Dec 2024
· source
· release history
＋Configurable checkpoint during executionshippedAllows controlling whether to checkpoint after every step or only at run end via new parameters.6 releases · 1 other source · first seen Apr 2025▸
release
Adds forced delta channel snapshot after a configurable maximum number of supersteps since the last snapshot, preventing unbounded checkpoint gaps.
checkpoint==4.1.0 · May 2026
· source
· release history
Forces a delta channel snapshot after a configurable max number of supersteps since the last snapshot, preventing unbounded replay.
1.2.0 · May 2026
· source
· release history
Reworks delta cadence logic for checkpoint writes, enabling finer-grained control over how incremental state changes are persisted.
checkpointpostgres==3.1.0a4 · May 2026
· source
· release history
Adds durability mode parameter to invoke and ainvoke for controlling checkpoint persistence behavior.
0.6.3 · Aug 2025
· source
· release history
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.66 · Apr 2025
· source
· release history
Adds checkpoint_during parameter to stream(), astream(), invoke(), and ainvoke() — set to False to checkpoint only at run end, reducing overhead in large graphs.
0.3.27 · Apr 2025
· source
· release history
example
Control whether LangGraph persists checkpoints during a synchronous graph run — useful when you want to skip persistence overhead for ephemeral, fire-and-forget invocations.$ graph.invoke(input, durability="ephemeral")
0.6.3 · Aug 2025
· source
＋Agent state Pydantic modelsshippedProvides predefined Pydantic models for representing agent state, including messages and structured responses.4 releases · 3 other sources · first seen Jul 2024▸
release
Automatic output coercion to Pydantic models or dataclasses when the graph's state schema is declared as one — no manual parsing needed.
1.1.0 · Mar 2026
· source
· release history
Adds AgentStatePydantic and AgentStateWithStructuredResponsePydantic Pydantic models for representing agent state with messages, remaining steps, and structured responses.
prebuilt==0.1.3 · Mar 2025
· source
· release history
Supports both TypedDict and Pydantic models interchangeably for agent state schema via updated StateSchemaType.
prebuilt==0.1.3 · Mar 2025
· source
· release history
Adds AgentStateWithStructuredResponse class to support structured responses in the ReAct agent executor.
0.2.75 · Feb 2025
· source
· release history
example
When your state is a Pydantic model, confirm the output is already coerced to the right type — no manual MyState(**result) call needed.$ from pydantic import BaseModel from langgraph.graph import StateGraph class MyState(BaseModel): answer: str count: int compiled = StateGraph(MyState).compile() # ...
1.1.0 · Mar 2026
· source
Use a Pydantic model as your graph state so ToolNode can extract typed fields directly — no dict conversion needed.$ 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:…
0.2.19 · Sep 2024
· source
Define a custom state schema with extra fields so the agent graph carries domain-specific context alongside messages.$ from typing import TypedDict, Annotated from langgraph.prebuilt import create_react_agent from langchain_openai import ChatOpenAI import operator class MyAgentState(TypedDict): messages:…
0.1.9 · Jul 2024
· source
＋Local graph testing servershippedProvides a `langgraph test` subcommand that starts a local server to validate graph compatibility with the API before deployment.4 releases · 3 other sources · first seen Jun 2024▸
Also counts toward: Command-line interface
release
Python 3.9 is no longer supported; setups running langgraph-checkpoint-postgres on Python 3.9 will break on upgrade.
checkpointpostgres==3.0.0 · Oct 2025
· source
· release history
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.82 · Apr 2025
· source
· release history
Upgrades the bundled PostgreSQL Docker image to pgvector/pgvector:pg16, enabling vector operations in local dev environments.
cli==0.1.69 · Jan 2025
· source
· release history
Adds langgraph test subcommand to start a local test server that validates graph compatibility with the LangGraph API server before deploying to LangGraph Cloud.
cli==0.1.45 · Jun 2024
· source
· release history
example
Expose your local LangGraph dev server publicly so remote teammates or browser-based frontends can reach it without localhost blocking.$ langgraph dev --tunnel
cli==0.2.6 · Apr 2025
· source
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
cli==0.1.82 · Apr 2025
· source
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
cli==0.1.48 · Jul 2024
· source
＋Shallow checkpoint storageshippedProvides a checkpoint saver implementation that stores only the most recent state to reduce storage requirements.7 releases · first seen Aug 2024▸
release
7 total
The postgres shallow checkpointer has been removed; setups using it must migrate to another checkpointer.
0.4.8 · Jun 2025
· source
· release history
Adds AsyncShallowPostgresSaver, the async counterpart to ShallowPostgresSaver, with the same lightweight storage semantics and a full async interface.
checkpointpostgres==2.0.9 · Dec 2024
· source
· release history
Adds ShallowPostgresSaver, a drop-in replacement for PostgresSaver that stores only the most recent checkpoint, reducing storage when time travel is not needed.
checkpointpostgres==2.0.9 · Dec 2024
· source
· release history
Adds ConnectionPool support to PostgresSaver, enabling psycopg connection pool usage alongside direct connections for high-concurrency scenarios.
checkpointpostgres==1.0.4 · Aug 2024
· source
· release history
Adds versioned database migrations (MIGRATIONS list) for both PostgresSaver and AsyncPostgresSaver, replacing one-shot static table creation.
checkpointpostgres==1.0.1 · Aug 2024
· source
· release history
New langgraph-checkpoint-postgres package open-sources the production-grade PostgresSaver previously available only in LangGraph Cloud.
0.2.0 · Aug 2024
· source
· release history
＋Developer utilities & type inferenceshippedProvides improved type annotations, schema introspection helpers, and Pydantic compatibility checks to streamline SDK usage and IDE autocompletion.5 releases · 2 other sources · first seen Jan 2025▸
release
Drops Pydantic V1 support — SchemaCoercionMapper and langgraph.utils.pydantic now exclusively use Pydantic V2 APIs.
0.4.1 · Apr 2025
· source
· release history
Extends get_input_schema to prioritize the input_model when available, surfacing typed input schemas for state graphs.
0.3.7 · Mar 2025
· source
· release history
Improves type annotations on the task decorator to consistently prioritize async functions in Union types.
0.3.6 · Mar 2025
· source
· release history
Expands task decorator function signature to accept *args and **kwargs and adds overloads for better IDE type inference.
0.2.61 · Jan 2025
· source
· release history
Enables add_messages as a partial function when called without arguments, improving flexibility in type annotations.
0.2.61 · Jan 2025
· source
· release history
example
Reference the now-public PLACEHOLDER constant when building custom batch queries against the Postgres store.$ from langgraph.store.postgres.base import PLACEHOLDER
checkpointpostgres==2.0.16 · Mar 2025
· source
Check whether a custom config type will be handled natively by Pydantic before wiring it into a Pregel graph.$ 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):…
0.3.4 · Mar 2025
· source
＋UI message streaming updatesshippedAllows pushing incremental or merged updates to UI messages during graph execution, enabling progressive content revelation without full replacements.3 releases · 4 other sources · first seen Sep 2024▸
release
Adds a merge parameter to push_ui_message enabling incremental/partial updates to existing UI messages without replacing them wholesale.
0.4.1 · Apr 2025
· source
· release history
New UIMessage TypedDict represents UI component updates with properties and metadata during graph execution.
0.3.25 · Apr 2025
· source
· release history
Enhances StreamMessagesHandler to track message IDs nested within input dictionaries for proper deduplication.
0.2.75 · Feb 2025
· source
· release history
example
Stream incremental prop updates to a UI message (e.g. progressively reveal content) instead of replacing the whole message on each update.$ 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…
0.4.1 · Apr 2025
· source
Stream UI component updates to a frontend during graph execution — e.g. show a progress card that is later replaced.$ 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":…
0.3.25 · Apr 2025
· source
Wire ui_message_reducer into a typed state so your graph automatically merges UI additions and removals across nodes.$ 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],…
0.3.25 · Apr 2025
· source
Surface LLM tokens as they are generated so a UI can display streamed responses without waiting for the full reply.$ for chunk in graph.stream(inputs, stream_mode="messages"): print(chunk)
0.2.23 · Sep 2024
· source
＋Task-specific checkpoint writesshippedAllows storing task-specific writes mid-execution via `put_writes` and `aput_writes` methods in checkpointers.7 releases · first seen Jul 2024▸
release
7 total
The return_exception parameter is removed from read_channel() in langgraph.pregel.io; code passing that argument will break.
0.3.15 · Mar 2025
· source
· release history
Adds optional task_path parameter to AsyncSqliteSaver.put_writes() and AsyncSqliteSaver.aput_writes() for async task traceability.
checkpointsqlite==2.0.3 · Jan 2025
· source
· release history
Adds task_path parameter to put_writes and aput_writes on BaseCheckpointSaver and InMemorySaver to track the nested path of tasks creating checkpoint writes.
checkpoint==2.0.10 · Jan 2025
· source
· release history
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.
checkpointpostgres==2.0.12 · Jan 2025
· source
· release history
Adds new INSERT_CHECKPOINT_WRITES_SQL constant enabling insert-only checkpoint write operations alongside the existing upsert path.
checkpointpostgres==1.0.7 · Sep 2024
· source
· release history
Extends BaseCheckpointSaver.put and aput with a new new_versions: ChannelVersions parameter exposing channel version info at write time.
checkpoint==1.0.1 · Aug 2024
· source
· release history
＋Nested subgraph discoveryshippedExpands `get_subgraphs` to discover nested Pregel instances within `RunnableSequence`, `RunnableLambda`, and `RunnableCallable` dependencies.5 releases · 2 other sources · first seen Sep 2024▸
release
Adds name parameter to Graph.compile(), StateGraph.compile(), and create_react_agent() to identify graphs when used as subgraphs.
0.2.70 · Feb 2025
· source
· release history
Introduces find_subgraph_pregel utility to recursively locate Pregel subgraphs within runnable components — useful for checkpoint handling and graph introspection.
0.2.35 · Oct 2024
· source
· release history
Automatically excludes subgraphs with checkpointing disabled (checkpointer is False) from subgraph enumeration.
0.2.27 · Sep 2024
· source
· release history
Adds optional namespace parameter to get_subgraphs and aget_subgraphs for filtering subgraphs by name, improving performance in nested-subgraph graphs.
0.2.27 · Sep 2024
· source
· release history
Expands get_subgraphs to discover nested Pregel instances inside RunnableSequence steps, RunnableLambda dependencies, and RunnableCallable function nonlocals.
0.2.16 · Sep 2024
· source
· release history
example
Inspect a compiled runnable to find whether it contains a Pregel subgraph, useful before attaching a checkpointer to a nested graph.$ from langgraph.pregel.utils import find_subgraph_pregel subgraph = find_subgraph_pregel(my_runnable) if subgraph: print("Found Pregel subgraph:", subgraph)
0.2.35 · Oct 2024
· source
Retrieve only the subgraph matching a specific namespace when inspecting a deeply nested graph, avoiding a full traversal.$ subgraphs = list(graph.get_subgraphs(namespace="my_agent"))
0.2.27 · Sep 2024
· source
＋Customizable graph entrypointsshippedUpdates the entrypoint decorator to return specific instance types and enforces non-generator functions for improved type safety.6 releases · 1 other source · first seen Dec 2024▸
release
Generators are no longer supported in the Functional API (@entrypoint); any entrypoint using a generator function will break on upgrade.
0.2.68 · Jan 2025
· source
· release history
Adds get_runnable_for_entrypoint and get_runnable_for_task functions in langgraph.pregel.call for targeted handling of distinct execution contexts.
0.2.66 · Jan 2025
· source
· release history
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.
0.2.65 · Jan 2025
· source
· release history
Adds automatic input/output type detection from function signatures in the entrypoint decorator, removing the need for manual type annotation wiring.
0.2.64 · Jan 2025
· source
· release history
Adds support for an optional previous parameter in entrypoint-decorated functions to access the prior return value in stateful Pregel graphs.
0.2.64 · Jan 2025
· source
· release history
Adds @entrypoint decorator (langgraph.func.entrypoint) to wrap regular or generator functions into Pregel graphs as callable entry points.
0.2.57 · Dec 2024
· source
· release history
example
Wrap an async function as a LangGraph task using the decorator directly without parentheses — useful for fire-and-forget subtasks in a functional graph.$ from langgraph.func import task @task async def fetch_data(url: str, timeout: int = 30) -> dict: # async I/O here ...
0.2.61 · Jan 2025
· source
＋Custom container image support for deploymentsverifiedAllows specifying a custom container image URI for self-hosted LangGraph deployments.4 releases · 2 other sources · first seen Apr 2025▸
Also counts toward: Command-line interface, Self-hosted deployment
release
Adds --image-pull-secret flag to the CLI deploy command to support pulling images from private container registries.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
cli==0.4.35 · Oct 2026
· source
· release history
Automatically logs in to the registry using the username returned by the control plane, removing the need to supply credentials manually.
cli==0.4.35 · Oct 2026
· source
· release history
Adds --image-uri flag to control the container image for self-hosted LangGraph deployments
cli==0.4.32 · Sep 2026
· source
· release history
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.7 · Apr 2025
· source
· release history
command line
--image-pull-secret — Name of a Kubernetes secret (type kubernetes.io/dockerconfigjson) in the deployment's namespace to use for pulling the image from a private registry. Repeat to give more than one. Only used when creating a deployment with --push-to or --image-uri.
1.2.16 · Oct 2026
example
Deploy a LangGraph agent using an image stored in a private container registry by passing the pull secret.$ langgraph deploy --image-pull-secret <your-registry-secret>
cli==0.4.35 · Oct 2026
· source
＋Type-safe v2 APIshippedIntroduces a version 2 API for graph execution methods that provides fully type-safe outputs, including discriminated union types for streaming parts and structured return objects.6 releases · first seen Aug 2024▸
release
Adds decrypt as a new replacement result type in the SDK
sdk==0.4.3 · Aug 2026
· source
· release history
Adds decrypt replacement result support to the Python SDK.
sdk==0.4.3 · Aug 2026
· source
· release history
Adds output, values, and controller extraction from stream lifecycle state.
sdk==0.4.0 · May 2026
· source
· release history
Adds version="v2" opt-in to invoke(), ainvoke(), stream(), and astream() for fully type-safe outputs.
1.1.0 · Mar 2026
· source
· release history
Adds type-safe stream/invoke calls with proper output type coercion, enabling strongly-typed responses from graph runs
sdk==0.3.10 · Mar 2026
· source
· release history
Introduces ChannelVersions type alias (dict[str, Union[str, int, float]]) for type-safe channel version handling.
checkpoint==1.0.1 · Aug 2024
· source
· release history
＋Store TTL & cache managementshippedManages data expiration and refresh by supporting session tokens, read-through TTL sliding, global default TTL, and background sweeping.1 release · 5 other sources · first seen Mar 2025▸
release
Adds expires_at and ttl_minutes columns plus an index on expires_at to the store table via new database migrations.
checkpointpostgres==2.0.17 · Mar 2025
· source
· release history
example
Enable background TTL sweeping so expired store entries are deleted automatically every N minutes without manual intervention.$ from langgraph.store.base import TTLConfig ttl_config = TTLConfig( sweep_interval_minutes=30 )
checkpoint==2.0.20 · Mar 2025
· source
Automatically expire agent memory store entries after 60 minutes, with a background sweeper running every 30 seconds.$ 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}, )…
checkpointpostgres==2.0.17 · Mar 2025
· source
Set a store-wide default TTL and enable automatic TTL refresh on reads so cached items stay alive while actively used.$ 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…
checkpoint==2.0.19 · Mar 2025
· source
Store a short-lived session token that auto-expires after 30 minutes, so stale credentials are never returned.$ await client.store.put_item(namespace, key="session:user123", value={"token": "abc"}, ttl=30)
sdk==0.1.55 · Mar 2025
· source
Retrieve a cached item and slide its expiration window forward so active users stay authenticated without a re-login.$ item = await client.store.get_item(namespace, key="session:user123", refresh_ttl=True)
sdk==0.1.55 · Mar 2025
· source
＋Managed value context integrationshippedIntegrates `Context` into the managed value system and adds methods for handling runtime placeholders during serialization.4 releases · 2 other sources · first seen Aug 2024▸
release
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.
0.2.13 · Aug 2024
· source
· release history
Adds replace_runtime_values and replace_runtime_placeholders methods to ManagedValueMapping for safe handling of runtime placeholders during graph serialization.
0.2.13 · Aug 2024
· source
· release history
New utility functions is_readonly_managed_value and is_writable_managed_value allow runtime inspection of managed value types.
0.2.7 · Aug 2024
· source
· release history
New WritableManagedValue abstract class extends the managed values system with update() and aupdate() methods for sync/async mutations.
0.2.7 · Aug 2024
· source
· release history
example
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.$ 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…
0.3.6 · Mar 2025
· source
Declare a runtime-only managed value to inject a context manager into your graph without it being serialized to checkpoints.$ from langgraph.managed.base import ManagedValue class MyRuntimeValue(ManagedValue, runtime=True): ...
0.2.13 · Aug 2024
· source
＋Agent and environment targeting in CLIshippedUpdates the deployment CLI to accept agent_id and environment arguments for precise targeting of specific agents and environments during deployment or configuration.4 releases · 1 other source · first seen Sep 2026▸
Also counts toward: Agent-based deployment, Command-line interface
release
Updates langgraph deploy to use agent_id and environment arguments for deployment targeting
cli==0.4.32 · Sep 2026
· source
· release history
Clarifies agent flags and adds support for environment variable defaults in CLI agent configuration.
cli==0.4.32 · Sep 2026
· source
· release history
Clarifies agent flags and supports environment variable defaults in CLI commands
cli==0.4.32 · Sep 2026
· source
· release history
Updates langgraph deploy to accept agent_id and environment arguments for targeting specific agents and environments.
cli==0.4.32 · Sep 2026
· source
· release history
example
Target a specific agent and environment when running the deployment command.$ langgraph deploy --agent-id my-agent-uuid --environment production
cli==0.4.32 · Sep 2026
· source
＋Config JSON Schema generationshippedProvides methods and files for generating and referencing JSON schemas for configuration validation and IDE autocompletion.5 releases · first seen Aug 2024▸
release
Adds JSON schema files (schema.json and schema.v0.json) referenceable in langgraph.json to enable IDE autocompletion and validation of LangGraph configuration.
cli==0.1.75 · Mar 2025
· source
· release history
Adds get_config_jsonschema method to Pregel for converting config schemas to JSON Schema format, consistent with existing get_input_jsonschema/get_output_jsonschema.
0.3.4 · Mar 2025
· source
· release history
Adds config_schema method to Pregel for proper configuration schema generation when the config type is a TypedDict, dataclass, or Pydantic model.
0.3.4 · Mar 2025
· source
· release history
Enriches Pregel.config_specs output with default values and descriptions for configuration fields via get_enhanced_type_hints.
0.2.58 · Dec 2024
· source
· release history
Makes GraphSchema fields (input_schema, state_schema, config_schema) optional for better TypeScript interoperability.
sdk==0.1.27 · Aug 2024
· source
· release history
＋Clear return with rich checkpoint persistenceshippedEnables returning a clean response to the caller while persisting richer state to the checkpoint, decoupling saved context from user output.4 releases · 1 other source · first seen Jul 2024▸
release
Adds entrypoint.final primitive to return a value to the caller that differs from the value saved in the checkpoint.
0.2.67 · Jan 2025
· source
· release history
Adds parents field to CheckpointMetadata, mapping checkpoint namespace to checkpoint ID for relationship tracking between checkpoints.
checkpoint==1.0.7 · Aug 2024
· source
· release history
Adds pending-send tracking in InMemorySaver: get_tuple now includes pending_sends from parent checkpoints, and list gains improved namespace filtering.
checkpoint==1.0.7 · Aug 2024
· source
· release history
Enhances checkpoint parent-child relationship tracking and includes parent configuration data in checkpoint tuples, improving support for nested graphs.
0.1.10 · Jul 2024
· source
· release history
example
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.$ 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;…
0.2.67 · Jan 2025
· source
＋Multimodal tool response supportshippedEnhances `ToolNode` to preserve multimodal content blocks (images, JSON) in tool responses instead of converting them to strings.3 releases · 2 other sources · first seen Sep 2024▸
release
Adds format="langchain-openai" parameter to add_messages to automatically convert message content (strings, text blocks, image_url blocks) to OpenAI-compatible format.
0.2.61 · Jan 2025
· source
· release history
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.
0.2.60 · Dec 2024
· source
· release history
Enhances ToolNode to handle multimodal content in tool responses, preserving image, image_url, text, and json content blocks instead of converting everything to strings.
0.2.25 · Sep 2024
· source
· release history
example
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.$ from langgraph.graph.message import add_messages from typing import Annotated from typing_extensions import TypedDict class State(TypedDict): messages: Annotated[list,…
0.2.61 · Jan 2025
· source
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.$ 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={…
0.2.60 · Dec 2024
· source
＋Deployment priority configurationshippedAllows configuring thread and deployment priority settings via a `priority` section in `langgraph.json` and a `Priority` class in the Python SDK.4 releases · first seen Oct 2026▸
release
Remove fairness_weight from PrioritySettings to simplify run priority configuration.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
sdk==0.4.12 · Nov 2026
· source
· release history
The fairness_weight field has been removed from PrioritySettings; any code that sets this field will break on upgrade.
sdk==0.4.12 · Nov 2026
· source
· release history
Adds a priority section to langgraph.json to configure deployment priority settings.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
cli==0.4.38 · Oct 2026
· source
· release history
Adds Priority class to the Python SDK for configuring thread priority settings.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
sdk==0.4.9 · Oct 2026
· source
· release history
＋Graph lifecycle hooksshippedProvides callback handlers to intercept and execute logic at key stages of the graph execution lifecycle.4 releases · first seen Oct 2024▸
release
Adds graph lifecycle callback handlers, enabling hooks into key stages of graph execution.
1.1.7a1 · Apr 2026
· source
· release history
Hook can return messages to update agent state or llm_input_messages to reshape only what the LLM sees, leaving persisted state untouched.
prebuilt==0.1.8 · Apr 2025
· source
· release history
Implements a hierarchical handler system supporting global fallback handlers alongside specific per-action handlers.
sdk==0.1.45 · Dec 2024
· source
· release history
Adds node_finished callback parameter to PregelRunner via CONFIG_KEY_NODE_FINISHED for node-completion hooks.
0.2.40 · Oct 2024
· source
· release history
＋Thread TTL managementshippedAdds strategies for pruning thread history, including a keep_latest option to control retention when time-to-live cleanup runs.2 releases · 2 other sources · first seen Mar 2025▸
Also counts toward: Scheduled jobs
release
Adds keep_latest prune strategy to ThreadTTLConfig, giving finer control over which threads are retained when TTL cleanup runs.
cli==0.4.14 · Mar 2026
· source
· release history
Adds ThreadTTLConfig class to set default TTL (in minutes), sweep interval, and expiry strategy (delete) for automatic cleanup of thread checkpoints.
cli==0.1.83 · Apr 2025
· source
· release history
example
Configure automatic deletion of stale thread checkpoints after a set period to keep storage lean in long-running deployments.$ from langgraph_cli.config import CheckpointerConfig, ThreadTTLConfig checkpointer = CheckpointerConfig( ttl=ThreadTTLConfig( default_minutes=1440, # delete thread data older than 24 hours…
cli==0.1.83 · Apr 2025
· source
Enable automatic TTL sweeping every 10 minutes so expired store entries are cleaned up without manual intervention.$ ttl_config = TTLConfig( sweep_interval_minutes=10 )
cli==0.1.77 · Mar 2025
· source
＋Pre-model hooksshippedAllows injecting custom nodes before every LLM call in agent creation for preprocessing message history.2 releases · 2 other sources · first seen Apr 2025▸
release
The TAG_NOSTREAM_ALT constant is removed from langgraph.constants; use NOSTREAM instead.
0.6.0 · Jul 2025
· source
· release history
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.
prebuilt==0.1.8 · Apr 2025
· source
· release history
example
Summarize earlier conversation turns and replace them with a summary message before each LLM call, without mutating the stored state.$ 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] +…
prebuilt==0.1.8 · Apr 2025
· source
Trim a long conversation to the last N messages before each LLM call to avoid exceeding the model's context window.$ 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,…
prebuilt==0.1.8 · Apr 2025
· source
＋Task labeling & graph visualizationshippedAssigns human-readable names to tasks and annotates routing edges to improve graph rendering and developer debugging.1 release · 3 other sources · first seen Jan 2025▸
release
Adds add_edge utility in graph visualization to prevent duplicate edges when rendering graphs with END nodes.
0.4.0 · Apr 2025
· source
· release history
example
Visualize a compiled graph including subgraphs and conditional edges using the new dedicated draw_graph function.$ from langgraph.pregel.draw import draw_graph draw_graph(compiled_graph)
0.3.32 · Apr 2025
· source
Annotate routing possibilities in a Command-driven edgeless graph so rendered visualizations show labeled edges between nodes.$ graph.add_node("router", router_fn, destinations={"process": "to_process", "fallback": "to_fallback"})
0.2.71 · Feb 2025
· source
Assign a human-readable display name to a task that wraps a lambda or method where the default __name__ would be unhelpful.$ 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()
0.2.68 · Jan 2025
· source
＋Tool configuration injectionshippedPasses the runtime configuration object to tools during invocation, enabling access to dynamic context.3 releases · 1 other source · first seen Jul 2024▸
release
Adds func_accepts_config parameter on RunnableCallable to explicitly control whether a wrapped function receives the LangChain config argument.
0.3.19 · Mar 2025
· source
· release history
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.59 · Dec 2024
· source
· release history
Enhances chat_agent_executor with route_tool_responses to support tools configured with return_direct, bypassing the agent on return.
0.2.23 · Sep 2024
· source
· release history
example
Disable automatic tool-error suppression in a ToolNode so exceptions propagate directly — useful when you want strict failure semantics in CI or testing.$ from langgraph.prebuilt import ToolNode tool_node = ToolNode(tools=[my_tool], handle_tool_errors=False)
0.1.6 · Jul 2024
· source
＋LangGraph Studio URL configurationshippedEnables connecting to a custom LangGraph Studio instance via command line option.2 releases · 2 other sources · first seen Aug 2024▸
Also counts toward: Command-line interface
release
Adds --studio_url option to the dev command, enabling connection to a custom LangGraph Studio instance instead of the default https://smith.langchain.com.
cli==0.1.78 · Mar 2025
· source
· release history
Makes the url parameter optional in get_client, with intelligent defaults so local dev requires no explicit URL.
sdk==0.1.27 · Aug 2024
· source
· release history
example
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
cli==0.1.78 · Mar 2025
· source
Connect to a local LangGraph server without specifying a URL — useful in dev environments where defaults are sufficient.$ from langgraph_sdk import get_client client = get_client() # url is now optional
sdk==0.1.27 · Aug 2024
· source
＋Wildcard interruption targetsshippedSupports using a wildcard symbol in interrupt parameters to target all nodes in a graph simultaneously.4 releases · first seen Aug 2024▸
release
Enhances multiple concurrent interrupt handling by collecting and combining them into a single interrupt for cleaner propagation.
0.3.13 · Mar 2025
· source
· release history
Supports passing "*" to interrupt_before/interrupt_after parameters in RunsClient and CronClient to interrupt all nodes without listing them individually.
sdk==0.1.33 · Oct 2024
· source
· release history
Adds error: Optional[str] and interrupts: list[dict] fields to TaskResultPayload for capturing task-level errors and interrupts in debug output.
0.2.10 · Aug 2024
· source
· release history
should_interrupt now returns the list of executable tasks to be interrupted instead of a boolean, enabling precise per-task interrupt control.
0.2.6 · Aug 2024
· source
· release history
＋Execution loop control & safety limitsshippedProvides managed values and guards to track remaining steps and safely abort agent loops before hitting recursion limits.2 releases · 2 other sources · first seen Oct 2024▸
release
Configures graph recursion limit via the LANGGRAPH_DEFAULT_RECURSION_LIMIT environment variable (default: 25), removing the need for per-run config.
0.3.10 · Mar 2025
· source
· release history
Adds RemainingSteps managed value to expose the number of remaining steps during loop execution, usable alongside IsLastStep for precise loop control.
0.2.37 · Oct 2024
· source
· release history
example
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
0.3.10 · Mar 2025
· source
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.$ 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…
0.2.37 · Oct 2024
· source
＋Configurable checkpoint metadata enrichmentshippedAutomatically combines configurable properties, existing metadata, and explicitly passed metadata into saved checkpoints across various saver implementations.4 releases · first seen Nov 2024▸
release
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.
checkpointsqlite==2.0.4 · Feb 2025
· source
· release history
Enriches InMemorySaver.put checkpoint metadata with non-private config["configurable"] entries (keys not prefixed with __) and any existing config["metadata"] values
checkpoint==2.0.13 · Feb 2025
· source
· release history
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.
checkpointpostgres==2.0.14 · Feb 2025
· source
· release history
Extends CheckpointMetadata.source to accept "fork" as a valid value, identifying checkpoints created as copies of other checkpoints.
checkpoint==2.0.6 · Nov 2024
· source
· release history
＋Structured output configurationshippedSupports custom prompts and various schema formats to enforce typed agent outputs.2 releases · 2 other sources · first seen Jan 2025▸
release
Accepts a (prompt, schema) tuple for response_format to supply a custom prompt when generating structured output.
0.2.62 · Jan 2025
· source
· release history
Supports OpenAI function/tool schemas, JSON Schema, TypedDict classes, and Pydantic models as the response schema.
0.2.62 · Jan 2025
· source
· release history
example
Supply a custom extraction prompt alongside the schema when the default structured-output prompt doesn't fit your domain.$ 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=[...],…
0.2.62 · Jan 2025
· source
Enforce a typed output schema on a ReAct agent so downstream code can rely on structured data instead of free-form text.$ from pydantic import BaseModel from langgraph.prebuilt import create_react_agent class AgentAnswer(BaseModel): answer: str confidence: float agent = create_react_agent( model, tools=[...],…
0.2.62 · Jan 2025
· source
＋Project scaffolding templatesshippedProvides interactive commands and project templates for rapidly creating new LangGraph applications.2 releases · 2 other sources · first seen Nov 2024▸
Also counts toward: Command-line interface, JavaScript scripting support
release
Adds new command to scaffold LangGraph projects interactively from five built-in templates (minimal chatbot, ReAct Agent, Memory Agent, Retrieval Agent, Data-enrichment Agent).
cli==0.1.54 · Nov 2024
· source
· release history
Adds a JavaScript/TypeScript project template for scaffolding LangGraph.js applications, including TypeScript config, ESLint, Jest, and sample StateAnnotation-based graph.
cli==0.1.53 · Nov 2024
· source
· release history
example
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.$ env: OPENAI_API_KEY: "sk-..." MY_CUSTOM_VAR: "value"
cli==0.1.58 · Nov 2024
· source
Bootstrap a new ReAct-style agent project without writing boilerplate — pick a template interactively and start coding immediately.$ langgraph new my-agent-project
cli==0.1.54 · Nov 2024
· source
＋Deployment listener managementshippedUsers can list the event listeners attached to a LangGraph deployment to audit or debug event subscriptions.2 releases · 1 other source · first seen Sep 2026▸
Also counts toward: Command-line interface, JSON data export
release
Adds --json flag to the deploy listeners list command for machine-readable JSON output.︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
cli==0.4.34 · Oct 2026
· source
· release history
Adds listener placement support for self-hosted deployments via the CLI.
cli==0.4.32 · Sep 2026
· source
· release history
example
List all deploy listeners attached to a LangGraph deployment to audit or debug event subscriptions.$ langgraph deploy listeners list
cli==0.4.33 · Oct 2026
· source
＋Mid-run attachment and tailingshippedAllows attaching to in-progress runs mid-flight to tail output in real time.1 release · 2 other sources · first seen Aug 2024▸
release
Adds join_stream() method to attach to an already-running run and receive its real-time output without buffering prior output.
sdk==0.1.29 · Aug 2024
· source
· release history
example
Tail logs from a running LangGraph deployment to debug production agent behavior.$ langgraph deploy logs <deployment-id>
cli==0.4.16 · Mar 2026
· source
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.$ async for chunk in client.runs.join_stream(thread_id, run_id): print(chunk)
sdk==0.1.29 · Aug 2024
· source
＋CLI checkpointer configurationshippedAllows passing checkpointer configuration settings directly through the CLI during deployment or invocation.2 releases · 1 other source · first seen Aug 2024▸
Also counts toward: Command-line interface
release
Passes checkpointer config through to the CLI, enabling checkpointer settings to be applied via CLI invocation.
cli==0.4.14 · Mar 2026
· source
· release history
Supports passing checkpointer configuration to Docker environments via the LANGGRAPH_CHECKPOINTER environment variable automatically.
cli==0.1.83 · Apr 2025
· source
· release history
example
Run versioned schema migrations on an existing PostgreSQL checkpoint database so it stays in sync after upgrading.$ 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…
checkpointpostgres==1.0.1 · Aug 2024
· source
＋Cron job configurationshippedProvides parameters for configuring stream modes, subgraphs, resumability, and durability when creating scheduled graph runs via the SDK.3 releases · first seen Mar 2025▸
Also counts toward: Scheduled jobs, Client SDKs
release
Adds stream_mode, stream_subgraphs, stream_resumable, and durability parameters to cron job creation in the Python SDK.
sdk==0.3.8 · Feb 2026
· source
· release history
Adds update method to the crons client for modifying existing cron jobs.
sdk==0.3.4 · Feb 2026
· source
· release history
Adds optional headers parameter to all cron job methods on CronClient and SyncCronClient (create, search, delete).
sdk==0.1.59 · Mar 2025
· source
· release history
＋Assistant search paginationshippedReturns paginated results when searching for assistants, improving handling of large result sets.2 releases · 1 other source · first seen Apr 2025▸
release
Includes pagination in assistants search responses.
prebuilt==1.0.6 · Jan 2026
· source
· release history
Adds pagination metadata to the assistants search response, enabling clients to page through large assistant lists.
sdk==0.2.12 · Dec 2025
· source
· release history
example
Retrieve the most recently updated assistants first — useful for auditing or surfacing active agents in a large deployment.$ results = await client.assistants.search(sort_by="updated_at", sort_order="desc")
sdk==0.1.65 · Apr 2025
· source
＋Mixed language project supportshippedSupports mixed Python and Node.js projects in a single configuration with automatic runtime version detection.3 releases · first seen Apr 2025▸
Also counts toward: Command-line interface, JavaScript scripting support, Python scripting support, Scripting language support
release
Adds monorepo support in the LangGraph CLI, enabling multi-package project structures to be managed from a single repository.
0.6.7 · Sep 2025
· source
· release history
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.
cli==0.2.2 · Apr 2025
· source
· release history
Automatically detects Python and JavaScript graphs by file extension, eliminating manual language configuration.
cli==0.2.2 · Apr 2025
· source
· release history
＋Keyword-only query parametersshippedUpdates search methods to use keyword-only query parameters, improving API clarity and type safety.3 releases · first seen Apr 2025▸
release
The query parameter in PostgresStore.search is now a named (keyword) parameter; callers passing it positionally will break.
checkpointpostgres==2.0.20 · Apr 2025
· source
· release history
The query parameter in AsyncPostgresStore.asearch is now a named (keyword) parameter; callers passing it positionally will break.
checkpointpostgres==2.0.20 · Apr 2025
· source
· release history
Updates search on PostgresStore and asearch on AsyncPostgresStore to require query as an explicit keyword argument rather than a positional parameter.
checkpointpostgres==2.0.20 · Apr 2025
· source
· release history
＋Message deletion supportshippedEnables the deletion of specific messages by ID from message graphs using `RemoveMessage`.2 releases · 1 other source · first seen Jul 2024▸
release
Adds REMOVE_ALL_MESSAGES constant to wipe an entire MessageGraph conversation history in a single RemoveMessage call.
0.3.23 · Apr 2025
· source
· release history
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.
0.1.6 · Jul 2024
· source
· release history
example
Prune a specific message from a running message graph by its ID — handy for trimming context or removing a malformed turn mid-conversation.$ 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":…
0.1.6 · Jul 2024
· source
＋Package manager detection helpershippedProvides a helper function to detect the correct package manager from package.json even without lock files.3 releases · first seen Nov 2024▸
release
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.
cli==0.1.80 · Mar 2025
· source
· release history
Supports Bun as a detected package manager: detects bun.lockb and runs bun i automatically for Bun-based projects.
cli==0.1.68 · Jan 2025
· source
· release history
Adds automatic Node.js package manager detection (npm, yarn, pnpm) based on lock files, selecting the correct install and build commands automatically.
cli==0.1.53 · Nov 2024
· source
· release history
＋PregelRunner async context detectionshippedRemoves restriction on coroutine-only calls in PregelRunner and adds context detection to return appropriate future types.2 releases · 1 other source · first seen Jan 2025▸
release
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.66 · Jan 2025
· source
· release history
Adds CONTEXT_NOT_SUPPORTED flag in langgraph.utils.future to handle Python versions whose event loops do not support contextvars.
0.2.66 · Jan 2025
· source
· release history
example
Safely submit a coroutine to a running event loop from a background thread — useful when mixing sync worker threads with an async LangGraph executor.$ 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)
0.2.66 · Jan 2025
· source
＋Automatic state injection into toolsshippedInjects graph state directly into tool arguments via `InjectedState` without requiring the LLM to generate it.2 releases · 1 other source · first seen Jul 2024▸
release
Adds messages_key parameter to ToolNode and tools_condition for flexible integration with non-standard state schemas.
0.2.40 · Oct 2024
· source
· release history
Adds InjectedState annotation to automatically inject graph state into tool arguments inside ToolNode, so tools can access state fields without the model generating them.
0.1.10 · Jul 2024
· source
· release history
example
Use a different state key for messages when your graph stores messages under a non-default key (e.g., chat_history).$ tool_node = ToolNode(tools, messages_key="chat_history") condition = tools_condition(messages_key="chat_history")
0.2.40 · Oct 2024
· source
＋Cross-thread memory sharingshippedEnables agents to retain and share information across separate conversation threads during execution.2 releases · first seen Oct 2024▸
release
Use browser_handoff to pause an agent at a login page and let the user sign in interactively in LangSmith Studio, with credentials persisted for later threads when using scope='user'.
announced · Oct 2026
· source
· release history
Adds cross-thread memory support in agent executors, enabling agents to retain information across separate conversation threads.
0.2.35 · Oct 2024
· source
· release history
＋Managed browser automation for agentsshippedsuggestedAutomatically equips agents with browser tools (snapshot, run, screenshot, handoff) and runs the browser in an isolated sandbox with a private localhost bridge, enabling end-to-end web automation and testing without a public URL.2 releases · first seen Oct 2026▸
Suggested capability: Model tool calling. This is our guess, not confirmed.
Also counts toward: JavaScript scripting support
release
Managed Deep Agents now runs the browser in a separate LangSmith sandbox with a private localhost bridge to the agent's sandbox, enabling end-to-end testing of apps at localhost ports without a public URL.
announced · Oct 2026
· source
· release history
Managed Deep Agents now adds four browser tools to agents automatically: browser_snapshot reads the page accessibility tree, browser_run executes batched actions or Playwright-style JavaScript via Stagehand, browser_screenshot captures the rendered page, and browser_handoff passes the browser to a human and…
announced · Oct 2026
· source
· release history
＋MCP server wiring helpershippedsuggestedProvides a helper function to easily wire MCP servers with connection credentials in managed deep agent applications.1 release · 1 other source · first seen Sep 2026▸
Suggested capability: Model tool calling. This is our guess, not confirmed.
release
Adds define_mcp helper in managed_deepagents to wire MCP servers with a connection credential, e.g. connections.get("linear-mcp", {"type": "user"}) passed as the connection field.
announced · Sep 2026
· source
· release history
example
Share one browser across all of a signed-in user's threads so the agent only asks for a login once and reuses the saved session in later conversations.$ # browser.py from managed_deepagents import define_browser browser = define_browser( scope="user", idle_ttl_seconds=1800, )
announced · Oct 2026
· source
＋Cron job metadata filteringshippedEnables filtering cron job searches by specific labels or properties in the metadata.1 release · 1 other source · first seen May 2026▸
release
Supports metadata filter parameter when searching and counting cron jobs via the SDK.
sdk==0.3.15 · May 2026
· source
· release history
example
Filter cron job searches by metadata to find only crons matching specific labels or properties.$ crons = await client.crons.search(metadata={"env": "production", "team": "infra"})
sdk==0.3.15 · May 2026
· source
＋Shared node configuration defaultsshippedAllows setting shared default configuration (such as models or retry policies) across all nodes in a graph via a single method, avoiding repetition on individual node definitions.1 release · 1 other source · first seen May 2026▸
release
Adds set_node_defaults() to StateGraph, letting you set shared default configuration across nodes.
1.2.0 · May 2026
· source
· release history
example
Apply shared defaults (e.g. a model or retry policy) to every node in a graph without repeating config on each .add_node() call.$ from langgraph.graph import StateGraph builder = StateGraph(MyState) builder.set_node_defaults(config={"model": "gpt-4o", "temperature": 0}) builder.add_node("extract", extract_node)…
1.2.0 · May 2026
· source
＋Minimal thread updatesshippedReduces response payload size for thread updates by allowing callers to request a reduced payload containing only essential state changes.1 release · 1 other source · first seen May 2026▸
release
Adds return_minimal parameter to the threads update API, allowing callers to request a reduced response payload.
sdk==0.3.14 · May 2026
· source
· release history
example
Reduce response payload size when updating a thread — useful in high-throughput pipelines where the full thread object is not needed.$ client.threads.update(thread_id, return_minimal=True)
sdk==0.3.14 · May 2026
· source
＋Deployment version managementshippedEnables listing deployment revisions to audit history or perform rollbacks.1 release · 1 other source · first seen Mar 2026▸
Also counts toward: Command-line interface
release
Adds deploy revisions list subcommand to list revisions of a LangGraph deployment.
cli==0.4.19 · Mar 2026
· source
· release history
example
List all revisions for a deployed LangGraph app to audit deployment history or roll back.$ langgraph deploy revisions list
cli==0.4.19 · Mar 2026
· source
＋Pydantic compatibility detectionshippedAdds utility functions to detect whether a given type is directly supported by Pydantic.2 releases · first seen Mar 2025▸
release
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.
0.6.0 · Jul 2025
· source
· release history
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.
0.3.4 · Mar 2025
· source
· release history
＋Blob storage for checkpointersshippedAdds dedicated blob storage to in-memory checkpointer for more efficient and lower-memory channel value management.2 releases · first seen Mar 2025▸
release
Adds pickle fallback for pandas objects in JsonPlusSerializer via serialize/deserialize path, so DataFrames and Series round-trip through checkpoints reliably.
checkpointpostgres==2.0.22 · Jul 2025
· source
· release history
Adds dedicated blob storage system to InMemorySaver for more efficient, lower-memory channel value management via a new blobs store and _load_blobs method.
checkpoint==2.0.22 · Mar 2025
· source
· release history
＋In-memory and file-based cachingshippedProvides cache implementations with namespace-scoped keys and clearing capabilities to speed up repeated operations without relying on external databases.2 releases · first seen May 2025▸
release
New InMemoryCache (moved into the sqlite package alongside FileCache) enables fast, non-persistent caching without a database.
checkpointsqlite==2.0.8 · May 2025
· source
· release history
Introduces a cache interface with InMemoryCache and FileCache (moved to sqlite package), including clear methods and namespace-scoped cache keys.
0.4.4 · May 2025
· source
· release history
＋Runtime version requirement enforcementshippedProvides centralized constants to enforce minimum Node.js and Python versions across the project environment.2 releases · first seen Nov 2024▸
release
Removes Python version upper bounds, allowing installation on future Python releases without constraint conflicts.
checkpoint==2.0.26 · May 2025
· source
· release history
Introduces MIN_NODE_VERSION and MIN_PYTHON_VERSION constants for centralized version requirement enforcement.
cli==0.1.56 · Nov 2024
· source
· release history
＋Static analysis support for channel writesshippedAllows declaring static channel write targets in the graph definition to improve static analysis capabilities.2 releases · first seen Apr 2025▸
release
Extends ChannelWrite.register_writer to accept static declarations for writers, with a new static field on ChannelWriteTupleEntry to declare writes for static analysis.
0.3.32 · Apr 2025
· source
· release history
Adds get_static_writes method to ChannelWrite to support static analysis of what a writer might write, enabling better resolution of conditional edges.
0.3.32 · Apr 2025
· source
· release history
＋Multiple retry policiesshippedSupports passing a sequence of retry policies to nodes and tasks, applying the first matching policy on exception.1 release · 1 other source · first seen Apr 2025▸
release
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.
0.3.28 · Apr 2025
· source
· release history
example
Apply ordered retry policies to a functional task so the first matching policy governs backoff and attempt count.$ 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…
0.3.28 · Apr 2025
· source
＋Loopback transport configurationshippedAllows dynamic setup and deferred initialization of local server loopback transports for testing and internal routing.2 releases · first seen Feb 2025▸
release
Adds configure_loopback_transports function and _registered_transports list for dynamic server transport configuration.
sdk==0.1.53 · Feb 2025
· source
· release history
Supports deferred loopback transport setup via the __LANGGRAPH_DEFER_LOOPBACK_TRANSPORT environment variable.
sdk==0.1.53 · Feb 2025
· source
· release history
＋Store authorization controlsshippedRestricts access to storage operations through decorator-based authorization handlers that enforce per-user or per-request data policies.2 releases · first seen Jan 2025▸
release
Adds @auth.on.store decorator to authorize access to storage operations, enabling per-user data access control.
sdk==0.1.53 · Feb 2025
· source
· release history
Adds auth.on.store decorators to authorize store operations (put, get, search, list_namespaces, delete) at the handler level.
sdk==0.1.50 · Jan 2025
· source
· release history
＋Embedding model provider initializationshippedAllows initializing embedding models via provider strings in index configuration, eliminating the need for manual instantiation.1 release · 1 other source · first seen Feb 2025▸
release
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.
checkpoint==2.0.12 · Feb 2025
· source
· release history
example
Configure a vector store index with an embedding model using a provider string instead of a manually constructed embeddings instance.$ from langgraph.store.base import IndexConfig index_config = IndexConfig( embed="openai:text-embedding-3-small", dims=1536, )
checkpoint==2.0.12 · Feb 2025
· source
＋Standardized error generationshippedOffers a helper function to produce consistent error messages with embedded troubleshooting documentation links.2 releases · first seen Oct 2024▸
release
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.
cli==0.1.68 · Jan 2025
· source
· release history
New create_error_message helper in langgraph.errors generates consistent error messages with links to troubleshooting documentation.
0.2.39 · Oct 2024
· source
· release history
＋Thread auto-creation policiesshippedAllows specifying behavior for missing threads (auto-create or reject) during stream, create, or wait operations instead of always raising an error.2 releases · first seen Jul 2024▸
release
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.
sdk==0.1.34 · Oct 2024
· source
· release history
New RunCreate TypedDict enables structured background run creation with fields for thread_id, assistant_id, input, metadata, and run configuration options.
sdk==0.1.26 · Jul 2024
· source
· release history
＋Thread creation conflict handlingshippedControls behavior when creating a thread that already exists via the `if_exists` parameter and `OnConflictBehavior` type.2 releases · first seen Jul 2024▸
release
Adds a SCHEDULED special channel constant (value -2) in WRITES_IDX_MAP on BaseCheckpointSaver to track scheduled task status in the checkpoint system.
checkpoint==1.0.10 · Sep 2024
· source
· release history
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.
sdk==0.1.26 · Jul 2024
· source
· release history
＋Managed service environment configurationshippedAutomates environment variable injection and health-gated dependency configuration for managed deployment services.2 releases · first seen Aug 2024▸
release
Injects REDIS_URI environment variable (redis://langgraph-redis:6379) automatically into the langgraph-api service.
cli==0.1.51 · Aug 2024
· source
· release history
Adds Redis 6 as a managed Docker Compose service with health-check gating, so langgraph-api only starts after Redis is healthy.
cli==0.1.51 · Aug 2024
· source
· release history
＋Browser session scopingshippedControls whether each conversation thread gets its own isolated browser session or shares a single persistent browser (with cookies and login state) across all of a signed-in user's threads.1 release · first seen Oct 2026▸
release
Control browser session sharing with scope='thread' (default, each conversation gets its own isolated browser) or scope='user' (one browser shared across a signed-in user's threads, with cookies and login state persisted).
announced · Oct 2026
· source
· release history
＋Postgres and SQLite store namespace isolation fixshippedFixes a security vulnerability where namespace labels containing a period could incorrectly reach other namespaces in Postgres and SQLite stores.1 release · first seen Oct 2026▸
release
CVE-2026-115883: Namespace labels containing . reach other namespaces in Postgres and SQLite stores (affects < 3.1.3)︀︄︇︀︅︉︀︅︀︀︃︀︀︅︅︀︅︊︀︄︆︀︃︄
CVE-2026-115883 · Oct 2026
· source
· release history
＋Cron job end time clearingshippedSupports clearing a cron job's end_time by passing None during an update operation, effectively making the schedule indefinite.1 release · first seen Aug 2026▸
release
Supports clearing a cron job's end_time by calling update(end_time=None) on the cron client.
sdk==0.4.3 · Aug 2026
· source
· release history
＋Scoped subgraph handlesshippedProvides async and sync handles for targeting and streaming specific subgraph execution within a larger graph.1 release · first seen May 2026▸
release
Adds scoped subgraph handles (async and sync) for targeting and streaming specific subgraph execution.
sdk==0.4.0 · May 2026
· source
· release history
＋Studio deployment supportshippedAdds a dedicated command to deploy LangGraph applications directly to LangGraph Studio from the CLI.1 release · first seen May 2026▸
Also counts toward: Command-line interface
release
Adds studio deploy command to the LangGraph CLI, enabling direct deployment to LangGraph Studio.
cli==0.4.25 · May 2026
· source
· release history
＋Checkpoint workflow timersshippedProvides alpha-level timer support to schedule and trigger stateful workflows based on checkpoint data.1 release · first seen Apr 2026▸
release
Adds alpha timer support for checkpoint-based workflows.
checkpoint==4.1.0a1 · Apr 2026
· source
· release history
＋Strict MessagePack deserializationshippedSupports enforcing strict security settings for MessagePack deserialization via environment variables to prevent unsafe deserialization attacks.1 release · first seen Apr 2026▸
release
Documents LANGGRAPH_STRICT_MSGPACK environment variable to control strict MessagePack deserialization security for checkpoints.
checkpoint==4.0.2 · Apr 2026
· source
· release history
＋Dictionary-format graph definitionsshippedSupports defining graphs in configuration files using dictionaries with paths and metadata, alongside standard import-path strings.1 release · first seen Apr 2025▸
release
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.
cli==0.1.89 · Apr 2025
· source
· release history
＋Custom JSON serialization hooksshippedEnables customization of JSONPlusSerializer initialization and MessagePack-to-JSON translation via hooks.1 release · first seen Mar 2025▸
release
Adds customizable JsonPlusSerializer.__init__ accepting an optional custom unpacking hook, plus _msgpack_ext_hook_to_json for better MessagePack-to-JSON type translation.
checkpoint==2.0.22 · Mar 2025
· source
· release history
＋Dependency-aware node schedulingshippedOptimizes graph execution by scheduling only nodes whose trigger channels were updated in the previous step.1 release · first seen Mar 2025▸
release
Adds dependency-aware node scheduling: only nodes whose trigger channels were updated in the previous step are evaluated, reducing unnecessary work in large graphs.
0.3.19 · Mar 2025
· source
· release history
＋Thread creation with initial state updatesshippedAllows applying a sequence of state updates immediately during thread creation, facilitating thread copying and initialization.1 release · first seen Mar 2025▸
release
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.
sdk==0.1.58 · Mar 2025
· source
· release history
＋Custom FastAPI/Starlette app mountingshippedEnables mounting a custom FastAPI or Starlette application with middleware, such as authentication, to the graph server.1 other source · first seen Feb 2025▸
example
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.$ http: app: ./my_middleware_app.py:app cors: allow_origins: - "https://my-frontend.example.com" allow_methods: - "GET" - "POST" disable_routes: - assistants - store
cli==0.1.72 · Feb 2025
· source
＋Checkpoint metadata extraction utilitiesshippedOffers functions to extract and process checkpoint metadata from runnable configurations with consistent handling of keys and types.1 release · first seen Feb 2025▸
release
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.
checkpoint==2.0.15 · Feb 2025
· source
· release history
＋Unified SyncAsyncFuture typeshippedIntroduces a unified type for task return values that implements both Future and awaitable protocols.1 release · first seen Jan 2025▸
release
Introduces unified SyncAsyncFuture type in langgraph.pregel.call that implements both the Future interface and the awaitable protocol for task return values.
0.2.68 · Jan 2025
· source
· release history
＋RunnableCallable argument unpackingshippedAdds parameter to explode tuple arguments in RunnableCallable for flexible invocation.1 release · first seen Jan 2025▸
release
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.
0.2.66 · Jan 2025
· source
· release history
＋Batch execution supportshippedAllows submitting multiple graph runs in a single API call for efficient batch processing.1 release · first seen Jul 2024▸
release
New create_batch method on LangGraphClient submits multiple runs in a single API call for more efficient batch operations.
sdk==0.1.26 · Jul 2024
· source
· release history
Lines in monospace are the tool's own words: help text
parsed from its source, or an endpoint from its API document. Under
release, a line is our summary of a dated release. Under
docs, it is quoted from the tool's own documentation or
website. Each links back to the source it came from.
Command line
20 commands for LangGraph, each
with where it came from. This tool has no source analysis yet, so there
is no option reference and no captured run beside them.
View
Source
No command matches.
Release-note detail over time
See how much detail LangGraph puts in its release notes, quarter by quarter, and compare it with tracked tools in the same category. This history uses up to ten retained, reviewed notes per tool; sparse or blank older quarters may reflect that limit.
Where LangGraph turns up in what others publish: how-tos, attack reports that
name it, and incident write-ups. A row says why it is here and quotes where the
article names it; the link goes to the publisher.
You will use LangGraph to orchestrate several AI agents, powered by OpenAI’s state-of-the-art LLMs, to build a sales pipeline that takes raw prospect data and turns it into a fully updated CRM entry, with zero manual…
2 more quotes
LangGraph handles the connections between these agents, how each one runs, and how data flows between them.
Understanding LangGraph for Sales Automation LangGraph is a framework for building stateful multi-step AI applications on top of LangChain.
In our previous post, we explored the fundamental concepts of LangGraph by building a Visual Web Browser Agent that could navigate, see, scroll, and summarize web pages.
2 more quotes
What Agentic AI , AI Art Generation , Computer Vision , Generative AI , Generative Models , Hugging Face Transformers , Multimodal Models , Vision Language Models Welcome back to our LangGraph series!
This is the essence of self-correction and iterative behavior , and LangGraph is perfectly designed for it.
Frameworks like LangGraph provide it through checkpointers – persistence layers that store execution state.
2 more quotes
Key Points Check Point Research analyzed LangGraph , an open-source framework for stateful AI agents with over 50 million monthly downloads, and uncovered three vulnerabilities in its persistence layer.
Who’s at risk: teams self-hosting LangGraph with the SQLite or Redis checkpointer, where the application exposes get_state_history() with a user-controlled filter .
Add the badge to your README
Maintain this project? The badge links readers straight to this page, so they can
follow every release here.
Choose a badge style and copy the code →