Langgraph Finish When a Path is Repeated

[ardakocaman100101]

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

prompt = ChatPromptTemplate.from_messages(
    [
        ("system", system_prompt),
        MessagesPlaceholder(variable_name="messages"),
        (
            "system",
            "Given the conversation above, who should act next?"
            " Or should we FINISH? Select one of: {options}",
        ),
    ]
).partial(options=str(options), members=", ".join(members))

llm = ChatOpenAI(model="gpt-3.5-turbo-0125", api_key="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")

supervisor_chain = (
    prompt
    | llm.bind_functions(functions=[function_def], function_call="route")
    | JsonOutputFunctionsParser()
)
#added edged in this part
for member in members:
    # We want our workers to ALWAYS "report back" to the supervisor when done
    workflow.add_edge(member, "supervisor")
# The supervisor populates the "next" field in the graph state
# which routes to a node or finishes
conditional_map = {k: k for k in members}
conditional_map["FINISH"] = END #"chart"
workflow.add_conditional_edges("supervisor", lambda x: x["next"], conditional_map)
#workflow.add_edge("chart",END)
workflow.set_entry_point("supervisor")

graph = workflow.compile()

Description

In langgraph, I want to finish the graph traversal of agents when supervisor agent is repeated itself. for example when
supervisor -> agent_x -> supervisor -> agent_x
I want to prevent going to agent_x for the second time. Should I create an extra data structure to keep record of the agents used, and when it wants to reused, the traversal to be stopped? Or is there a better way to accomplish this?
Thanks

System Info

langchain==0.1.17
langchain-chroma==0.1.0
langchain-community==0.0.36
langchain-core==0.1.48
langchain-experimental==0.0.57
langchain-groq==0.1.3
langchain-openai==0.1.3
langchain-pinecone==0.1.0
langchain-text-splitters==0.0.1
langdetect==1.0.9
langgraph==0.0.38
langsmith==0.1.50

[dosubot[bot]]

To prevent your langgraph traversal from looping back to previously visited agents, you can implement a mechanism to track the sequence of agents and supervisors visited. This involves maintaining a history or stack of visited nodes and checking this history before transitioning to the next node. If the next node would result in a repeated sequence that has already been encountered, you can terminate the traversal or skip to the next possible node.

Here's a conceptual approach to integrate into your existing code:

1. Enhance your agent execution logic to include a check for repeated sequences before taking the next step. This can be done by implementing a method that analyzes the history of visited nodes (agents and supervisors) and identifies if the current path involves a repeated sequence.

2. In the method that detects repeated sequences, implement the logic to analyze the intermediate_steps (or a similar structure that tracks the traversal history). This method should determine if the current node, in combination with its predecessors, forms a sequence that has already been encountered.

By incorporating this mechanism, your traversal logic will be aware of the history of visited nodes, allowing it to make informed decisions to avoid infinite loops or redundant traversals. This approach ensures efficient and effective graph traversal by preventing the traversal from revisiting the same sequence of supervisor and agent nodes.

Details

Sources

• libs/langchain/langchain/agents/agent.py
• libs/experimental/langchain_experimental/graph_transformers/llm.py
• libs/core/langchain_core/runnables/graph.py
• libs/partners/openai/langchain_openai/chat_models/base.py
• libs/core/langchain_core/prompts/chat.py
• libs/core/langchain_core/output_parsers/openai_functions.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.

To continue the conversation, mention @dosu.

[ardakocaman100101]

I wrote a work around for this:

with tracing_v2_enabled(project_name="agents") as cb:
    keys = []
    for output in graph.stream(inputs, {"recursion_limit": 10}):
        agent = next(iter(output.items()))[0]
        if agent in keys and agent!="supervisor":
            break
        keys.append(next(iter(output.items()))[0])
        for key, value in output.items():
            print(f"Output from node '{key}':")
            print("---")
            print(value)
            result.append(value)
        print("---\n")

so basically i created a list for used agent memory. when an agent other than the supervisor is repeated, stream is broken to call the final answer manually