Chapter 3

Modules

Modules are the building blocks that bring signatures to life—they implement the actual LM calls and can be composed into complex pipelines.

7 Sections ~2-3 hours ⭐⭐ Intermediate

🧩 Building with Modules

From simple predictors to complex multi-step pipelines

What You'll Learn

By the end of this chapter, you will:

✅ Understand the role of modules in DSPy
✅ Use all built-in modules (Predict, ChainOfThought, ReAct, etc.)
✅ Create custom modules by subclassing dspy.Module
✅ Compose modules into multi-step pipelines
✅ Handle state and data flow between modules
✅ Build production-ready modular systems

Chapter Overview

This chapter takes you from basic module usage to building sophisticated LM applications:

📖

What Are Modules?

Understand modules as the "how" to signatures' "what"—the executable components.

🔧

Built-in Modules

Master Predict, ChainOfThought, ProgramOfThought, ReAct, and more.

🏗️

Creating Custom Modules

Build your own modules with __init__ and forward methods.

🔗

Module Composition

Combine modules into pipelines and handle complex workflows.

🏋️

Exercises

Build real-world modules and pipelines hands-on.

Modules vs. Signatures

Understanding the relationship between signatures and modules is key:

📝 Signatures

# WHAT to do (specification)
class Summarize(dspy.Signature):
    """Summarize the text."""
    text: str = dspy.InputField()
    summary: str = dspy.OutputField()
Defines inputs/outputs Declarative contract No execution logic

🧩 Modules

# HOW to do it (implementation)
summarize = dspy.Predict(Summarize)

# Or with reasoning
summarize = dspy.ChainOfThought(Summarize)

result = summarize(text="...")
Executes the signature Adds behavior (CoT, etc.) Can be composed

Key Concepts Preview

⚡

dspy.Predict

Basic module that executes a signature with a single LM call.

💭

dspy.ChainOfThought

Adds step-by-step reasoning before generating the final answer.

🛠️

dspy.ReAct

Enables tool use with an action-observation loop.

🔄

dspy.Module

Base class for creating custom modules with complex logic.

Prerequisites

Before starting this chapter, ensure you have:

✅ Completed Chapter 1 (DSPy Fundamentals)
✅ Completed Chapter 2 (Signatures)
✅ Python classes understanding (init, methods, inheritance)
✅ Working DSPy environment with API keys
💡

Note: This chapter builds heavily on Signatures from Chapter 2. Make sure you're comfortable creating class-based signatures.

🚀

Let's Build!

Ready to turn your signatures into powerful, composable modules? Let's start!

Continue to What Are Modules?