DSPy 简介 #
什么是 DSPy？ #
DSPy（Declarative Self-improving Language Programs, Pythonically）是由斯坦福大学 NLP 小组开发的一个框架，用于通过编程方式优化语言模型的提示词（Prompts）。它将提示工程从手写提示词转变为声明式编程，让开发者可以像编写普通代码一样构建 LLM 应用。
核心定位 #
text
┌─────────────────────────────────────────────────────────────┐
│ DSPy │
├─────────────────────────────────────────────────────────────┤
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 签名 │ │ 模块 │ │ 优化器 │ │
│ │ Signatures │ │ Modules │ │ Optimizers │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 检索器 │ │ 自动优化 │ │ 编译器 │ │
│ │ Retrievers │ │ Auto-Tune │ │ Compilers │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────────┘
DSPy 的历史 #
发展历程 #
text
2023年 ─── DSPy 项目启动
│
│ Stanford NLP Group
│ Omar Khattab 等人开发
│ 解决 Prompt 工程痛点
│
2023年 ─── DSPy 论文发表
│
│ "Demonstrate-Search-Predict"
│ 提出 Declarative LM Programming
│ 引入 Signature 和 Module 概念
│
2024年 ─── DSPy 2.0 发布
│
│ 更强大的优化器
│ 更好的错误处理
│ 更丰富的模块支持
│
2024年 ─── DSPy 2.5+
│
│ 支持更多 LLM 后端
│ 改进的 Teleprompter
│ 社区生态扩展
│
至今 ─── 快速发展
│
│ GitHub 20k+ Stars
│ 活跃的社区
│ 企业级应用
里程碑版本 #
| 版本 | 时间 | 重要特性 |
|---|---|---|
| 1.0 | 2023.10 | 初始发布，核心框架 |
| 2.0 | 2024.01 | 新优化器架构 |
| 2.1 | 2024.03 | 更多 LLM 支持 |
| 2.2 | 2024.05 | 改进的错误处理 |
| 2.3 | 2024.07 | 流式响应支持 |
| 2.4 | 2024.09 | 异步支持 |
| 2.5 | 2024.11 | 多模态支持 |
为什么需要 DSPy？ #
传统 Prompt 工程的问题 #
在使用 DSPy 之前，LLM 应用开发面临以下挑战：
python
# 传统方式：手写提示词
prompt = """
你是一个专业的问答助手。
请根据以下上下文回答问题。
上下文：{context}
问题：{question}
请用简洁的语言回答。
"""
# 问题：
# 1. 提示词需要反复调试
# 2. 换模型需要重新调整
# 3. 难以系统化优化
# 4. 缺乏可复用性
# 5. 难以评估效果
DSPy 的解决方案 #
python
import dspy
# DSPy 方式：声明式编程
class QA(dspy.Signature):
"""根据上下文回答问题"""
context = dspy.InputField()
question = dspy.InputField()
answer = dspy.OutputField(desc="简洁的回答")
class RAG(dspy.Module):
def __init__(self):
super().__init__()
self.retrieve = dspy.Retrieve(k=3)
self.generate_answer = dspy.ChainOfThought(QA)
def forward(self, question):
context = self.retrieve(question).passages
return self.generate_answer(context=context, question=question)
# 优势：
# 1. 声明式定义，清晰明了
# 2. 自动优化提示词
# 3. 模型无关
# 4. 可复用、可组合
# 5. 可评估、可调试
DSPy 的核心特点 #
1. 声明式编程 #
text
┌─────────────────────────────────────────────────────────────┐
│ DSPy 声明式编程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 传统方式（命令式）： │
│ - "请用三句话回答" │
│ - "请按照以下格式输出" │
│ - "请一步步思考" │
│ │
│ DSPy 方式（声明式）： │
│ - 定义输入输出（签名） │
│ - 定义处理流程（模块） │
│ - 框架自动生成最优提示 │
│ │
│ 好处： │
│ ✅ 关注"做什么"而非"怎么做" │
│ ✅ 代码即文档 │
│ ✅ 易于维护和修改 │
│ │
└─────────────────────────────────────────────────────────────┘
2. 自动优化 #
text
┌─────────────────────────────────────────────────────────────┐
│ DSPy 自动优化 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 传统方式： │
│ 手动调整提示词 -> 测试 -> 再调整 -> 再测试... │
│ │
│ DSPy 方式： │
│ 提供训练数据 -> 选择优化器 -> 自动编译 -> 最优提示词 │
│ │
│ 优化器可以： │
│ - 自动生成 Few-shot 示例 │
│ - 优化指令措辞 │
│ - 选择最佳推理路径 │
│ - 适应不同模型 │
│ │
└─────────────────────────────────────────────────────────────┘
3. 模块化设计 #
text
┌─────────────────────────────────────────────────────────────┐
│ DSPy 模块化 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 内置模块： │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ dspy.Predict - 基础预测模块 │ │
│ │ dspy.ChainOfThought - 思维链模块 │ │
│ │ dspy.ReAct - 推理行动模块 │ │
│ │ dspy.Retrieve - 检索模块 │ │
│ │ dspy.ProgramOfThoughts - 程序化思维 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ 组合使用： │
│ 模块可以像乐高积木一样组合，构建复杂应用 │
│ │
└─────────────────────────────────────────────────────────────┘
4. 模型无关 #
text
┌─────────────────────────────────────────────────────────────┐
│ DSPy 模型支持 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 支持的模型： │
│ ✅ OpenAI (GPT-4, GPT-3.5) │
│ ✅ Anthropic (Claude) │
│ ✅ Google (Gemini) │
│ ✅ Meta (Llama) │
│ ✅ Mistral │
│ ✅ 本地模型 (Ollama, vLLM) │
│ ✅ 自定义模型 │
│ │
│ 切换模型只需一行代码： │
│ dspy.settings.configure(lm=dspy.OpenAI(model="gpt-4")) │
│ dspy.settings.configure(lm=dspy.Claude(model="claude-3")) │
│ │
└─────────────────────────────────────────────────────────────┘
DSPy vs 传统 Prompt 工程 #
对比分析 #
| 特性 | 传统 Prompt | DSPy |
|---|---|---|
| 开发方式 | 手写提示词 | 声明式编程 |
| 优化方式 | 手动调试 | 自动优化 |
| 可维护性 | 低 | 高 |
| 可复用性 | 低 | 高 |
| 模型迁移 | 需要重写 | 无缝切换 |
| 可测试性 | 困难 | 内置评估 |
| 学习曲线 | 低 | 中等 |
代码对比 #
python
# 传统方式
def traditional_qa(question, context):
prompt = f"""
你是一个专业的问答助手。
请根据以下上下文回答问题。
如果上下文中没有答案，请说"不知道"。
上下文：{context}
问题：{question}
回答：
"""
return llm.generate(prompt)
# DSPy 方式
class QA(dspy.Signature):
"""根据上下文回答问题，如果不知道请说不知道"""
context = dspy.InputField()
question = dspy.InputField()
answer = dspy.OutputField()
qa = dspy.Predict(QA)
result = qa(context=context, question=question)
DSPy 的核心概念 #
签名（Signatures） #
python
# 签名定义了模块的输入输出
class Summarize(dspy.Signature):
"""将长文本总结为简短摘要"""
document = dspy.InputField(desc="需要总结的长文本")
summary = dspy.OutputField(desc="简短的摘要，不超过100字")
模块（Modules） #
python
# 模块是签名的具体实现
class RAG(dspy.Module):
def __init__(self, num_passages=3):
super().__init__()
self.retrieve = dspy.Retrieve(k=num_passages)
self.generate = dspy.ChainOfThought(GenerateAnswer)
def forward(self, question):
context = self.retrieve(question).passages
return self.generate(context=context, question=question)
优化器（Optimizers） #
python
# 优化器自动改进模块
from dspy.teleprompt import BootstrapFewShot
optimizer = BootstrapFewShot(metric=my_metric, max_bootstrapped_demos=4)
optimized_rag = optimizer.compile(RAG(), trainset=train_examples)
检索器（Retrievers） #
python
# 检索器从知识库获取相关内容
rm = dspy.ColBERTv2(url='http://localhost:8893/api/search')
dspy.settings.configure(rm=rm)
retrieve = dspy.Retrieve(k=3)
results = retrieve("什么是机器学习？")
DSPy 的应用场景 #
1. RAG 应用 #
text
┌─────────────────────────────────────────────────────────────┐
│ RAG 应用架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ 用户 │ │ 检索 │ │ 生成 │ │
│ │ 问题 │────>│ 模块 │────>│ 模块 │ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ │
│ │ 知识库 │ │ 回答 │ │
│ └─────────┘ └─────────┘ │
│ │
│ DSPy 优势： │
│ - 自动优化检索策略 │
│ - 自动优化回答质量 │
│ - 可评估端到端效果 │
│ │
└─────────────────────────────────────────────────────────────┘
2. 智能代理 #
python
class Agent(dspy.Module):
def __init__(self):
super().__init__()
self.think = dspy.ChainOfThought(Think)
self.act = dspy.ReAct(Act)
def forward(self, task):
plan = self.think(task=task)
result = self.act(task=task, plan=plan)
return result
3. 数据处理流水线 #
python
class DataPipeline(dspy.Module):
def __init__(self):
super().__init__()
self.extract = dspy.Predict(Extract)
self.transform = dspy.ChainOfThought(Transform)
self.validate = dspy.Predict(Validate)
def forward(self, raw_data):
extracted = self.extract(data=raw_data)
transformed = self.transform(data=extracted)
validated = self.validate(data=transformed)
return validated
4. 多轮对话 #
python
class ChatBot(dspy.Module):
def __init__(self):
super().__init__()
self.understand = dspy.ChainOfThought(Understand)
self.respond = dspy.Predict(Respond)
self.memory = []
def forward(self, user_input):
intent = self.understand(input=user_input, history=self.memory)
response = self.respond(intent=intent, history=self.memory)
self.memory.append((user_input, response))
return response
DSPy 的架构 #
text
┌─────────────────────────────────────────────────────────────┐
│ DSPy 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ 用户代码 │ │
│ │ Signatures + Modules + Programs │ │
│ └──────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ DSPy 核心 │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │Predict │ │CoT │ │ReAct │ │Retrieve │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │ │
│ └──────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ 优化器层 │ │
│ │ BootstrapFewShot | MIPRO | BootstrapFinetune │ │
│ └──────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ 后端层 │ │
│ │ OpenAI | Claude | Gemini | Llama | Local │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
DSPy 的优势与局限 #
优势 #
text
✅ 自动化优化
- 无需手写提示词
- 自动生成 Few-shot 示例
- 持续改进
✅ 可维护性
- 代码即文档
- 模块化设计
- 易于测试
✅ 模型无关
- 轻松切换模型
- 统一的 API
- 跨模型优化
✅ 可复用性
- 模块可组合
- 签名可共享
- 优化器可配置
✅ 可评估性
- 内置评估框架
- 多种指标
- 易于调试
局限性 #
text
⚠️ 学习曲线
- 需要理解新概念
- 需要一定的编程基础
- 文档仍在完善
⚠️ 调试复杂
- 自动优化过程不透明
- 需要理解优化器原理
- 错误信息可能模糊
⚠️ 资源需求
- 优化需要训练数据
- 可能需要多次调用 LLM
- 成本可能较高
⚠️ 生态成熟度
- 相比 LangChain 较新
- 社区资源较少
- 部分功能仍在开发
学习路径 #
text
入门阶段
├── DSPy 简介（本文）
├── 安装与配置
├── 第一个程序
└── 签名基础
进阶阶段
├── 模块详解
├── 检索器使用
├── 优化器入门
└── 评估方法
高级阶段
├── 高级优化器
├── 自定义模块
├── 复杂流程
└── 性能调优
实战阶段
├── RAG 应用
├── 智能代理
├── 多轮对话
└── 生产部署
下一步 #
现在你已经了解了 DSPy 的基本概念，接下来学习 DSPy 基础概念，开始你的 DSPy 编程之旅！
最后更新：2026-03-30