Human-in-the-loop with LangGraph in LangChain - Mini Project: Build & Apply

Human-in-the-loop with LangGraph

📖 Scenario: You are building a simple LangGraph workflow that processes user input and allows a human to review and approve the output before finalizing it. This simulates a real-world scenario where AI suggestions need human validation.

🎯 Goal: Create a LangGraph workflow with a human-in-the-loop step that takes a user question, generates an AI response, and then waits for human approval before completing.

📋 What You'll Learn

Create a LangGraph dictionary called graph with a nodes key containing a node named input_node that accepts a question string.

Add a configuration variable called approval_required set to true to control human approval.

Add a node named ai_response_node that uses LangChain's LLMChain to generate a response from the question.

Add a human_approval_node that simulates human approval by checking approval_required and waits for approval before continuing.

💡 Why This Matters

🌍 Real World

Human-in-the-loop workflows are common in AI applications where human review improves accuracy and trust, such as customer support or content moderation.

💼 Career

Understanding how to build and configure LangGraph workflows with human steps is valuable for AI developers and data scientists working on interactive AI systems.

1

Create the initial LangGraph data structure

Create a dictionary called graph with a key nodes containing a dictionary with one node named input_node. This node should have a type of input and accept a question string.

LangChain

# Create the LangGraph dictionary with an input_node
# Your code here

Hint

Think of graph as a map of steps. The input_node is where the user question enters the workflow.

2

Add a configuration variable for approval control

Add a variable called approval_required and set it to true to indicate that human approval is needed.

LangChain

graph = {
    'nodes': {
        'input_node': {
            'type': 'input',
            'inputs': ['question']
        }
    }
}

# Add approval_required variable
# Your code here

Hint

This variable will help us decide if the workflow should wait for human approval.

3

Add AI response node using LLMChain

Add a node named ai_response_node inside graph['nodes'] with type set to LLMChain. It should take question as input and produce response as output.

LangChain

graph = {
    'nodes': {
        'input_node': {
            'type': 'input',
            'inputs': ['question']
        }
    }
}
approval_required = true

# Add ai_response_node to graph['nodes']
# Your code here

Hint

This node uses AI to generate an answer from the question.

4

Add human approval node to control workflow

Add a node named human_approval_node inside graph['nodes'] with type set to human. It should take response as input and have a condition that checks if approval_required is true.

LangChain

graph = {
    'nodes': {
        'input_node': {
            'type': 'input',
            'inputs': ['question']
        },
        'ai_response_node': {
            'type': 'LLMChain',
            'inputs': ['question'],
            'outputs': ['response']
        }
    }
}
approval_required = true

# Add human_approval_node to graph['nodes']
# Your code here

Hint

This node simulates waiting for a human to approve the AI response before continuing.

Practice

1. What is the main purpose of using Human-in-the-loop with LangGraph?

easy

A. To combine AI processing steps with human feedback for better results

B. To replace human input entirely with AI automation

C. To create static AI models without any human interaction

D. To speed up AI training by skipping validation steps

Solution

1. Step 1: Understand Human-in-the-loop concept

   Human-in-the-loop means AI and humans work together, where humans check or improve AI outputs.

2. Step 2: Role of LangGraph in this context

   LangGraph helps build flows that connect AI steps with human feedback nodes to improve results.

3. Final Answer:

   To combine AI processing steps with human feedback for better results -> Option A

4. Quick Check:

   Human-in-the-loop = AI + human feedback [OK]

Hint: Human-in-the-loop means AI plus human checks [OK]

Common Mistakes:

• Thinking it removes human input
• Assuming it only automates AI without feedback
• Confusing it with fully automated AI pipelines

2. Which of the following is the correct way to add a human feedback node in a LangGraph flow?

easy

A. flow.create_human('review')

B. flow.add_human('review')

C. flow.add_node(HumanNode(name='review'))

D. flow.insert_human_node('review')

Solution

1. Step 1: Recall LangGraph syntax for adding nodes

   LangGraph uses flow.add_node() method to add nodes, including human nodes.

2. Step 2: Identify correct human node creation

   HumanNode is the class representing human feedback nodes, so flow.add_node(HumanNode(name='review')) is correct.

3. Final Answer:

   flow.add_node(HumanNode(name='review')) -> Option C

4. Quick Check:

   Use add_node with HumanNode class [OK]

Hint: Use add_node with HumanNode to add human steps [OK]

Common Mistakes:

• Using non-existent methods like add_human or insert_human_node
• Forgetting to instantiate HumanNode class
• Passing string directly without node wrapper

3. Given this LangGraph flow snippet:

flow.add_node(AINode(name='generate'))
flow.add_node(HumanNode(name='check'))
flow.connect('generate', 'check')
result = flow.run(input='Hello')

What will happen when flow.run is called?

medium

A. The flow runs human node first, then AI node

B. The flow runs only the AI node and skips the human node

C. The flow throws an error because human nodes cannot be connected

D. The AI node generates output, then the human node requests feedback before continuing

Solution

1. Step 1: Analyze flow node order and connections

   The AI node 'generate' runs first, then its output is passed to the human node 'check' via connect.

2. Step 2: Understand human node behavior in flow.run

   HumanNode pauses for human feedback before continuing, so the flow waits for human input after AI output.

3. Final Answer:

   The AI node generates output, then the human node requests feedback before continuing -> Option D

4. Quick Check:

   AI runs first, then human feedback [OK]

Hint: AI node runs before connected human node in flow [OK]

Common Mistakes:

• Assuming human nodes are skipped automatically
• Thinking human nodes run before AI nodes
• Believing human nodes cause errors when connected

4. You wrote this code snippet:

flow.add_node(HumanNode('review'))
flow.connect('review', 'generate')

But it throws an error. What is the likely cause?

medium

A. HumanNode must be instantiated with a named argument like name='review'

B. You cannot connect a human node to an AI node

C. The connect method requires node objects, not strings

D. HumanNode cannot be added to LangGraph flows

Solution

1. Step 1: Check HumanNode instantiation syntax

   HumanNode requires named argument 'name', so HumanNode('review') is invalid syntax.

2. Step 2: Confirm connection method accepts node names as strings

   Connecting nodes by their names as strings is valid, so error is not from connect method usage.

3. Final Answer:

   HumanNode must be instantiated with a named argument like name='review' -> Option A

4. Quick Check:

   HumanNode needs name= argument [OK]

Hint: HumanNode requires name= parameter when created [OK]

Common Mistakes:

• Passing positional argument instead of named argument
• Assuming connect only accepts node objects
• Thinking human nodes cannot be connected

5. You want to build a LangGraph flow where AI generates text, a human reviews and edits it, then AI summarizes the final text. Which flow setup correctly implements this?

hard

A. flow.add_node(AINode(name='generate'))
flow.add_node(AINode(name='summarize'))
flow.add_node(HumanNode(name='review'))
flow.connect('generate', 'summarize')
flow.connect('summarize', 'review')

B. flow.add_node(AINode(name='generate'))
flow.add_node(HumanNode(name='review'))
flow.add_node(AINode(name='summarize'))
flow.connect('generate', 'review')
flow.connect('review', 'summarize')

C. flow.add_node(HumanNode(name='review'))
flow.add_node(AINode(name='generate'))
flow.add_node(AINode(name='summarize'))
flow.connect('review', 'generate')
flow.connect('generate', 'summarize')

D. flow.add_node(AINode(name='generate'))
flow.add_node(HumanNode(name='review'))
flow.add_node(AINode(name='summarize'))
flow.connect('review', 'generate')
flow.connect('summarize', 'review')

Solution

1. Step 1: Identify correct node order for the flow

   The flow should be AI generate -> human review/edit -> AI summarize final text.

2. Step 2: Check connections match the desired order

   flow.add_node(AINode(name='generate')) flow.add_node(HumanNode(name='review')) flow.add_node(AINode(name='summarize')) flow.connect('generate', 'review') flow.connect('review', 'summarize') connects 'generate' to 'review', then 'review' to 'summarize', matching the required sequence.

3. Final Answer:

   AI generate, then human review, then AI summarize with correct connections -> Option B

4. Quick Check:

   Correct node order and connections = flow.add_node(AINode(name='generate')) flow.add_node(HumanNode(name='review')) flow.add_node(AINode(name='summarize')) flow.connect('generate', 'review') flow.connect('review', 'summarize') [OK]

Hint: Connect nodes in logical order: AI -> Human -> AI [OK]

Common Mistakes:

• Placing human node before AI generate
• Connecting nodes in wrong sequence
• Skipping human review step