Module 04: Prompt Chaining and Orchestration

Duration: 3 hours | Difficulty: Intermediate | Prerequisites: Modules 01–03

Learning Objectives

By the end of this module, you will be able to:

• Decompose complex tasks into multi-step prompt chains
• Implement sequential, parallel, and conditional chaining patterns
• Build map-reduce workflows for processing large datasets with LLMs
• Apply self-consistency techniques for more reliable outputs
• Design robust multi-step workflows with error handling

1. Why Prompt Chaining?

The Single-Prompt Trap

One giant prompt is like asking someone to research, outline, write, edit, and fact-check in a single breath. Chains give each step a narrow job—higher quality, easier debugging.

2. Sequential Chains

Output of step n becomes input (or context) for step n+1.

Key Example: Four-stage doc pipeline—each stage is a focused LLM call. In production you’d log intermediates.

[object Object], openai ,[object Object], OpenAI

client = OpenAI(api_key=,[object Object],)

,[object Object], ,[object Object],(,[object Object],) -> ,[object Object],:
    r = client.chat.completions.create(
        model=,[object Object],,
        messages=[
            {,[object Object],: ,[object Object],, ,[object Object],: system},
            {,[object Object],: ,[object Object],, ,[object Object],: prompt},
        ],
        temperature=,[object Object],,
    )
    ,[object Object], r.choices[,[object Object],].message.content


,[object Object], ,[object Object],(,[object Object],) -> ,[object Object],:
    extracted = llm(
        ,[object Object],,
        ,[object Object],,
    )
    analysis = llm(
        ,[object Object],,
        ,[object Object],,
    )
    recs = llm(
        ,[object Object],,
        ,[object Object],,
    )
    summary = llm(
        ,[object Object],,
        ,[object Object],,
    )
    ,[object Object], {
        ,[object Object],: extracted,
        ,[object Object],: analysis,
        ,[object Object],: recs,
        ,[object Object],: summary,
    }


doc = ,[object Object],
,[object Object],(sequential_chain(doc)[,[object Object],])

If a step’s output is messy, fix that step before adding new ones—downstream prompts amplify garbage.

3. Parallel Chains

When analyses don’t depend on each other, run them concurrently—wall-clock time drops.

Sketch: asyncio.gather around three async LLM calls, each with its own system prompt, then merge results in Python.

4. Conditional Routing

Classify first, then dispatch to a specialist prompt pack.

5. Map-Reduce Pattern

Map: run the same prompt on many chunks (summaries, extractions).
Reduce: one prompt merges partial outputs into a coherent whole.

6. Self-Consistency

Sample multiple answers (higher temperature), then vote on the final short answer line. Great for riddles and fragile arithmetic; expensive for prose.

7. Building Reliable Multi-Step Workflows

You can implement a tiny Chain class with depends_on (DAG) later—start with functions + dict context until you feel pain.

Reliability features (retries, timeouts, fallbacks) are part of the chain, not an afterthought.

Practice Exercises

Exercise 1: Translation Pipeline (Beginner)

Build a chain that: translates text to French → back-translates to English → compares the original with the back-translation to identify potential translation issues.

Exercise 2: Research Synthesizer (Intermediate)

Create a map-reduce chain that takes 5 article snippets on the same topic, extracts claims from each, identifies agreements/contradictions, and produces a balanced synthesis.

Exercise 3: Self-Consistency Calculator (Intermediate)

Implement self-consistency for math word problems. Test with 10 problems. Compare accuracy with and without self-consistency (use 1 sample vs. 5 samples with majority vote).

Exercise 4: Conditional Content Generator (Advanced)

Build a content pipeline that detects the input type (email, report, social post) and routes to specialized formatting chains. Each chain should have 3+ steps.

Exercise 5: Fault-Tolerant Pipeline (Advanced)

Extend a chain design to support: fallback steps (if step A fails, try step B), timeout per step, and a final “recovery” step that summarizes partial results if the chain doesn't fully complete.

Mini-Project: Automated Report Generator

Ingest CSV/JSON → parallel stats narratives → final Markdown report section → optional “consistency check” pass. Reuse your sequential pattern from section 2.

Key Takeaways

Resources for Further Learning

• LangChain LCEL
• Prompt Chaining Patterns
• Self-Consistency Paper
• DSPy

← Previous: LLM APIs | Next: Embeddings & Vector Databases →