mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
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]>
578 lines
28 KiB
HTML
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("openai/gpt-4o-mini")
|
|
dspy.configure(lm=lm)
|
|
|
|
# Simple prediction
|
|
predictor = dspy.Predict("question -> answer")
|
|
|
|
# Use module
|
|
result = predictor(question="What is the capital of France?")
|
|
print(result.answer) # "Paris"
|
|
|
|
# With typed signature
|
|
classifier = dspy.Predict("text -> category, confidence: float")
|
|
result = classifier(text="This movie was amazing!")
|
|
print(f"{result.category} ({result.confidence})")</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't need reasoning</li></ul>
|
|
<h3>Pattern 2: ChainOfThought Module</h3>
|
|
<pre><code class="lang-python">import dspy
|
|
|
|
class QASignature(dspy.Signature):
|
|
"""Answer questions with reasoning."""
|
|
question = dspy.InputField(desc="Question to answer")
|
|
answer = dspy.OutputField(desc="Answer to the question")
|
|
|
|
# Add chain-of-thought reasoning
|
|
cot = dspy.ChainOfThought(QASignature)
|
|
|
|
# Module automatically adds reasoning step
|
|
result = cot(question="If it takes 5 machines 5 minutes to make 5 widgets, how long for 100 machines to make 100 widgets?")
|
|
|
|
print("Reasoning:", result.reasoning) # Shows step-by-step thinking
|
|
print("Answer:", result.answer) # "5 minutes"</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):
|
|
"""Answer questions using search results."""
|
|
question = dspy.InputField()
|
|
answer = dspy.OutputField()
|
|
|
|
# Define tools that ReAct can use
|
|
def search(query: str) -> str:
|
|
"""Search for information."""
|
|
# Implement actual search (e.g., Google, Wikipedia)
|
|
return f"Search results for: {query}"
|
|
|
|
def calculate(expression: str) -> float:
|
|
"""Evaluate mathematical expressions."""
|
|
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="What is the population of the capital of France?")
|
|
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):
|
|
"""Solve math problems by generating Python code."""
|
|
problem = dspy.InputField(desc="Math problem to solve")
|
|
solution = dspy.OutputField(desc="Numerical solution")
|
|
|
|
# ProgramOfThought generates and executes code
|
|
pot = dspy.ProgramOfThought(MathProblem)
|
|
|
|
result = pot(problem="What is 15% of 240 plus 30% of 150?")
|
|
|
|
print("Code:", result.code) # Generated Python code
|
|
print("Solution:", 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):
|
|
"""Custom Retrieval-Augmented Generation module."""
|
|
|
|
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("context, question -> answer")
|
|
|
|
def forward(self, question):
|
|
# Step 1: Retrieve relevant passages
|
|
passages = self.retrieve(question).passages
|
|
|
|
# Step 2: Format context
|
|
context = "\n\n".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="What is DSPy?")
|
|
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):
|
|
"""Answer questions using multi-step reasoning."""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
# Step 1: Break down question
|
|
self.decompose = dspy.Predict("question -> sub_questions: list[str]")
|
|
|
|
# Step 2: Answer sub-questions
|
|
self.answer_sub = dspy.ChainOfThought("question -> answer")
|
|
|
|
# Step 3: Synthesize final answer
|
|
self.synthesize = dspy.ChainOfThought("question, sub_answers -> final_answer")
|
|
|
|
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"Q: {sub_q}\nA: {ans.answer}")
|
|
|
|
# Synthesize final answer
|
|
result = self.synthesize(
|
|
question=question,
|
|
sub_answers="\n\n".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="Compare and contrast Python and JavaScript")
|
|
|
|
print("Sub-questions:", result.sub_questions)
|
|
print("Final answer:", 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):
|
|
"""Predictor with automatic retry on failure."""
|
|
|
|
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, 'answer') and result.answer.strip():
|
|
return result
|
|
|
|
except Exception as e:
|
|
last_error = e
|
|
print(f"Attempt {attempt + 1} failed: {e}")
|
|
|
|
# All retries failed
|
|
raise Exception(f"All {self.max_retries} attempts failed. Last error: {last_error}")
|
|
|
|
# Use robust predictor
|
|
predictor = RobustPredictor("question -> answer")
|
|
result = predictor(question="What is DSPy?")</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):
|
|
"""Run multiple predictors in parallel and combine results."""
|
|
|
|
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("answers: list[str] -> best_answer: str")
|
|
|
|
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("question -> answer", num_predictors=5)
|
|
result = ensemble(question="What is the meaning of life?")
|
|
print("All answers:", result.all_answers)
|
|
print("Best answer:", 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'T: Use ChainOfThought for all tasks (overkill for simple ones)
|
|
❌ DON'T: Use ReAct without proper tools
|
|
❌ DON'T: Create monolithic custom modules
|
|
❌ DON'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("input -> output")
|
|
|
|
# Reasoning predictor
|
|
cot = dspy.ChainOfThought("question -> answer")
|
|
|
|
# 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("text -> category")</code></pre>
|
|
<p>✅ Use Predict for simple tasks:</p>
|
|
<pre><code class="lang-python"># Good
|
|
classifier = dspy.Predict("text -> category")</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> |