Multi-Step Reasoning with LangGraph: The Iterative Agent

The biggest weakness of simple Graph RAG is the "Single Shot" trap. If the first query doesn't find the answer, the system fails. But a human expert would say, "Okay, I didn't find the budget for Project X, let me look at the parent Department's budget instead." This is Recursive Reasoning.

In this lesson, we will use LangGraph to build a "Thinking Agent." We will move from a linear chain to a State Machine. We will learn how to define an agent that can query the graph, look at the results, and decide if it needs to perform another, deeper query or if it's ready to answer the user.

---

1. The Cyclic Agent Workflow

In LangGraph, an agent is a graph (of nodes/logic) that processes another graph (the database).

1. Node: Query Generator: Writes a Cypher query.
2. Node: Graph Executor: Runs the query and gets the data.
3. Node: Evaluator: Analyzes the data.
   • Condition A: "I have the answer" -> Go to Final Answer.
   • Condition B: "I'm missing a piece of data" -> Go back to Query Generator with a new hint.

The Loop: This cycle can run 3-5 times until the "Information Gap" is closed.

---

2. Defining the "State"

The "State" is a shared dictionary that persists through the loop. For Graph RAG, our state should look like this:

from typing import TypedDict, List

class AgentState(TypedDict):
    question: str
    cypher_queries: List[str]
    graph_results: List[str]
    reasoning_history: List[str]
    final_answer: str

By keeping the reasoning_history, the agent remembers what it has already tried, preventing it from getting stuck in an infinite loop of the same broken query.

---

3. The "Tool-Use" Pattern

Instead of one giant function, we give the agent a Toolbox.

• Tool A: get_entity_neighbors(name)
• Tool B: get_path_between(A, B)
• Tool C: semantic_search(text)

The agent acts as a Controller. It says: "I'll start with Tool C to find the project, then I'll use Tool A to see who leads it."

graph TD
    Start((Start)) --> Q[Query Generator]
    Q --> E[Graph Executor]
    E --> V{Is it enough?}
    V -->|No| R[Refinement Node]
    R --> Q
    V -->|Yes| A[Answer Node]
    
    style V fill:#f4b400,color:#fff
    style A fill:#34A853,color:#fff

---

4. Implementation: A Simple LangGraph Cycle

from langgraph.graph import StateGraph, END

# 1. Define the Nodes
def generate_query(state: AgentState):
    # Logic to generate Cypher based on state['question']
    return {"cypher_queries": [new_query]}

def run_query(state: AgentState):
    # Logic to execute the last query against Neo4j
    return {"graph_results": [raw_data]}

# 2. Build the Graph
workflow = StateGraph(AgentState)
workflow.add_node("generator", generate_query)
workflow.add_node("executor", run_query)

workflow.set_entry_point("generator")
workflow.add_edge("generator", "executor")

# Add a conditional edge
workflow.add_conditional_edges(
    "executor",
    should_continue, # A function that checks if we have enough data
    {
        "continue": "generator",
        "end": END
    }
)

---

5. Summary and Exercises

LangGraph transforms Graph RAG from a "Search" to a "Search Party."

• Cyclic Workflows allow for refinement and error recovery.
• State Management keeps the agent focused and prevents loops.
• Conditional Logic enables the agent to decide when it's "Done."
• Persistence allows you to save the state of a "Deep Reasoning" session.

Exercises

1. State Audit: What happens if you don't store the cypher_queries in the state? Can the agent "Learn" from its previous mistakes?
2. Logic Task: Write a should_continue function that stops the loop if the length of graph_results is greater than 0, OR if the loop has run 3 times.
3. Visualization: Draw the "Thought Process" of an agent asked to: "Find the total salary of everyone working on Project Jupiter." How many graph calls does it need? (Step 1: Find Team. Step 2: Find Salaries).

In the next lesson, we will look at how to monitor these complex bots: Debugging and Observability in Graph Chains.