> ## Documentation Index > Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt > Use this file to discover all available pages before exploring further. # Stateful Persistence Checkpoints > Describes LangGraph's checkpointing to persist workflow runtime state for pause and resume, crash recovery, backend options, security, and production best practices. LangGraph enables agents to persist runtime state so workflows can pause and resume without losing progress. This capability is critical for real-world automation that spans hours or days, depends on external systems, or requires user input across multiple sessions. The image explains the importance of stateful persistence, showing a robot managing state during pause and resume states with benefits like long workflows, external dependencies, and multi-session input.

The image explains the importance of stateful persistence, showing a robot managing state during pause and resume states with benefits like long workflows, external dependencies, and multi-session input.

## What is stateful persistence? Stateful persistence (checkpointing) saves the full runtime state of a graph—data, counters, flags, loop positions, and execution context—so an agent can be paused and later resumed from the same point. Checkpoints are durable: they live outside process memory in a database or object store, similar to saving a game's progress. Consider a tax-filing chatbot: if the user goes idle mid-session, checkpointing ensures the assistant resumes from the exact step rather than starting over. The image illustrates an overview of stateful persistence, showing the process of saving the state of a graph, including data, counters, flags, and loop status, into a stateful persistence vault, followed by a durable checkpoint and storage in a database and file storage.

The image illustrates an overview of stateful persistence, showing the process of saving the state of a graph, including data, counters, flags, and loop status, into a stateful persistence vault, followed by a durable checkpoint and storage in a database and file storage.

## Real-world analogy Imagine a delivery driver, Ravi. He pauses mid-route for lunch and marks which deliveries remain. When he resumes, he continues from that checkpoint—no need to redo completed deliveries. The same concept applies to workflow checkpoints. The image is a diagram labeled "Stateful Persistence – Overview," showing a delivery route from an office to multiple houses, with stops for deliveries and lunch. The diagram includes a character named Ravi and a summary of delivery statuses.

The image is a diagram labeled "Stateful Persistence – Overview," showing a delivery route from an office to multiple houses, with stops for deliveries and lunch. The diagram includes a character named Ravi and a summary of delivery statuses.

## Why checkpointing matters Checkpointing enables: * Crash recovery and process restarts without losing progress. * Long-running workflows that span sessions or human interactions. * Pausing while waiting for external triggers (webhooks, API calls) or user confirmations, then resuming exactly where the workflow paused.

## Quick example — enable checkpointing (in-memory) Below is a minimal Python example showing how to enable checkpointing with an in-memory checkpointer, compile a graph with persistence, run it (which saves state keyed by a `thread_id`), and later resume with the same `thread_id`. ```python theme={null} from langgraph.checkpoint.memory import InMemorySaver # Create a checkpointer and compile the graph with persistence enabled checkpointer = InMemorySaver() app = graph.compile(checkpointer=checkpointer) # Use a thread_id to associate a session with its persisted state config = {"configurable": {"thread_id": "session-123"}} # First run: state is automatically checkpointed after each step result = app.invoke(inputs, config=config) print("First run result:", result) # Later: resume using the same thread id and new inputs resumed_result = app.invoke(new_inputs, config=config) print("Resumed graph result:", resumed_result) ``` Pick a `thread_id` that uniquely represents the user session or workflow instance. Treat thread IDs like session tokens and protect them with the same care as authentication credentials. ## Production backends and trade-offs In production, checkpoint storage should be durable and secure. LangGraph supports pluggable checkpointers and common backends: | Backend | Best for | Notes / Example | | -------------------- | ----------------------------------------- | ------------------------------------------------------------------------- | | Redis | Real-time session storage, low-latency | Very fast; good for ephemeral sessions and quick resume. | | Cloud object storage | Long-term durable storage | Use `S3` or equivalent for archived or infrequently accessed checkpoints. | | Databases | Auditing, analytics, enterprise workflows | Relational or document DBs can store metadata and support queries. | | Custom checkpointers | Integrate with existing infrastructure | Implement serialization and storage to match your requirements. | Be mindful of checkpoint frequency—excessively frequent saves increase overhead. Save at meaningful boundaries: task completion, decision points, or when waiting for user input. The image illustrates how LangGraph handles persistence, showing a process where a state is bookmarked for later resumption, even after walking away, closing a tab, or shutting down.

The image illustrates how LangGraph handles persistence, showing a process where a state is bookmarked for later resumption, even after walking away, closing a tab, or shutting down.

## Common production use cases * Asynchronous tasks: checkpoint before sending a message or webhook; resume when a callback arrives. * Human-in-the-loop flows: pause while awaiting user verification and continue once confirmed. * Crash recovery: reload the most recent checkpoint after an infrastructure failure. Table: Example use cases and where checkpointing helps | Use Case | When to checkpoint | Benefit | | ------------------------ | ------------------------------- | ---------------------------------------------- | | Webhook-driven process | Before sending external request | Resume on callback without redoing prior steps | | Multi-step approval | After each approval stage | Continue approval chain across sessions | | Long-running computation | At checkpoints between stages | Recover progress if the process is interrupted | When a graph is compiled with a checkpointer, LangGraph automatically stores the workflow state after each step, associating it with the configured `thread_id`. To resume, run the graph again with the same `thread_id` and the runtime will restore the last saved state and continue execution. ```python theme={null} from langgraph.checkpoint.memory import InMemorySaver checkpointer = InMemorySaver() # Compile graph with persistence enabled app = graph.compile(checkpointer=checkpointer) config = {"configurable": {"thread_id": "user_123"}} # Run graph - state is automatically checkpointed app.invoke(state, config=config) # Later: resume without losing progress result = app.invoke(new_inputs, config=config) print("Resumed graph result:", result) ``` The image illustrates a process titled "Saving a Checkpoint" for a system named LangGraph, involving serialization, storage, and versioning. It also suggests configuring the checkpointer and using a thread_id to resume.

The image illustrates a process titled "Saving a Checkpoint" for a system named LangGraph, involving serialization, storage, and versioning. It also suggests configuring the checkpointer and using a thread_id to resume.

## Security & reliability considerations Production checkpointing systems commonly include: * Encryption and hashing of persisted states. * Audit logs and metadata (timestamps, session IDs). * Versioning and schema evolution support to maintain compatibility. The image outlines methods for saving a checkpoint in high-availability systems, including encrypting/hashing the state, logging for audit trails, and tagging the state with metadata. It highlights that this method provides a foundation for long-term and persistent AI workflows.

The image outlines methods for saving a checkpoint in high-availability systems, including encrypting/hashing the state, logging for audit trails, and tagging the state with metadata. It highlights that this method provides a foundation for long-term and persistent AI workflows.

Persisted state can contain sensitive data (PII, API keys, tokens). Always encrypt persisted checkpoints, restrict access with IAM, and maintain audit trails to meet compliance and security requirements. ## Resuming execution When resuming, LangGraph: 1. Loads the latest checkpoint associated with the `thread_id`. 2. Reconstructs the runtime graph, including the last executed node and execution context. 3. Continues execution from that saved point. Because the checkpoint stores both state data and execution context, resuming is deterministic and reliable. The image outlines a process for "Resuming Execution" in a system called LangGraph, detailing steps like loading checkpoints and reconstructing runtime graphs, and explaining why this process works.

The image outlines a process for "Resuming Execution" in a system called LangGraph, detailing steps like loading checkpoints and reconstructing runtime graphs, and explaining why this process works.

Resume patterns: The image outlines three methods of resuming execution: user-driven continuation, multi-turn workflows, and external triggers, each with a brief description.

The image outlines three methods of resuming execution: user-driven continuation, multi-turn workflows, and external triggers, each with a brief description.

* User-driven continuation: pause to ask clarifying questions and resume after a response. * Multi-turn workflows: staged approvals or document reviews across sessions. * External triggers: webhooks, scheduled jobs, or callbacks resume the workflow. ## Best practices * Save checkpoints at meaningful boundaries (decision points, task completions). * Choose a persistence backend aligned with latency, durability, and cost needs. * Encrypt persisted data and maintain access logs. * Treat checkpoint storage as critical infrastructure—implement monitoring, backups, and recovery plans. The image showcases three best practices: strategic timing, data protection, and critical infrastructure, each represented by a colored icon and brief description.

The image showcases three best practices: strategic timing, data protection, and critical infrastructure, each represented by a colored icon and brief description.

## Key takeaways * Checkpointing makes LangGraph agents robust to crashes and restarts. * Persistence allows workflows to span multiple sessions and actors. * Checkpoints preserve both workflow state and execution context, enabling precise resumption. * Design checkpointing with security, durability, and operational controls in mind. The image lists four key takeaways about persistence in LangGraph agents, highlighting their robustness, session-spanning ability, workflow enablement, and reliability foundation.

The image lists four key takeaways about persistence in LangGraph agents, highlighting their robustness, session-spanning ability, workflow enablement, and reliability foundation.

## References * Redis: [https://redis.io/](https://redis.io/) * AWS S3: [https://aws.amazon.com/s3/](https://aws.amazon.com/s3/)