langgraph

por langchain-ai

Construye flujos de trabajo de agente duraderos y con estado con LangGraph. Úsalo cuando necesites control de flujo personalizado basado en grafos, intervención humana, persistencia o múltiples agentes…

npx skills add https://github.com/langchain-ai/docs --skill langgraph

Descargar ZIP GitHub

421

LangGraph

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