Prompt Chaining (Sequential Processing)

A sequential pattern where each LLM call processes the previous output.

Overview

Prompt Chaining is a pattern that chains multiple LLM calls in sequence. The output of each step becomes the input for the next step.

Use Cases

Stepwise processing like translation → summary → analysis
Content generation → validation → correction pipeline
Data extraction → transformation → validation flow

Implementation Example

from langgraph.graph import StateGraph, START, END
from typing import TypedDict

class State(TypedDict):
    text: str
    translated: str
    summarized: str
    analyzed: str

def translate_node(state: State):
    """Translate English → Japanese"""
    translated = llm.invoke(
        f"Translate to Japanese: {state['text']}"
    )
    return {"translated": translated}

def summarize_node(state: State):
    """Summarize translated text"""
    summarized = llm.invoke(
        f"Summarize this text: {state['translated']}"
    )
    return {"summarized": summarized}

def analyze_node(state: State):
    """Analyze summary"""
    analyzed = llm.invoke(
        f"Analyze sentiment: {state['summarized']}"
    )
    return {"analyzed": analyzed}

# Build graph
builder = StateGraph(State)
builder.add_node("translate", translate_node)
builder.add_node("summarize", summarize_node)
builder.add_node("analyze", analyze_node)

# Edges for sequential execution
builder.add_edge(START, "translate")
builder.add_edge("translate", "summarize")
builder.add_edge("summarize", "analyze")
builder.add_edge("analyze", END)

graph = builder.compile()

Benefits

✅ Simple: Processing flow is linear and easy to understand ✅ Predictable: Always executes in the same order ✅ Easy to Debug: Each step can be tested independently ✅ Gradual Improvement: Quality improves at each step

Considerations

⚠️ Accumulated Delay: Takes time as each step executes sequentially ⚠️ Error Propagation: Earlier errors affect later stages ⚠️ Lack of Flexibility: Dynamic branching is difficult

Advanced Patterns

Pattern 1: Chain with Validation

def validate_translation(state: State):
    """Validate translation quality"""
    is_valid = check_quality(state["translated"])
    return {"is_valid": is_valid}

def route_after_validation(state: State):
    if state["is_valid"]:
        return "continue"
    return "retry"

# Validation → continue or retry
builder.add_conditional_edges(
    "validate",
    route_after_validation,
    {
        "continue": "summarize",
        "retry": "translate"
    }
)

Pattern 2: Gradual Refinement

def draft_node(state: State):
    """Create draft"""
    draft = llm.invoke(f"Write a draft: {state['topic']}")
    return {"draft": draft}

def refine_node(state: State):
    """Refine draft"""
    refined = llm.invoke(f"Improve this draft: {state['draft']}")
    return {"refined": refined}

def polish_node(state: State):
    """Final polish"""
    polished = llm.invoke(f"Polish this text: {state['refined']}")
    return {"final": polished}

vs Other Patterns

Pattern	Prompt Chaining	Parallelization
Execution Order	Sequential	Parallel
Dependencies	Yes	No
Execution Time	Long	Short
Use Case	Stepwise processing	Independent tasks

Summary

Prompt Chaining is the simplest pattern, optimal for cases requiring stepwise processing. Use when each step depends on the previous step.

02_graph_architecture_parallelization.md - Comparison with parallel processing
02_graph_architecture_evaluator_optimizer.md - Combination with validation loop
01_core_concepts_edge.md - Edge basics

3.8 KiB Raw Blame History