DSPy Declarative Language Model Programming Skill

DSPy Declarative Language Model Programming

Build AI systems with automatic prompt optimization from Stanford NLP.

When to Use

Building complex AI systems with multiple components
Programming LMs declaratively instead of manual prompting
Optimizing prompts automatically using data-driven methods
Creating modular AI pipelines that are maintainable
Building RAG systems, agents, or classifiers with better reliability

Quick Start

pip install dspy

Basic Question Answering

import dspy

lm = dspy.Claude(model="claude-sonnet-4-5-20250929")
dspy.settings.configure(lm=lm)

# Define a signature (input -> output)
class QA(dspy.Signature):
    """Answer questions with short factual answers."""
    question = dspy.InputField()
    answer = dspy.OutputField(desc="often between 1 and 5 words")

qa = dspy.Predict(QA)
response = qa(question="What is the capital of France?")
print(response.answer)  # "Paris"

Chain of Thought Reasoning

class MathProblem(dspy.Signature):
    """Solve math word problems."""
    problem = dspy.InputField()
    answer = dspy.OutputField(desc="numerical answer")

cot = dspy.ChainOfThought(MathProblem)
response = cot(problem="If John has 5 apples and gives 2 to Mary, how many does he have?")
print(response.rationale)  # Shows reasoning steps
print(response.answer)     # "3"

Core Modules

| Module | Use Case | |--------|----------| | dspy.Predict | Basic prediction | | dspy.ChainOfThought | Reasoning with steps | | dspy.ReAct | Agent-like with tools | | dspy.ProgramOfThought | Code generation for reasoning |

ReAct Agent

from dspy.predict import ReAct

class SearchQA(dspy.Signature):
    """Answer questions using search."""
    question = dspy.InputField()
    answer = dspy.OutputField()

def search_tool(query: str) -> str:
    """Search Wikipedia."""
    return results

react = ReAct(SearchQA, tools=[search_tool])
result = react(question="When was Python created?")

Automatic Optimization

BootstrapFewShot

from dspy.teleprompt import BootstrapFewShot

trainset = [
    dspy.Example(question="What is 2+2?", answer="4").with_inputs("question"),
    dspy.Example(question="What is 3+5?", answer="8").with_inputs("question"),
]

def validate_answer(example, pred, trace=None):
    return example.answer == pred.answer

optimizer = BootstrapFewShot(metric=validate_answer, max_bootstrapped_demos=3)
optimized_qa = optimizer.compile(qa, trainset=trainset)

MIPRO Optimizer

from dspy.teleprompt import MIPRO

optimizer = MIPRO(
    metric=validate_answer,
    num_candidates=10,
    init_temperature=1.0
)

optimized_cot = optimizer.compile(cot, trainset=trainset, num_trials=100)

Multi-Stage Pipeline

class MultiHopQA(dspy.Module):
    def __init__(self):
        super().__init__()
        self.retrieve = dspy.Retrieve(k=3)
        self.generate_query = dspy.ChainOfThought("question -> search_query")
        self.generate_answer = dspy.ChainOfThought("context, question -> answer")

    def forward(self, question):
        search_query = self.generate_query(question=question).search_query
        passages = self.retrieve(search_query).passages
        context = "\n".join(passages)
        answer = self.generate_answer(context=context, question=question).answer
        return dspy.Prediction(answer=answer, context=context)

Structured Output

from pydantic import BaseModel, Field

class PersonInfo(BaseModel):
    name: str = Field(description="Full name")
    age: int = Field(description="Age in years")
    occupation: str = Field(description="Current job")

class ExtractPerson(dspy.Signature):
    """Extract person information from text."""
    text = dspy.InputField()
    person: PersonInfo = dspy.OutputField()

extractor = dspy.TypedPredictor(ExtractPerson)
result = extractor(text="John Doe is a 35-year-old software engineer.")

LLM Providers

# Anthropic
lm = dspy.Claude(model="claude-sonnet-4-5-20250929")

# OpenAI
lm = dspy.OpenAI(model="gpt-4")

# Local (Ollama)
lm = dspy.OllamaLocal(model="llama3.1", base_url="http://localhost:11434")

dspy.settings.configure(lm=lm)

Save and Load

# Save optimized module
optimized_qa.save("models/qa_v1.json")

# Load later
loaded_qa = dspy.ChainOfThought("question -> answer")
loaded_qa.load("models/qa_v1.json")

vs Alternatives

| Feature | DSPy | LangChain | Manual | |---------|------|-----------|--------| | Prompt Engineering | Automatic | Manual | Manual | | Optimization | Data-driven | None | Trial & error | | Modularity | High | Medium | Low | | Learning Curve | Medium-High | Medium | Low |

Choose DSPy when:

You have training data or can generate it
Need systematic prompt improvement
Building complex multi-stage systems

Resources

Docs: https://dspy.ai
GitHub: https://github.com/stanfordnlp/dspy
Paper: "DSPy: Compiling Declarative Language Model Calls into Self-Improving Pipelines"

Agent Skills: DSPy Declarative Language Model Programming

Install this agent skill to your local

Skill Files