Conditional routing in graphs in LangChain - Mini Project: Build & Apply

Conditional Routing in Graphs with LangChain

📖 Scenario: You are building a simple chatbot flow using LangChain. The chatbot should decide which response path to take based on user input conditions. This is like choosing different roads on a map depending on traffic or weather.

🎯 Goal: Create a LangChain graph with nodes and edges that route conditionally based on user input. The chatbot will ask a question and follow different paths depending on the answer.

📋 What You'll Learn

Create a LangChain graph with at least three nodes

Add a condition variable to decide routing

Use conditional routing to choose the next node based on the condition

Complete the graph with a final node that ends the conversation

💡 Why This Matters

🌍 Real World

Conditional routing in graphs is useful for building chatbots, decision trees, and workflows that change behavior based on user input or data.

💼 Career

Understanding conditional routing in LangChain graphs helps developers create smarter conversational AI and automated systems that adapt to different scenarios.

1

Create initial LangChain graph nodes

Create three LangChain nodes named start_node, yes_node, and no_node. Each node should have a simple prompt string: "Do you like coffee?", "Great! Coffee is awesome.", and "No worries! Tea is nice too.", respectively.

LangChain

# Create three LangChain nodes with the exact names and prompts
# Your code here

Hint

Use Node from langchain.graphs and BasePromptTemplate from langchain.prompts to create nodes with prompts.

2

Add a condition variable for routing

Create a variable called likes_coffee and set it to True. This variable will control which path the graph takes.

LangChain

from langchain.prompts import BasePromptTemplate
from langchain.graphs import Graph, Node

start_node = Node(prompt=BasePromptTemplate(template="Do you like coffee?"))
yes_node = Node(prompt=BasePromptTemplate(template="Great! Coffee is awesome."))
no_node = Node(prompt=BasePromptTemplate(template="No worries! Tea is nice too."))

# Create a boolean variable likes_coffee and set it to True
# Your code here

Hint

Just create a variable named likes_coffee and assign True to it.

3

Add conditional routing edges to the graph

Create a LangChain Graph named chat_graph with start_node as the root. Add edges from start_node to yes_node and no_node using conditions: route to yes_node if likes_coffee is True, else route to no_node.

LangChain

from langchain.prompts import BasePromptTemplate
from langchain.graphs import Graph, Node

start_node = Node(prompt=BasePromptTemplate(template="Do you like coffee?"))
yes_node = Node(prompt=BasePromptTemplate(template="Great! Coffee is awesome."))
no_node = Node(prompt=BasePromptTemplate(template="No worries! Tea is nice too."))

likes_coffee = True

# Create a Graph named chat_graph with start_node as root
# Add conditional edges from start_node to yes_node and no_node based on likes_coffee
# Your code here

Hint

Use Graph(root=start_node) to create the graph. Use add_edge with a condition lambda that returns likes_coffee or its negation.

4

Add a final node to complete the graph

Create a LangChain node named end_node with the prompt "Thanks for chatting!". Add edges from both yes_node and no_node to end_node without conditions to complete the graph.

LangChain

from langchain.prompts import BasePromptTemplate
from langchain.graphs import Graph, Node

start_node = Node(prompt=BasePromptTemplate(template="Do you like coffee?"))
yes_node = Node(prompt=BasePromptTemplate(template="Great! Coffee is awesome."))
no_node = Node(prompt=BasePromptTemplate(template="No worries! Tea is nice too."))

likes_coffee = True

chat_graph = Graph(root=start_node)
chat_graph.add_edge(start_node, yes_node, condition=lambda: likes_coffee)
chat_graph.add_edge(start_node, no_node, condition=lambda: not likes_coffee)

# Create end_node with prompt "Thanks for chatting!"
# Add edges from yes_node and no_node to end_node without conditions
# Your code here

Hint

Create end_node like the other nodes. Add edges from yes_node and no_node to end_node without conditions.

Practice

1. What is the main purpose of conditional routing in Langchain graphs?

easy

A. To randomly select a node without any rules

B. To execute all nodes in parallel regardless of conditions

C. To stop the graph execution immediately

D. To choose the next node based on specific conditions

Solution

1. Step 1: Understand conditional routing concept

   Conditional routing means selecting the next step based on rules or conditions.

2. Step 2: Match purpose with options

   Only To choose the next node based on specific conditions describes choosing the next node based on conditions, which fits the concept.

3. Final Answer:

   To choose the next node based on specific conditions -> Option D

4. Quick Check:

   Conditional routing = choose next node by condition [OK]

Hint: Think: routing means choosing path by rules [OK]

Common Mistakes:

• Confusing routing with parallel execution
• Assuming routing stops the graph
• Thinking routing is random

2. Which of the following is the correct way to define a condition function for routing in Langchain?

easy

A. def condition(context): return context['value'] > 10

B. condition = context => context.value > 10

C. def condition(): return context['value'] > 10

D. condition(context): return context.value > 10

Solution

1. Step 1: Check function syntax in Python

   Python functions require 'def' keyword, a parameter list, and a return statement.

2. Step 2: Validate each option

   def condition(context): return context['value'] > 10 correctly defines a function with one parameter and returns a boolean. condition = context => context.value > 10 uses JavaScript syntax. def condition(): return context['value'] > 10 misses the parameter. condition(context): return context.value > 10 misses 'def' keyword.

3. Final Answer:

   def condition(context): return context['value'] > 10 -> Option A

4. Quick Check:

   Python function with parameter and return = def condition(context): return context['value'] > 10 [OK]

Hint: Remember Python function syntax: def name(params): return value [OK]

Common Mistakes:

• Using JavaScript arrow function syntax in Python
• Omitting function parameters
• Missing 'def' keyword

3. Given this routing setup in Langchain graph:

conditions = [
  lambda ctx: ctx['score'] > 80,
  lambda ctx: ctx['score'] > 50
]
routes = ['high', 'medium', 'low']
context = {'score': 65}

Which route will be chosen?

medium

A. "high"

B. "medium"

C. "low"

D. Error due to missing condition

Solution

1. Step 1: Evaluate conditions in order with context

   First condition: score > 80? 65 > 80 is False. Second condition: score > 50? 65 > 50 is True.

2. Step 2: Match true condition to route

   Second condition matches, so route at index 1 is chosen, which is "medium".

3. Final Answer:

   "medium" -> Option B

4. Quick Check:

   First true condition index = route chosen [OK]

Hint: Check conditions top to bottom, pick first true route [OK]

Common Mistakes:

• Choosing 'high' because 65 > 50 but ignoring order
• Picking 'low' when conditions match
• Assuming error if not all conditions true

4. Identify the error in this Langchain routing code snippet:

def route_condition(context):
  if context['value'] > 10:
    return True
  elif context['value'] < 5:
    return False

routes = ['path1', 'path2']
# Routing uses route_condition

medium

A. Routes list should have three paths

B. The function uses wrong comparison operators

C. The function does not return a value for all cases

D. The function should return strings, not booleans

Solution

1. Step 1: Check function return paths

   The function returns True if value > 10, False if value < 5, but returns nothing if value is between 5 and 10.

2. Step 2: Understand routing condition requirements

   Routing conditions must return a boolean for every input to decide path. Missing return causes errors or unexpected behavior.

3. Final Answer:

   The function does not return a value for all cases -> Option C

4. Quick Check:

   All code paths must return a boolean [OK]

Hint: Ensure all if/else paths return a value [OK]

Common Mistakes:

• Ignoring missing return in some cases
• Thinking routes count must match conditions exactly
• Returning wrong data types

5. You want to route a Langchain graph node based on user input where:
- If input contains "urgent", go to 'priority' node
- If input length > 100, go to 'long' node
- Otherwise, go to 'normal' node

Which conditional routing setup correctly implements this logic?

hard

A. conditions = [lambda ctx: 'urgent' in ctx['input'], lambda ctx: len(ctx['input']) > 100]
routes = ['priority', 'long', 'normal']

B. conditions = [lambda ctx: len(ctx['input']) > 100, lambda ctx: 'urgent' in ctx['input']]
routes = ['long', 'priority', 'normal']

C. conditions = [lambda ctx: 'urgent' in ctx['input'] and len(ctx['input']) > 100]
routes = ['priority', 'long', 'normal']

D. conditions = [lambda ctx: 'urgent' not in ctx['input'], lambda ctx: len(ctx['input']) <= 100]
routes = ['normal', 'long', 'priority']

Solution

1. Step 1: Match conditions to requirements in order

   First condition checks if 'urgent' is in input, matching priority route. Second checks input length > 100 for long route.

2. Step 2: Confirm routes order matches conditions plus default

   Routes list has 'priority', 'long', then 'normal' as default if no condition matches.

3. Final Answer:

   conditions = [lambda ctx: 'urgent' in ctx['input'], lambda ctx: len(ctx['input']) > 100] routes = ['priority', 'long', 'normal'] -> Option A

4. Quick Check:

   Order and logic match requirements [OK]

Hint: Order conditions by priority, add default route last [OK]

Common Mistakes:

• Swapping condition order and routes
• Combining conditions incorrectly
• Using negated conditions that break logic