什么是RAG检索生成增强？

RAG检索生成增强详解

原创于 2025-06-29 20:31:44 发布 · 911 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#postgresql #java #RAG

概述

工作流程

1、文档收集和切割

文档收集：从网页、PDF、数据库等各种来源收集原始文档。
文档预处理：清洗、标准化文本格式。
文档切割：将海量文档分割成适当大小的片段，可基于固定大小、语义边界、递归分割策略。
- 就像把厚重词典拆解成单词卡片
- 📌 关键价值：优质的知识切割如同图书馆分类系统，决定了后续检索效率
清洗数据：删除HTML标签、特殊符号，修正错误文本
保留来源：记录每块内容的出处，便于后续引用和验证

2、向量转换和存储

翻译成数字：将文字转换为数字向量，让机器能"理解"含义
向量转换：使用Embedding模型将文本块转换为高维向量表示，以捕获文本的语义特征。
向量存储：将生成的向量和对应文本存入向量数据库，支持高效的相似性搜索。

3、文档过滤和检索

查询处理：将用户问题转换为向量表示，计算用户问题与存储文档片段的相似度
过滤机制：基于元数据、关键词或自定义规则进行过滤。
相似度搜索：在向量数据库中查找与问题向量最相似的文档块，常用算法有余弦相似度、欧氏距离等。
精细排序：对初步结果进行二次筛选，把最相关的放在前面
智能筛选：根据问题背景过滤不相关结果
上下文组装：将检索到的多个文档块组装成连贯上下文。

4、查询增强和关联

提示词组装：将检索到的相关文档与用户问题组合成增强提示。
上下文融合：大模型基于增强提示生成回答。
源引用：在回答中添加信息来源引用。
后处理：格式化、摘要或其他处理以优化最终输出。
理解问题：分析用户真正想知道什么
改进问题：自动调整查询，使其更容易找到相关信息
组合信息：将查询和检索到的文档巧妙结合
事实回答：让AI基于找到的真实信息生成回答，避免编造

文档加载

将知识库按照主题分类组织，便于管理和后续检索
在这里插入图片描述
利用 SpringAI tika + markdown 解决大部分文件~

DocumentReader：读取文档（如PDF，TXT，SON），得到文档列表
DocumentTransformer：转换文档，拆分、加摘要、提关键词，得到处理后的文档列表
DocumentWriter：存文档，将文档列表保存到存储中

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-markdown-document-reader</artifactId>
    <version>1.0.0-M6</version>
</dependency>


<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-tika-document-reader</artifactId>
  <version>1.0.0-M6</version>
</dependency>

编写文档加载器

import lombok.extern.slf4j.Slf4j;
import org.springframework.ai.document.Document;
import org.springframework.ai.reader.markdown.MarkdownDocumentReader;
import org.springframework.ai.reader.markdown.config.MarkdownDocumentReaderConfig;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.*;


/**
 * 智能健康助手文档加载器
 */
@Component
@Slf4j
public class HealthAppDocumentLoader {

    private final ResourcePatternResolver resourcePatternResolver;
    // 定义文件名关键词到类别的映射
    private static final Map<String, String> CATEGORY_MAP = new HashMap<>();

    static {
        CATEGORY_MAP.put("医院", "医疗机构");
        CATEGORY_MAP.put("科室", "医疗机构");
        CATEGORY_MAP.put("口腔科", "医疗机构");
        CATEGORY_MAP.put("神经内科", "医疗机构");
        CATEGORY_MAP.put("儿科", "医疗机构");
        CATEGORY_MAP.put("心血管内科", "医疗机构");

        CATEGORY_MAP.put("健康食物", "饮食");
        CATEGORY_MAP.put("高蛋白食物", "饮食");
        CATEGORY_MAP.put("高纤维蔬菜", "饮食");
        CATEGORY_MAP.put("低糖食物", "饮食");
        CATEGORY_MAP.put("健康早餐搭配", "饮食");
        CATEGORY_MAP.put("糖尿病饮食建议", "饮食");
        CATEGORY_MAP.put("饮食计划模板", "饮食");

        CATEGORY_MAP.put("热量估算指南", "营养");
        CATEGORY_MAP.put("维生素来源", "营养");
        CATEGORY_MAP.put("热量摄入推荐", "营养");
        CATEGORY_MAP.put("营养素需求表", "营养");

        CATEGORY_MAP.put("BMI计算指南", "健康知识");
        CATEGORY_MAP.put("血压管理常识", "健康知识");
        CATEGORY_MAP.put("睡眠质量提升", "健康知识");
        CATEGORY_MAP.put("运动健康指南", "健康知识");
    }

    public HealthAppDocumentLoader(
            @Qualifier("webApplicationContext") ResourcePatternResolver resourcePatternResolver) {
        this.resourcePatternResolver = resourcePatternResolver;
    }

    /**
     * 加载所有 Markdown 文档并转换为 Document 对象
     * @return 所有文档列表
     */
    public List<Document> loadMarkdowns() {
        List<Document> allDocuments = new ArrayList<>();
        try {
            Resource[] resources = resourcePatternResolver.getResources("classpath:document/**/*.md");
            for (Resource resource : resources) {
                String filename = resource.getFilename();
                if (filename == null || !filename.endsWith(".md")) continue;

                String baseName = filename.substring(0, filename.length() - 3); // 去掉 .md 后缀

                // 根据文件名中的关键词，从 CATEGORY_MAP 中查找匹配的文档类别
                String category = CATEGORY_MAP.entrySet().stream()
                        .filter(entry -> baseName.contains(entry.getKey()))
                        .map(Map.Entry::getValue)
                        .findFirst()
                        .orElse("通用");

                // 创建 Markdown 解析配置对象
                // 构建配置
                MarkdownDocumentReaderConfig config = MarkdownDocumentReaderConfig.builder()
                        .withHorizontalRuleCreateDocument(true)
                        .withIncludeCodeBlock(false)
                        .withIncludeBlockquote(false)
                        //元数据字段
                        .withAdditionalMetadata("filename", filename)  //添加文件名
                        .withAdditionalMetadata("category", category)  //添加分类
                        .build();

                MarkdownDocumentReader reader = new MarkdownDocumentReader(resource, config);
                allDocuments.addAll(reader.get());
            }
        } catch (IOException e) {
            log.error("Markdown 文档加载失败", e);
        }
        return allDocuments;  //返回所有解析完成的文档列表
    }
}

假设有如下文件：

文件名	提取的 category
北京协和医院.md	医疗机构
高蛋白食物.md	饮食
BMI计算指南.md	健康知识
热量估算指南.md	营养
我的自定义文档.md	通用

这样就能在每个 Document 中添加合适的分类元数据，供后续用于推荐、过滤、搜索等场景。

向量存储

将上述解析得到的知识库document列表存入向量数据库

不建议在生产中使用基于内存的向量存储。因此这里我们使用PostgreSQL的插件PGVetor作为向量数据库。

环境配置

<!-- PGVector 向量存储 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-pgvector-store</artifactId>
    <version>1.0.0-M6</version>
</dependency>

@Configuration
public class PgVectorVectorStoreConfig {

    @Resource
    private HealthAppDocumentLoader healthAppDocumentLoader;
    @Bean
    @Primary
    // todo 按需使用加载
    public VectorStore pgVectorVectorStore(@Qualifier("postgresJdbcTemplate") JdbcTemplate jdbcTemplate, EmbeddingModel dashscopeEmbeddingModel) {
        // 创建PgVectorStore实例，配置向量存储的参数
        VectorStore vectorStore = PgVectorStore.builder(jdbcTemplate, dashscopeEmbeddingModel)
            .dimensions(1536)                    // 设置向量的维度，可选，默认为模型维度或1536
            .distanceType(COSINE_DISTANCE)       // 设置计算向量间距离的方法，可选，默认为余弦距离
            .indexType(HNSW)                     // 设置索引类型，可选，默认为HNSW（高效近似最近邻搜索）
            .initializeSchema(true)              // 是否初始化数据库模式，可选，默认为false
            .schemaName("public")                // 设置数据库模式名称，可选，默认为"public"
            .vectorTableName("vector_store")     // 设置存储向量数据的表名，可选，默认为"vector_store"
            .maxDocumentBatchSize(10000)         // 设置文档批量插入的最大数量，可选，默认为10000
            .build();
        // 加载文档
        List<Document> documents = healthAppDocumentLoader.loadMarkdowns();
        int batchSize = 25;
        for (int i = 0; i < documents.size(); i += batchSize) {
            int end = Math.min(i + batchSize, documents.size());
            List<Document> batch = documents.subList(i, end);
            vectorStore.add(batch); // 分批插入
        }
        return vectorStore;
    }
}

修改yml文件

spring:
  datasource:
    mysql:
      url: jdbc:mysql://localhost:3306/your_mysql_db?useSSL=false&serverTimezone=UTC
      username: root
      password: your_password
      driver-class-name: com.mysql.cj.jdbc.Driver

    postgres:
      url: jdbc:postgresql://localhost:5432/your_postgres_db
      username: postgres
      password: your_password
      driver-class-name: org.postgresql.Driver

文档过滤和检索

a. 预检索：优化用户查询

改写查询：用 AI 让模糊的问题更清晰RewriteQueryTransformer
翻译查询：将非目标语言翻译成模型支持的语言TranslationQueryTransformer
压缩查询：结合对话历史，生成简洁查询CompressionQueryTransformer
扩展查询：生成多个变体，提高召回率MultiQueryExpander

b. 检索：查找相关文档

使用 DocumentRetriever 从向量库中搜索最相关的文档
支持设置：
- 相似度阈值 .similarityThreshold(0.7)
- 返回数量 .topK(5)
- 元数据过滤 .filterExpression(...)
使用 ChatModel（如 dashscopeChatModel）驱动的 RewriteQueryTransformer，将用户输入（如 “怎么治高血压”）改写为更精准的医学术语（如 “高血压的标准治疗方案”）

/**
 * 查询重写器
 */
@Component
public class QueryRewriter {

    private final QueryTransformer queryTransformer;

    public QueryRewriter(ChatModel dashscopeChatModel) {
        ChatClient.Builder builder = ChatClient.builder(dashscopeChatModel);
        // 创建查询重写转换器
        queryTransformer = RewriteQueryTransformer.builder()
                .chatClientBuilder(builder)
                .build();
    }
    /**
     * 执行查询重写
     *
     * @param prompt
     * @return
     */
    public String doQueryRewrite(String prompt) {
        Query query = new Query(prompt);
        // 执行查询重写
        Query transformedQuery = queryTransformer.transform(query);
        // 输出重写后的查询
        return transformedQuery.text();
    }
}