Learning roadmap · 5 stages · about 27 h · up to Gold

Zero to LangGraph, coming from Python

Five stages from a first state graph to a tested agent that pauses for a human: state and reducers, tools, memory and interrupts, workflow patterns, tests and a local server.

Goal Build, test and run a small agent with LangGraph that pauses for a human decision and keeps its state.

Links opened on 13 Nov 2026 · 20 sources: 19 opened and kept, 1 behind a login or paywall

  • For self-study
  • Starts from a neighbouring field
  • 6 h a week
  • Start 16 Nov 2026
  • Goal date 24 Jan 2027
5 stages over about 27 h, climbing from Bronze to Gold. Times are estimates.

Stage 1 of 5

State, nodes and edges

Bronze · about 4.5 h · 84% hands-on

Install LangGraph and build graphs from plain functions, with no model and no API key.

  1. Step 1 of 4

    Install and run a first graph

    about 45 min · 35 min of it hands-on

    After this step langgraph is installed in a clean environment and you have run a compiled graph with no model and no API key.

    Before you open a source

    A node is a plain function. Will it return the whole state or only what changed?

    Sources

    • Main source · Documentation

      LangGraph overview · LangChain

      Gives the install command and a minimal graph that needs no model or API key, the first thing this roadmap builds.

      Free · about 15 min · opened 13 Nov 2026

    • Alternative · Documentation

      Python tutorial: Virtual Environments and Packages · Python Software Foundation

      The official walkthrough for creating and activating a virtual environment, so langgraph is installed in a clean place.

      Free · about 20 min · opened 13 Nov 2026

    Do

    Create a virtual environment and run pip install -U langgraph. Type the smallest graph from the overview (START, one node, END), compile it and invoke it. Then change what the node returns and run it again.

    Check yourself

    1. What must you do to a StateGraph after adding nodes and edges and before you call invoke?

      Show the answer

      Call compile(). Compilation checks the graph structure and returns the runnable graph.

    Key points

    • pip install -U langgraph installs the library. Running a graph made of plain functions needs no model and no key.
    • You build a StateGraph(State), add nodes and edges, and must compile() it before calling invoke.
    • graph.invoke(input) returns the final state as a dict.
    • A node is a function that takes the state and returns a partial update.
  2. Step 2 of 4

    State and reducers

    about 1 h · 45 min of it hands-on

    State is a typed dict. A key without a reducer is overwritten by each update. A key with a reducer merges updates.

    Before you open a source

    Two nodes in a row both return {"log": ["x"]}. Is log ["x"] or ["x", "x"] at the end?

    Sources

    • Main source · Documentation

      LangGraph: Graph API overview · LangChain

      Defines state, reducers, nodes, edges, super-steps, Send, Command and the recursion limit. The reference for stages 1 and 4.

      Free · about 1 h · opened 13 Nov 2026

    Do

    Write a State with one plain key and one key annotated with operator.add. Write two nodes that each return an update for both keys, run them in sequence and print the state after each node.

    Check yourself

    1. State has foo: int and bar: Annotated[list[str], operator.add]. It is {"foo": 1, "bar": ["hi"]} and a node returns {"bar": ["bye"]}. What is the state now?

      Show the answer

      {"foo": 1, "bar": ["hi", "bye"]}. foo is untouched because the update did not mention it, and bar is appended by the reducer.

    Key points

    • Nodes return partial updates, not the full state.
    • With no reducer a new value overwrites the old value for that key.
    • Annotated[list[str], operator.add] makes a key append instead of overwrite.
    • A reducer is a function of (current value, update) that returns the new value.
  3. Step 3 of 4

    Edges, branches and loops

    about 1 h · 45 min of it hands-on

    A routing function chooses the next node. Routing back to an earlier node makes a loop, and the recursion limit stops a runaway one.

    Before you open a source

    A conditional edge always routes back to the same node. What do you expect to happen?

    Sources

    • Main source · Documentation

      LangGraph: Graph API overview · LangChain

      Defines state, reducers, nodes, edges, super-steps, Send, Command and the recursion limit. The reference for stages 1 and 4.

      Free · about 1 h · opened 13 Nov 2026

    • Alternative · Reference

      StateGraph API reference · LangChain

      Lists the StateGraph methods used in the drills: add_node, add_edge, add_conditional_edges and compile.

      Free · about 15 min · opened 13 Nov 2026

    Do

    Add a counter to the state and a node that increments it. Add a conditional edge that returns the node name to loop, or END once the counter reaches 3. Then break the condition on purpose and read the error.

    Check yourself

    1. What is a super-step?

      Show the answer

      One round of execution. Nodes that run in parallel share a super-step, nodes that run in sequence use separate ones. The run ends when no node is active and no messages are in transit.

    Key points

    • add_edge always goes from one node to the next. add_conditional_edges calls a function that returns the next node name or END.
    • The routing function can return a list of names to run several nodes in parallel in the next super-step.
    • The recursion limit caps the super-steps in one run. Going over it raises GraphRecursionError.
    • For each node use static edges or dynamic routing (conditional edges or Command), not both.
  4. Step 4 of 4

    Three tiny graphs from scratch

    about 1.5 h · 1.5 h of it hands-on

    Repetition with the docs closed: the three shapes that everything later builds on.

    Sources

    • Main source · Reference

      StateGraph API reference · LangChain

      Lists the StateGraph methods used in the drills: add_node, add_edge, add_conditional_edges and compile.

      Free · about 15 min · opened 13 Nov 2026

    Do

    Without copying, build (1) a linear graph of three nodes, (2) a graph that branches on a value and rejoins, (3) a loop that stops after N rounds. Print the node name and the state inside every node.

    Key points

    • Draw the graph on paper first: nodes as boxes, edges as arrows. Then write the code.
    • Compilation checks the graph structure, for example for orphaned nodes, so a bad wiring fails before the first run.

Signpost at the end of the stage

Base camp

Show, test or explain each of these. Tick 2 of 3 to pass.

What you can show

  • Show a graph whose state has one overwritten key and one appended key, and explain the difference.
  • Show a loop that ends on a condition, and name what stops it if the condition is wrong.
  • Explain in one sentence what a super-step is.

Camp

Skeleton of the triage graph

about 1.5 h · Part of the capstone

The support-ticket agent as plain functions. No model yet.

Rungs of the ladder

Climb the ladder: first with the guide, then changed, then your own.

  1. Guided Build a graph with three nodes: classify (returns a fixed label), draft (returns a fixed reply) and send (prints it). Route urgent labels to a second draft node.

Stage 2 of 5

A model with tools

Silver · about 6 h · 78% hands-on

Add a model and tools, read the message list, and design the state before wiring nodes.

  1. Step 1 of 4

    The quickstart agent

    about 2 h · 1.5 h of it hands-on

    Build the docs calculator agent: a model node, a tool node and a loop that runs until the model stops asking for tools.

    Before you open a source

    The model can answer or ask for a tool. Which edge must be conditional, and what does it check?

    Sources

    • Main source · Documentation

      LangGraph quickstart: a calculator agent · LangChain

      A complete model, tool and loop agent in one file, with the should_continue routing function and bind_tools.

      Free · about 45 min · opened 13 Nov 2026

    • Alternative · Documentation

      LangChain: Tools · LangChain

      Explains the @tool decorator and why a tool needs a clear docstring and type hints.

      Free · about 25 min · opened 13 Nov 2026

    Do

    Create an API key with a model provider, type the quickstart into one file and run it on "Add 3 and 4". Then ask something that needs two tools and read the printed messages.

    Check yourself

    1. Why does the quickstart graph have an edge from tool_node back to llm_call?

      Show the answer

      The model has to read the tool result before it can answer or ask for another tool. Without the edge the run would end after the first tool.

    Key points

    • @tool turns a typed function with a docstring into a tool. The docstring tells the model what the tool does.
    • model.bind_tools(tools) lets the model return tool calls instead of text.
    • should_continue checks the last message for tool_calls: if there are some it goes to tool_node, otherwise to END.
    • The loop is llm_call, tool_node, llm_call again, until the model makes no tool call.
  2. Step 2 of 4

    Messages as state

    about 1 h · 40 min of it hands-on

    Chat history is a list in the state with an appending reducer. See what goes into it and how the model reads it.

    Before you open a source

    After a tool runs, what must be added to the message list before the model is called again?

    Sources

    • Main source · Documentation

      LangChain: Models · LangChain

      Shows init_chat_model and how a model returns tool calls, which the model node in the agent depends on.

      Free · about 25 min · opened 13 Nov 2026

    • Alternative · Documentation

      LangGraph: Graph API overview · LangChain

      Defines state, reducers, nodes, edges, super-steps, Send, Command and the recursion limit. The reference for stages 1 and 4.

      Free · about 1 h · opened 13 Nov 2026

    Do

    Print every message after the calculator agent finishes. Mark which ones the model wrote and which one the tool wrote, and find the field that links a tool result to the call that asked for it.

    Key points

    • Messages are appended with a reducer, so each node adds to the history instead of replacing it.
    • A tool result is a ToolMessage whose tool_call_id matches the model call that asked for it.
    • The model sees the whole list on every call, so a long history costs more tokens.
    • init_chat_model builds a chat model for the provider you choose. Other providers need their own key and package.
  3. Step 3 of 4

    Design before you wire

    about 1.5 h · 50 min of it hands-on

    Map the steps, decide what each one does, then design the state. The docs walk through this order with an email agent.

    Before you open a source

    For an email agent, would you keep the raw email in state or a ready-made prompt string?

    Sources

    • Main source · Documentation

      LangGraph: Thinking in the Graph API · LangChain

      Walks through designing an email agent: steps first, then state, then nodes. Also covers node size and interrupt().

      Free · about 40 min · opened 13 Nov 2026

    Do

    Take the triage idea: read ticket, classify, look up docs, draft, human review, send. Write the steps on paper, label each as a model step, data step, action step or user-input step, and write the State class with raw data only.

    Key points

    • Break the work into discrete steps. Each node does one thing.
    • Keep raw data in state and format prompts inside the nodes that need them.
    • The graph checkpoints at node boundaries, so smaller nodes repeat less work after a failure or a pause.
    • Transient failures get retry policies. Problems a user can fix pause with interrupt().
  4. Step 4 of 4

    Add two tools of your own

    about 1.5 h · 1.5 h of it hands-on

    Make the agent yours: new tools, a bad input and a tool that fails.

    Sources

    • Main source · Documentation

      LangChain: Tools · LangChain

      Explains the @tool decorator and why a tool needs a clear docstring and type hints.

      Free · about 25 min · opened 13 Nov 2026

    Do

    Add two tools to the calculator agent: one that looks up a fake ticket by id in a dict, one that raises an error on an unknown id. Run both, read what happens after the error and write down how you would handle it.

    Key points

    • The model chooses a tool from its name, type hints and docstring, so write them for the model.
    • In the quickstart tool_node an uncaught error stops the run. Catch it and return text the model can read.

Signpost at the end of the stage

Tool camp

Show, test or explain each of these. Tick 2 of 3 to pass.

What you can show

  • Run your agent on a question that needs two tool calls and show the message list.
  • Explain why the loop ends.
  • Show the State class for the triage agent and say why it holds raw data.

Camp

Put a model in the triage graph

about 2 h · Part of the capstone

Replace the fixed classify and draft nodes with model calls. The graph shape stays.

Rungs of the ladder

Climb the ladder: first with the guide, then changed, then your own.

  1. Changed Make classify return one of three labels from a model and draft write a reply for that label. Keep the nodes small and the state raw.

Stage 3 of 5

Memory and pauses

Silver · about 5.5 h · 76% hands-on

Save state with a checkpointer, keep it across restarts and stop for a human decision.

  1. Step 1 of 4

    Remember a conversation

    about 1.5 h · 55 min of it hands-on

    Compile with a checkpointer and pass a thread_id. The same id continues the conversation, a new id starts fresh.

    Before you open a source

    You invoke the graph twice with the same thread_id. Does the second call see the first call?

    Sources

    • Main source · Documentation

      LangGraph: Persistence · LangChain

      Explains checkpointers versus stores, and the warning that InMemorySaver loses everything when the process restarts.

      Free · about 20 min · opened 13 Nov 2026

    • Alternative · Documentation

      LangGraph: Checkpointers · LangChain

      Covers threads, checkpoints, get_state and the SqliteSaver package, which needs its own install.

      Free · about 40 min · opened 13 Nov 2026

    Do

    Compile the calculator agent with InMemorySaver. Ask "Add 3 and 4", then ask "Now multiply that by 2" on the same thread_id. Repeat the second question on a new thread_id and compare.

    Check yourself

    1. Why does the follow-up question only work on the same thread_id?

      Show the answer

      The checkpointer loads the saved state for that thread, so the earlier messages are there. A new thread_id has no saved state.

    Key points

    • compile(checkpointer=InMemorySaver()) saves a checkpoint of the state after each step.
    • config={"configurable": {"thread_id": ...}} picks the thread to load. A new id starts with empty state.
    • A checkpointer is short-term memory for one thread. A store is long-term memory across threads.
    • InMemorySaver keeps checkpoints in RAM, so they are lost when the process restarts.
  2. Step 2 of 4

    Survive a restart

    about 1.5 h · 1 h of it hands-on

    Swap the in-memory saver for SQLite so the state outlives the process.

    Before you open a source

    After you stop and restart the script, what is left of the thread with InMemorySaver? With SqliteSaver?

    Sources

    • Main source · Documentation

      LangGraph: Checkpointers · LangChain

      Covers threads, checkpoints, get_state and the SqliteSaver package, which needs its own install.

      Free · about 40 min · opened 13 Nov 2026

    Do

    Install langgraph-checkpoint-sqlite and compile with SqliteSaver on a file. Run once and stop the script. Start it again with the same thread_id and read the saved state with graph.get_state.

    Key points

    • langgraph-checkpoint-sqlite is a separate package. SqliteSaver stores checkpoints in a local SQLite file.
    • The docs call SQLite ideal for experiments and local work, and point to PostgresSaver for production.
    • graph.get_state(config) returns the latest saved state of a thread.
  3. Step 3 of 4

    Pause for a human

    about 2 h · 1.5 h of it hands-on

    interrupt() stops the graph and hands a question to the caller. Command(resume=...) answers it on the same thread.

    Before you open a source

    A node calls interrupt("Send this reply?"). Where does the question show up, and how do you answer it?

    Sources

    • Main source · Documentation

      LangGraph: Interrupts · LangChain

      Defines interrupt() and Command(resume=...), the rule that a node restarts on resume, and the try/except trap.

      Free · about 50 min · opened 13 Nov 2026

    Do

    Add a review node before send in the triage graph. It calls interrupt with the draft and returns whether it was approved. Run until the pause, print the payload, resume with True, then run again and resume with False.

    Check yourself

    1. Your review node sends an email and then calls interrupt(). What goes wrong on resume?

      Show the answer

      The node restarts from the top, so the email is sent a second time. Put the side effect after the interrupt, or make it idempotent.

    Key points

    • interrupt() needs a checkpointer and a thread_id. The payload must be JSON-serializable.
    • With invoke the pause shows up as result["__interrupt__"]. You resume with Command(resume=value) on the same thread.
    • On resume the node restarts from its first line, so code before interrupt() must be safe to run twice.
    • Do not wrap interrupt() in a bare try/except, and keep several interrupts in the same order.
  4. Step 4 of 4Side trail

    Replay and fork

    about 1 h · 45 min of it hands-on

    Every checkpoint is a restore point. Replay re-runs from one. Fork changes the state first.

    Before you open a source

    If you replay from an old checkpoint, are the later model calls read from a cache or made again?

    Sources

    • Main source · Documentation

      LangGraph: Use time-travel · LangChain

      Explains replay and fork from a checkpoint, with get_state_history and update_state.

      Free · about 30 min · opened 13 Nov 2026

    Do

    List a thread's checkpoints with get_state_history, pick one before the draft node and replay from it. Then fork it with a changed ticket text and compare the two drafts.

    Key points

    • get_state_history lists a thread's checkpoints, newest first.
    • Replay re-executes the nodes after the checkpoint, including model calls, so the result can differ.
    • Fork updates the state at a checkpoint and resumes from there, which creates an alternative path.

Signpost at the end of the stage

Memory camp

Show, test or explain each of these. Tick 2 of 3 to pass.

What you can show

  • Show two threads with different histories on the same graph.
  • Show state that survives stopping and restarting your script.
  • Show a pause with its printed question, one resume that approves and one that rejects.

Camp

Add human approval

about 2 h · Part of the capstone

The triage graph drafts a reply and waits for a person before it sends.

Rungs of the ladder

Climb the ladder: first with the guide, then changed, then your own.

  1. Changed On rejection, loop back to draft with the reviewer's comment in the state. Cap the number of rewrites at three.

Stage 4 of 5

Workflow patterns

Gold · about 6 h · 75% hands-on

Route, fan out, map over a list with Send, split into subgraphs and stream the result.

  1. Step 1 of 4

    Routing and parallel branches

    about 2 h · 1.5 h of it hands-on

    Two standard patterns: send the input down the right branch, or run independent branches at once and merge the results.

    Before you open a source

    What must the state hold so a routing function can choose between a billing ticket and a bug ticket?

    Sources

    • Main source · Documentation

      LangGraph: Workflows and agents · LangChain

      Code for prompt chaining, parallelization, routing, orchestrator-worker and evaluator-optimizer in one place.

      Free · about 1 h · opened 13 Nov 2026

    Do

    In the triage graph let classify return one of three labels as structured output, and route each label to its own draft node. Then add two lookup nodes that run in parallel and a node that merges their results.

    Key points

    • Workflows follow predetermined code paths. Agents decide their own steps and tool use.
    • Routing classifies the input and sends it down a specialised path through a conditional edge.
    • Parallel nodes share one super-step, so give a key they both write a reducer that merges updates.
    • The docs list five patterns: prompt chaining, parallelization, routing, orchestrator-worker, evaluator-optimizer.
  2. Step 2 of 4

    Map-reduce with Send

    about 1.5 h · 1 h of it hands-on

    When the number of items is only known at run time, Send starts one worker per item.

    Before you open a source

    Edges are fixed when you build the graph. How could a graph run one worker per item of a list of unknown length?

    Sources

    • Main source · Documentation

      LangGraph: Graph API overview · LangChain

      Defines state, reducers, nodes, edges, super-steps, Send, Command and the recursion limit. The reference for stages 1 and 4.

      Free · about 1 h · opened 13 Nov 2026

    Do

    Add a node that turns a batch of tickets into a list, and a conditional edge that returns [Send("draft", {"ticket": t}) for t in tickets]. Give the results key an operator.add reducer and run it on five tickets.

    Key points

    • Send(node, state) runs that node once with its own input. Return a list of them from a conditional edge.
    • The workers run in parallel and write to shared keys, so those keys need a reducer.
    • Use Send for orchestrator-worker shapes, where the number of tasks is only known at run time.
  3. Step 3 of 4

    Subgraphs

    about 1.5 h · 55 min of it hands-on

    A compiled graph can be a node in another graph. Use it to split a big graph into parts you can test alone.

    Before you open a source

    Parent and subgraph have different state keys. How can they still pass data?

    Sources

    • Main source · Documentation

      LangGraph: Subgraphs · LangChain

      Shows the two ways to use a subgraph and the checkpointer modes that decide what it remembers.

      Free · about 40 min · opened 13 Nov 2026

    Do

    Move the draft-and-review part of the triage graph into its own compiled graph and use it in the parent. Check what the parent sees when the subgraph runs.

    Key points

    • If parent and subgraph share state keys, pass the compiled subgraph straight to add_node.
    • If their state schemas differ, call the subgraph from a function that maps parent state to its input and back.
    • By default a subgraph inherits the parent's checkpointer, so interrupts still work inside it.
  4. Step 4 of 4

    Stream what happens

    about 1.5 h · 55 min of it hands-on

    stream() yields output while the graph runs. Pick a stream mode for state changes, full state, model tokens or custom messages.

    Before you open a source

    What is the difference between getting the full state after each step and getting only what each node changed?

    Sources

    • Main source · Documentation

      LangGraph: Streaming · LangChain

      A table of stream modes (values, updates, messages, custom, checkpoints, tasks, debug) with runnable examples.

      Free · about 40 min · opened 13 Nov 2026

    Do

    Run the triage graph with stream_mode "updates", then "values", then "messages". Print what arrives for each, and decide which you would use for a progress bar and which for a chat window.

    Key points

    • The "values" mode streams the full state after each step. The "updates" mode streams only the changes.
    • The "messages" mode streams model tokens with metadata. The "custom" mode carries data a node emits with get_stream_writer.
    • Pass a list of modes to get several kinds of output at once.
    • The "checkpoints" and "tasks" modes need a checkpointer.

Signpost at the end of the stage

Pattern camp

Show, test or explain each of these. Tick 2 of 3 to pass.

What you can show

  • Show one conditional route and one parallel fan-out in the same graph.
  • Show Send creating one worker per item.
  • Show a subgraph used as a node, and say which stream mode you would use for a progress bar.

Camp

Scale the triage graph

about 2 h · Part of the capstone

The agent handles a whole batch of tickets in one run.

Rungs of the ladder

Climb the ladder: first with the guide, then changed, then your own.

  1. Changed Handle a batch of tickets in one run with Send, and route each ticket to the right drafting branch.

Stage 5 of 5

Test, run and ship

Gold · about 5.5 h · 82% hands-on

Test nodes and graphs with pytest, serve the graph locally, trace a run and review your own work.

  1. Step 1 of 4

    Test nodes and graphs

    about 2 h · 1.5 h of it hands-on

    Test one node alone, then the whole graph with a fresh checkpointer for each test.

    Before you open a source

    How would you test one node without calling a model or any other node?

    Sources

    • Main source · Documentation

      LangGraph: Test · LangChain

      Shows a fresh graph and checkpointer per test, testing one node through graph.nodes, and partial execution.

      Free · about 25 min · opened 13 Nov 2026

    • Alternative · Documentation

      pytest: Get Started · pytest-dev

      The first pytest page: write a test_ function, use assert, and run the suite.

      Free · about 15 min · opened 13 Nov 2026

    Do

    Install pytest. Write tests that call graph.nodes["classify"].invoke(...) with a stand-in for the model, one end-to-end test with a fresh InMemorySaver and thread_id, and one test for the rejection path.

    Check yourself

    1. Why compile the graph with a new checkpointer inside each test?

      Show the answer

      A shared checkpointer keeps state between tests, so one test can change the result of another. A fresh one per test keeps them independent.

    Key points

    • Build the graph inside the test or a fixture and compile it with a new checkpointer, so tests share no state.
    • compiled_graph.nodes["name"].invoke(state) runs a single node and bypasses the checkpointer.
    • Test the rejection and failure paths, not only the happy path.
    • pytest collects functions named test_*, and a plain assert shows both values when it fails.
  2. Step 2 of 4

    Run it as a server

    about 1.5 h · 1 h of it hands-on

    langgraph dev starts a local Agent Server with an API and a Studio view of your graph.

    Before you open a source

    A dev server needs more than a plain script. A config file, an account key, or both?

    Sources

    • Main source · Documentation

      LangGraph: Run a local server · LangChain

      Steps for langgraph-cli, langgraph dev, Studio and the API docs page, with the LangSmith key prerequisite.

      Free · about 40 min · opened 13 Nov 2026

    Do

    Install langgraph-cli, set up the project as the docs describe and point it at the triage graph. Run langgraph dev, send one request from Studio and one from the API docs page.

    Key points

    • pip install -U "langgraph-cli[inmem]" gives you langgraph dev. The docs say Python 3.11 or newer.
    • langgraph dev starts an in-memory Agent Server on port 2024 with Studio and an API docs page.
    • The docs list a LangSmith API key (free to sign up) as a prerequisite.
    • The in-memory server is for development and testing. The docs send you elsewhere for production.
  3. Step 3 of 4Side trail

    Trace a run

    about 45 min · 35 min of it hands-on

    A trace records every node and model call of a run, so you can see where time and tokens go.

    Sources

    • Main source · Documentation

      LangSmith Observability · LangChain

      Explains traces and how to create a LangSmith account and API key for tracing a run.

      Free · about 20 min · opened 13 Nov 2026

    • Alternative · Documentation

      LangGraph quickstart: a calculator agent · LangChain

      A complete model, tool and loop agent in one file, with the should_continue routing function and bind_tools.

      Free · about 45 min · opened 13 Nov 2026

    Do

    Create a LangSmith account and API key, turn on tracing with the environment variables from the quickstart, and run the triage graph. Find the node in the trace that took longest.

    Key points

    • The quickstart turns tracing on with LANGSMITH_TRACING=true and a LANGSMITH_API_KEY in the shell.
    • A trace shows the tool calls and model responses of a run, which makes a wrong loop easy to spot.
  4. Step 4 of 4

    Review your own graph

    about 1.5 h · 1 h of it hands-on

    Read the finished triage graph as a stranger would, and fix three things.

    Sources

    • Main source · Documentation

      LangGraph: Thinking in the Graph API · LangChain

      Walks through designing an email agent: steps first, then state, then nodes. Also covers node size and interrupt().

      Free · about 40 min · opened 13 Nov 2026

    Do

    List the nodes, find one node that does two jobs, one state key nobody reads and one path without a test. Fix each, then run the tests and the local server once more.

    Key points

    • Split a node that does two jobs. The graph checkpoints between nodes, so smaller nodes repeat less after a failure.
    • A state key nobody reads is a candidate for deletion. Less state means fewer bugs to track.

Signpost at the end of the stage

Summit camp

Show, test or explain each of these. Tick 3 of 3 to pass.

What you can show

  • Run pytest on your graph and show that it passes, including a rejection test.
  • Show the graph answering a request under langgraph dev.
  • Explain to someone else why your graph has the nodes it has.

Camp

Build an agent of your own

about 5 h · Part of the capstone

A different agent with a pause for a human, a checkpointer and tests.

Rungs of the ladder

Climb the ladder: first with the guide, then changed, then your own.

  1. Your own Pick an agent from the menu. Design the state on paper first, then build it with a human pause, a checkpointer and tests. Keep the docs closed for the first draft.

Pick one

  • Expense approval agent
  • Meeting notes to action items
  • Code review helper that asks before it commits

It is done when

  • Runs end to end under langgraph dev
  • Pauses for a person before any side effect
  • At least five passing tests
  • You can explain every node and every state key

For this camp

  • Course

    LangChain Academy: Introduction to LangGraph (Python) · LangChain

    A video course on the same ideas. Optional extra on the project shelf.

    Login or paywall The title and outline were read on 13 Nov 2026, the lessons were not.

    The course page showed a sign-in screen on 2026-11-13. Title read, lessons not read. Open it yourself before relying on it.

    Free

Capstone

A support-ticket triage agent

One graph that grows at every camp: plain functions first, then a model, then a human approval step, then batches, then tests and a local server.

The camps of every stage build up to this.

This outline and the map are the same roadmap: progress made in one shows in the other.

Times are estimates.