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

	Facebook
	Twitter
	Linkedin
	E-Mail

Agentic AI > LangGraph > LangGraph Conditional Routing

LangGraph Conditional Routing

Author: Venkata Sudhakar

Not every customer query should follow the same path. A billing question needs a different agent with different tools than a technical support question or a sales enquiry. LangGraph conditional routing lets you classify each incoming query and branch to the right specialised node automatically. This is more powerful than a single agent trying to handle everything - each specialist node has exactly the tools, context, and system prompt it needs for its domain. Routing happens in milliseconds and is transparent - you can log exactly which path each query took.

Conditional routing in LangGraph uses add_conditional_edges() which takes a node name, a function that reads the state and returns a string, and a mapping from strings to destination node names. The routing function is typically a fast LLM call that classifies the query intent - billing, technical, sales, or general. The state carries the original query and the route decision forward so every downstream node can see why it was selected. This audit trail is valuable for quality monitoring and for retraining the classifier over time.

The below example shows a telecom company routing customer queries to four specialised agents: billing and payments, technical support, plan upgrades, and general enquiries - each with its own focused system prompt and response style.

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from typing import TypedDict

llm = ChatOpenAI(model="gpt-4o-mini", api_key="your-api-key", temperature=0.2)
fast_llm = ChatOpenAI(model="gpt-4o-mini", api_key="your-api-key",
                      temperature=0.0, max_tokens=10)

class QueryState(TypedDict):
    query:    str
    route:    str   # set by classifier node
    response: str   # set by specialist node

# Node 1: Classifier - fast cheap call to decide route
def classify_query(state: QueryState) -> dict:
    result = fast_llm.invoke(
        "Classify this telecom customer query into exactly one category.\n"
        "BILLING: payment, invoice, charge, refund, bill amount\n"
        "TECHNICAL: network, internet, speed, signal, outage, device\n"
        "SALES: upgrade, new plan, offers, discount, add-on\n"
        "GENERAL: anything else\n\n"
        "Query: " + state["query"] + "\n\nReply with one word only: "
        "BILLING, TECHNICAL, SALES, or GENERAL"
    ).content.strip().upper()
    # Sanitise to valid routes
    route = result if result in ["BILLING","TECHNICAL","SALES","GENERAL"] else "GENERAL"
    print("Classified as:", route)
    return {"route": route}

# Routing function - reads state, returns next node name
def route_query(state: QueryState) -> str:
    return state["route"]

# Specialist nodes - each focused on its domain
def billing_agent(state: QueryState) -> dict:
    resp = llm.invoke(
        "You are a billing specialist for ConnectIndia Telecom. "
        "You handle payment queries, invoice disputes, and refund requests. "
        "Be precise about amounts and timelines. Always offer to raise a ticket.\n\n"
        "Customer: " + state["query"]
    )
    return {"response": resp.content}

def technical_agent(state: QueryState) -> dict:
    resp = llm.invoke(
        "You are a technical support engineer for ConnectIndia Telecom. "
        "You diagnose network issues, outages, and device problems. "
        "Give step-by-step troubleshooting. Escalate if needed.\n\n"
        "Customer: " + state["query"]
    )
    return {"response": resp.content}

def sales_agent(state: QueryState) -> dict:
    resp = llm.invoke(
        "You are a sales consultant for ConnectIndia Telecom. "
        "You explain plan upgrades, current offers, and add-on services. "
        "Be enthusiastic but not pushy. Focus on value.\n\n"
        "Customer: " + state["query"]
    )
    return {"response": resp.content}

def general_agent(state: QueryState) -> dict:
    resp = llm.invoke(
        "You are a helpful customer service agent for ConnectIndia Telecom. "
        "Answer general enquiries about the company and services.\n\n"
        "Customer: " + state["query"]
    )
    return {"response": resp.content}

Building the graph with conditional routing and testing four different queries,

# Build the graph with conditional routing
graph = StateGraph(QueryState)
graph.add_node("classify",  classify_query)
graph.add_node("BILLING",   billing_agent)
graph.add_node("TECHNICAL", technical_agent)
graph.add_node("SALES",     sales_agent)
graph.add_node("GENERAL",   general_agent)

graph.set_entry_point("classify")
graph.add_conditional_edges(
    "classify",
    route_query,
    {"BILLING": "BILLING", "TECHNICAL": "TECHNICAL",
     "SALES": "SALES", "GENERAL": "GENERAL"}
)
for node in ["BILLING", "TECHNICAL", "SALES", "GENERAL"]:
    graph.add_edge(node, END)

app = graph.compile()

test_queries = [
    "I was charged twice for my recharge last week. Need refund urgently.",
    "My 5G internet speed has dropped to 2Mbps since yesterday morning.",
    "What plans do you have for unlimited calling with 2GB daily data?",
    "What are your customer care hours on Sundays?"
]

for q in test_queries:
    print("Customer:", q)
    result = app.invoke({"query": q, "route": "", "response": ""})
    print("Route:   ", result["route"])
    print("Reply:   ", result["response"][:130])
    print()

It gives the following output showing routing decisions,

Customer: I was charged twice for my recharge last week. Need refund urgently.
Classified as: BILLING
Route:    BILLING
Reply:    I completely understand your concern about the duplicate charge. I
          can see this needs urgent attention. Please share your mobile number
          and transaction date and I will raise a priority refund ticket...

Customer: My 5G internet speed has dropped to 2Mbps since yesterday morning.
Classified as: TECHNICAL
Route:    TECHNICAL
Reply:    Let us troubleshoot this step by step. First, please restart your
          device and check if the 5G icon appears in the status bar. If yes,
          run a speed test at fast.com and share the result...

Customer: What plans do you have for unlimited calling with 2GB daily data?
Classified as: SALES
Route:    SALES
Reply:    Great choice! Our most popular option is the ConnectIndia 399 plan
          which gives you unlimited calls, 2GB daily data, and 100 SMS for
          28 days. We also have the 499 plan with 3GB daily...

Customer: What are your customer care hours on Sundays?
Classified as: GENERAL
Route:    GENERAL
Reply:    ConnectIndia customer care is available 24x7 including Sundays.
          You can reach us at 1800-123-4567 (toll-free) or chat on our app.

# Each query routed to the right specialist in milliseconds
# Billing agent never sees technical questions and vice versa
# Route logged in state for quality monitoring and analytics

Conditional routing scales well: add more specialist nodes without touching existing ones. A financial services company might have 8-10 routes (loans, credit cards, demat, insurance, KYC, complaints, fraud, general). Each node can have different tools, different LLM models (use a cheaper model for general, a smarter one for complaints), and different escalation logic. Monitor your classifier accuracy weekly - log every query and its route, then spot-check 50 per week to see if the classifier is misdirecting queries. A well-tuned classifier with clear category definitions achieves over 95% routing accuracy on real customer queries.

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