LangGraph v1.0 represents a major shift in how we build agentic applications, moving beyond simple chains to stateful, durable, and controllable graph-based workflows.
Below is a visual guide to the complete v1.0 ecosystem, followed by a detailed breakdown of every module.
🗺️ The LangGraph v1.0 Map
(Visualized from the official documentation structure)
⚡ Getting Started
The entry point for developers new to the graph architecture.
- Thinking in LangGraph: A conceptual guide to shifting from "chains" (DAGs) to "graphs" (cycles), emphasizing state management and loops.
- Workflows + Agents: Explains the distinction between deterministic workflows (fixed paths) and autonomous agents (LLM-driven paths).
- Local Server: Tools to spin up a local instance of the LangGraph API for rapid development and testing.
🔋 Core Capabilities
These modules provide the "superpowers" that separate LangGraph from standard LLM wrappers.
- Persistence: The ability to save the full state of a graph at every step. This allows workflows to survive server restarts or long pauses without losing context.
- Durable Execution: Guarantees that long-running agents complete their tasks. If a step fails or the system crashes, it resumes exactly where it left off rather than restarting from zero.
- Streaming: Built-in support for streaming events and tokens in real-time, crucial for building responsive chat interfaces.
- Interrupts (Human-in-the-loop): A mechanism to pause the graph execution to wait for external input (e.g., a human approving a tool call) before proceeding.
- Time Travel: A debugging and steering feature that allows you to view past graph states, rewind to a specific step, edit the state, and fork the execution from that point.
- Memory: Manages conversational state across threads. It supports Short-term memory (within a thread) and Long-term memory (across different sessions).
- Subgraphs: Allows you to nest graphs within other graphs. This is essential for building modular Multi-Agent Systems where each agent is its own graph.
🏭 Production
Tools designed to take your agent from a prototype to a reliable, scalable application.
- Application Structure: Best practices for organizing code, configuring state schemas, and managing dependencies in large projects.
- Test: Dedicated testing utilities to ensure graph logic, state transitions, and tool outputs behave as expected.
- LangSmith Studio: A visual IDE that lets you interact with your graph, inspect checkpoints, and debug complex loops without writing extra code.
- Agent Chat UI: Ready-made, customizable frontend components for chatting with LangGraph agents.
- LangSmith Deployment: Infrastructure solutions optimized for hosting long-running, stateful agent processes.
- Observability: Deep integration for tracing execution paths, monitoring latency/costs, and analyzing agent decisions in production.
🧩 LangGraph APIs
Different ways to define and run your workflows.
- Graph API: The core, declarative way to build agents using
StateGraph. You explicitly define nodes (functions) and edges (control flow). - Functional API: A newer, code-first approach that allows you to use standard functions and decorators (like
@entrypointand@task) to build workflows without strictly defining a graph structure. - Runtime (Pregel): The underlying execution engine inspired by Google's Pregel system. It handles the message passing, state synchronization, and fault tolerance that powers both the Graph and Functional APIs.