大模型

Spring AI 利用 ollama:qwen:7b 和 pgvector 创新实现高效 RAG 问答系统

Ne0inhk

06 Feb 2025 — 12 min read

了解完嵌入模型、向量数据库相关知识后，在此基础上可以实现一个RAG本地问答系统。

什么RAG？

RAG（Retrieval-Augmented Generation）检索增强生成，即大模型LLM在回答问题或生成文本前，会先从大量的文档中检索出相关信息，然后基于这些检索出的信息进行回答或生成文本，从而可以提高回答的质量，而不是任由LLM来发挥。

使用一个简单的公式来描述RAG：RAG = 检索技术 + LLMs提示

RAG 技术就是给大语言模型新知识，解决大模型的 “AI 幻想症”、“无法获取领域知识”和数据安全性问题！！

RAG架构

Spring AI 官方文档给出的架构图如下；

www.zeeklog.com - Spring AI 利用 ollama:qwen:7b 和 pgvector 创新实现高效 RAG 问答系统

架构由离线部分和在线部分两部分组成；

离线部分：数据读取 -> 文档拆分 -> 向量化 -> 数据存储
在线部分：用户提问 -> 数据检索（召回） -> prompt拼装 -> LLM生成

该架构为最简单的RAG架构，有关论文介绍了RAG的演化由朴素RAG->高级RAG->模块化RAG，因此简单RAG是后续发展的理论基石，所以先将其掌握，在后续研究高级RAG加入了哪些优化，如何落地的。现在先仅实现一个简单的RAG问答系统。

离线部分 ETL Framework

下图为ETL处理流程及实现架构；对于 ETL 主要涉及到文件的读取、拆分、写入三个部分，将详细看下实现源码：

文件读取 DocumentReader

public interface DocumentReader extends Supplier<List<Document>> {
    default List<Document> read() {
       return get();
    }
}

实现类：

JsonReader：读取解析Json格式的文档
TextReader：读取解析纯文本格式的文件
TikaDocumentReader：从多种文档格式读取解析数据，包括像PDF, DOC/DOCX, PPT/PPTX 和 HTML。底层使用Apache tika技术实现。
PagePdfDocumentReader：以页的方式读取解析PDF文件，底层依赖PdfBox实现。
ParagraphPdfDocumentReader：以段落的方式读取解析PDF文件，根据TOC目录结构。注意：并不是所有的PDF文件都包含PDF catalog。

文件拆分 DocumentTransformer

public interface DocumentTransformer extends Function<List<Document>, List<Document>> {
    default List<Document> transform(List<Document> transform) {
        return (List)this.apply(transform);
    }
}

其有4个实现类型，根据多种策略实现不同的类；

TokenTextSplitter：将文档按照Token完整性进行拆分
ContentFormatTransformer：
KeywordMetadataEnricher：关键词提取
SummaryMetadataEnricher：文档摘要

文档的拆分粒度对于相似度搜索至关重要，拆分粒度不合理将会导致相似度搜索问题，比如拆分粒度太大，可能会搜到不相关内容，或者搜索到的上下文过多，导致超出大模型窗口大小，相反粒度太小会丢失上下文信息，使得大模型回到质量受到影响。

分析一下TokenTextSplitter源码

TokenTextSplitter 该类是对读取文档进行拆分，其拆分对于相似度检索影响非常大。比如拆分块的大小；

public class TokenTextSplitter extends TextSplitter {

    private final EncodingRegistry registry = Encodings.newLazyEncodingRegistry();
    private final Encoding encoding = registry.getEncoding(EncodingType.CL100K_BASE);

    // The target size of each text chunk in tokens
    // 生成每个块的大小，比如一段文本总的tokens为1600，此时defaultChunkSize=800，
    // 那么就将text的tokens拆分成为两个
    private int defaultChunkSize = 800;

    // The minimum size of each text chunk in characters
    // 拆分后的文本块的最小字符数
    private int minChunkSizeChars = 350;

    // Discard chunks shorter than this
    // 丢弃块的最短长度，这个指的是字符，
    // 如果字符长度小于该值，则不再嵌入处理直接丢弃
    private int minChunkLengthToEmbed = 5;

    // The maximum number of chunks to generate from a text
    // 一个文本最多生成的块的最大数量
    private int maxNumChunks = 10000;
   
   // 是否保留分割符，如果值为true，会执行chunkText.trim()
    private boolean keepSeparator = true;

    public TokenTextSplitter() {
    }
}

当修改defaultChunkSize = 100时，上传文本被拆分为5个数据块。然后在进行测试，效果如下；

如果defaultChunkSize值设置的不合理，则会导致拆分文本会丢失上下文信息

设置合理的chunk size可以比较精确的查询上下文信息，而且可以控制发送给大模型窗口的大小。

TokenTextSplitter底层使用技术

底层依赖 jtokkit，一个专为 Java 开发者设计的高效文本分词库。它提供了一种简单易用的接口，使您能够轻松地对输入文本进行编码和解码。有兴趣的可以深入看下。

<dependency>
    <groupId>com.knuddels</groupId>
    <artifactId>jtokkit</artifactId>
    <version>1.0.0</version>
</dependency>

文件写入 DocumentWriter

public interface DocumentWriter extends Consumer<List<Document>> {
    default void write(List<Document> documents) {
       accept(documents);
    }
}

实现类有两个：

FileDocumentWriter：持久化到文件中
VectorStore：持久化到向量数据库中，Spring AI 集成10+种。

简单的RAG系统的实现

离线部分

离线部分主要使用 Spring AI ETL FrameWork 完成文件的处理。

package org.ivy.service;

import lombok.RequiredArgsConstructor;
import org.springframework.ai.document.Document;
import org.springframework.ai.document.DocumentTransformer;
import org.springframework.ai.reader.tika.TikaDocumentReader;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.core.io.Resource;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.util.List;

@Service
@RequiredArgsConstructor
public class OfflineService {

    private final VectorStore vectorStore;
    private final DocumentTransformer transformer;

    /**
     * 上传文件，并拆分文档，向量化到数据库
     *
     * @param file 文件
     * @return 上传结果
     */
    public String upload(MultipartFile file) {
        Resource resource = file.getResource();
        TikaDocumentReader reader = new TikaDocumentReader(resource);
        // 读取文档
        List<Document> documents = reader.get();
        // 拆分文档
        List<Document> transform = transformer.transform(documents);
        // 向量化到数据库
        vectorStore.accept(transform);
        return "ok";
    }
}

在线部分

主要是去向量数据库相似度查询，重点看下 SearchRequest 请求对象，其中包含一些请求参数控制；

public class SearchRequest {
    // 相似度查询阙值，默认为0.0，为提高相似度准确性，可以提高此值
    public static final double SIMILARITY_THRESHOLD_ACCEPT_ALL = 0.0;
    // 相似度前k个
    public static final int DEFAULT_TOP_K = 4;
    // 查询内容
    public String query;
    // 返回topK个文档
    private int topK = DEFAULT_TOP_K;
    // 相似度阙值，默认为0.0
    private double similarityThreshold = SIMILARITY_THRESHOLD_ACCEPT_ALL;
    // 过滤条件，根据元数据进行过滤，可以辅助精确检索
    private Filter.Expression filterExpression;
    }

在线部分代码实现；

package org.ivy.service;

import jakarta.annotation.Resource;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.chat.prompt.SystemPromptTemplate;
import org.springframework.ai.document.Document;
import org.springframework.ai.ollama.OllamaChatModel;
import org.springframework.ai.vectorstore.SearchRequest;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

import java.util.List;
import java.util.Map;

@Service
public class OnlineService {
    @Value("classpath:rag.st")
    private org.springframework.core.io.Resource ragTemplate;
    @Resource
    private OllamaChatModel chatModel;
    @Resource
    private VectorStore vectorStore;

    public Flux<String> simple(String prompt) {
        ChatClient client = ChatClient.builder(chatModel).build();
        return client.prompt()
                .user(prompt)
                .stream()
                .content();

    }

    public Flux<String> rag(String prompt) {
        // 检索
        SearchRequest searchRequest = SearchRequest.query(prompt);
        List<Document> documents = vectorStore.similaritySearch(searchRequest);
        // 提示词生成
        List<String> context = documents.stream().map(Document::getContent).toList();
        SystemPromptTemplate promptTemplate = new SystemPromptTemplate(ragTemplate);
        Prompt p = promptTemplate.create(Map.of("context", context, "question", prompt));
        ChatClient chatClient = ChatClient.builder(chatModel).build();
        // 大模型生成内容
        return chatClient.prompt(p).stream().content();
    }
}