Dive into LangGraph
An open e-book for Agent developers covering LangGraph 1.0 in 14 hands-on chapters — from ReAct agents to multi-agent systems and RAG — also installable as a Claude Code Skill that writes quality LangGraph code for you.
Permissions are restrained: CI workflows request only contents:read and pin GitHub Actions by SHA; the app conditionally registers search tools per provider (dashscope-only tools withheld from ark/ollama), verified by tests. Tutorials cover PII detection, sensitive-word filtering, and HITL, but as a distributed Skill no code evidence of pre-execution user confirmation was shown — deducted. External effects (web search via DashScope/Tavily/DDGS) are explicitly declared tutorial features. No rollback mechanism is described; only HITL indirectly touches it. Attribution is clear: official docs/links and CC BY-NC-SA.
Dependencies are declared in both pyproject/requirements and locked via uv sync --locked; CI runs lint, unit tests, and notebook smoke checks. Three test files cover tool registration, streaming responses, error rendering, and cancellation cleanup; errors are asynchronously summarized and rendered into history — well evidenced. The default package index is a third-party Tencent mirror, a potential availability single point for non-CN users — deducted.
Clear positioning from beginner to advanced LangGraph 1.0 users; 14 chapters span quickstart to RAG/multi-agent/deployment; bilingual README; near-full marks for scenario coverage. Capability boundaries of the Skill are declared but boundary details are not shown; environment requires Python >=3.13, a high bar — deducted.
Good information architecture: README chapter table, online reading, consistent file naming (1.quickstart.ipynb etc.). The LICENSE is full CC BY-NC-SA 4.0 text consistent with the README statement (NOASSERTION metadata is a registry recognition gap, not an evidence gap). Install notes are complete but no .env example or key-configuration guidance is shown. No known-limitations section — deducted; version 1.0.0 and News updates exist but no formal CHANGELOG; maintenance path shown via contribution guide and CI, single-maintainer commitment unclear.
As a tutorial + Skill + runnable Gradio app, marginal value is clear: promises pure v1.0 content, includes a tested practical app, and cost (one install) is proportionate. Output usability is supported by tests of streaming, tool-call formatting, and error summarization, but output is educational, not production-grade — deducted.
Claims are mostly traceable to concrete files: dependency lists, CI config, tests, LICENSE full text. The 'no v0.2 residue' promise depends on notebook contents not supplied here, so only partially credited — deducted. Cross-references to official docs/langgraph-101 provide corroboration paths; facts (files exist) kept separate from inference (teaching quality). Static review; low confidence.
- Distributed under CC BY-NC-SA 4.0 (non-commercial); obtain legal review before enterprise use.
- Once installed via npx skills add, the Skill injects prompt instructions into Claude Code; review SKILL.md before installing (file not supplied in this review).
- pyproject defaults to a third-party Tencent PyPI mirror; override with the official index outside mainland China.
- Requires Python >=3.13 — a high environment bar.
- No .env/key-configuration example is shown; running the app and web-search chapters requires paid DashScope/Tavily APIs configured by the user.
- No rollback or state-cleanup mechanism is described; do not use this tutorial-grade code in production directly.
What does this agent do, and when should you use it?
Dive into LangGraph is an open-source e-book project in the GitHub repository luochang212/dive-into-langgraph, targeting the stable LangGraph 1.0 released in mid-October 2025. The tutorial distills the core features of both LangGraph and LangChain into 14 Jupyter chapters, spanning StateGraph workflows, middleware, human-in-the-loop, memory, context engineering, MCP servers, supervisor patterns, parallelization, RAG, web search, Deep Agents, and a Gradio-based conversational app. Content is published online via GitHub Pages with CI and deploy-book workflows. Since March 2026, the project is also packaged as an Agent Skill installable into Claude Code via npx, enabling it to help write LangChain/LangGraph code directly. The work is licensed under CC BY-NC-SA 4.0, which prohibits commercial use.
The project has two parts. First, the tutorial itself: 14 ipynb chapters demonstrate concrete APIs — building your first ReAct agent, creating workflows with StateGraph, custom middleware for budget control/message truncation/sensitive-word filtering/PII detection, built-in HITL middleware, short- and long-term memory, context management via State/Store/Runtime, connecting an MCP Server, two supervisor approaches (tool-calling and langgraph-supervisor), concurrency via nodes/@task/Map-reduce/Sub-graphs, three RAG flavors (vector, keyword, hybrid), web search via DashScope/Tavily/DDGS, Deep Agents, a Gradio streaming chat app, and the langgraph dev debug UI. Second, an Agent Skill: SKILL.md under skills/dive-into-langgraph/ gives Claude Code domain knowledge for writing LangChain/LangGraph code. Runtime dependencies include langgraph, langchain[openai], langgraph-supervisor, langmem, fastmcp, and langgraph-checkpoint-sqlite/redis from requirements.txt.
- A Python developer new to LangGraph 1.0 who wants a systematic tutorial free of v0.2-era legacy patterns.
- An engineer implementing production guardrails — budget control, sensitive-word filtering, PII detection — using the custom middleware in Chapter 3.
- A developer adding short/long-term memory or context engineering, guided by Chapters 5–6 and langmem usage.
- A team building RAG (vector, keyword, or hybrid retrieval) or web search (DashScope, Tavily, DDGS).
- A Claude Code user who wants the Skill to generate LangGraph 1.0-compliant code instead of reading the whole book.
- A developer wanting a customizable streaming chat app to extend, based on the Chapter 13 Gradio + LangChain application.
What are this agent's strengths and limitations?
- Written entirely against the stable LangGraph v1.0; the author explicitly promises no v0.6 legacy residue, reducing rework risk.
- Fourteen chapters cover production concerns (middleware guardrails, HITL, memory, MCP, supervisor patterns, concurrency), not just toy examples.
- Dual form: readable as an e-book and installable as a Claude Code Skill that assists code writing.
- Backed by GitHub Actions CI and a deploy-book workflow, keeping content verified and auto-published to GitHub Pages.
- Chapter 13 ships a reusable, extensible Gradio application with source in /app.
- Licensed under CC BY-NC-SA 4.0, which forbids commercial use — a constraint for commercial adoption.
- Tightly coupled to the LangChain/LangGraph ecosystem; tutorial value requires ongoing maintenance as the frameworks evolve.
- Web search and model calls depend on external services (DashScope, Tavily, etc.), requiring your own API keys and incurring their costs.
- The Skill form is documented only for Claude Code; other coding assistants have no documented install path.
- The GitHub license field reads NOASSERTION; you must check the repository's CC license file for exact terms.
How do you install or deploy this agent?
- Clone: git clone https://github.com/luochang212/dive-into-langgraph. 2. Install Python dependencies: pip install -r requirements.txt (includes langgraph, langchain[openai], langgraph-supervisor, langmem, fastmcp, dashscope, tavily-python, etc.). 3. To install as a Claude Code Skill: npx skills add luochang212/dive-into-langgraph. Chapters involving web search or model calls need API keys for services such as DashScope and Tavily; the repo manages environment variables with python-dotenv.
How do you use this agent?
- Read: browse chapters 1.quickstart.ipynb through 14.langgraph_cli.ipynb in the repo, or read online at https://luochang212.github.io/dive-into-langgraph/. 2. Run locally: execute the notebooks in a Jupyter environment in order, starting with the Chapter 1 ReAct agent. 3. Debug: run langgraph dev to launch the langgraph-cli debug UI. 4. Hands-on: use the Gradio agent app in /app (Chapter 13) and extend it. 5. Skill mode: after installing the Skill in Claude Code, simply ask it to write LangChain/LangGraph code.
How does this agent compare with similar options?
The repository itself lists LangChain's official tutorials langgraph-101 and langchain-academy as further reading; the differentiators are that this project is an original Chinese-language tutorial organized into 14 topic chapters and additionally ships as a Claude Code Skill.