	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Agentic AI > LangGraph > LangGraph Conditional Edges

LangGraph Conditional Edges

Author: Venkata Sudhakar

A conditional edge in LangGraph decides which node to visit next based on the current state. This is how you give an agent the ability to branch - for example, routing to a tool executor when the LLM wants to call a tool, or routing to END when the LLM has a final answer. Without conditional edges, your graph can only go in one fixed direction. With them, the graph adapts dynamically at runtime.

A conditional edge is added with graph.add_conditional_edges(from_node, routing_function). The routing function receives the current state and returns a string - the name of the next node to go to, or END. Typically you inspect the last message in the state: if it has tool_calls, route to the tools node; otherwise route to END.

The below example shows the exact routing function pattern used in a ReAct agent loop. The LLM node runs, then the conditional edge checks whether the LLM wants to call a tool or is done.

from typing import TypedDict, Annotated, Sequence
from langchain_core.messages import BaseMessage
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
import operator

@tool
def add(a: int, b: int) -> int:
    "Add two numbers."
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    "Multiply two numbers."
    return a * b

tools = [add, multiply]
llm = ChatOpenAI(model="gpt-4o-mini", api_key="your-key").bind_tools(tools)

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

def llm_node(state: State):
    return {"messages": [llm.invoke(state["messages"])]}

# This is the conditional edge routing function
# It inspects the last LLM message and decides where to go next
def route(state: State) -> str:
    last = state["messages"][-1]
    if hasattr(last, "tool_calls") and last.tool_calls:
        return "tools"   # LLM wants a tool - go to tool executor
    return END           # LLM gave a final answer - stop

graph = StateGraph(State)
graph.add_node("llm", llm_node)
graph.add_node("tools", ToolNode(tools))
graph.set_entry_point("llm")
graph.add_conditional_edges("llm", route)  # route() decides what happens after llm
graph.add_edge("tools", "llm")             # after tools always go back to llm
app = graph.compile()

It gives the following output,

from langchain_core.messages import HumanMessage

result = app.invoke({"messages": [HumanMessage(content="What is 6 multiplied by 7?")]})
print(result["messages"][-1].content)

# Execution trace:
# llm_node  -> tool_calls: [multiply(a=6, b=7)]  -> route returns "tools"
# tools     -> result: 42                        -> edge goes back to llm
# llm_node  -> no tool_calls, final answer       -> route returns END

# Output:
The result of 6 multiplied by 7 is 42.

The routing function is just a plain Python function - you can put any logic there. Return a string matching a node name to continue, or END to stop. You can also return different node names for different cases, for example routing to an error_handler node if the tool raised an exception.

Send your comments, suggestions or queries regarding this site to [email protected].