Conditional routing in graphs in LangChain - Step-by-Step Execution

Concept Flow - Conditional routing in graphs

Start at Entry Node

↓

Evaluate Condition on Node

↓

Follow Yes Edge

↓

Next Node

↓

End Node

The graph starts at an entry node, evaluates a condition, and routes to the next node based on Yes/No outcomes until reaching the end.

Execution Sample

LangChain

graph = {
  'start': lambda x: 'node1' if x > 0 else 'node2',
  'node1': lambda x: 'end',
  'node2': lambda x: 'end'
}

current = 'start'
while current != 'end':
  current = graph[current](5)

This code routes through a graph starting at 'start', choosing next nodes based on a condition until reaching 'end'.

Execution Table

Step	Current Node	Input Value	Condition Evaluated	Next Node	Action Taken
1	start	5	5 > 0 is True	node1	Follow 'Yes' edge to node1
2	node1	5	No condition (direct to end)	end	Move to end node
3	end	-	Reached end node	-	Stop routing

💡 Reached 'end' node, routing stops.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
current	start	node1	end	end
input_value	5	5	5	5

Key Moments - 3 Insights

Why does the routing stop when current node is 'end'?

Because the execution_table row 3 shows 'end' node reached, which is the termination condition for routing.

What happens if the condition at 'start' node is False?

The routing follows the 'No' edge to 'node2' instead of 'node1', as shown by the condition evaluation in execution_table row 1.

Why do we evaluate conditions at each node?

To decide which path to take next, enabling dynamic routing based on input, as shown in execution_table steps 1 and 2.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'current' after step 1?

A node1

B node2

C start

D end

💡 Hint

Check the 'current node' column in execution_table row 2.

At which step does the routing reach the 'end' node?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Current Node' column in execution_table to find when 'end' appears.

If the input value was -1, which node would be visited after 'start'?

A node1

B node2

C end

D start

💡 Hint

Refer to the condition 'x > 0' in execution_table row 1 and think about the False branch.

Concept Snapshot

Conditional routing in graphs:
- Start at an entry node
- Evaluate a condition at each node
- Follow edges based on condition outcome (Yes/No)
- Continue until reaching an end node
- Enables dynamic path selection based on input

Full Transcript

Conditional routing in graphs means starting at a specific node and deciding which path to take next by checking a condition at that node. If the condition is true, you follow one path; if false, another. This continues until you reach an end node, where routing stops. For example, starting at 'start', if the input is greater than zero, you go to 'node1'; otherwise, you go to 'node2'. Both 'node1' and 'node2' lead to 'end', which stops the routing. This method helps in making decisions step-by-step in a graph based on changing inputs.

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