langgraph
/langgraph
Build stateful, durable agent workflows with LangGraph. Use when you need custom graph-based control flow, human-in-the-loop, persistence, or multi-agent orchestration.
- Author
- langchain-ai ↗
- Repository
- docs ↗
- Licence
- MIT
- Last repository change
- 27.10.2026
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 12
No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Build stateful, durable agent workflows with LangGraph. Use when you need custom graph-based control flow, human-in-the-loop, persistence, or multi-agent orchestration.
Original author description
Build stateful, durable agent workflows with LangGraph. Use when you need custom graph-based control flow, human-in-the-loop, persistence, or multi-agent orchestration.
How it works
- When to use
- When NOT to use
- Install
- Quick reference
- Key concepts
- Key documentation
- API reference
- Related skills
SKILL.md preview
---
name: langgraph
description: Build stateful, durable agent workflows with LangGraph. Use when you need custom graph-based control flow, human-in-the-loop, persistence, or multi-agent orchestration.
license: MIT
compatibility: Python 3.10+, Node.js 22+
metadata:
author: langchain-ai
version: "1.0"
---
# 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](https://docs.langchain.com/oss/langchain/overview) agents instead—less boilerplate for common patterns
- For a batteries-included agent with planning and subagents, use [Deep Agents](https://docs.langchain.com/oss/deepagents/overview) instead
- LangGraph is the **orchestration layer**—use it when you need fine-grained control over agent behavior
## Install
```bash
# Python
pip install -U langgraph
# JavaScript/TypeScript
npm install @langchain/langgraph @langchain/core
```
## Quick reference
### Graph API (recommended for most use cases)
```python
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)
```python
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
```python
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](https://docs.langchain.com/oss/langgraph/overview)—What LangGraph is and when to use it
- [Quickstart](https://docs.langchain.com/oss/langgraph/quickstart)—Build your first graph
- [Persistence](https://docs.langchain.com/oss/langgraph/persistence)—Add memory and durable execution
- [Interrupts](https://docs.langchain.com/oss/langgraph/interrupts)—Human-in-the-loop patterns
- [Streaming](https://docs.langchain.com/oss/langgraph/streaming)—Stream intermediate results
- [Graph API](https://docs.langchain.com/oss/langgraph/graph-api)—Define nodes, edges, and state
- [Deploy](https://docs.langchain.com/oss/langgraph/deploy)—Deploy to production with LangSmith
## API reference
For SDK class and method details, use the [LangChain API Reference](https://reference.langchain.com) 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
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · langchain-ai/docs | 100 | MIT |
| yonatangross/orchestkit | 100 | MIT |
| yonatangross/orchestkit | 100 | MIT |
| magnus919/agent-skills | 100 | MIT |
| TerminalSkills/skills | 100 | Apache-2.0 |
| davila7/claude-code-templates | 100 | MIT |
| Aadarsh-x54/deep-agents-with-langchain | 100 | MIT |
| bcastelino/agent-skills-kit | 100 | MIT |
| MARUCIE/openclaw-foundry | 100 | MIT |
Database snapshot: 13.11.2026 · package version ad6e975e22a1 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100langchain-and-langgraph-agent-orchestration
Guides building LLM applications with LangChain's chain/agent abstractions and, for stateful multi-step agents, LangGraph's graph-based orchestration (nodes, edges, cycles, checkpointed persistence, human-in-the-loop interrupts). Use when a user asks to "build this with… - 100building-langgraph-agents
LangGraph development for stateful multi-agent applications, cyclic workflows, conditional routing, human-in-the-loop patterns, and persistent state management. Use for complex AI orchestration, agent coordination, and production-grade agentic systems. - 100langgraph-stateful-agent-graphs
Use this skill when designing cyclic, stateful, and fault-tolerant multi-agent architectures with checkpoints using LangGraph. - 100langgraph-workflows
Build agent workflows with LangGraph 1.0 state machines and graph patterns. Use this skill when creating agent graphs, implementing state machines, building multi-step agent workflows, or using LangGraph. Activate when: LangGraph, agent graph, state graph, agent workflow, graph… - 100langgraph-patterns
Production-grade agentic workflows with LangGraph — graph orchestration, state machines, human-in-the-loop, and advanced control flow. Use when building or debugging a LangGraph app, modeling agent state, or adding checkpoints and human approval steps. - 100langchain-langgraph-human-in-loop
Build LangGraph 1.0 human-in-the-loop approval flows with interrupt_before\ \ /\ninterrupt_after and Command(resume=...) \u2014 JSON-serializable state,\ \ clean\nresume semantics, and UI wiring for approval decisions. Use when adding\ \ an\napproval gate before an expensive…