今天我们将探索Deep Research系统的另一个重要创新——RAG知识增强系统，看看系统如何通过知识检索实现研究能力的提升。

为什么需要RAG知识增强？

传统的AI研究系统通常仅依赖模型自身的预训练知识，这种方式存在明显局限：

• 知识时效性：预训练知识无法覆盖最新信息和实时数据
• 领域专业性：通用模型在特定领域的知识深度有限
• 上下文局限：单次对话的上下文长度限制影响复杂推理

Deep Research RAG系统通过知识检索 + 混合查询 + 智能融合，实现了真正的"知识驱动式"研究。

RAG知识增强系统架构

用户文件
专业知识库








用户查询
多查询重写
RAG节点服务
RAG类型选择
UserFileRagNode
ProfessionalKbRagNode
HybridRagProcessor
查询前处理
混合检索
文档后处理
知识增强结果
ResearcherNode
最终研究报告

核心组件深度剖析

1. RAG节点服务（RagNodeService）

作为整个RAG系统的节点工厂，RagNodeService负责创建和配置不同类型的RAG节点，支持统一的HybridRagProcessor和传统策略模式的灵活切换。

在DeepResearchConfiguration中的配置：

.addNode("user_file_rag", ragNodeService.createUserFileRagNode())
.addNode("professional_kb_rag", ragNodeService.createProfessionalKbRagNode())

核心职责：

• 创建用户文件RAG节点，处理用户上传的文档
• 创建专业知识库RAG节点，访问预置的专业知识
• 优先使用统一的HybridRagProcessor进行处理
• 提供向传统策略模式的回退机制

关键代码实现：

@Service
public class RagNodeService {

    @Autowired(required = false)
    private HybridRagProcessor hybridRagProcessor;

    /**
     * 创建用户文件RAG节点，优先使用统一的HybridRagProcessor
     */
    public AsyncNodeAction createUserFileRagNode() {
        if (hybridRagProcessor != null) {
            // 使用统一的RAG处理器，包含完整的前后处理和混合查询逻辑
            return node_async(new RagNode(hybridRagProcessor, ragAgent));
        } else {
            // 回退到传统的策略模式
            return node_async(new RagNode(
                userFileRetrievalStrategy != null ? List.of(userFileRetrievalStrategy) : List.of(),
                fusionStrategy, ragAgent));
        }
    }

    /**
     * 创建专业知识库RAG节点，优先使用统一的HybridRagProcessor
     */
    public AsyncNodeAction createProfessionalKbRagNode() {
        if (hybridRagProcessor != null) {
            // 使用统一的RAG处理器，包含完整的前后处理和混合查询逻辑
            return node_async(new RagNode(hybridRagProcessor, ragAgent));
        } else {
            // 回退到传统的策略模式
            return node_async(new RagNode(
                professionalKbEsStrategy != null ? List.of(professionalKbEsStrategy) : List.of(),
                fusionStrategy, ragAgent));
        }
    }
}

RAG节点服务创建流程：

是
否


节点创建请求
HybridRagProcessor可用?
创建统一RAG节点
创建传统策略节点
RagNode + HybridRagProcessor
RagNode + RetrievalStrategy

2. 混合RAG处理器（HybridRagProcessor）

HybridRagProcessor作为统一RAG引擎，整合了前后处理逻辑和混合查询能力，提供完整的RAG处理流程。

核心职责：

• 执行完整的RAG处理流程（前处理→检索→后处理）
• 支持查询扩展、翻译等前处理功能
• 实现ES混合查询和向量搜索的智能切换
• 提供文档去重、排序等后处理能力

接口定义：

public interface HybridRagProcessor {

    /**
     * 执行完整的RAG处理流程
     */
    List<Document> process(Query query, Map<String, Object> options);

    /**
     * 查询前处理：查询扩展、翻译等
     */
    List<Query> preProcess(Query query, Map<String, Object> options);

    /**
     * 执行混合检索（支持ES混合查询和向量搜索）
     */
    List<Document> hybridRetrieve(List<Query> queries,
        co.elastic.clients.elasticsearch._types.query_dsl.Query filterExpression,
        Map<String, Object> options);

    /**
     * 文档后处理：相关性排序、去重、压缩等
     */
    List<Document> postProcess(List<Document> documents, Map<String, Object> options);

    /**
     * 根据元数据上下文构建ES过滤表达式
     */
    co.elastic.clients.elasticsearch._types.query_dsl.Query buildFilterExpression(Map<String, Object> options);
}

DefaultHybridRagProcessor核心实现：

@Component
@ConditionalOnProperty(prefix = "spring.ai.alibaba.deepresearch.rag", name = "enabled", havingValue = "true")
public class DefaultHybridRagProcessor implements HybridRagProcessor {

    private final VectorStore vectorStore;
    private final RrfHybridElasticsearchRetriever hybridRetriever;
    private final MultiQueryExpander queryExpander;
    private final TranslationQueryTransformer queryTransformer;
    private final DocumentSelectFirstProcess documentPostProcessor;
    private final RrfFusionStrategy rrfFusionStrategy;

    @Override
    public List<Document> process(Query query, Map<String, Object> options) {
        logger.debug("Starting RAG processing for query: {}", query.text());

        // 1. 查询前处理
        List<Query> processedQueries = preProcess(query, options);

        // 2. 构建过滤表达式
        Query filterExpression = buildFilterExpression(options);

        // 3. 执行混合检索
        List<Document> documents = hybridRetrieve(processedQueries, filterExpression, options);

        // 4. 文档后处理
        List<Document> finalDocuments = postProcess(documents, options);

        logger.debug("RAG processing completed. Retrieved {} documents", finalDocuments.size());
        return finalDocuments;
    }
}

HybridRagProcessor处理流程：

原始查询
查询前处理
构建过滤表达式
混合检索
文档后处理
最终文档列表
查询扩展
查询翻译
ES混合查询
向量搜索
RRF重排序
文档去重

3. RAG节点（RagNode）

RagNode作为RAG执行器，支持统一的HybridRagProcessor和传统的策略模式，实现灵活的RAG处理。

核心特性：

• 支持两种构造模式：统一处理器模式和传统策略模式
• 自动会话上下文管理和用户身份识别
• 集成流式生成，支持实时结果返回
• 提供完整的错误处理和超时机制

关键代码实现：

public class RagNode implements NodeAction {

    private final HybridRagProcessor hybridRagProcessor;
    private final List<RetrievalStrategy> retrievalStrategies;
    private final FusionStrategy fusionStrategy;

    /**
     * 统一RAG处理器构造函数
     */
    public RagNode(HybridRagProcessor hybridRagProcessor, ChatClient ragAgent) {
        this.hybridRagProcessor = hybridRagProcessor;
        this.ragAgent = ragAgent;
        this.retrievalStrategies = null;
        this.fusionStrategy = null;
    }

    @Override
    public Map<String, Object> apply(OverAllState state) throws Exception {
        logger.info("rag_node is running.");
        String queryText = StateUtil.getQuery(state);

        Map<String, Object> options = new HashMap<>();
        state.value("session_id", String.class).ifPresent(v -> options.put("session_id", v));
        state.value("user_id", String.class).ifPresent(v -> options.put("user_id", v));
        options.put("query", queryText); // 添加查询文本供后处理使用

        List<Document> documents = new ArrayList<>();

        // 使用统一的RAG处理器或传统的策略模式
        if (hybridRagProcessor != null) {
            // 使用统一的RAG处理器，包含完整的前后处理逻辑
            Query query = new Query(queryText);
            documents = hybridRagProcessor.process(query, options);
        } else if (retrievalStrategies != null && fusionStrategy != null) {
            // 传统策略模式（向后兼容）
            List<List<Document>> allResults = new ArrayList<>();
            for (RetrievalStrategy strategy : retrievalStrategies) {
                allResults.add(strategy.retrieve(queryText, options));
            }
            documents = fusionStrategy.fuse(allResults);
        }

        // 构建上下文并生成响应
        StringBuilder contextBuilder = new StringBuilder();
        for (Document doc : documents) {
            contextBuilder.append(doc.getText()).append("\n");
        }

        // 生成响应
        Flux<ChatResponse> streamResult = ragAgent.prompt()
            .messages(new UserMessage(contextBuilder.toString()))
            .user(queryText)
            .stream()
            .chatResponse()
            .timeout(Duration.ofSeconds(180))
            .retry(2);

        var generatedContent = StreamingChatGenerator.builder()
            .startingNode("rag_llm_stream")
            .startingState(state)
            .mapResult(response -> Map.of("rag_content",
                Objects.requireNonNull(response.getResult().getOutput().getText())))
            .buildWithChatResponse(streamResult);

        return Map.of("rag_content", generatedContent);
    }
}

4. 检索策略体系

Deep Research系统实现了灵活的检索策略体系，支持不同数据源的统一访问：

用户文件检索策略

@Component
public class UserFileRetrievalStrategy implements RetrievalStrategy {

    private final HybridRagProcessor hybridRagProcessor;

    @Override
    public List<Document> retrieve(String query, Map<String, Object> options) {
        String sessionId = (String) options.get("session_id");
        if (sessionId == null || sessionId.isBlank()) {
            return List.of(); // 没有session_id时不返回用户文件
        }

        // 构建用户文件检索的上下文选项
        Map<String, Object> ragOptions = new HashMap<>(options);
        ragOptions.put("source_type", SourceTypeEnum.USER_UPLOAD.getValue());
        ragOptions.put("session_id", sessionId);

        // 使用统一的RAG处理器执行完整的处理流程
        Query ragQuery = new Query(query);
        return hybridRagProcessor.process(ragQuery, ragOptions);
    }
}

专业知识库检索策略

@Component
public class ProfessionalKbEsStrategy implements RetrievalStrategy {

    private final HybridRagProcessor hybridRagProcessor;

    @Override
    public List<Document> retrieve(String query, Map<String, Object> options) {
        // 构建专业知识库检索的上下文选项
        Map<String, Object> ragOptions = new HashMap<>(options);
        ragOptions.put("source_type", SourceTypeEnum.PROFESSIONAL_KB_ES.getValue());
        // 专业知识库使用固定的session_id标识
        ragOptions.put("session_id", "professional_kb_es");

        // 使用统一的RAG处理器执行完整的处理流程，包含ES混合查询
        Query ragQuery = new Query(query);
        return hybridRagProcessor.process(ragQuery, ragOptions);
    }
}

混合查询与多模式检索

ES混合查询配置

spring:
  ai:
    alibaba:
      deepresearch:
        rag:
          enabled: true
          elasticsearch:
            hybrid:
              enabled: true
              bm25-boost: 1.0
              knn-boost: 1.0
              rrf-window-size: 10
              rrf-rank-constant: 60

RRF混合Elasticsearch检索器

public class RrfHybridElasticsearchRetriever {

    public List<Document> retrieve(Query query, Query filterExpression) {
        // 1. BM25文本搜索
        List<Document> bm25Results = performBm25Search(query, filterExpression);

        // 2. KNN向量搜索
        List<Document> knnResults = performKnnSearch(query, filterExpression);

        // 3. RRF算法融合结果
        return rrfFusion(bm25Results, knnResults);
    }
}

混合检索流程：

查询文本
BM25检索
向量检索
BM25结果
KNN结果
RRF融合算法
融合排序结果

工作流集成与状态流转

RAG节点在整体工作流中的位置

// DeepResearchConfiguration中的边配置
.addConditionalEdges("rewrite_multi_query", edge_async(new RewriteAndMultiQueryDispatcher()),
    Map.of("background_investigator", "background_investigator",
           "user_file_rag", "user_file_rag", END, END))
.addConditionalEdges("user_file_rag", edge_async(new UserFileRagDispatcher()),
    Map.of("background_investigator", "background_investigator", END, END))
.addConditionalEdges("background_investigator", edge_async(new BackgroundInvestigationDispatcher()),
    Map.of("reporter", "reporter", "planner", "planner", END, END))
.addEdge("planner", "information")
.addConditionalEdges("research_team", edge_async(new ResearchTeamDispatcher()),
    Map.of("professional_kb_decision", "professional_kb_decision",
           "parallel_executor", "parallel_executor", END, END))
.addConditionalEdges("professional_kb_decision", edge_async(new ProfessionalKbDispatcher()),
    Map.of("professional_kb_rag", "professional_kb_rag",
           "reporter", "reporter", END, END))
.addEdge("professional_kb_rag", "reporter")

完整工作流程图

需要RAG
需要调查





需要专业知识
直接执行



用户查询
多查询重写
条件分发
用户文件RAG
背景调查
背景调查
信息收集
研究团队
专业知识决策
专业知识库RAG
并行执行器
报告生成
研究团队汇总

配置驱动的RAG管道

RAG处理管道配置

spring:
  ai:
    alibaba:
      deepresearch:
        rag:
          pipeline:
            # 查询处理
            query-expansion-enabled: true
            query-translation-enabled: false
            query-translation-language: "English"

            # 检索配置
            top-k: 10
            similarity-threshold: 0.7

            # 后处理配置
            deduplication-enabled: true
            post-processing-select-first-enabled: true
            rerank-enabled: true
            rerank-top-k: 5
            rerank-threshold: 0.8

处理管道组件初始化

// 初始化查询处理器
this.queryExpander = ragProperties.getPipeline().isQueryExpansionEnabled()
    ? MultiQueryExpander.builder().chatClientBuilder(chatClientBuilder).build() : null;

this.queryTransformer = ragProperties.getPipeline().isQueryTranslationEnabled()
    ? TranslationQueryTransformer.builder()
        .chatClientBuilder(chatClientBuilder)
        .targetLanguage(ragProperties.getPipeline().getQueryTranslationLanguage())
        .build() : null;

// 初始化文档后处理器
this.documentPostProcessor = ragProperties.getPipeline().isPostProcessingSelectFirstEnabled()
    ? new DocumentSelectFirstProcess() : null;

总结

通过RAG知识增强系统的深度剖析，我们看到了Deep Research系统在知识驱动研究方面的设计：

如何学习大模型 AI ？

我国在AI大模型领域面临人才短缺，数量与质量均落后于发达国家。2023年，人才缺口已超百万，凸显培养不足。随着Al技术飞速发展，预计到2025年，这一缺口将急剧扩大至400万，严重制约我国Al产业的创新步伐。加强人才培养，优化教育体系，国际合作并进，是破解困局、推动AI发展的关键。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

2025最新大模型学习路线

明确的学习路线至关重要。它能指引新人起点、规划学习顺序、明确核心知识点。大模型领域涉及的知识点非常广泛，没有明确的学习路线可能会导致新人感到迷茫，不知道应该专注于哪些内容。

对于从来没有接触过AI大模型的同学，我帮大家准备了从零基础到精通学习成长路线图以及学习规划。可以说是最科学最系统的学习路线。

针对以上大模型的学习路线我们也整理了对应的学习视频教程，和配套的学习资料。

大模型经典PDF书籍

新手必备的大模型学习PDF书单来了！全是硬核知识，帮你少走弯路！

配套大模型项目实战

所有视频教程所涉及的实战项目和项目源码等

博主介绍＋AI项目案例集锦

MoPaaS专注于Al技术能力建设与应用场景开发，与智学优课联合孵化，培养适合未来发展需求的技术性人才和应用型领袖。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】

为什么要学习大模型？

2025人工智能大模型的技术岗位与能力培养随着人工智能技术的迅速发展和应用 ， 大模型作为其中的重要组成部分 ， 正逐渐成为推动人工智能发展的重要引擎 。大模型以其强大的数据处理和模式识别能力， 广泛应用于自然语言处理 、计算机视觉 、 智能推荐等领域 ，为各行各业带来了革命性的改变和机遇 。

适合人群

• 在校学生：包括专科、本科、硕士和博士研究生。学生应具备扎实的编程基础和一定的数学基础，有志于深入AGI大模型行业，希望开展相关的研究和开发工作。
• IT行业从业人员：包括在职或失业者，涵盖开发、测试、运维、产品经理等职务。拥有一定的IT从业经验，至少1年以上的编程工作经验，对大模型技术感兴趣或有业务需求，希望通过课程提升自身在IT领域的竞争力。
• IT管理及技术研究领域人员：包括技术经理、技术负责人、CTO、架构师、研究员等角色。这些人员需要跟随技术发展趋势，主导技术创新，推动大模型技术在企业业务中的应用与改造。
• 传统AI从业人员：包括算法工程师、机器视觉工程师、深度学习工程师等。这些AI技术人才原先从事机器视觉、自然语言处理、推荐系统等领域工作，现需要快速补充大模型技术能力，获得大模型训练微调的实操技能，以适应新的技术发展趋势。
  

课程精彩瞬间

大模型核心原理与Prompt：掌握大语言模型的核心知识，了解行业应用与趋势；熟练Python编程，提升提示工程技能，为Al应用开发打下坚实基础。

RAG应用开发工程：掌握RAG应用开发全流程，理解前沿技术，提升商业化分析与优化能力，通过实战项目加深理解与应用。

Agent应用架构进阶实践：掌握大模型Agent技术的核心原理与实践应用，能够独立完成Agent系统的设计与开发，提升多智能体协同与复杂任务处理的能力，为AI产品的创新与优化提供有力支持。

模型微调与私有化大模型：掌握大模型微调与私有化部署技能，提升模型优化与部署能力，为大模型项目落地打下坚实基础。

顶尖师资，深耕AI大模型前沿技术

实战专家亲授，让你少走弯路

一对一学习规划，职业生涯指导

• 真实商业项目实训
• 大厂绿色直通车

人才库优秀学员参与真实商业项目实训

以商业交付标准作为学习标准，具备真实大模型项目实践操作经验可写入简历，支持项目背调

大厂绿色直通车，冲击行业高薪岗位

文中涉及到的完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】