Agent Recursion Between Tools and Agent - GraphRecursionError

[suribe06]

I am building an agent using LangGraph, which should decide whether to use its internal knowledge or external tools to answer user queries. The agent should attempt to respond using its own knowledge first and then, if necessary, call external tools (such as an API) to gather real-time data. However, I am encountering an issue where the agent repeatedly switches between itself and the tools, resulting in a GraphRecursionError: Recursion limit of 25 reached without hitting a stop condition.

Here is an overview of the setup:

1. The agent is bound to external tools and makes decisions about whether or not to use them based on the content of the query.
2. I use a decision node (decision_node) that checks if the agent needs to use tools or not.
3. The agent tries to call tools when needed, but once the tool returns a response, the agent falls back into an infinite loop, continuously jumping between the agent and the tool node.
4. This causes the graph to exceed its recursion limit without reaching a proper end state.

This is my code:

class State(TypedDict):
    messages: Annotated[Sequence[BaseMessage], operator.add]
    intermediate_steps: Dict
    use_tool: bool

# Agent and Tool setup
model = ChatOpenAI(temperature=0.7, model_name="gpt-4o")
tool = TavilySearchResults(max_results=1)
tool_node = ToolNode(tools=[tool])

tool_choice = "required"
agent = model.bind_tools([tool], tool_choice=tool_choice)

# Decision Chain and Node
def decision_node(state: State) -> State:
    last_message = state['messages'][-1].content
    output = decision_chain.invoke(last_message).content
    state['use_tool'] = "external" in output.lower()
    return state

# Routing and Calling Logic
def route_tools(state: State) -> Literal["agent", "llm"]:
    return "agent" if state['use_tool'] else "llm"

def call_model(state: State):
    messages = state['messages']
    response = model.invoke(messages)
    state["messages"].append(response)
    return state

def call_agent(state: State):
    messages = state['messages']
    response = agent.invoke(messages)
    print(state)
    return {"messages": [response]}

def should_continue(state: State) -> Literal["tools", END]:
    messages = state['messages']
    last_message = messages[-1]
    if last_message.tool_calls:
        return "tools"
    return END

# Workflow definition
workflow = StateGraph(State)

workflow.add_node("decision", decision_node)
workflow.add_node("llm", call_model)
workflow.add_node("agent", call_agent)
workflow.add_node("tools", tool_node)

workflow.add_edge(START, "decision")
workflow.add_conditional_edges(source="decision", path=route_tools, path_map={"llm": "llm", "agent": "agent"})
workflow.add_conditional_edges(source="agent", path=should_continue)
workflow.add_edge("tools", 'agent')
workflow.add_edge("llm", END)

checkpointer = MemorySaver()
app = workflow.compile(checkpointer=checkpointer)

From the LangSmith trace, it appears that the agent keeps bouncing between the agent node and the tool node, which leads to hitting the recursion limit. Once the tool is executed, I expect the agent to format the response and return it to the user, but instead, it keeps retrying the agent-tool cycle.

Expected Behavior: The agent should:

1.Try to respond using its knowledge base.
2. If it determines that it needs real-time data (e.g., a tool call), it should invoke the tool node.
3. After getting the tool’s response, the agent should format the result and return the final answer without further recursion between the agent and the tools.

Is there a better way to handle tool invocation in a manner that stops the agent from recursively switching between the tool and itself? Am I missing a termination condition or misplacing the logic for handling the tool response in the workflow?

[nfcampos]

Hi, the issue is you're forcing the model to always call a tool, with tool_choice=required. Thus the model will always return a tool call, and the stop condition should_continue will always return "tools"