langgraph

Xây dựng quy trình tác tử có trạng thái, bền vững với LangGraph. Sử dụng khi bạn cần luồng điều khiển tùy chỉnh dựa trên đồ thị, có sự can thiệp của con người, tính bền vững hoặc đa tác tử…

LangGraph is a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents. It provides durable execution, streaming, human-in-the-loop interactions, and time-travel debugging.

When to use

Use LangGraph when you need to:

Design custom agent workflows with explicit graph-based control flow
Add durable execution so agents survive failures and restarts
Implement human-in-the-loop with interrupts and approval steps
Build multi-agent systems with state shared across agents
Stream intermediate results from long-running agent tasks
Time-travel debug by replaying agent execution from any checkpoint

When NOT to use

For a simple tool-calling agent, use LangChain agents instead—less boilerplate for common patterns
For a batteries-included agent with planning and subagents, use Deep Agents instead
LangGraph is the orchestration layer—use it when you need fine-grained control over agent behavior

Install

# Python
pip install -U langgraph

# JavaScript/TypeScript
npm install @langchain/langgraph @langchain/core

Quick reference

Graph API (recommended for most use cases)

from langgraph.graph import StateGraph, MessagesState, START, END

def my_node(state: MessagesState):
    return {"messages": [{"role": "ai", "content": "hello world"}]}

graph = StateGraph(MessagesState)
graph.add_node(my_node)
graph.add_edge(START, "my_node")
graph.add_edge("my_node", END)
graph = graph.compile()

result = graph.invoke(
    {"messages": [{"role": "user", "content": "Hello!"}]}
)

Functional API (for simple pipelines)

from langgraph.func import entrypoint, task

@task
def step_one(input: str) -> str:
    return f"processed: {input}"

@entrypoint()
def pipeline(input: str) -> str:
    return step_one(input).result()

Add human-in-the-loop

from langgraph.types import interrupt

def human_approval(state: MessagesState):
    answer = interrupt({"question": "Approve this action?"})
    return {"messages": [{"role": "user", "content": answer}]}

Key concepts

Concept	Description
`StateGraph`	Define nodes and edges that form your agent's control flow
`MessagesState`	Built-in state schema for chat-based agents
`compile()`	Compile a graph builder into an executable graph
`interrupt()`	Pause execution and wait for human input
Checkpointer	Persist state for durable execution and time-travel
Graph API vs Functional API	Graph API for complex workflows; Functional API for linear pipelines

Key documentation

Overview—What LangGraph is and when to use it
Quickstart—Build your first graph
Persistence—Add memory and durable execution
Interrupts—Human-in-the-loop patterns
Streaming—Stream intermediate results
Graph API—Define nodes, edges, and state
Deploy—Deploy to production with LangSmith

API reference

For SDK class and method details, use the LangChain API Reference site:

Browse: https://reference.langchain.com/python/langgraph
MCP server: https://reference.langchain.com/mcp

Related skills

langchain—Core building blocks for models, tools, and simple agents
deep-agents—High-level agent harness built on LangGraph
langsmith—Trace, evaluate, and deploy your LangGraph agents