Why is calling DSPy 'another LangChain' a category error?

Short answer·Medium·4.0 · 0·~3 min·Asked atDatabricks Cohere Anthropic

Attempt it

A teammate says 'DSPy is just another LangChain, only with worse docs.' Explain why that framing is a category error, using a PyTorch analogy to make the distinction concrete.

Free · 2 AI evals / day

LangChain and DSPy look similar from a distance, both are Python libraries, both let you build LLM applications. But they sit at different layers of the stack. **LangChain is a composition library.** Its core abstraction is the Runnable: an object with `.invoke`, `.batch`, `.stream`. You wire Runnables together with the pipe operator (`prompt | model | parser`) to build a pipeline. You write the prompt text yourself; LangChain just executes what you composed. **DSPy is an optimizer.** Its core abstraction is the Signature, a typed declaration of inputs and outputs ("question → answer"). You pick a Module (`Predict`, `ChainOfThought`, `ReAct`) that says how to run it, define a Metric that scores outputs against your data, and call `optimizer.compile(...)`. The optimizer then searches over prompt phrasings and few-shot demonstrations to maximize your metric on the training set. The PyTorch analogy makes this clean. LangChain is like writing the forward pass of a neural net by hand. DSPy is like declaring a model + loss + optimizer and letting `optimizer.step()` improve the weights. You can use them together, DSPy programs can run inside LangChain pipelines, but they are not substitutes.

**LangChain is a composition library; DSPy is an optimizer.** That is the category distinction, and it is the entire reason the "DSPy is just another LangChain" framing is wrong. LangChain gives you Runnables and the pipe operator. You write `prompt | model | parser` and the library executes the graph. The prompt text is your work, the library just composes execution. DSPy gives you Signatures (typed input/output declarations), Modules (`Predict`, `ChainOfThought`, `ReAct`), Metrics, and Optimizers (`BootstrapFewShot`, `MIPROv2`, `COPRO`). You declare the program, pick the metric, hand it a small trainset, and call `optimizer.compile(program, trainset=..., metric=...)`. The optimizer searches the prompt and demonstrations space to maximize the metric. The PyTorch analogy is exact. LangChain is to LLM apps as "hand-written forward pass" is to neural networks: composition without optimization. DSPy is to LLM apps as "declare model + loss + optimizer, then call `.step()`" is to neural networks: composition plus a search procedure that improves the parameters (which, in DSPy, are prompts and demos rather than weights). The two can coexist. A DSPy-compiled program can absolutely sit inside a LangChain pipeline as one Runnable among many. But they are not substitutes for each other: replacing LangChain with DSPy gives you nothing if you are not running `compile`, and replacing DSPy with LangChain throws away the compile loop that is the whole point.

Quick reference

TL;DR

LangChain composes prompts you wrote; DSPy compiles prompts you didn't, by optimizing them against a metric and a trainset. Different layers of the stack, not substitutes.

Memory aid

Easy to grasp

Picture two carpentry shops. The first one sells you a toolbox: saws, drills, clamps, glue. You bring the design in your head and build the chair yourself. That is LangChain, a kit of composition tools. The second shop sells you a robot. You hand it a rough drawing, a few examples of finished chairs, and a way to score how good a chair is, and the robot iteratively builds and rebuilds chairs until the scores stop improving. That is DSPy. Calling them the same thing is like calling the toolbox and the robot interchangeable hardware purchases. They both make chairs but operate at completely different levels.

Key concepts

LLM Frameworks Prompt Engineering LLM Evaluation

Detailed answer & concept explanation

~4 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.

Quick scan · 2–4 min

Everything important, quickly.

Name the category distinction (composition vs optimization), give the PyTorch analogy, walk the four DSPy primitives (Signature, Module, Metric, Optimizer), describe the compile loop concretely, explain that LangChain and DSPy compose rather than substitute, and close with the failure mode of "using DSPy without ever calling compile".

Real-world examples

Real products, models, and research that use this idea.

Databricks published a 2024 case study using DSPy MIPROv2 to compile retrieval-augmented programs that outperformed hand-engineered prompts on internal QA benchmarks.
JetBlue used DSPy to compile a customer-support classification module against a labeled trainset, replacing months of manual prompt tuning.
Stanford's STORM project (long-form report generation) is built natively on DSPy and exemplifies the compile against a metric loop end to end.
LangChain itself can wrap a compiled DSPy module as a Runnable, this is the common production pattern when teams want LangChain's IO/composition plus DSPy's prompt-search.

Interviewer follow-ups

What an interviewer would ask next. Try answering before peeking at the approach.

QWalk through what `dspy.MIPROv2` actually does during `compile`.

QWhen would you actively prefer plain LangChain LCEL over DSPy for a RAG pipeline?

QHow do you keep a DSPy-compiled program reproducible across teammates and across runs?

Don't say this

Red flags and common mistakes that signal junior thinking. Click to expand.

Most common mistake

Dismissing DSPy as "just prompt templates with extra steps". The compile against a metric loop is the entire point and has no equivalent in LangChain.

60-second cheat sheet

The night-before-the-interview bullets. Scan these on the way to the call.

References

Primary sources. Skim if you want the original framing.