# How create_deep_agent Integrates with LangGraph Checkpointing and Store

> Learn how create_deep_agent integrates with LangGraph checkpointing and store for stateful agent execution and cross-run data. Explore persistence with compiled graphs.

- Repository: [LangChain/deepagents](https://github.com/langchain-ai/deepagents)
- Tags: deep-dive
- Published: 2026-03-17

---

**The `create_deep_agent` function integrates with LangGraph's persistence layer by accepting `checkpointer` and `store` parameters that it forwards directly to the underlying `CompiledStateGraph`, enabling stateful agent execution and cross-run data storage.**

The `create_deep_agent` function in the `langchain-ai/deepagents` repository constructs sophisticated AI agents by building a LangGraph `CompiledStateGraph`. Understanding how `create_deep_agent` integrates with LangGraph checkpointing and store mechanisms is essential for production deployments requiring state persistence across sessions.

## How create_deep_agent Handles Persistence Parameters

The function signature in [`libs/deepagents/deepagents/graph.py`](https://github.com/langchain-ai/deepagents/blob/main/libs/deepagents/deepagents/graph.py) exposes two optional parameters that control LangGraph's persistence layer. The **`checkpointer`** parameter accepts a LangGraph `Checkpointer` instance that records the agent's state after each step, while the **`store`** parameter accepts a `BaseStore` for arbitrary key-value data persistence. According to the source code at lines 94-96, these parameters are defined as optional arguments in the public API.

When assembling the agent, `create_deep_agent` forwards these objects unchanged to the underlying `create_agent` function from LangChain. At lines 300-303 in [`graph.py`](https://github.com/langchain-ai/deepagents/blob/main/graph.py), the function returns:

```python
return create_agent(
    model,
    ...,
    checkpointer=checkpointer,
    store=store,
    ...
)

```

This effectively passes the persistence configuration directly to the compiled graph. If omitted, LangGraph falls back to default in-memory checkpointing and a no-op store, meaning the agent cannot survive process restarts or share data across separate runs.

## The Assembly Pipeline: Where Checkpointing Fits

The integration occurs at the final stage of a five-step assembly process:

1. **Model resolution** – the LLM is prepared via `resolve_model` (defined in [`libs/deepagents/deepagents/_models.py`](https://github.com/langchain-ai/deepagents/blob/main/libs/deepagents/deepagents/_models.py)).
2. **Backend selection** – a `StateBackend` is chosen for filesystem-related tools.
3. **Middleware composition** – standard middlewares (todo list, filesystem, summarization, etc.) are assembled.
4. **Agent creation** – `create_agent` receives the model, tools, middleware list, and the LangGraph persistence objects.
5. **Graph configuration** – recursion limits and metadata are applied before returning the compiled graph.

Because checkpointing and storage are **plug-in points** at the end of this pipeline, developers can configure state durability without modifying built-in middleware logic in `libs/deepagents/deepagents/middleware/*`.

## Code Examples: Configuring Checkpointing and Storage

### Basic Usage with Default In-Memory Checkpointing

```python
from deepagents.graph import create_deep_agent

agent = create_deep_agent()

# Agent runs with ephemeral state; data is lost when the Python process ends.

```

### Persistent Checkpointing with SQLite

```python
from deepagents.graph import create_deep_agent
from langgraph.checkpoint.sql import SqlCheckpoint
from pathlib import Path

# Store checkpoints in a local SQLite file

checkpoint = SqlCheckpoint(
    db_url=f"sqlite:///{Path('checkpoints.db')}"
)

agent = create_deep_agent(
    checkpointer=checkpoint,
)

# The agent's state can now be resumed across sessions.

```

### Custom Key-Value Storage with Redis

```python
from deepagents.graph import create_deep_agent
from langgraph.store.redis import RedisStore

store = RedisStore(host="localhost", port=6379, db=0)

agent = create_deep_agent(
    store=store,
)

# Middleware or tools can now read/write persistent data across runs.

```

### Full Persistence Configuration

```python
from deepagents.graph import create_deep_agent
from langgraph.checkpoint.sql import SqlCheckpoint
from langgraph.store.redis import RedisStore

agent = create_deep_agent(
    checkpointer=SqlCheckpoint(db_url="sqlite:///agent_state.db"),
    store=RedisStore(host="redis", port=6379),
)

# Both agent state and key-value data persist externally.

```

## Key Source Files and Implementation Details

| File | Purpose |
|------|---------|
| [`libs/deepagents/deepagents/graph.py`](https://github.com/langchain-ai/deepagents/blob/main/libs/deepagents/deepagents/graph.py) | Core factory that assembles the Deep Agent and forwards `checkpointer`/`store` to LangGraph (lines 94-96, 300-303). |
| [`libs/deepagents/deepagents/_models.py`](https://github.com/langchain-ai/deepagents/blob/main/libs/deepagents/deepagents/_models.py) | Resolves model strings to LangChain `BaseChatModel` instances before checkpointing begins. |
| `libs/deepagents/deepagents/middleware/*` | Middleware stack that runs before graph creation; operates independently of persistence but relies on the same backend infrastructure. |

## Summary

- `create_deep_agent` accepts `checkpointer` and `store` parameters that map directly to LangGraph's persistence APIs
- These parameters are forwarded unchanged to `create_agent` at lines 300-303 in [`graph.py`](https://github.com/langchain-ai/deepagents/blob/main/graph.py)
- Omitting these parameters results in in-memory checkpointing that cannot survive process restarts
- The persistence layer acts as a plug-in point at the end of the agent assembly pipeline
- Developers can mix checkpoint implementations (SQLite, Redis, etc.) without modifying middleware logic

## Frequently Asked Questions

### What happens if I don't provide a checkpointer to create_deep_agent?

If omitted, LangGraph defaults to in-memory checkpointing. While this works for single-session agents, the state cannot be resumed after a process restart, making it unsuitable for production workflows requiring fault tolerance.

### Can I use create_deep_agent with a custom store implementation?

Yes. The `store` parameter accepts any LangGraph `BaseStore` implementation. You can provide custom stores by implementing the `BaseStore` interface, allowing integration with proprietary databases or specialized caching layers.

### How does the checkpointer parameter affect agent resumption?

The `checkpointer` records the agent's state after each graph step. When resuming, LangGraph uses this checkpoint to restore the exact execution state, enabling long-running agents to continue from interruption points without losing context.

### Where are the checkpointer and store parameters defined in the source code?

These parameters appear in the function signature at lines 94-96 of [`libs/deepagents/deepagents/graph.py`](https://github.com/langchain-ai/deepagents/blob/main/libs/deepagents/deepagents/graph.py), where they are typed as optional `Checkpointer` and `BaseStore` instances respectively.