深度解析RAG检索增强生成技术及工程实践

> RAG（Retrieval-Augmented Generation，检索增强生成）是当前AI Agent的核心技术之一。本文基于Java后端专家Agent项目的真实实现，深入讲解RAG的技术架构、全流程实现以及工程化落地的最佳实践。

一、前言

RAG是一种结合了信息检索和自然语言处理的先进技术，在构建智能问答系统和聊天机器人中有着广泛的应用。本文将详细介绍RAG技术的原理及其在实际项目的应用过程中可能遇到的问题与解决方案，帮助读者更好地理解和使用该技术。

二、RAG技术架构

RAG全流程概述

┌──────────────────────────────────────┐
│        文档加载 → 文本切分           │
├──────────────────────────────────────┤
│   ├── 向量化 → 存储 → 检索阶段 ──┐  │
│   │                                │  │
│   │  用户查询 → 向量化 → Top-K     │  │
│   │    检索 → 格式化上下文 → LLM   │  │
│   └──────────────────────────────────┘  │
└───────────────────────────────────────┐
                                       │
                                    向量数据库
                                     ChromaDB

该架构涵盖文档加载、文本切分、向量化存储以及检索等关键步骤，确保知识库的高效构建与查询能力。

三、核心模块实现

3.1 文档加载器（MarkdownDocumentLoader）

职责： 递归扫描知识目录并加载所有 Markdown 文件

@Component
public class MarkdownDocumentLoader {

    /**
     * 加载指定路径下的所有 Markdown 文件。
     */
    public List
<Metadata> loadDocuments(String knowledgeDir) {
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] resources = resolver.getResources(knowledgeDir + "**/*.md");

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

        for (Resource resource : resources) {
            if (!resource.getFilename().equalsIgnoreCase("readme.md")) {
                String content = readResource(resource);
                if (content != null && !content.trim().isEmpty()) {
                    Metadata metadata = createMetadataFromFilePath(resource.getURI());
                    documents.add(metadata);
                }
            }
        }

        // 按路径排序，保证加载顺序一致
        documents.sort(Comparator.comparing(Metadata::getSource));
        return documents;
    }

    private String readResource(Resource resource) throws IOException {
        try (InputStream is = resource.getInputStream()) {
            return new String(is.readAllBytes(), StandardCharsets.UTF_8);
        }
    }

    private Metadata createMetadataFromFilePath(String filePath) {
        // 处理相对路径，返回 source 和 category
        Path path = Paths.get(filePath).getParent();
        String source = path.toString().replace(knowledgeDir, "");
        return new Metadata(source, resource.getFilename(), extractCategory(source));
    }
}

文档加载器的职责是从指定的知识目录递归扫描所有Markdown文件，并提取每个文件的内容与元数据信息。

3.2 文本切分器（MarkdownTextSplitter）

核心策略： 按语义边界优先切分，保证每个chunk语义完整

@Component
public class MarkdownTextSplitter {

    private static final String[] separators = {
        "\n## ",      // 二级标题
        "\n### ",     // 三级标题
        "\n#### ",    // 四级标题
        "\n\n",       // 段落
        "\n",         // 换行
        "。",         // 中文句号
        "；"          // 中文分号
    };

    private int chunkSize = 800;      // 块大小（字符数）
    private int overlap = 200;        // 块重叠以保持上下文连续性

    /**
     * 将单个文档切分为多个文本块。
     */
    public List
<Chunk> split(String content, Metadata metadata) {
        List
<Chunk> chunks = new ArrayList<>();
        List
<String> segments = splitBySeparators(content);

        StringBuilder current = new StringBuilder();
        int currentSize = 0;

        for (String segment : segments) {
            if (currentSize + segment.length() > chunkSize && currentSize > 0) {
                // 当前块已满，保存
                chunks.add(createChunk(current.toString(), metadata, chunks.size()));

                // 处理重叠部分以保证上下文连续性
                String overlapText = getOverlapText(current.toString());
                current = new StringBuilder(overlapText);
                currentSize = overlapText.length();
            }
            current.append(segment);
            currentSize += segment.length();
        }

        if (current.length() > 0) {
            chunks.add(createChunk(current.toString(), metadata, chunks.size()));
        }
        return chunks;
    }

    private List
<String> splitBySeparators(String text) {
        // 分段逻辑
        for (String separator : separators) {
            text = text.replaceAll(Pattern.quote(separator), separator);
        }

        String[] parts = text.split("\\n\n|\\n|\。|\；");
        return Arrays.asList(parts);
    }

    private Chunk createChunk(String content, Metadata metadata, int index) {
        // 创建新的块
        return new Chunk(content, metadata.getSource(), metadata.getFilename(), metadata.getCategory(), index);
    }
}

文本切分器负责将文档内容按照预定的语义边界进行分割，确保每个块具有完整的语义连贯性。

3.3 知识库服务（KnowledgeBaseService）

核心职责： 构建向量库 + 检索相关上下文

@Service
public class KnowledgeBaseService {

    private final VectorStore vectorStore;
    private final MarkdownDocumentLoader documentLoader;
    private final MarkdownTextSplitter textSplitter;

    private boolean loaded = false;
    private int vectorCount = 0;

    /**
     * 构建知识库（全量重建）。
     */
    public synchronized void build() {
        if (loaded) return; // 避免重复加载

        List
<Metadata> documents = documentLoader.loadDocuments("classpath:knowledge/");

        for (Metadata metadata : documents) {
            String content = readDocumentContent(metadata);
            List
<Chunk> chunks = textSplitter.split(content, metadata);

            vectorStore.insert(chunks.stream()
                    .map(chunk -> new VectorEntry(chunk.getContent(), getEmbedding(chunk)))
                    .collect(Collectors.toList()));

            // 更新向量计数
            vectorCount += chunks.size();
        }

        loaded = true;
    }

    private String readDocumentContent(Metadata metadata) {
        // 读取文档内容
        return documentLoader.readResource(metadata.getSource());
    }

    private List
<Float> getEmbedding(Chunk chunk) throws Exception {
        // 文本编码生成向量
        return textEncoder.encode(chunk.getContent()).tolist();
    }
}

知识库服务负责将加载的文档内容进行切分、向量化，并存储到向量数据库中，以便后续的检索操作。

通过以上模块的具体实现，可以构建完整的RAG系统并支持高效的知识查询。希望本文能够为读者提供深入了解和应用RAG技术的基础与实践指导。

四、常见问题及解决方案

❌ 问题 1：检索结果噪声大

原因： 面对短文本时简单向量检索可能会导致不相关的结果。

解决方案：混合检索与重排序

// 1. 关键词预检索（BM25/全文检索）
List
<Document> bm25Results = keywordSearch(query);

// 2. 向量检索
int topK = properties.getKnowledge().getTopK();
List
<Document> vectorResults = vectorStore.similaritySearch(
    SearchRequest.builder()
        .query(query)
        .topK(topK * 2) // 超出常规的 Top-K 来筛选更多候选结果
        .build()
);

// 3. 取交集作为候选集，以确保相关性
List
<Document> candidates = intersection(bm25Results, vectorResults);

// 4. 重排序（Rerank）
List
<Document> reranked = rerankService.rerank(query, candidates, topK);

❌ 问题 2：Embedding API 批量限制

原因： 向量存储API有每批次的最大数量限制，通常为10条。

错误写法：

// ❌ 一次性传入大量文档会导致超出限制
vectorStore.add(allDocuments); // 超过限制会失败

正确写法：

int batchSize = 10;
for (int i = 0; i < allDocuments.size(); i += batchSize) {
    int end = Math.min(i + batchSize, allDocuments.size());
    List
<Document> batch = allDocuments.subList(i, end);
    vectorStore.add(batch); // 分批处理，避免超出限制
}

❌ 问题 3：语义被切断

原因： 简单按固定长度切分会导致完整的段落或列表文本被分割为两部分。

解决方案：基于语义边界进行切分

// 分隔符优先级，从最高到最低
private static final String[] SEPARATORS = {
    "\n## ",      // 二级标题（最高）
    "\n### ",     // 三级标题
    "\n\n",       // 段落
    "\n",         // 单独的换行符
    ""            // 字符级切分（最低）
};

❌ 问题 4：跨块上下文丢失

原因： 当两个相邻的chunk之间没有重叠时，会导致关键信息丢失。

解决方案：Chunk Overlap

// 每个块保留200字的overlap以确保连续性
private int chunkOverlap = 200;

// 获取重叠文本（尝试在段落边界截取）
private String getOverlapText(String text) {
    if (text.length() <= chunkOverlap) return text;
    String tail = text.substring(text.length() - chunkOverlap);
    int paragraphBreak = tail.indexOf("\n\n");
    if (paragraphBreak > 0 && paragraphBreak < tail.length() - 50)
        return tail.substring(paragraphBreak + 2);
    return tail;
}

❌ 问题 5：检索为空时 Agent 回答质量下降

原因： 当知识库中没有相关文档时，Agent 可能会基于不充分的信息来回答。

解决方案：降级与兜底策略

public RetrievalResult retrieve(String query) {
    try {
        List
<Document> results = vectorStore.similaritySearch(
            SearchRequest.builder()
                .query(query)
                .topK(topK)
                .build()
        );
        if (results.isEmpty()) return new RetrievalResult("【提示】知识库中没有找到直接相关的文档，请基于通用知识回答。", 0);

        return new RetrievalResult(formatContext(results), results.size());
    } catch (Exception e) {
        log.warn("[KB] 检索失败，降级为无 RAG 模式", e);
        // 返回提示信息
        return new RetrievalResult("【提示】知识库暂时不可用，请基于通用知识回答。", 0); 
    }
}

❌ 问题 6：向量数据库连接失败

原因： 向量数据库未启动或配置错误。

解决方案：启动检查与懒加载

# application.yml 配置文件
spring:
  ai:
    vectorstore:
      chroma:
        url: http://localhost:8000

@PostConstruct
public void init() {
    try {
        // 检查连接状态
        vectorStore.similaritySearch(
            SearchRequest.builder()
                .query("")
                .topK(5)
                .build()
        );
    } catch (Exception e) { 
        log.warn("向量数据库未启动，请检查配置或服务器状态");
    }
}

五、知识库监控与更新

知识库状态监控

public Map<String, Object> getStatus() {
    return new HashMap<>() {{
        put("exists", loaded);
        put("knowledge_files", documentCount);
        put("vector_count", vectorCount);
        put("rag_enabled", loaded);
    }};
}

知识库热更新

public synchronized void updateDocument(String source, String content) {
    // 1. 删除旧向量
    vectorStore.delete(Filter.eq("source", source));

    // 2. 更新文档内容并重新切分
    List
<Document> chunks = textSplitter.split(content);

    for (Document chunk : chunks)
        vectorStore.add(chunk);
}

六、面试高频问题

Q1：RAG 和 Fine-tuning 的区别？

Q2：如何提升 RAG 检索精度？

1. 文档预处理：去除噪声，如HTML标签和特殊字符。
2. 语义切分：根据标题或段落进行文本切割，保留完整的语义单元。
3. 混合检索：结合关键词与向量搜索，取交集作为最终结果。
4. 重排序：使用Rerank模型对候选文档进行重新排序。
5. 上下文压缩：减少Token消耗，提高相关性。

Q3：如何选择合适的向量数据库？

七、总结

通过掌握这些核心能力和避坑经验，你可以构建出更稳定和高效的RAG系统。

> 🔗 相关阅读：智能问答系统