网站Logo 时光杂货铺

RAG优化技术

admin
5
2026-11-02

RAG 优化实战:元数据过滤原理与落地实践

在 RAG(检索增强生成)的所有优化手段中,元数据过滤是实现成本最低、效果提升最直接、生产环境必落地的一项基础优化。它不依赖复杂的算法模型,仅通过 “标签化 + 预筛选” 的思路,就能同时解决检索准确率、内容可信度和数据权限三大核心问题。本文结合 Spring AI 的实际代码,系统梳理元数据过滤的原理、场景与落地方式。

一、什么是 RAG 中的元数据

元数据(Metadata),通俗来讲就是 “描述数据的数据”。在 RAG 体系中,每一段被切分后的文本块(Chunk)在存入向量数据库时,除了正文内容和向量值之外,都会附带一组结构化的元数据信息。

我们可以将向量库中的一条记录理解为:

  • 正文内容(Content):用于语义相似度计算的原始文本;

  • 向量值(Vector):正文经过 Embedding 模型生成的高维向量;

  • 元数据(Metadata):一组键值对形式的标签信息,例如文件名、页码、版本号、所属部门、创建时间等。

在使用 Navicat 等工具查看向量数据表时,通常会看到一个名为 metadata 的字段,其本质就是一个 JSON 或 Map 结构,用于存储上述标签信息。框架默认会自动写入 source(文件来源路径)、页码等基础字段,业务层面也可以按需追加自定义字段。

元数据的核心价值在于:让向量检索从 “全库语义匹配” 升级为 “指定范围内的语义匹配”,兼顾了向量检索的语义理解能力与关系型数据库的精确过滤能力。

二、元数据过滤的三大核心应用场景

1. 精确范围过滤:解决语义相近带来的答案混淆

向量相似度检索的本质是计算文本语义的接近程度,它对细微的版本、范围差异区分能力较弱。

举一个典型场景:企业存在 2023、2024、2025 三个版本的汽车用户手册,不同版本中 “车辆启动方式” 的描述各不相同 ——2023 版为钥匙启动,2024 版为旋钮启动,2025 版为手机启动。

如果不做元数据过滤,当用户提问 “2023 版汽车如何启动” 时,三个版本的文本块语义高度相似,纯向量检索很可能将三个版本的内容全部召回。若后续流程未做强校验,大模型极易引用错误版本的内容,导致回答与用户需求不符。

引入元数据过滤后,流程变为:

  1. 文档入库时,为每个文本块打上 fileName 或 version 标签;

  2. 用户提问时,先通过元数据过滤,将检索范围限定在 2023 版对应的文本块;

  3. 在缩小后的范围内执行相似度检索。

这种 “先过滤、后检索” 的模式,能够彻底排除无关版本的干扰,显著提升回答准确率。

2. 内容来源溯源:提升回答可信度与可验证性

RAG 系统中,用户天然会对回答产生疑问:答案是真正来自企业知识库,还是大模型自行生成的内容?

元数据为回答提供了可追溯的依据。在文本块入库时保留文档名称、页码、章节、版本号等信息,当大模型生成最终答案后,可以将引用的来源信息同步展示给用户,例如:

参考来源:《汽车用户手册(2024 年版)》第 5 页

该能力的价值体现在三方面:

  • 增强可信度:明确的来源标识能够证明答案基于官方文档生成,而非模型杜撰;

  • 便于核对校验:用户对答案存疑时,可直接定位到原文对应位置进行核实;

  • 提升使用效率:在文档数量多、内容复杂的场景下,帮助用户快速定位原始资料。

3. 数据权限隔离:企业级应用的安全底线

企业级知识库普遍存在分级授权的需求:部分文档属于部门内部机密,仅对特定岗位开放;部分文档为全员公开内容。若向量检索直接全库检索,普通员工的提问可能召回机密文档,造成数据泄露。

元数据是实现低成本权限隔离的主流方案:

  1. 文档入库时,在元数据中写入部门 ID、角色 ID、保密等级、可见用户范围等权限字段;

  2. 用户发起查询时,先根据当前用户身份构造元数据过滤条件,剔除所有无权限访问的文本块;

  3. 在权限允许的范围内执行相似度检索与答案生成。

该方案无需改造向量库底层架构,仅通过标签过滤即可实现数据隔离,是绝大多数企业级 RAG 系统的标准做法。

三、Spring AI 落地实现

基于 Spring AI 框架,元数据过滤的落地分为两步:文档入库时写入元数据标签、检索查询时添加过滤条件。

1. 文档入库:追加业务元数据

文档读取并切片完成后,在向量化存储之前,可通过 Document.getMetadata().put() 方法为每个文本块追加自定义业务字段。

示例代码

@GetMapping("/embedding")
public String embedding(String filePath, String fileName) {
    List<Document> documents;
    try {
        // 读取文件并完成文本切片
        documents = documentReaderFactory.read(new File(filePath));
    } catch (IOException e) {
        throw new RuntimeException("文档读取失败", e);
    }

    // 为每个文本块追加 fileName 元数据标签
    for (Document document : documents) {
        document.getMetadata().put("fileName", fileName);
    }

    // 向量化并写入向量数据库
    embeddingService.embedAndStore(documents);
    return "success";
}

入库后,框架默认的 source、页码等字段与自定义的 fileName 字段会共同保存在 metadata 中,各司其职。

2. 检索过滤:两种常用实现方式

方式一:原生向量检索(VectorStore 方式)

适用于需要自主控制检索逻辑、手动拼装 Prompt 的场景。通过 SearchRequest 的 filterExpression 指定过滤条件,语义等价于 SQL 中的 WHERE 子句。

@GetMapping("/retrieveMetadata")
public String retrieveMetadata(String query, String fileName) {
    SearchRequest searchRequest = SearchRequest.builder()
            .query(query)
            .topK(5)
            .similarityThreshold(0.5f)
            // 元数据过滤:仅检索 fileName 匹配的文本块
            .filterExpression("fileName == '" + fileName + "'")
            .build();

    return embeddingService.similaritySearch(searchRequest).toString();
}

说明:

  • filterExpression 在相似度计算之前生效,先缩小范围再匹配,兼顾准确性与性能;

  • similarityThreshold 为相似度阈值,用于过滤掉相关性过低的结果,具体取值需结合业务数据调试;

  • 示例中采用字符串拼接仅为演示便捷,生产环境建议对特殊字符转义或使用结构化 Filter 构建器,避免语法错误与注入风险。

方式二:QuestionAnswerAdvisor 端到端方式

适用于使用 Spring AI 内置 RAG 能力的场景,通过 qa_filter_expression 参数将过滤条件传递给 QuestionAnswerAdvisor,框架内部自动完成检索、Prompt 拼装与大模型调用。

示例代码

@GetMapping("/retrieveAdvisorWithMetadata")
public String retrieveAdvisorWithMetadata(String query, String fileName) {
    return chatClient.prompt(query)
            .advisors(advisorSpec ->
                    advisorSpec.param("qa_filter_expression", "fileName == '" + fileName + "'")
            )
            .call()
            .content();
}

说明:

  • qa_filter_expression 是 QuestionAnswerAdvisor 约定的固定参数名;

  • 框架内部会自动将过滤条件应用于向量检索阶段,业务代码更简洁;

  • 演示示例由前端直接传入文件名,真实项目中通常由大模型从用户提问中抽取过滤参数,实现用户无感知的范围限定。

四、生产环境最佳实践与避坑

  1. 业务字段与框架字段分层解耦 不要依赖 source 等框架默认字段做业务过滤。这类字段的值会随部署环境、存储路径变化而改变,业务过滤应统一使用自定义的业务字段,如 fileId、fileName、tenantId 等。

  2. 元数据只存过滤与标识类字段 元数据用于存储标签、ID、时间等小体量结构化信息,不要将大段正文内容存入其中。原始文本由 content 字段承载,避免元数据膨胀影响检索性能。

  3. 统一字段命名规范 全项目范围内保持元数据字段名一致,例如统一使用驼峰 fileName 或下划线 file_name,避免混用导致过滤条件失效,降低维护成本。

  4. 优先使用预过滤,避免内存后过滤 元数据过滤应下推到向量数据库层面执行,利用数据库的索引能力提升性能。不建议全量召回后在应用内存中做过滤,避免数据量增大后性能急剧下降。

  5. 相似度阈值需结合场景调试 不存在通用的最优阈值。不同的 Embedding 模型、不同的文档领域,相似度分布差异较大,需基于真实业务数据反复调优,在召回率与准确率之间找到平衡。

五、总结

元数据过滤是 RAG 优化体系中的基础能力,也是从 Demo 走向生产的必经一步。它以极低的实现成本,同时解决了检索范围精准控制、回答来源可追溯、企业数据权限隔离三大核心问题。

在实际项目中,元数据的设计往往不止 fileName 一个字段,通常还会包含文件 ID、租户标识、文档类型、时间维度等多个业务维度,支撑更复杂的检索与管控需求。掌握元数据过滤的设计思路与落地方法,是构建稳定、可靠、安全的企业级 RAG 系统的必备基础。

RAG 优化技术:问题改写原理与落地实践

在 RAG 系统中,向量检索的效果高度依赖查询语句的表达质量。真实场景下用户的自然语言提问往往存在表述模糊、信息残缺、上下文依赖、语义粒度不适配等问题,直接用于相似度检索极易出现召回不足或召回偏差,进而影响最终答案的准确性。

问题改写(Query Rewriting)是 RAG 检索侧成本最低、收益最显著的前置优化手段之一。它通过大模型对原始查询进行重写加工,将用户自然语言提问转化为更适配向量检索的标准查询表达,能够在架构改动极小的前提下,大幅提升检索召回率与回答质量,是生产级 RAG 系统的标配能力。

一、四种主流问题改写策略

问题改写并非单一技术,而是一组优化思路的集合。工业界主流的改写策略分为四类,分别适配不同的问题缺陷与业务场景。

1. 分解:复杂问题的子查询拆分

解决痛点

对于多跳推理、多维度对比类的复杂问题,单条查询难以一次性命中全部关键信息。直接检索往往只能匹配到局部片段,无法支撑完整推理,最终导致大模型回答片面或错误。

核心原理

将用户的复杂查询拆解为若干个相互独立、逻辑清晰、可单独检索的子问题。每个子问题独立执行向量检索,收集所有相关文档块后,将全部检索结果与原始问题一并送入大模型,由模型完成信息整合与最终推理。

典型示例

  • 多跳问题:「iPhone 15 发布的时候,苹果的 CEO 是谁?」 拆解为两个子查询:

    1. iPhone 15 的发布时间是什么时候?

    2. 2023 年 9 月苹果公司的 CEO 是谁?

  • 对比类问题:「Kafka 和 RocketMQ 的异同点是什么?」 拆解为三个子查询:

    1. Kafka 的核心特性有哪些?

    2. RocketMQ 的核心特性有哪些?

    3. Kafka 与 RocketMQ 的特性差异有哪些?

该策略通常配合结构化 Prompt 使用,约束大模型输出标准 JSON 数组格式,便于程序直接解析与批量检索。

2. 富化:残缺查询的信息补全

解决痛点

多轮对话场景下,用户普遍会使用指代性表述(如 “它”“这个”),省略前文已出现的主语与背景信息;此外,口语化提问、简称、行业黑话也会导致查询信息密度不足,向量检索无法精准匹配。

核心原理

结合对话历史上下文,对原始问题进行指代消解、语义补全与术语归一,将残缺、省略、口语化的提问,重写为独立完整、无歧义、包含全部必要背景信息的标准查询,再执行相似度检索。

典型示例

对话上下文:用户先提问「什么是向量数据库?」,后续追问「它有什么优势?」 富化后查询:「向量数据库相比传统关系型数据库有哪些技术优势?」

该策略的核心价值是消除上下文依赖,让每一次检索都基于完整语义,是多轮对话式 RAG 系统的必配优化。

3. 多样化:同义表述的多路覆盖

解决痛点

用户的表达习惯与知识库文档的措辞风格往往存在差异。同一语义可以有多种表述方式,例如 “接口性能优化” 与 “提升接口响应速度” 语义高度一致,但纯向量检索可能因措辞差异导致相似度分偏低,造成相关内容漏召回。

核心原理

基于用户原始问题,生成 3~5 个语义完全一致、但措辞与表述角度不同的查询变体。将原始查询与所有变体并行执行检索,汇聚全部召回结果并去重后,用于后续答案生成。通过多路召回覆盖文档中更多样的表述方式,显著提升召回率。

典型示例

原始问题:「怎么优化 Java 接口的响应速度?」 生成查询变体:

  1. Java 接口性能调优的常用方法有哪些?

  2. 如何提升 SpringBoot 接口的响应效率?

  3. Java 后端接口响应缓慢有哪些优化方案?

4. 回溯提示:具体问题的抽象提炼

解决痛点

用户的提问往往偏向具体场景与生活化表达,而知识库通常存储通用规则与制度条文。直接用具体场景检索,很可能因为知识库没有对应表述而匹配失败。例如用户询问 “老舅结婚可以请几天假”,制度文档中不会逐条写明具体亲属场景。

该策略也称为 Step-Back Prompting,核心思想是 “后退一步看本质”。

核心原理

先引导大模型从具体问题中抽象出更通用、更本质的规则类问题,聚焦背后的原理、制度与通用知识;再使用抽象后的通用问题执行知识库检索,最后将检索到的通用规则与原始具体问题结合,由大模型推理生成针对性答案。

典型示例

原始问题:「我老舅结婚,我可以请几天假去参加他的婚礼?」 后退抽象后问题:「公司员工探亲假与事假的请假政策是怎样的?」

二、工程化落地实现

1. 封装问题重写服务

工程落地中,通常将所有改写策略封装为独立的 QuestionRewriteService 服务层,每个策略对应一个独立方法,并绑定固定的 Prompt 模板,严格约束输出格式,保证结果可被程序稳定解析。

核心结构包括:

  • decompose():问题分解,返回子查询列表

  • enrich():问题富化,结合对话历史返回补全后的完整查询

  • diversify():查询多样化,返回多个语义变体数组

  • stepBack():回溯提示,返回抽象后的通用问题

  • rewriteQuery():组合策略方法,按业务编排串联多种改写能力

以下为核心服务类的标准实现:

示例代码:

@Service
@Slf4j
public class QuestionRewriteService {

    @Autowired
    private ChatModel chatModel;

    // 分解策略提示词模板
    private static final String DECOMPOSE_PROMPT = """
            # 角色
            你是一名专业的查询逻辑分析专家。
            # 任务
            将给定的“用户原始问题”分解为一系列相互独立、逻辑清晰,且可单独用于检索的子查询列表。
            你的输出必须是一个标准的JSON数组格式。
            # 用户原始问题
            {QUESTION}
            # 输出格式要求 (JSON Array)
            [
              "子查询1",
              "子查询2",
              "子查询3"
            ]
            # 输出
            请直接输出JSON数组,不要包含解释或多余的文字。
            """;

    // 富化、多样化、回溯提示提示词模板(略,结构与上述一致)
    private static final String ENRICH_PROMPT = "...";
    private static final String DIVERSIFY_PROMPT = "...";
    private static final String STEP_BACK_PROMPT = "...";

    /**
     * 问题分解
     */
    public List<String> decompose(String question) {
        log.info("问题分解开始 | 原始问题: {}", question);
        PromptTemplate promptTemplate = new PromptTemplate(DECOMPOSE_PROMPT);
        promptTemplate.add("QUESTION", question);
        String result = chatModel.call(promptTemplate.create()).getResult().getOutput().getText();
        log.info("问题分解完成 | 结果: {}", result);
        return JSON.parseArray(result, String.class);
    }

    /**
     * 组合改写策略:后退 → 分解 → 多样化
     */
    public List<String> rewriteQuery(String query) {
        log.info("组合重写开始 | 原始问题: {}", query);
        // 1. 先抽象后退
        String stepBackQuery = this.stepBack(query);
        // 2. 对后退后的问题做分解
        List<String> decomposedQueries = this.decompose(stepBackQuery);
        // 3. 每个子问题生成多样化变体
        List<String> finalQueries = new ArrayList<>();
        for (String subQuery : decomposedQueries) {
            finalQueries.addAll(this.diversify(subQuery));
        }
        if (finalQueries.isEmpty()) {
            finalQueries.add(query);
        }
        log.info("组合重写完成 | 最终查询列表: {}", finalQueries);
        return finalQueries;
    }
}

2. 集成到 RAG 问答链路

将问题重写服务接入原有问答接口后,完整的检索生成流程变为:

用户提问 → 问题改写生成批量查询 → 多路并行检索 → 结果去重 → 拼接提示词 → 大模型生成答案

改造后的接口实现如下: 示例代码

@GetMapping("/chatWithQueryRewrite")
public String chatWithQueryRewrite(@RequestParam("query") String query) {
    // 1. 执行问题改写,生成最终查询列表
    List<String> rewriteQuery = queryRewriteService.rewriteQuery(query);

    // 2. 多路检索 + 结果去重
    Set<Document> similarDocs = new LinkedHashSet<>();
    for (String q : rewriteQuery) {
        List<Document> docs = embeddingService.similarSearch(q);
        if (docs != null && !docs.isEmpty()) {
            similarDocs.addAll(docs);
        }
    }

    log.info("共检索到 {} 个相关文档块", similarDocs.size());

    // 3. 拼接文档内容
    String documentContent = similarDocs.stream()
            .map(Document::getText)
            .collect(Collectors.joining("\n\n=========文档分隔线===========\n\n"));

    // 4. 构建提示词并调用大模型
    String promptTemplate = """
    请基于以下提供的参考文档内容,回答用户的问题。
    参考文档:
    {documents}
    用户问题: {question}
    """;

    Prompt realPrompt = new PromptTemplate(promptTemplate)
            .create(Map.of("documents", documentContent, "question", query));

    return chatClient.prompt(realPrompt).call().chatResponse().getResult().getOutput().getText();
}

3. 效果对比

  • 无问题改写:复杂、口语化、指代类问题极易出现 0 命中,大模型只能依赖自身知识回答,容易出现幻觉,答案与知识库内容脱节。

  • 加入问题改写:通过多策略组合优化查询表达,原本 0 命中的问题可召回多条相关文档块,大模型基于真实知识库内容作答,准确率与可控性显著提升。

三、生产环境最佳实践

  1. 避免策略过度堆叠 每增加一层改写策略,就会增加一次大模型调用,直接提升接口延迟与调用成本。并非策略越多效果越好,需在回答质量与系统性能之间找到平衡。

  2. 按需组合,场景化选型 不同业务场景适用不同策略:单轮问答无需富化,简单常识问题无需分解与后退。应基于用户提问习惯与业务特点,灵活选择组合方案,避免全量策略一刀切。

  3. 多路召回必须去重 多个查询变体检索会返回重复文档片段,必须通过 Set 或按文档 ID 去重。重复片段不仅浪费 Token 成本,还可能导致大模型重复输出,影响回答质量。

  4. 固化 Prompt,约束改写边界 改写的核心原则是「只优化表述,不改变原意」。必须通过 Prompt 严格约束大模型的改写范围,禁止模型主动补充信息、修改问题方向或自由发挥,确保改写结果稳定可控。

  5. 增加触发判断机制 对于表述完整、语义清晰的简单问题,可直接跳过改写流程。建议增加简单的规则判断或模型分类判断,只对需要优化的问题执行改写,进一步降低不必要的开销。

四、总结

问题改写是 RAG 检索侧的基础优化,它从查询表达本身入手,通过分解、富化、多样化、回溯提示四类策略,系统性解决用户提问天然存在的复杂度、残缺性、表述差异与粒度错位问题。

该技术实现门槛低、收益见效快,是从 Demo 走向生产的必经一步。落地过程中无需追求大而全的策略堆砌,结合业务场景选用适配的组合方案,在效果、延迟与成本之间找到最优平衡点,才是问题改写的核心落地思路。

RAG 优化技术:查询路由原理与工程落地

在 RAG 的入门认知中,很多人会形成一个思维定式:RAG 就是「向量数据库检索 + 大模型生成」。但真正走向生产级应用时会发现,企业知识的形态是多元的 —— 既有非结构化文档,也有结构化业务数据,还有实体关系图谱,单一的向量检索无法覆盖所有场景。

查询路由(Query Routing)是 RAG 架构层面的核心优化思想。它的核心逻辑是先识别问题意图,再将请求分发到最合适的处理链路与数据源,用专业的能力回答对应类型的问题。该技术既可以提升回答的精准度,又能避免全量检索带来的性能损耗与信息干扰,是构建复杂企业级 RAG 系统的必备能力。

主流的路由方案分为两类:数据源路由(分发到不同类型的数据库)与提示词路由(分发到不同的系统提示词模板)。本文结合 Spring AI 与 LangChain4j 的实际代码,系统讲解两种路由的实现原理与工程落地方式。

一、数据源路由:异构数据源的智能分发

1.1 应用背景

企业内部的知识存在多种形态,不同形态的知识对应最优的检索方式完全不同:

  • 非结构化文档(制度手册、技术文档、产品说明):适合向量数据库做语义相似度检索

  • 结构化数据(人员信息、业务统计、配置参数):适合关系型数据库做精确查询与统计

  • 实体关系(组织架构、知识图谱、链路追溯):适合图数据库做关联路径查询

如果所有问题统一走向量数据库,结构化、关系类问题的回答效果会大幅下降;如果所有问题同时检索全部数据源,又会造成严重的资源浪费与结果噪音。数据源路由就是为了解决这一矛盾:让每类问题只命中最适配的数据源。

1.2 多数据源服务层封装

工程落地中,通常将每一类数据源的查询能力封装为独立的 Service,对内屏蔽底层实现差异,对外提供统一的查询入口。以下为三类数据源的模拟实现,真实环境中会替换为对应的数据库 SDK 调用。

向量数据库服务

负责非结构化文档的语义检索,是 RAG 最基础的检索能力。

@Service
public class VectorDatabaseService {
    /**
     * 向量语义检索
     * @param query 用户查询
     * @return 匹配的文档片段
     */
    public String searchVectorDatabase(String query) {
        return "向量数据库搜索结果: 基于语义相似性,找到与'" + query + "'相关的文档片段。" +
                "实际应用中会连接 Milvus、PGVector、Chroma 等向量数据库,返回TopN相关文本块。";
    }
}

适用场景:文档问答、内容检索、语义匹配、知识推荐类问题。

图数据库服务

负责实体与关系的路径查询,通常对接知识图谱,处理关联类问题。

@Service
public class GraphDatabaseService {
    /**
     * 图数据库关系查询
     * @param query 用户查询
     * @return 实体关联路径结果
     */
    public String searchGraphDatabase(String query) {
        return "图数据库搜索结果: 基于关系图谱,找到与'" + query + "'相关的实体关系和路径。" +
                "实际应用中会连接 Neo4j、ArangoDB 等图数据库,执行 Cypher 查询返回关联结果。";
    }
}

适用场景:组织架构查询、人物关系、实体关联、链路追溯类问题。

关系型数据库服务

负责结构化数据的精确查询与统计,通常配合 Text-to-SQL 技术使用。

@Service
public class RelationalDatabaseService {
    /**
     * 关系型数据库结构化查询
     * @param query 用户查询
     * @return 结构化查询结果
     */
    public String searchRelationalDatabase(String query) {
        return "关系型数据库搜索结果: 基于结构化查询,找到与'" + query + "'匹配的数据记录。" +
                "实际应用中会连接 MySQL、PostgreSQL,通过Text-to-SQL生成语句并执行查询统计。";
    }
}

适用场景:数据统计、精确匹配、报表查询、数值计算类问题。

1.3 路由决策核心:意图识别服务

路由的核心是「分类器」,这里通过大模型做轻量级意图识别,判断问题所属的数据源类型。相比传统关键词规则,大模型分类的泛化能力更强,适配自然语言的复杂表达。

@Service
public class QueryRouteService {

    /**
     * 数据源路由提示词模板
     * 核心设计要点:分类边界清晰、输出格式固定、默认兜底策略
     */
    private static final String DATASOURCE_ROUTE_PROMPT =
            """
                你需要判断用户的查询问题适合使用哪种数据库进行检索。
                如果是语义相似性搜索、文档检索、内容推荐类问题,回答'VECTOR'
                如果是关系查询、知识图谱、实体关联类问题,回答'GRAPH'
                如果是结构化数据查询、统计分析、精确匹配类问题,回答'RELATIONAL'
                如果无法确定,请回答'VECTOR'
                只回答VECTOR、GRAPH或RELATIONAL,不要其他内容。

                用户问题:
                {QUESTION}
                """;

    @Autowired
    private ChatModel chatModel;

    /**
     * 执行路由分类
     * @param query 用户原始问题
     * @return 数据源类型枚举值
     */
    public String route(String query) {
        PromptTemplate promptTemplate = new PromptTemplate(DATASOURCE_ROUTE_PROMPT);
        promptTemplate.add("QUESTION", query);
        // 调用大模型执行分类,提取纯文本结果
        return chatModel.call(promptTemplate.create()).getResult().getOutput().getText();
    }
}

路由 Prompt 的设计有三个关键原则:

  1. 边界清晰:明确每一类对应的问题特征,减少模糊地带的误判

  2. 强格式约束:要求仅输出固定枚举值,禁止解释性文字,保证程序可直接解析

  3. 默认兜底:无法判断时指定默认分类,避免出现未知值导致流程中断

1.4 链路串联:请求分发与容错兜底

Controller 层负责接收前端请求,串联「路由决策 → 数据源分发 → 结果返回」的完整流程,并加入工程化容错处理。

@RequestMapping("/rag/routing")
@RestController
public class RagQueryRoutingController {

    @Autowired
    private QueryRouteService ragRoutingService;

    @Autowired
    private VectorDatabaseService vectorDatabaseService;
    @Autowired
    private GraphDatabaseService graphDatabaseService;
    @Autowired
    private RelationalDatabaseService relationalDatabaseService;

    @RequestMapping("/query")
    public String ragQuery(HttpServletResponse response, @RequestParam String question) {
        response.setCharacterEncoding("UTF-8");

        // 1. 执行路由决策:判断问题对应的最优数据源
        String databaseType = ragRoutingService.route(question);

        String result;
        // 2. 根据分类结果分发到对应数据源
        switch (databaseType.trim()) {
            case "VECTOR":
                result = vectorDatabaseService.searchVectorDatabase(question);
                break;
            case "GRAPH":
                result = graphDatabaseService.searchGraphDatabase(question);
                break;
            case "RELATIONAL":
                result = relationalDatabaseService.searchRelationalDatabase(question);
                break;
            default:
                // 3. 兜底机制:分类异常时默认走向量库,保证服务可用性
                result = "无法确定合适的数据库类型,默认使用向量数据库: " +
                        vectorDatabaseService.searchVectorDatabase(question);
        }

        return String.format("路由到: %s 数据库\n\n查询结果:\n%s", databaseType, result);
    }
}

工程化细节说明:

  • databaseType.trim():去除大模型输出前后的空格、换行符。大模型偶尔会在输出首尾添加空白字符,直接匹配会导致分类失败,这是生产环境的必加细节。

  • default 兜底分支:当大模型返回非预期内容时,降级为默认数据源,避免接口直接报错,是高可用设计的基础要求。

1.5 完整执行流程

  1. 用户发起提问,请求到达后端接口

  2. 调用路由服务,大模型识别问题类型,返回数据源分类结果

  3. 根据分类结果,调用对应数据源的查询服务

  4. 封装检索结果,返回给前端展示

二、提示词路由:多场景 Prompt 的动态匹配

2.1 应用背景

单一的系统提示词(人设)很难覆盖所有业务场景。例如医疗助手场景中,用户既可能咨询病情诊断,也可能咨询用药建议,使用统一的通用人设回答,专业度会明显不足。

提示词路由的核心思路是:提前定义多套不同领域、不同人设的系统提示词,先识别用户问题的类别,再选择最匹配的提示词调用大模型,让回答更贴合业务场景、专业度更高。

以下示例基于 LangChain4j 框架实现,通过声明式注解的方式管理多套提示词,代码结构更简洁。

2.2 声明式 AI 服务定义

LangChain4j 提供了 @AiService 注解,可以通过接口声明的方式定义 AI 服务,每个方法通过 @SystemMessage 绑定独立的系统提示词,框架自动完成底层实现。

import dev.langchain4j.service.SystemMessage;
import dev.langchain4j.service.spring.AiService;
import reactor.core.publisher.Flux;

@AiService
public interface MedicalPromptRoutingService {

    /**
     * 医生咨询:病情诊断方向的系统提示词
     */
    @SystemMessage("你是一个专业的医生,可以从专业的医疗角度给出患者建议。")
    Flux<String> doctorConsultation(String userMessage);

    /**
     * 药师咨询:用药指导方向的系统提示词
     */
    @SystemMessage("你是一个专业的药学专家,掌握丰富的药品知识,能够在用药方面给出更好的建议。")
    Flux<String> pharmacistConsultation(String userMessage);

    /**
     * 路由分类器:识别用户问题类型,返回固定枚举值
     */
    @SystemMessage("你需要判断用户的询问是关于病情咨询还是用药建议。" +
            "如果是询问病情、症状、诊断相关的问题,回答'DOCTOR'。" +
            "如果是询问药物、用药方法、药物副作用相关的问题,回答'PHARMACIST'。" +
            "只回答DOCTOR或PHARMACIST,不要其他内容。")
    String determineConsultationType(String userMessage);
}

核心注解说明:

  • @AiService:标记该接口为 AI 服务,框架自动生成代理实现,封装大模型调用、提示词拼装、流式输出等底层逻辑。

  • @SystemMessage:绑定方法对应的系统提示词,调用该方法时会自动将此提示词作为 System 角色传入大模型。

  • Flux<String>:响应式流式返回,对应大模型的流式输出效果,实现逐字打字的交互体验。

三个方法职责明确:两个业务方法分别对应不同场景的问答能力,一个分类方法负责路由决策,和数据源路由的架构范式完全一致。

2.3 路由分发控制层

控制层先调用分类方法识别意图,再根据结果分发到对应的问答方法,全程保持流式输出。

@RequestMapping("/medical")
@RestController
public class MedicalAssistantController {

    @Autowired
    private MedicalPromptRoutingService medicalRoutingService;

    @RequestMapping("/consultation")
    public Flux<String> medicalConsultation(HttpServletResponse response, @RequestParam String question) {
        response.setCharacterEncoding("UTF-8");

        // 1. 意图识别:判断是病情咨询还是用药咨询
        String consultationType = medicalRoutingService.determineConsultationType(question);

        // 2. 根据分类结果路由到对应提示词链路
        if ("DOCTOR".equals(consultationType.trim())) {
            return medicalRoutingService.doctorConsultation(question);
        } else if ("PHARMACIST".equals(consultationType.trim())) {
            return medicalRoutingService.pharmacistConsultation(question);
        } else {
            // 3. 兜底:分类异常时默认走医生咨询链路
            return medicalRoutingService.doctorConsultation(question);
        }
    }
}

2.4 完整执行流程

  1. 用户提交咨询问题

  2. 调用分类方法,大模型判断问题属于病情类还是用药类

  3. 根据分类结果,选择对应的系统提示词

  4. 拼接系统提示词与用户问题,调用大模型流式生成回答

  5. 以流式响应的方式返回给前端

三、生产环境最佳实践与避坑

3.1 统一的路由设计范式

无论是数据源路由还是提示词路由,本质都遵循同一套工程化范式:

轻量分类 → 精准分发 → 兜底保障

通过一次低成本的大模型分类调用,换取后续更精准、更高效的处理,是典型的「小成本换大收益」的优化思路。

3.2 生产级优化要点

  1. 规则兜底 + 大模型分类 纯大模型分类存在不稳定与成本问题。生产环境通常采用「关键词规则优先,大模型分类兜底」的方案:能通过关键词明确判断的直接路由,模糊场景再交给大模型,兼顾成本与稳定性。

  2. 严格的结果校验 大模型的输出不总是稳定的,必须对分类结果做白名单校验。不在预期枚举值内的结果,直接触发兜底逻辑,避免程序匹配失败。

  3. 高频问题路由缓存 对于高频、固定的问题,可以缓存路由分类结果,无需每次都调用大模型做分类,进一步降低延迟与调用成本。

  4. 策略模式替代分支判断 当路由类型较多时,switch/if-else 会变得难以维护。建议使用策略模式重构分发逻辑,新增路由类型时无需修改原有代码,符合开闭原则。

  5. 路由日志埋点 记录每个问题的路由分类结果、是否命中兜底、实际执行链路,便于后续分析误判案例、持续优化分类提示词。

3.3 常见落地误区

  • 分类粒度过细:分类维度越多,误判概率越高,维护成本也越高。应当结合业务实际需要设置分类,避免为了优化而过度拆分。

  • 忽略路由开销:路由本身需要一次大模型调用,对于简单问题可能得不偿失。需要在效果提升与额外开销之间找到平衡。

  • 缺失兜底机制:完全依赖大模型分类,没有降级方案,一旦模型输出异常就会导致整体服务不可用。

四、总结

查询路由是 RAG 从单一 Demo 走向复杂企业应用的标志性技术。它打破了「RAG = 向量检索」的固化认知,通过「先分类、后分发」的架构思想,实现了多数据源、多场景的差异化处理。

数据源路由解决的是「去哪里检索知识」的问题,提示词路由解决的是「用什么方式回答」的问题。两者可以独立使用,也可以组合叠加 —— 先路由到对应数据源,再路由到对应提示词,构建分层的智能分发体系。

在实际项目中,路由设计应当遵循「够用即可、逐步扩展」的原则,从最核心的分类做起,结合业务数据持续调优,在效果、成本与系统复杂度之间找到最优平衡。