探寻多步检索之谜：DSPy在多跳搜索任务中的奥秘

步子哥

在当今信息爆炸的时代，如何在庞大且杂乱的数据海洋中迅速定位到所需信息变得尤为关键。今天，我们将走近由 Stanford NLP 团队推出的 DSPy 工具，探索其在“多跳搜索”（Multi-Hop Search）任务中的应用奥秘。本文将带您踏上一段充满科学探索精神的旅程，从依赖安装、数据加载、索引构建、语义检索，再到模块设计、模型优化与实验跟踪，让我们一起揭开多跳搜索的神秘面纱。

🚀 初始设置：依赖安装与数据下载

在所有科研工具中，良好的起步总是敲门砖。DSPy 为我们提供了一种灵活且高效的编程方式，让我们可以“拼装”出复杂任务的流水线。而完成这一旅程的第一步，就是安装最新版本的 DSPy。

首先，我们只需运行以下指令安装 DSPy：

pip install -U dspy

为更好地了解系统内部的运行情况，还可以通过 MLflow 进行实验追踪。MLflow 是一个 LLMOps 工具，它可以将各个实验步骤、提示语以及优化过程以可视化方式展现在屏幕上，使整个调试过程透明且易于复盘。只需按照以下几步即可启动 MLflow：

安装 MLflow：

   %pip install mlflow>=2.20

在单独的终端中启动 MLflow UI：

   mlflow ui --port 5000

在代码中配置 MLflow 追踪：

   import mlflow
   mlflow.set_tracking_uri("http://localhost:5000")
   mlflow.set_experiment("DSPy")
   mlflow.dspy.autolog()

这一切为后续实验的解读、错误排查和模型优化提供了极大的帮助和便利。

📚 数据加载与BM25索引构建

在多跳搜索任务中，一个庞大的数据集往往是必不可少的。我们选择使用一个特别有趣的数据集——汇集了 500 万条维基百科摘要（2017 年版）的数据。这份数据主要包含了各个页面前几段的概述，体积虽然压缩后有 500MB，但下载与解压只需几分钟。

接下来，我们用 Python 的 ujson 模块逐条加载每个 JSONLine 文件中的记录，将页面标题和文本拼接后形成待检索的语料库。例如以下 Python 代码展示了如何加载数据并计数语料库中的条目数：

import ujson
corpus = []
with open("wiki.abstracts.2017.jsonl") as f:
    for line in f:
        line = ujson.loads(line)
        corpus.append(f"{line['title']} | {' '.join(line['text'])}")
print(len(corpus))

加载完数据后，我们便需要构建一个检索索引。DSPy 配合轻量级的 BM25S 库，可以高效地对文本数据进行分词、去停用词以及词干还原处理。我们利用英文停用词、Stemmer 对数据进行分词处理，并调试 BM25S 参数（如 k1=0.9，b=0.4），建立起一个高效的索引系统：

import bm25s
import Stemmer
stemmer = Stemmer.Stemmer("english")
corpus_tokens = bm25s.tokenize(corpus, stopwords="en", stemmer=stemmer)
retriever = bm25s.BM25(k1=0.9, b=0.4)
retriever.index(corpus_tokens)

通过这一简单的流程，我们就能将庞大的文本数据编织成一个便于搜索的语义索引网络，为后续的查询操作奠定基础。

🔍 多跳搜索任务的设计理念

多跳搜索任务本质上是一种递归的信息检索和推理过程。相比传统的单跳检索，多跳搜索不仅要回答查询问题，还要通过多个中间“跳跃”（hop）来不断积累信息，最终达到对复杂问题的全面解答。DSPy 通过模块化设计，提供了一个灵活且易于扩展的解决方案。

在这个任务中，核心目标是从一个复杂的声明（claim）中提取相关信息，利用多次搜索和逐步推理来获取所需的 Wikipedia 页面标题。DSPy 利用两个子模块来实现这一过程：

生成查询模块（generate_query）
该模块通过 Chain-of-Thought 思维链条，将当前的声明和已有的笔记（notes）结合，生成一个查询字符串。正如通过连贯的思维进行总结和归纳一样，该模块让模型不断反思自身已获得的信息，然后生成下一步的查询。
笔记修正模块（append_notes）
在执行搜索后，系统会将返回的上下文（context）传递给该模块，经过进一步推理后更新已有的笔记，并提取出目标页面标题。两者的交替迭代，正体现了信息在不断的反馈与积累中逐渐趋于完善。

下面这段代码展示了如何构建一个多跳搜索模块：

class Hop(dspy.Module):
    def __init__(self, num_docs=10, num_hops=4):
        self.num_docs, self.num_hops = num_docs, num_hops
        self.generate_query = dspy.ChainOfThought('claim, notes -> query')
        self.append_notes = dspy.ChainOfThought('claim, notes, context -> new_notes: list[str], titles: list[str]')

    def forward(self, claim: str) -> list[str]:
        notes = []
        titles = []
        for _ in range(self.num_hops):
            query = self.generate_query(claim=claim, notes=notes).query
            context = search(query, k=self.num_docs)
            prediction = self.append_notes(claim=claim, notes=notes, context=context)
            notes.extend(prediction.new_notes)
            titles.extend(prediction.titles)
        return dspy.Prediction(notes=notes, titles=list(set(titles)))

在这段代码中，每次循环相当于一次“跳跃”，不断生成新的查询，并在当前信息基础上优化已有答案，从而对任务陈述进行更深层次的解读。

🛠 搜索函数与上下文检索

为了实现真正高效的查询与信息检索，我们还需要定义一个基础的搜索函数。该函数将用户提交的查询文本进行分词、去除停用词，并利用 BM25S 检索系统从构建好的语料库中找到相关文档及其得分。下面的代码展示了如何基于 BM25S 库实现这一功能：

def search(query: str, k: int) -> list[str]:
    tokens = bm25s.tokenize(query, stopwords="en", stemmer=stemmer, show_progress=False)
    results, scores = retriever.retrieve(tokens, k=k, n_threads=1, show_progress=False)
    run = {corpus[doc]: float(score) for doc, score in zip(results[0], scores[0])}
    return run

这个函数中，通过将查询文本转化为 tokens，利用预先构建的 BM25 索引进行检索，最终返回一个映射文档和分数的数据结果。这样，在多跳搜索模块中，我们就可以调用这个函数获取与当前查询最相关的上下文内容，为后续链式推理提供数据支持。

🧪 评估指标：Top-5 Recall 的计算

在复杂的多跳检索任务中，评价模型效果的指标尤为重要。本例中，我们采用了 Top-5 Recall 作为评估指标，其基本含义是：在模型返回的前 5 个页面标题中，有多少个与事实黄金标准一致。具体来说，假设每个样本的正确标题数量为 3，那么若模型返回的前 5 个标题中分别包含其中的 2 个，则 recall 值为 2/3。

我们可以用以下函数来计算 Top-5 Recall：

def top5_recall(example, pred, trace=None):
    gold_titles = example.titles
    recall = sum(x in pred.titles[:5] for x in gold_titles) / len(gold_titles)
    if trace is not None:
        return recall >= 1.0
    return recall

在评估时，我们调用 DSPy 的 Evaluate 模块，并设置一些线程数目、进度显示等参数，以实时看到模型在开发集（devset）中评估的表现与调整过程。

🔍 MLflow 集成与追踪评估

为了更好地追踪模型训练与优化过程，DSPy 提供了与 MLflow 的无缝整合。通过 MLflow，我们可以记录每一次模型优化的细节，观察调用日志、提示语调整以及参数变化，从而对模型的表现进行定量分析。

例如，下面的代码片段展示了如何在 MLflow 中记录一次评估运行，并将对应的评分和详细结果以表格方式保存：

import mlflow
with mlflow.start_run(run_name="hop_evaluation"):
    evaluate = dspy.Evaluate(
        devset=devset,
        metric=top5_recall,
        num_threads=16,
        display_progress=True,
        return_all_scores=True,
        return_outputs=True,
    )
    aggregated_score, outputs, all_scores = evaluate(Hop())
    mlflow.log_metric("top5_recall", aggregated_score)
    mlflow.log_table(
        {
            "Claim": [example.claim for example in eval_set],
            "Expected Titles": [example.titles for example in eval_set],
            "Predicted Titles": outputs,
            "Top 5 Recall": all_scores,
        },
        artifact_file="eval_results.json",
    )

这种集成机制不仅有助于团队协作、版本控制，还有助于理解模型在不同数据集上的表现，从整体上提高多跳搜索任务的鲁棒性与准确率。

💡 提示优化：探索 MIPROv2 的潜力

尽管基础模型已经能够完成多跳搜索任务，但 DSPy 更引以为豪的是其提示语（prompt）的优化能力。通过引入更大规模的语言模型，如 OpenAI 的 GPT-4o 作为“教师模型”，我们可以不断优化小规模模型（例如 Meta 的 Llama-3.1-8B）内部的提示语生成流程。利用 MIPROv2 模块，可以对生成查询模块和笔记修正模块的提示进行联合优化，从而显著提升任务效果。

下面的代码示例展示了如何利用 MIPROv2 进行提示优化，并在训练集、开发集上进行实验与评估：

models = dict(prompt_model=gpt4o, teacher_settings=dict(lm=gpt4o))
tp = dspy.MIPROv2(metric=top5_recall, auto="medium", num_threads=16, **models)
kwargs = dict(minibatch_size=40, minibatch_full_eval_steps=4, requires_permission_to_run=False)
optimized = tp.compile(Hop(), trainset=trainset, max_bootstrapped_demos=4, max_labeled_demos=4, **kwargs)

经过大约 35 分钟的优化后，模型的 Top-5 Recall 从 30% 左右跃升到了接近 60%。这一显著的效果表明，通过提示优化，模型不仅在查询生成和上下文整合上更加精准，也在反馈过程中能够更好地学习如何改进。

📝 代码细节与实现揭秘

在我们进一步提高多跳搜索模型的表现时，对每一个细节的深入理解至关重要。在整个 DSPy 的编程流水线中，每一个模块和函数都各司其职，共同构成一个逻辑严密的检索系统：

数据加载和预处理
我们整个流程都依赖于庞大的 Wikipedia 摘要数据。通过 BM25S 库进行文本分词与索引构建，是实现高效检索的基石。
模块化设计（Hop 模块）
使用继承自 dspy.Module 的 Hop 类，让多跳搜索任务得以清晰分解。生成查询和笔记修正两大子模块之间的互相协作，是整个系统的核心所在。
搜索函数
封装的 search 函数对查询的分词、检索得分、索引匹配进行了高度抽象，使得多跳搜索过程中的每一次查询调用都简单而明确。
评估与反馈机制
Top-5 Recall 的设计和 MLflow 的集成，使得模型开发者能够在每一次迭代中直观地看待模型性能，并针对性的进行参数调整与提示优化。
提示优化与 MIPROv2
引入大模型作为“教师”，通过对小模型的提示进行联合优化，让系统在探索未知领域时拥有更强的知识迁移能力。这不仅体现了跨模型协同工作的优势，更展示了 DSPy 平台在解决复杂交互任务中的巨大潜力。

在整个实现过程中，DSPy 的核心设计理念始终围绕“递归推理、模块协同”展开。每一个环节的改进，都让模型在不断迭代与反馈中变得日益强大。

🔗 模型保存与复现：从本地文件到 MLflow 实验

除了模型训练与优化，保存与加载模型、实现实验复现也是科研工作中不可或缺的一部分。在 DSPy 中，我们不仅可以将经过优化的模型保存为本地 JSON 文件，还可以通过 MLflow 将整个实验过程保存下来。以下代码展示了如何保存并加载优化后的模型：

optimized.save("optimized_hop.json")
loaded_program = Hop()
loaded_program.load("optimized_hop.json")
print(loaded_program(claim="The author of the 1960s unproduced script written for The Beatles, Up Against It, and Bernard-Marie Koltès are both playwrights.").titles)

此外，MLflow 的集成使得实验结果、环境配置及依赖包信息全部冻结保存，为团队协作和后续复现提供了极大便利。您还可以通过 MLflow 的 Web UI 查看所有模型优化记录、调用日志以及性能曲线，形成一条完整的实验追踪链。

🌟 总结与未来展望

本文详细介绍了 DSPy 工具在多跳搜索任务中的实现方式——从依赖安装、数据加载、BM25 索引构建，到模块设计与链式检索，再到模型评估与提示优化，以及最后的模型保存与 MLflow 实验跟踪。通过这条完整的科研流水线，我们不仅见证了模型从粗糙初始状态吸取反馈、不断自我完善的历程，也看到了大模型教师在小模型优化中的价值。

多跳搜索任务本质上是一种探索与逐步验证的过程，它对应复杂问题求解中的多层逻辑推理。DSPy 的模块化设计与快速迭代能力，正是满足这一需求最有力的工具之一。未来，我们期待 DSPy 在以下几个方向有更多突破：

更为精细的提示优化算法：通过跨语境、多层级提示联合训练，让模型更好地捕捉隐藏的语义联系。
大规模数据集的高效检索：结合分布式检索系统和 GPU 加速技术，针对实时查询任务实现极速响应。
强化学习与反馈机制：引入在线反馈系统，让模型在部署后能够利用用户交互数据持续优化性能。
多模态信息融合：不仅限于文本数据，未来的系统将兼容图像、视频等多种媒体，提供更全面的信息支持。

DSPy 的出现，为复杂信息检索任务提供了一种全新的思路，也为未来自然语言处理与人工智能领域的发展指明了方向。无论是在科研实践中，还是在工业界的应用场景内，多跳搜索无疑都将成为不可或缺的核心技术之一。

📖 参考文献

Stanford NLP. “DSPy Multi-Hop Search Tutorial.” DSPy 官方文档, 2024.
MLflow DSPy Documentation. “MLflow 集成与追踪实验.” MLflow 官方网站, 2024.
BM25S Library Documentation. “轻量级文本检索工具介绍.” GitHub, 2024.
Huggingface Datasets. “HoVer 多跳任务数据集介绍.” Huggingface, 2024.
OpenAI GPT-4o & Meta Llama 系列. “大型语言模型在小模型优化中的应用实例.” 相关技术博客, 2024.

在信息检索与人工智能日益融合的时代，DSPy 多跳搜索任务无疑为科研人员和工程师提供了一条既高效又直观的研究路径。未来，随着更多智能化工具和技术的不断涌现，我们有理由相信，复杂决策与多层逻辑推理将变得更加简单、快捷，从而推动人工智能领域迎来全新的发展篇章。

探索永无止境，而科技之光，正照亮我们不断前行的道路。

以上便是 DSPy 多跳搜索任务的全面解读，希望这篇文章给您带来启示，助您在科研探索的旅途上取得更多突破！

步子哥

穿越数据迷宫：DSPy Retrieval-Augmented Generation 的奇幻征程

在大数据时代，我们常常需要在庞大文本库中检索与问题相关的信息，而仅靠一个生成式模型往往不足以回答复杂问题。DSPy 为我们提供了一条融合检索和生成的捷径 —— Retrieval-Augmented Generation (简称 RAG) 。本文将带你走进 DSPy 的 RAG 教程，揭示如何配置环境、构建检索器、整合生成模块，并利用 MLflow 追踪实验，打造一款高质量的技术查询问答系统。

🚀 环境配置：为 RAG 奠定坚实基础

在使用 DSPy 构建 RAG 程序之前，我们首先需要配置好开发环境。跟随 DSPy 的教程，只需要几行代码就能设置好环境并验证身份。最关键的是通过设置 OPENAI_API_KEY 来保证 DSPy 能够调用 OpenAI 的 GPT-4o-mini 模型（或其他你喜欢的语言模型）。

首先，我们通过 pip 安装最新版本的 DSPy：

pip install -U dspy

接下来，导入 DSPy 并配置模型：

import dspy

lm = dspy.LM('openai/gpt-4o-mini')
dspy.configure(lm=lm)

为了更好地可视化每一次模型调用和调试过程，DSPy 推荐你使用 MLflow 进行追踪。只需按照以下步骤操作：

安装 MLflow：

   %pip install mlflow>=2.20

启动 MLflow UI（建议在一个独立终端运行）：

   mlflow ui --port 5000

在代码中设置 MLflow 追踪地址和实验名称，并启用自动记录：

   import mlflow
   mlflow.set_tracking_uri("http://localhost:5000")
   mlflow.set_experiment("DSPy")
   mlflow.dspy.autolog()

有了这些配置，我们就可以更清晰地看到 DSPy 中每一步的操作细节，从而为后续模型优化提供数据支撑。

🔎 探索基础模块：从 Predict 到 Chain-of-Thought

使用 DSPy 构建问答系统，我们可以选择最简单的模块——dspy.Predict。这个模块根据我们定义的 signature（输入输出的结构）直接让 LM 返回答案。例如，我们可以这样构造一个简单的问答模块：

qa = dspy.Predict('question: str -> response: str')
response = qa(question="what are high memory and low memory on linux?")
print(response.response)

在这个例子中，DSPy 会生成一条提示，并把生成的答案解析为 response 字段。这样不仅简化了直接调用 LM 的工作，而且自动处理了输入输出的绑定。此外，DSPy 还支持更具推理能力的模块，如 dspy.ChainOfThought，它不仅生成答案，还能完整呈现生成过程中的思考详细信息。

例如，我们可以使用 Chain-of-Thought 模块：

cot = dspy.ChainOfThought('question -> response')
pred = cot(question="should curly braces appear on their own line?")
print(pred.response)

Chain-of-Thought 模块能够在生成答案前先进行一段“推理”过程，其输出的 reasoning 字段展示了模型思考的步骤，有助于理解其输出为何如此。

📚 数据准备：从 RAG-QA Arena 加载技术问答数据

DSPy RAG 教程中针对技术问答任务，使用了来自 RAG-QA Arena 的数据。该数据集包含由 StackExchange 提供的技术问题和较长的黄金答案，是提升问答系统效果的重要训练数据。我们使用以下代码下载并加载数据：

import ujson
from dspy.utils import download

# 下载技术问答数据集（格式为 JSON Lines 文件）
download("https://huggingface.co/dspy/cache/resolve/main/ragqa_arena_tech_examples.jsonl")

with open("ragqa_arena_tech_examples.jsonl") as f:
    data = [ujson.loads(line) for line in f]

加载完毕之后，我们将数据转换为 DSPy 内置的 Example 格式（方便后续训练与评估）：

data = [dspy.Example(**d).with_inputs('question') for d in data]

为了方便对系统进行迭代优化，我们通常还将数据划分为训练集、开发集和测试集。例如：

import random
random.Random(0).shuffle(data)
trainset, devset, testset = data[:200], data[200:500], data[500:1000]

这样，我们就为系统评估和优化提供了充足的数据样本。

🔍 构建检索器：利用 OpenAI Embedding 与 FAISS 加速搜索

传统的生成式问答模型往往依靠知识存储在参数中，而在 Retrieval-Augmented Generation (RAG) 中，我们将检索外部知识库与生成模型结合，使得问答结果更加准确可靠。在 DSPy 中，可以使用任何 Python 代码实现检索。上手最简单的方法是利用 OpenAI 提供的文本嵌入（Embedding），结合 FAISS 库进行局部 Top-K 搜索。

首先，我们下载经过下采样处理后的技术问答语料库（约 28,000 条文档）：

download("https://huggingface.co/dspy/cache/resolve/main/ragqa_arena_tech_corpus.jsonl")

然后，我们将文档加载并进行截断（防止过长）：

max_characters = 6000  # 控制文档最大字符数
topk_docs_to_retrieve = 5  # 每次检索返回5篇文档

with open("ragqa_arena_tech_corpus.jsonl") as f:
    corpus = [ujson.loads(line)['text'][:max_characters] for line in f]
print(f"Loaded {len(corpus)} documents. Will encode them below.")

接下来，我们使用 DSPy 的 Embedder 生成 512 维嵌入向量，并构造 Embeddings 检索器：

embedder = dspy.Embedder('openai/text-embedding-3-small', dimensions=512)
search = dspy.retrievers.Embeddings(embedder=embedder, corpus=corpus, k=topk_docs_to_retrieve)

这一步骤主要依靠 FAISS 加速搜索（注意：你可能需要安装 faiss-cpu 或者配置 brute_force_threshold=30000 以避免一些系统限制）。

🤖 构建 RAG 模块：将检索与生成无缝连接

有了检索器之后，我们就可以构建 RAG 模块，将检索到的上下文信息与生成模块组合在一起。在 DSPy 中，我们可以使用 dspy.Module 定义一个多步骤的程序。下面的 RAG 类展示了如何先利用检索器获取相关文档，再通过 Chain-of-Thought 模块生成答案：

class RAG(dspy.Module):
    def __init__(self):
        # 定义生成模块，输入为 context 与 question，输出为 response
        self.respond = dspy.ChainOfThought('context, question -> response')

    def forward(self, question):
        # 使用之前定义的 search 检索上下文信息
        context = search(question).passages
        # 调用生成模块，结合上下文与问题生成答案
        return self.respond(context=context, question=question)

使用这个 RAG 模块非常简单，只需实例化并传入问题：

rag = RAG()
result = rag(question="what are high memory and low memory on linux?")
print(result.response)

DSPy 将自动调用检索器获取相关知识，再结合 LM 生成答案，整个流程灵活且易于扩展。

📏 评估策略：Semantic F1 与系统指标

为了衡量问答系统的效果，我们不仅需要比较生成答案和黄金答案的字面相似度，更希望通过语义层面评估两者之间的覆盖情况。DSPy 提供了 Semantic F1 评估模块，该模块使用简单而直接的方式：从问题、黄金答案与系统输出中提取关键信息，计算 recall 和 precision。

例如，我们可以这样实例化 Semantic F1：

from dspy.evaluate import SemanticF1

metric = SemanticF1(decompositional=True)
pred = cot(**example.inputs())  # 使用 Chain-of-Thought 模块生成预测
score = metric(example, pred)
print(f"Semantic F1 Score: {score:.2f}")

在评估环节，DSPy 提供的 Evaluate 模块允许你在多个样本上批量计算分数，从而快速了解系统整体性能。

⚙️ 优化与迭代：利用 MIPROv2 美化提示语

即使构建了基本的 RAG 模块，离应用真实场景的高性能问答系统还差一步：提示语优化。DSPy 内置的 MIPROv2 优化器可以针对各个子模块（本例中的 Chain-of-Thought 生成模块）联合优化提示语，从而进一步提升系统表现。

优化过程大致如下：

tp = dspy.MIPROv2(metric=metric, auto="medium", num_threads=24)
optimized_rag = tp.compile(RAG(), trainset=trainset,
                           max_bootstrapped_demos=2, max_labeled_demos=2,
                           requires_permission_to_run=False)

经过优化后，RAG 模块会在生成答案时提供更加精准而详尽的回答。通过对比未优化（baseline）的输出与经过 MIPROv2 优化后的输出，你将发现整个系统在 Semantic F1 得分上得到了明显改善（示例中从 55% 提升到了 61% 左右）。

此外，为了确保成本可控，DSPy 允许你实时跟踪调用成本，例如，通过遍历 lm.history 中的 'cost' 字段，可以累计 API 调用总费用。

💾 模型保存与加载：实现轻松复现

当你经过多次优化与训练后，保存模型和系统状态非常重要。DSPy 支持将优化后的 RAG 模块存储到本地文件中（如 JSON 格式），或者通过 MLflow 保存模型以便于团队协作和实验重现。

例如，将优化后的模型保存到文件：

optimized_rag.save("optimized_rag.json")
loaded_rag = RAG()
loaded_rag.load("optimized_rag.json")

加载后，你就可以像之前一样直接调用模型来回答问题：

result = loaded_rag(question="cmd+tab does not work on hidden or minimized windows")
print(result.response)

MLflow 集成还可让你跟踪每个实验步骤、成本以及环境配置，进一步提升整个系统的透明度和复现性。

🔮 展望未来：不断迭代、突破创新

通过这一教程，我们初步实现了一个技术问答系统 —— 从简单的生成模型，到结合外部检索的 Retrieval-Augmented Generation，再到利用 MIPROv2 优化提示语，使 Semantic F1 得分从 42% 提升到 61%。这一系列步骤展示了 DSPy 在集成检索与生成、快速迭代与优化方面的强大能力。

未来，你可以进一步探索以下方向来持续提升系统质量：

系统架构优化：例如，尝试让 LM 自动生成检索查询，或者构建多层检索与生成组合的 STORM 管道。
多模态信息融合：不仅限于文本，还可以整合图像、音频等多种数据源来丰富问答内容。
成本控制与效率提升：通过剪枝、蒸馏等技术，将大模型优化为轻量版，从而大规模部署时降低调用成本。
持续评估与数据扩充：收集更多真实的用户问答数据，进一步细化评价指标，使系统更贴近实际需求。

DSPy 的灵活模块化设计、完善的评估追踪机制以及高效的提示优化工具，为未来多任务、多模态 AI 系统的构建提供了无限可能。无论你是科研工作者还是工程师，都能通过 DSPy 快速构建出属于自己的高质量问答系统。

📖 参考资料

Stanford NLP. “Retrieval-Augmented Generation - DSPy Tutorial.” DSPy 官方文档, 2024.
MLflow DSPy Documentation. “MLflow 集成与实验追踪.” MLflow 官方网站, 2024.
FAISS 库文档. “高效向量检索工具介绍.” GitHub, 2024.
RAG-QA Arena 数据集. “技术问答数据集介绍.” Huggingface, 2024.
MIPROv2 优化器相关文献. “提示语优化在生成模型中的应用实践.” 相关技术博客, 2024.

DSPy Retrieval-Augmented Generation 让我们看到了结合外部检索与生成模型的巨大潜力，通过不断的迭代与实验，每一步优化都有助于推动问答系统的整体表现。未来，随着更多高效检索工具与生成模型的出现，AI 问答系统的边界将不断被重塑与突破，带来更多令人期待的创新体验。