Are conditional edges executed before the previous node finishes?

[PBenavides]

Hello! I am new to LangGraph and I am not sure how does the library manage the execution of the nodes. I have the following case, where I am using the Send class to create more executions based on some defined logic.

The node before using the Send conditional_edge has a LLM call (node_with_llm), and all the nodes after the conditional edge (last_node) are using that response as a context.

But the thing is that apparently conditional_edge executes before node_with_llm finishes and update the state with this context.

My graph:

Here is the code to Replicate

import os
from typing import Optional, TypedDict
from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage, HumanMessage
from langgraph.constants import Send
from langgraph.graph import END, START, StateGraph

gpt_model = ChatOpenAI(model="gpt-4o", api_key=os.environ.get('OPENAI_API_KEY'))

def node_a(state):
    value_a = state["value_a"] + 1
    return {"value_a": value_a}

def node_b(state):
    value_b = state["value_b"] + 1
    return {"value_b": value_b}

def node_with_llm(state):
    response = gpt_model.invoke([HumanMessage(content=f"Hey! Give me a random text of 8 sentences.")])
    return {"llm_response": response.content}

def last_node(state):
    llm_response = str(state["value_c"]) + state["llm_response"]
    print(llm_response)
    return {"another_response": llm_response}

def conditional_edge_send(state):
    print("Sending states to nodes")
    return [
        Send("last_node",
        {
            "value_c": n
        }) for n in range(1,8)
    ]

class OverallState(TypedDict):
    value_a: int
    value_b: int
    llm_response: Optional[str]
    another_response: Optional[str]

def create_graph():

    graph = StateGraph(OverallState)
    graph.add_node("node_a", node_a)
    graph.add_node("node_b", node_b)
    graph.add_node("node_with_llm", node_with_llm)
    graph.add_node("last_node", last_node)

    graph.add_edge(START, "node_a")
    graph.add_edge(START, "node_b")
    graph.add_edge("node_a", "node_with_llm")
    graph.add_edge("node_b", "node_with_llm")

    graph.add_conditional_edges("node_with_llm", conditional_edge_send, ["last_node"] )
    graph.add_edge("last_node", END)
    graph = graph.compile()

    return graph

graph = create_graph()
from IPython.display import Image, display
display(Image(graph.get_graph(xray=True).draw_mermaid_png()))

config = {
    "configurable": {
            "thread_id": "1",
            "run_name": "Test"}, 
        "recursion_limit": 10
}

init_state = OverallState(
    value_a = 1,
    value_b = 2
    )

i = 0
for chunk in graph.stream(init_state , config, stream_mode="values"):
    print(chunk)

[hinthornw]

They execute afterwards, but the Send targets receive exactly what you put in the send payload, which does not include the LLM result in your example code (your edge is just sending the value for c)

[PBenavides]

Thanks! It works now. So it is a completely new state defined in the Send payload.