Files
skills/public/dspy-modules.html
zeekayandHanzo Dev 9e10c1c10e Each llms index points at the other two
hanzoskills.com/llms.txt now opens with the install line, the API
reference index and the company index, so an agent that lands on any
one of the three can find the rest.

robots.txt claimed 537 documents while llms.txt counts 920. The number
is gone from robots.txt; llms.txt derives it.

public/ is regenerated from scripts/site.py, which it had fallen
behind: the copy-prompt menu and agent bar were in the generator and
not in the committed pages. tests/site.mjs passes against the result.

Co-authored-by: Hanzo Dev <[email protected]>
2026-09-11 00:27:59 -07:00

578 lines
28 KiB
HTML

<!doctype html>
<html lang="en"><head>
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>dspy-modules</title>
<meta name="color-scheme" content="dark">
<style>
/* Committed to one visual world: a dark instrument panel. No light variant —
the dot field and the hairline rules only read on black, and a naive
inversion would wash both out. Every colour is painted explicitly so the page
never borrows a host background. */
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
:root{
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
--font-zen-pixel-square:'Zen Pixel Square',monospace;
--mono:var(--font-zen-mono);
--sans:var(--font-zen-sans);
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
--r:999px; --r-soft:14px;
}
*{box-sizing:border-box}
html{-webkit-text-size-adjust:100%}
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
/* The dot field. A halftone made of one repeating radial-gradient, faded out
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
/* No overflow clip here: the dot field is inset to the box already, and a clip
would cut off the copy-prompt menu. */
.hero{position:relative;border-bottom:1px solid var(--line)}
.hero::before{content:"";position:absolute;inset:0;
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
background-size:7px 7px;
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
pointer-events:none}
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
nav{border-bottom:1px solid var(--line)}
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
justify-content:space-between;align-items:center;gap:1rem}
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--ink);text-decoration:none;
display:inline-flex;align-items:center;gap:.6rem}
.brand i{font-style:normal;color:var(--faint)}
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--soft);text-decoration:none}
nav a.up:hover{color:var(--ink)}
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
h1 em{font-style:normal;color:var(--faint)}
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
line-height:1.2;font-weight:400}
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
.btn.solid:hover{background:#d8d8d4}
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
/* Copy-prompt selector. Each row copies the prompt for its own target. */
.copy{position:relative;display:inline-flex}
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
padding:.4rem;display:flex;flex-direction:column;
box-shadow:0 12px 32px rgba(0,0,0,.75)}
.menu[hidden]{display:none}
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
white-space:nowrap}
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
.mi:hover .mark{color:var(--ink)}
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
letter-spacing:.1em;text-transform:uppercase}
/* Works-with bar: one scrolling row, name and mark per agent. */
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
display:flex;align-items:center}
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
-webkit-overflow-scrolling:touch;
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
.bar::-webkit-scrollbar{display:none}
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
text-decoration:none;background:var(--ground)}
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
.agent .mark{width:.95rem;height:.95rem}
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
p{margin:0 0 1rem;max-width:70ch}
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
li{margin:.22rem 0}
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
text-decoration-color:var(--line-hi)}
a:hover{text-decoration-color:var(--ink)}
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
display:block;overflow-x:auto}
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
.curl{display:block;background:var(--panel);border:1px solid var(--line);
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
white-space:pre;line-height:1.9}
.curl b{color:var(--ink);font-weight:400}
.curl i{font-style:normal;color:var(--faint)}
/* index */
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
#q:focus{outline:none;border-color:var(--soft)}
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
text-transform:uppercase;margin:0 0 2rem}
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
padding-bottom:.45rem}
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
border-radius:var(--r-soft);text-decoration:none}
.row:hover{background:#0a0a0a}
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
color:var(--faint);font-size:.85rem}
footer a{color:var(--soft)}
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
margin:0 0 2rem;font-size:.85rem}
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
border-bottom:1px solid var(--line);padding-bottom:.4rem}
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
.fmap a:hover{text-decoration:underline}
.fmap div{color:var(--faint);line-height:1.5}
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
@media (max-width:640px){
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
.btns{gap:.5rem}
.btn{padding:.75rem 1.15rem;font-size:.68rem}
.copy,.copy .btn{width:100%;justify-content:center}
.menu{left:0;right:0;min-width:0}
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
.strip b{border-right:0;padding-right:0}
.bar{width:100%}
}
</style>
<link rel="alternate" type="text/markdown" href="/dspy-modules.md">
<link rel="icon" href="/favicon.svg">
<link rel="canonical" href="https://hanzoskills.com/dspy-modules">
</head>
<!-- Reading this with a machine? Every page here is also plain markdown.
This one: https://hanzoskills.com/dspy-modules.md
Index: https://hanzoskills.com/llms.txt
Corpus: https://hanzoskills.com/all.md
Append .md to any path for the markdown twin. -->
<body>
<nav><div class="in">
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
<a class="up" href="/">All skills</a>
</div></nav>
<div class="wrap">
<h1>dspy-modules</h1><p class="lede">Building composable prediction modules with Predict, ChainOfThought, ReAct, and custom modules</p><h1>DSPy Modules</h1>
<p><strong>Scope</strong>: Predict, ChainOfThought, ReAct, ProgramOfThought, custom modules, composition <strong>Lines</strong>: ~450 <strong>Last Updated</strong>: 2025-10-25</p>
<h2>When to Use This Skill</h2>
<p>Activate this skill when:</p>
<ul><li>Building prediction pipelines with DSPy</li><li>Choosing between Predict, ChainOfThought, and ReAct modules</li><li>Creating custom DSPy modules</li><li>Composing multiple modules into complex workflows</li><li>Implementing multi-step reasoning systems</li><li>Optimizing module selection for specific tasks</li></ul>
<h2>Core Concepts</h2>
<h3>What are Modules?</h3>
<p><strong>Definition</strong>: Modules are composable building blocks that replace hand-written prompts</p>
<p><strong>Purpose</strong>:</p>
<ul><li><strong>Abstraction</strong>: Encapsulate prompting strategies</li><li><strong>Reusability</strong>: Use same module across different tasks</li><li><strong>Optimization</strong>: Modules can be automatically tuned</li><li><strong>Composition</strong>: Chain modules for complex workflows</li></ul>
<p><strong>Key insight</strong>: Modules separate strategy (how to prompt) from task (what to ask)</p>
<h3>Built-in Module Types</h3>
<p><strong>Predict</strong>: Basic prediction</p>
<ul><li>Simplest module</li><li>Direct signature → output mapping</li><li>No intermediate reasoning</li><li>Fast, efficient</li></ul>
<p><strong>ChainOfThought</strong>: Multi-step reasoning</p>
<ul><li>Adds reasoning step before answer</li><li>Better for complex tasks</li><li>Shows work/explanation</li><li>Slightly slower but more accurate</li></ul>
<p><strong>ReAct</strong>: Reasoning + Acting</p>
<ul><li>Iterative thought-action-observation loops</li><li>Can call tools/retrieve information</li><li>Good for multi-step tasks requiring external data</li><li>Most complex, most powerful</li></ul>
<p><strong>ProgramOfThought</strong>: Code generation + execution</p>
<ul><li>Generates Python code to solve problems</li><li>Executes code for precise computations</li><li>Excellent for math, data analysis</li><li>Requires code execution environment</li></ul>
<h3>Module Composition</h3>
<p><strong>Pattern</strong>: Small modules → Complex systems</p>
<ul><li>Each module has focused responsibility</li><li>Modules pass data through signatures</li><li>Compose modules in <code>forward()</code> method</li><li>Create reusable module libraries</li></ul>
<hr>
<h2>Patterns</h2>
<h3>Pattern 1: Basic Predict Module</h3>
<pre><code class="lang-python">import dspy
# Configure LM
lm = dspy.LM(&quot;openai/gpt-4o-mini&quot;)
dspy.configure(lm=lm)
# Simple prediction
predictor = dspy.Predict(&quot;question -&gt; answer&quot;)
# Use module
result = predictor(question=&quot;What is the capital of France?&quot;)
print(result.answer) # &quot;Paris&quot;
# With typed signature
classifier = dspy.Predict(&quot;text -&gt; category, confidence: float&quot;)
result = classifier(text=&quot;This movie was amazing!&quot;)
print(f&quot;{result.category} ({result.confidence})&quot;)</code></pre>
<p><strong>When to use</strong>:</p>
<ul><li>Simple classification tasks</li><li>Direct question answering</li><li>Fast prototyping</li><li>Tasks that don&#x27;t need reasoning</li></ul>
<h3>Pattern 2: ChainOfThought Module</h3>
<pre><code class="lang-python">import dspy
class QASignature(dspy.Signature):
&quot;&quot;&quot;Answer questions with reasoning.&quot;&quot;&quot;
question = dspy.InputField(desc=&quot;Question to answer&quot;)
answer = dspy.OutputField(desc=&quot;Answer to the question&quot;)
# Add chain-of-thought reasoning
cot = dspy.ChainOfThought(QASignature)
# Module automatically adds reasoning step
result = cot(question=&quot;If it takes 5 machines 5 minutes to make 5 widgets, how long for 100 machines to make 100 widgets?&quot;)
print(&quot;Reasoning:&quot;, result.reasoning) # Shows step-by-step thinking
print(&quot;Answer:&quot;, result.answer) # &quot;5 minutes&quot;</code></pre>
<p><strong>When to use</strong>:</p>
<ul><li>Complex reasoning tasks</li><li>Math problems</li><li>Multi-step questions</li><li>When you need explanations</li></ul>
<p><strong>How it works</strong>:</p>
<ul><li>DSPy adds <code>reasoning</code> field to signature</li><li>LM generates reasoning before answer</li><li>More accurate for complex tasks</li></ul>
<h3>Pattern 3: ReAct Module (with Tools)</h3>
<pre><code class="lang-python">import dspy
class SearchQA(dspy.Signature):
&quot;&quot;&quot;Answer questions using search results.&quot;&quot;&quot;
question = dspy.InputField()
answer = dspy.OutputField()
# Define tools that ReAct can use
def search(query: str) -&gt; str:
&quot;&quot;&quot;Search for information.&quot;&quot;&quot;
# Implement actual search (e.g., Google, Wikipedia)
return f&quot;Search results for: {query}&quot;
def calculate(expression: str) -&gt; float:
&quot;&quot;&quot;Evaluate mathematical expressions.&quot;&quot;&quot;
return eval(expression) # Use safely in production!
# Create ReAct module with tools
react = dspy.ReAct(
SearchQA,
tools=[search, calculate],
max_iters=5, # Maximum thought-action cycles
)
# ReAct will:
# 1. Think about the question
# 2. Decide which tool to use
# 3. Execute the tool
# 4. Observe results
# 5. Repeat until answer found
result = react(question=&quot;What is the population of the capital of France?&quot;)
print(result.answer)</code></pre>
<p><strong>When to use</strong>:</p>
<ul><li>Questions requiring external information</li><li>Multi-step tasks with tool use</li><li>Information retrieval + reasoning</li><li>Agent-like behavior</li></ul>
<p><strong>How it works</strong>:</p>
<ul><li>Iterative Thought → Action → Observation loop</li><li>Selects and executes tools</li><li>Stops when answer is confident</li></ul>
<h3>Pattern 4: ProgramOfThought Module</h3>
<pre><code class="lang-python">import dspy
class MathProblem(dspy.Signature):
&quot;&quot;&quot;Solve math problems by generating Python code.&quot;&quot;&quot;
problem = dspy.InputField(desc=&quot;Math problem to solve&quot;)
solution = dspy.OutputField(desc=&quot;Numerical solution&quot;)
# ProgramOfThought generates and executes code
pot = dspy.ProgramOfThought(MathProblem)
result = pot(problem=&quot;What is 15% of 240 plus 30% of 150?&quot;)
print(&quot;Code:&quot;, result.code) # Generated Python code
print(&quot;Solution:&quot;, result.solution) # Executed result</code></pre>
<p><strong>When to use</strong>:</p>
<ul><li>Mathematical computations</li><li>Data analysis tasks</li><li>Precise numerical answers</li><li>Complex calculations</li></ul>
<p><strong>Benefits</strong>:</p>
<ul><li>More accurate than text-based reasoning for math</li><li>Shows executable code</li><li>Verifiable results</li></ul>
<h3>Pattern 5: Custom Module</h3>
<pre><code class="lang-python">import dspy
class RAGModule(dspy.Module):
&quot;&quot;&quot;Custom Retrieval-Augmented Generation module.&quot;&quot;&quot;
def __init__(self, num_passages=3):
super().__init__()
self.num_passages = num_passages
# Sub-modules
self.retrieve = dspy.Retrieve(k=num_passages)
self.generate = dspy.ChainOfThought(&quot;context, question -&gt; answer&quot;)
def forward(self, question):
# Step 1: Retrieve relevant passages
passages = self.retrieve(question).passages
# Step 2: Format context
context = &quot;\n\n&quot;.join(passages)
# Step 3: Generate answer with context
result = self.generate(context=context, question=question)
return result
# Use custom module
rag = RAGModule(num_passages=5)
result = rag(question=&quot;What is DSPy?&quot;)
print(result.answer)</code></pre>
<p><strong>When to use</strong>:</p>
<ul><li>Custom workflows not covered by built-in modules</li><li>Complex multi-step pipelines</li><li>Reusable domain-specific logic</li><li>Production systems</li></ul>
<p><strong>Structure</strong>:</p>
<ul><li>Inherit from <code>dspy.Module</code></li><li>Define sub-modules in <code>__init__()</code></li><li>Implement <code>forward()</code> method</li><li>Return results (or dspy.Prediction)</li></ul>
<h3>Pattern 6: Module Composition</h3>
<pre><code class="lang-python">import dspy
class MultiStepQA(dspy.Module):
&quot;&quot;&quot;Answer questions using multi-step reasoning.&quot;&quot;&quot;
def __init__(self):
super().__init__()
# Step 1: Break down question
self.decompose = dspy.Predict(&quot;question -&gt; sub_questions: list[str]&quot;)
# Step 2: Answer sub-questions
self.answer_sub = dspy.ChainOfThought(&quot;question -&gt; answer&quot;)
# Step 3: Synthesize final answer
self.synthesize = dspy.ChainOfThought(&quot;question, sub_answers -&gt; final_answer&quot;)
def forward(self, question):
# Decompose into sub-questions
decomp = self.decompose(question=question)
# Answer each sub-question
sub_answers = []
for sub_q in decomp.sub_questions:
ans = self.answer_sub(question=sub_q)
sub_answers.append(f&quot;Q: {sub_q}\nA: {ans.answer}&quot;)
# Synthesize final answer
result = self.synthesize(
question=question,
sub_answers=&quot;\n\n&quot;.join(sub_answers)
)
return dspy.Prediction(
sub_questions=decomp.sub_questions,
sub_answers=sub_answers,
answer=result.final_answer
)
# Use composed module
qa = MultiStepQA()
result = qa(question=&quot;Compare and contrast Python and JavaScript&quot;)
print(&quot;Sub-questions:&quot;, result.sub_questions)
print(&quot;Final answer:&quot;, result.answer)</code></pre>
<p><strong>Benefits</strong>:</p>
<ul><li>Break complex tasks into manageable steps</li><li>Each sub-module optimizable independently</li><li>Clear separation of concerns</li><li>Easier debugging</li></ul>
<h3>Pattern 7: Module with Retry Logic</h3>
<pre><code class="lang-python">import dspy
class RobustPredictor(dspy.Module):
&quot;&quot;&quot;Predictor with automatic retry on failure.&quot;&quot;&quot;
def __init__(self, signature, max_retries=3):
super().__init__()
self.predictor = dspy.ChainOfThought(signature)
self.max_retries = max_retries
def forward(self, **kwargs):
last_error = None
for attempt in range(self.max_retries):
try:
result = self.predictor(**kwargs)
# Validate result (example: check if answer is non-empty)
if hasattr(result, &#x27;answer&#x27;) and result.answer.strip():
return result
except Exception as e:
last_error = e
print(f&quot;Attempt {attempt + 1} failed: {e}&quot;)
# All retries failed
raise Exception(f&quot;All {self.max_retries} attempts failed. Last error: {last_error}&quot;)
# Use robust predictor
predictor = RobustPredictor(&quot;question -&gt; answer&quot;)
result = predictor(question=&quot;What is DSPy?&quot;)</code></pre>
<p><strong>When to use</strong>:</p>
<ul><li>Production systems requiring reliability</li><li>Handling transient API failures</li><li>Quality-critical applications</li></ul>
<h3>Pattern 8: Parallel Module Execution</h3>
<pre><code class="lang-python">import dspy
from concurrent.futures import ThreadPoolExecutor
class EnsemblePredictor(dspy.Module):
&quot;&quot;&quot;Run multiple predictors in parallel and combine results.&quot;&quot;&quot;
def __init__(self, signature, num_predictors=3):
super().__init__()
# Create multiple predictor instances
self.predictors = [
dspy.ChainOfThought(signature)
for _ in range(num_predictors)
]
self.vote = dspy.Predict(&quot;answers: list[str] -&gt; best_answer: str&quot;)
def forward(self, **kwargs):
# Execute predictors in parallel
with ThreadPoolExecutor(max_workers=len(self.predictors)) as executor:
futures = [
executor.submit(pred, **kwargs)
for pred in self.predictors
]
results = [f.result() for f in futures]
# Extract answers
answers = [r.answer for r in results]
# Vote on best answer
best = self.vote(answers=answers)
return dspy.Prediction(
all_answers=answers,
answer=best.best_answer
)
# Use ensemble
ensemble = EnsemblePredictor(&quot;question -&gt; answer&quot;, num_predictors=5)
result = ensemble(question=&quot;What is the meaning of life?&quot;)
print(&quot;All answers:&quot;, result.all_answers)
print(&quot;Best answer:&quot;, result.answer)</code></pre>
<p><strong>When to use</strong>:</p>
<ul><li>Improve prediction quality through voting</li><li>Reduce variance in outputs</li><li>Critical decisions requiring consensus</li></ul>
<hr>
<h2>Quick Reference</h2>
<h3>Module Comparison</h3>
<p>| Module | Reasoning | Speed | Accuracy | Use Case | |--------|-----------|-------|----------|----------| | Predict | None | Fastest | Good | Simple tasks | | ChainOfThought | Sequential | Fast | Better | Complex reasoning | | ReAct | Iterative + Tools | Slow | Best (with tools) | Multi-step + retrieval | | ProgramOfThought | Code gen | Medium | Excellent (math) | Computations |</p>
<h3>Creating Custom Modules</h3>
<pre><code class="lang-python">class MyModule(dspy.Module):
def __init__(self):
super().__init__()
# Define sub-modules
def forward(self, **kwargs):
# Implement logic
return dspy.Prediction(...)</code></pre>
<h3>Module Best Practices</h3>
<pre><code>✅ DO: Use Predict for simple tasks
✅ DO: Use ChainOfThought for complex reasoning
✅ DO: Use ReAct when you need external information
✅ DO: Compose small modules into larger systems
✅ DO: Return dspy.Prediction from custom modules
❌ DON&#x27;T: Use ChainOfThought for all tasks (overkill for simple ones)
❌ DON&#x27;T: Use ReAct without proper tools
❌ DON&#x27;T: Create monolithic custom modules
❌ DON&#x27;T: Forget to call super().__init__() in custom modules</code></pre>
<h3>Quick Module Templates</h3>
<pre><code class="lang-python"># Simple predictor
pred = dspy.Predict(&quot;input -&gt; output&quot;)
# Reasoning predictor
cot = dspy.ChainOfThought(&quot;question -&gt; answer&quot;)
# With tools
react = dspy.ReAct(signature, tools=[tool1, tool2])
# Custom module
class Custom(dspy.Module):
def __init__(self):
super().__init__()
self.pred = dspy.Predict(sig)
def forward(self, x):
return self.pred(input=x)</code></pre>
<hr>
<h2>Anti-Patterns</h2>
<p>❌ <strong>Using ChainOfThought for everything</strong>: Slower and more expensive</p>
<pre><code class="lang-python"># Bad - overkill for simple classification
classifier = dspy.ChainOfThought(&quot;text -&gt; category&quot;)</code></pre>
<p>✅ Use Predict for simple tasks:</p>
<pre><code class="lang-python"># Good
classifier = dspy.Predict(&quot;text -&gt; category&quot;)</code></pre>
<p>❌ <strong>Not composing modules</strong>: Monolithic, hard to optimize</p>
<pre><code class="lang-python"># Bad - everything in one module
class Monolith(dspy.Module):
def forward(self, x):
# 100 lines of complex logic
pass</code></pre>
<p>✅ Compose smaller modules:</p>
<pre><code class="lang-python"># Good
class Pipeline(dspy.Module):
def __init__(self):
super().__init__()
self.step1 = Module1()
self.step2 = Module2()
self.step3 = Module3()</code></pre>
<p>❌ <strong>Ignoring module return format</strong>: Breaks composition</p>
<pre><code class="lang-python"># Bad
def forward(self, x):
result = self.pred(x)
return result.answer # Returns string, not Prediction</code></pre>
<p>✅ Return Prediction objects:</p>
<pre><code class="lang-python"># Good
def forward(self, x):
result = self.pred(x)
return dspy.Prediction(answer=result.answer, confidence=0.9)</code></pre>
<hr>
<h2>Related Skills</h2>
<ul><li><code>dspy-signatures.md</code> - Defining signatures for modules</li><li><code>dspy-optimizers.md</code> - Optimizing module parameters</li><li><code>dspy-rag.md</code> - Building RAG pipelines with modules</li><li><code>dspy-assertions.md</code> - Adding validation to modules</li><li><code>dspy-evaluation.md</code> - Evaluating module performance</li></ul>
<hr>
<p><strong>Last Updated</strong>: 2025-10-25 <strong>Format Version</strong>: 1.0 (Atomic)</p>
<footer>
<div class="fmap">
<div><b>Build</b>
<a href="https://hanzo.app">hanzo.app</a> app builder
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
<div><b>Run</b>
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
<div><b>Account</b>
<a href="https://hanzo.id">hanzo.id</a> sign in
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
<div><b>Company</b>
<a href="https://hanzo.ai">hanzo.ai</a> canonical
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
</div>
<div class="fend"><a href="/dspy-modules.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
</footer>
</div></body></html>