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"