DSPy — Programming Language Models

The Solution: Program, Don't Prompt

DSPy (Declarative Self-improving Python) is a framework from the Stanford NLP group that replaces fragile hand-written prompts with declarative programs. Instead of guessing the perfect wording, you describe the shape of the task with a signature — what input goes in and what output comes out — then choose a reasoning module (Predict, ChainOfThought, ReAct), and a compiler automatically generates and tunes the actual prompt for your specific data and metric. The core slogan is "program, don't prompt": you write Python that declares intent, and DSPy figures out the string that makes a given model perform best.

How it works

Three layers stack on top of each other. A signature like context, question -> answer declares the fields and their types. A module wraps that signature in a reasoning strategy — for example dspy.ChainOfThought tells the model to think step by step before answering. Finally an optimizer (also called a teleprompter), such as BootstrapFewShot or MIPROv2, runs your program over a handful of labeled examples, measures the result with a metric you define, and searches for the best combination of few-shot demonstrations and instructions. The output is a compiled program: a concrete, reproducible prompt you can save, version, and rerun. Because the prompt is generated rather than hand-typed, swapping the underlying model means recompiling instead of rewriting everything by hand.

When to use it — and the tradeoffs

Reach for DSPy when you have a multi-step pipeline (retrieval + reasoning + extraction), a measurable metric, and a small set of labeled examples — that is exactly where manual prompt tuning becomes a guessing game. It pairs especially well with RAG and multi-hop question answering, where many sub-prompts interact. The tradeoffs are real: there is a learning curve, compilation makes extra LLM calls (which cost time and money), and a good metric is mandatory — without one the optimizer has nothing to optimize. For a single throwaway prompt, plain prompting is faster. As a concrete example, imagine a support- ticket classifier. You write the signature ticket -> category, wrap it in dspy.Predict, define a metric that returns 1 when the predicted category matches the label, and hand the optimizer 50 labeled tickets. BootstrapFewShot tries different demonstration sets, keeps the ones that push accuracy up, and emits a final prompt — no manual example-picking, and you can recompile the same program for a cheaper or newer model in minutes.

Where Is This Used?

• NLP Pipelines: Chain multiple modules (summarize -> classify -> extract) with auto-optimized prompts at each step
• RAG Optimization: Automatically optimize retrieval queries and generation prompts together for better answers
• Multi-hop QA: Complex questions requiring multiple reasoning steps — DSPy chains modules and optimizes the full pipeline
• Classification: Auto-optimized prompts with best few-shot examples selected by the compiler for your specific data

Try It Yourself!

Explore the interactive visualization below to see how DSPy transforms a manual prompt into a compiled, optimized program.