# How to control graph recursion limit¶

You can set the graph recursion limit when invoking or streaming the graph. The recursion limit sets the number of **supersteps** that the graph is allowed to execute before it raises an error. Read more about the concept of recursion limits here. Let's see an example of this in a simple graph with parallel branches to better understand exactly how the recursion limit works.

If you want to see an example of how you can return the last value of your state instead of receiving a recursion limit error form your graph, read this how-to.

## Setup¶

First, let's install the required packages

Set up LangSmith for LangGraph development

Sign up for LangSmith to quickly spot issues and improve the performance of your LangGraph projects. LangSmith lets you use trace data to debug, test, and monitor your LLM apps built with LangGraph — read more about how to get started here.

## Define the graph¶

```
import operator
from typing import Annotated, Any
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END
class State(TypedDict):
# The operator.add reducer fn makes this append-only
aggregate: Annotated[list, operator.add]
def node_a(state):
return {"aggregate": ["I'm A"]}
def node_b(state):
return {"aggregate": ["I'm B"]}
def node_c(state):
return {"aggregate": ["I'm C"]}
def node_d(state):
return {"aggregate": ["I'm A"]}
builder = StateGraph(State)
builder.add_node("a", node_a)
builder.add_edge(START, "a")
builder.add_node("b", node_b)
builder.add_node("c", node_c)
builder.add_node("d", node_d)
builder.add_edge("a", "b")
builder.add_edge("a", "c")
builder.add_edge("b", "d")
builder.add_edge("c", "d")
builder.add_edge("d", END)
graph = builder.compile()
```

As we can see, our graph will execute nodes `b`

and `c`

in parallel (i.e. in a single super-step), which means that if we run this graph it should take exactly 3 steps. We can set the recursion limit to 3 first to check that it raises an error (the recursion limit is inclusive, so if the limit is 3 the graph will raise an error when it reaches step 3) as expected:

## Use the graph¶

```
from langgraph.errors import GraphRecursionError
try:
graph.invoke({"aggregate": []}, {"recursion_limit": 3})
except GraphRecursionError:
print("Recursion Error")
```

```
try:
graph.invoke({"aggregate": []}, {"recursion_limit": 4})
except GraphRecursionError:
print("Recursion Error")
```

Perfect, just as we expected the graph runs successfully in this case.

Setting the correct graph recursion limit is important for avoiding graph runs stuck in long-running loops and thus helps minimize unnecessary costs