How to limit the number of recursion in the graph that contains several loops ？

[Eskiii]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

for the examples of langgraph: https://github.com/langchain-ai/langgraph/blob/main/examples/rag/langgraph_self_rag.ipynb

Description

in the self-rag graph: https://github.com/langchain-ai/langgraph/blob/main/examples/rag/langgraph_self_rag.ipynb，which contain three loops, i wonder how to limit the maximum number of times of one of the loops.

For example, limit the loop: retrive - grade_documents - decide_to_generate - retrieve to 3, and limit the other loop: generate - grade_generation_v_documents_and_question - generate to 5.

Looking forward to reply， thank you!

System Info

langchain-experimental == 0.0.49
langchain-openai == 0.1.1
langchain == 0.1.13
langchain-community == 0.0.29
langchain-core == 0.1.34
langchain-text-splitters == 0.0.1
python == 3.10.12

[dosubot[bot]]

Hey @Eskiii, great to see you diving deeper into the LangChain world! Facing a new challenge, I see? Let's tackle this one together.

To limit the number of iterations for specific loops within your graph, you can create custom chain classes that inherit from SequentialChain or SimpleSequentialChain in the LangChain framework. These custom classes can incorporate logic to track and limit iterations for each loop.

Here's a step-by-step guide to achieve this:

1. Create Custom Chain Classes: Extend SequentialChain or SimpleSequentialChain to include iteration tracking and limiting functionality.

2. Track Iterations: Implement a counter within your custom class to monitor the number of iterations.

3. Limit Iterations: Before proceeding with each iteration, check if the counter has reached the predefined maximum. If so, terminate the loop; otherwise, continue.

Here's an example to illustrate this approach:

from langchain.chains import SequentialChain

class LimitedIterationChain(SequentialChain):
    def __init__(self, components, max_iterations):
        super().__init__(components)
        self.max_iterations = max_iterations
        self.current_iteration = 0

    def __call__(self, *args, **kwargs):
        while self.current_iteration < self.max_iterations:
            super().__call__(*args, **kwargs)
            self.current_iteration += 1
        self.current_iteration = 0  # Reset for potential reuse

# Example usage with your specific loops
sequence_1_chain = LimitedIterationChain(components_sequence_1, max_iterations=3)
sequence_2_chain = LimitedIterationChain(components_sequence_2, max_iterations=5)

Replace components_sequence_1 and components_sequence_2 with the actual components for your loops. This setup ensures that sequence_1_chain and sequence_2_chain will iterate up to their specified limits.

This method requires you to adjust the logic based on your specific implementation details and how components are called within each iteration. For further insights on handling iterations with SequentialChain or SimpleSequentialChain, consider exploring the unit tests in the LangChain repository.

Sources

• libs/langchain/langchain/chains/init.py
• libs/langchain/tests/unit_tests/chains/test_sequential.py

About Dosu

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[Eskiii]

however, a loop maybe contain within another loop (just like the example: https://github.com/langchain-ai/langgraph/blob/main/examples/rag/langgraph_self_rag.ipynb), which together form a graph, in this case, how to limit a standardalone loop?

[maximeperrindev]

Hi @Eskiii

You can pass {"recursion_limit": 15} for example to limit the graph loop iterations.

chain.invoke(...,{"recursion_limit": 15})

[Eskiii]

It seems that "recursion_limit" works globally, this variable is no more applicable if i want to control the recursion limit for a specific loop in a graph that contains multiple loops.

In the following case, this variable cannot fulfill such a requirement:

1. limit loop1: retrive - grade_documents - decide_to_generate - retrieve to 3
2. limit loop2: retrive - grade_documents - decide_to_generate - generate - grade_generation_v_documents_and_question - retrieve to 3
3. limit loop3: generate - grade_generation_v_documents_and_question - generate to 5.

from langgraph.graph import END, StateGraph

workflow = StateGraph(GraphState)

# Define the nodes
workflow.add_node("retrieve", retrieve) # retrieve
workflow.add_node("grade_documents", grade_documents) # grade documents
workflow.add_node("generate", generate) # generatae
workflow.add_node("transform_query", transform_query) # transform_query

# Build graph
workflow.set_entry_point("retrieve")
workflow.add_edge("retrieve", "grade_documents")
workflow.add_conditional_edges(
    "grade_documents",
    decide_to_generate,
    {
        "transform_query": "transform_query",
        "generate": "generate",   # loop1
    },
)
workflow.add_edge("transform_query", "retrieve")
workflow.add_conditional_edges(
    "generate",
    grade_generation_v_documents_and_question,
    {
        "not supported": "generate",   #loop2
        "useful": END,
        "not useful": "transform_query",  # loop3
    },
)

# Compile
app = workflow.compile()

[Towhid1]

I am also facing similar issue. stuck in loop.

[electricjimi]

The solution I found is to create a defaultdict { name of step : counter} to keep track of how many times a specific step is performed.
Then I pass it around inside the GraphState: if counter for this specific step is > LIMIT, I skip to the next step.