Conditional Routing with LangGraph

From Simple Decisions to Complex Routing

So far, our conditional logic has been a binary choice, implemented in our should_continue function: should the agent call a tool or end the conversation?

def should_continue(state: AgentState):
    if state["messages"][-1].tool_calls:
        return "tools" # Go to the tool node
    return "end"     # Go to the end

This is a form of conditional routing, but LangGraph allows for much more. The add_conditional_edges function can handle any number of paths. The core mechanism consists of three parts:

1. Source Node: The node after which the decision is made.
2. Routing Function: A function that inspects the current state and returns a string (or any hashable value) indicating which path to take.
3. Path Map: A dictionary that maps the values returned by the routing function to the names of the destination nodes.

This pattern allows for creating highly dynamic and intelligent workflows, as shown in the diagram below.

Building a Multi-Personality Agent

To put this into practice, we'll build a new agent that first classifies the user's intent and then routes the query to a specialized LLM persona for a tailored response.

The flow will be:

1. Start: Receive user input.
2. Classifier: A node uses an LLM to classify the input as requiring either a "logical" or "emotional" response. This decision is stored in the agent's state.
3. Router (Conditional Edge): Our routing function reads the classification from the state and directs the workflow to one of two paths.
4. Specialist Agents:
   • Logical Agent: A node with a system prompt geared towards factual, analytical answers.
   • Therapist Agent: A node with a system prompt designed for empathetic, supportive answers.
5. End: The specialist agent provides its response, and the graph concludes.

The following video tutorial provides a complete, step-by-step walkthrough of building this exact agent. As a software engineer, you'll find its code-centric approach very clear. We will work through it together.

Let's Code: Full Implementation

After watching the video, you should have a solid grasp of the components. Here is the complete code for the agent. You can create a new Python file and follow along. This code mirrors what was built in the video, with minor adjustments for clarity and to ensure it runs as a standalone script.

First, ensure you have the necessary dependencies. In addition to the ones from the previous lesson, you'll need pydantic and python-dotenv.

uv pip install langgraph langchain-anthropic pydantic python-dotenv

Next, create a .env file in your project root and add your Anthropic API key (the example uses Claude, but you can adapt it for OpenAI if you prefer).

ANTHROPIC_API_KEY="your_api_key_here"

Now, here is the full main.py:

import os
from dotenv import load_dotenv
from typing import Annotated, Literal
from typing_extensions import TypedDict

from langchain_anthropic import ChatAnthropic
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from pydantic import BaseModel, Field

# --- 1. Setup Environment ---
load_dotenv()

# --- 2. Define State and Pydantic Models ---
class State(TypedDict):
    """The state of our graph."""
    messages: Annotated[list, add_messages]
    # This field will be used by the router
    message_type: str | None

class MessageClassifier(BaseModel):
    """Pydantic model for classifying the user's message."""
    message_type: Literal["emotional", "logical"] = Field(
        ...,
        description="Classify the message as requiring an emotional/therapist or logical response."
    )

# --- 3. Initialize Model ---
llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")

# --- 4. Define Graph Nodes ---

def classify_message(state: State):
    """
    Classifies the user's message and updates the message_type in the state.
    """
    # Use a version of the LLM that is forced to produce structured output
    classifier_llm = llm.with_structured_output(MessageClassifier)
    
    last_message = state["messages"][-1]
    
    # System prompt to guide the classification
    system_prompt = """You are a master at reading people. Classify the user's message as either 'emotional' if it deals with feelings, personal problems, or requires empathy, or 'logical' if it asks for facts, information, or practical solutions."""
    
    # Invoke the classifier
    result = classifier_llm.invoke(
        [
            ("system", system_prompt),
            ("user", last_message.content)
        ]
    )
    
    print(f"--- Classifier decided: {result.message_type} ---")
    return {"message_type": result.message_type}

def logical_agent(state: State):
    """
    Generates a response from a logical, fact-based perspective.
    """
    system_prompt = "You are a purely logical assistant. Focus on facts and provide clear, concise answers based on evidence."
    response = llm.invoke([("system", system_prompt)] + state["messages"])
    return {"messages": [response]}

def therapist_agent(state: State):
    """
    Generates a response from an empathetic, supportive perspective.
    """
    system_prompt = "You are a compassionate therapist. Focus on the emotional aspects of the user's message, show empathy, and validate their feelings."
    response = llm.invoke([("system", system_prompt)] + state["messages"])
    return {"messages": [response]}

# --- 5. Define the Router ---
def router(state: State) -> Literal["logical_agent", "therapist_agent"]:
    """
    Reads the message_type from the state and decides which agent to route to.
    """
    return f"{state['message_type']}_agent"

# --- 6. Assemble the Graph ---
graph_builder = StateGraph(State)

# Add all the nodes
graph_builder.add_node("classify_message", classify_message)
graph_builder.add_node("logical_agent", logical_agent)
graph_builder.add_node("therapist_agent", therapist_agent)

# The entry point is the classifier
graph_builder.set_entry_point("classify_message")

# Add the conditional edge from the classifier to the specialist agents
graph_builder.add_conditional_edges(
    "classify_message",
    router,
    {
        "logical_agent": "logical_agent",
        "therapist_agent": "therapist_agent"
    }
)

# The specialist agents lead to the end
graph_builder.add_edge("logical_agent", END)
graph_builder.add_edge("therapist_agent", END)

# Compile the graph
graph = graph_builder.compile()

# --- 7. Run the Agent ---
def run_agent(query):
    print(f"\n--- Querying Agent: '{query}' ---")
    response = graph.invoke({"messages": [("user", query)]})
    print("--- Final Response ---")
    print(response["messages"][-1].content)


# Test with a logical query
run_agent("What are the main components of a CPU?")

# Test with an emotional query
run_agent("I'm feeling really overwhelmed with work lately.")

When you run this script, you'll see the output from the classifier node for each query, followed by a response generated by the corresponding specialist agent. This demonstrates conditional routing in action!

Conclusion

Congratulations! You have now mastered one of the most fundamental concepts for building advanced agents: conditional routing. You've moved beyond simple linear chains and can now create dynamic, stateful workflows that adapt their behavior based on the situation.

Key Takeaways:

• Conditional Routing is the mechanism for creating branches in your agent's workflow.
• The add_conditional_edges function is the primary tool for this, requiring a source node, a routing function, and a path map.
• The Routing Function's sole job is to inspect the current state and return a key that determines the next step.
• Using an LLM with Structured Output (e.g., via Pydantic) is a robust way to make routing decisions, as it provides predictable output that your routing function can easily parse.
• This pattern allows for the creation of "specialist" agents, where a primary agent routes tasks to sub-agents that are experts in a specific domain.

In our next lesson, we will tackle error handling. Real-world agents need to be resilient to failures, such as a tool's API being temporarily down. We will implement strategies like automatic retries to make our agent more robust and production-ready.