Human-in-the-loop with LangGraph in LangChain

Introduction

Human-in-the-loop means a person helps a computer program make better decisions. LangGraph lets you build these programs easily by connecting steps and asking for human help when needed.

When a computer program is unsure about an answer and needs a person to check.

When you want to improve AI results by adding human feedback.

When automating tasks but want a person to review important steps.

When building chatbots that ask humans for help on tricky questions.

When combining AI and human work to get better accuracy.

Syntax

LangChain

from langchain.graphs import LangGraph
from langchain.schema import HumanMessage

def human_in_loop_example():
    graph = LangGraph()

    # Add nodes (steps) to the graph
    graph.add_node('step1', lambda: 'AI output')

    # Add human review node
    def human_review(input_text):
        # This simulates asking a human
        return HumanMessage(content=f'Reviewed: {input_text}')

    graph.add_node('human_check', human_review)

    # Connect nodes
    graph.add_edge('step1', 'human_check')

    # Run the graph
    result = graph.run('step1')
    return result

LangGraph lets you create nodes (steps) and connect them to form a flow.

HumanMessage is used to represent human input or feedback in the flow.

Examples

This example shows a simple AI step followed by a human review step.

LangChain

graph = LangGraph()
graph.add_node('ai_step', lambda: 'AI says hello')
graph.add_node('human_step', lambda x: HumanMessage(content=f'Human checked: {x}'))
graph.add_edge('ai_step', 'human_step')
result = graph.run('ai_step')

Shows what happens if you try to run a node that does not exist (usually an error or no output).

LangChain

graph = LangGraph()
# Empty graph run
result = graph.run('nonexistent_node')

Graph with only one human node, no AI steps.

LangChain

graph = LangGraph()
graph.add_node('only_human', lambda: HumanMessage(content='Human input only'))
result = graph.run('only_human')

Graph with AI start and human final check.

LangChain

graph = LangGraph()
graph.add_node('start', lambda: 'Start AI')
graph.add_node('end', lambda x: HumanMessage(content=f'Final check: {x}'))
graph.add_edge('start', 'end')
result = graph.run('start')

Sample Program

This program creates a LangGraph with two steps: an AI step and a human review step. It runs the graph and prints the final human-reviewed message.

LangChain

from langchain.graphs import LangGraph
from langchain.schema import HumanMessage

def human_in_loop_demo():
    graph = LangGraph()

    # AI step that generates a message
    def ai_step():
        return 'AI generated text'

    # Human review step that takes AI output
    def human_review(input_text):
        # Simulate human reviewing and confirming
        return HumanMessage(content=f'Human reviewed: {input_text}')

    # Add nodes
    graph.add_node('ai_step', ai_step)
    graph.add_node('human_review', human_review)

    # Connect AI step to human review
    graph.add_edge('ai_step', 'human_review')

    # Run the graph starting from AI step
    print('Before running graph:')
    print('Nodes:', list(graph.nodes.keys()))

    result = graph.run('ai_step')

    print('\nAfter running graph:')
    print('Result:', result.content)

if __name__ == "__main__":
    human_in_loop_demo()

Important Notes

The time complexity depends on the number of nodes and edges in the graph.

Space complexity depends on how much data each node stores and passes.

A common mistake is forgetting to connect nodes, so the flow does not run as expected.

Use human-in-the-loop when AI alone is not reliable enough or needs human judgment.

Summary

Human-in-the-loop means combining AI steps with human feedback in a flow.

LangGraph helps build these flows by connecting AI and human nodes.

This approach improves results by letting humans check or fix AI outputs.

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