Skip to content
Skills Library
AI & agents · Building & coding

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.

Repository
docs ↗
Licence
MIT
Last repository change
27.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
12
Deprecation

No signals detected. Repository changed on 27.10.2026, without references to retired models or APIs.

Licence

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

  1. When to use
  2. When NOT to use
  3. Install
  4. Quick reference
  5. Key concepts
  6. Key documentation
  7. API reference
  8. Related skills
Original SKILL.md headings · 109 lines, 438 words
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

RepositoryScoreLicence
This page · langchain-ai/docs100MIT
yonatangross/orchestkit100MIT
yonatangross/orchestkit100MIT
magnus919/agent-skills100MIT
TerminalSkills/skills100Apache-2.0
davila7/claude-code-templates100MIT
Aadarsh-x54/deep-agents-with-langchain100MIT
bcastelino/agent-skills-kit100MIT
MARUCIE/openclaw-foundry100MIT

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…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.