SpringAI+DeepSeek大模型应用开发——5 ChatPDF

ChatPDF 知识库

RAG检索增强

由于训练大模型非常耗时，再加上训练语料本身比较滞后，所以大模型存在知识限制问题：

• 知识数据比较落后，往往是几个月之前的；不包含太过专业领域或者企业私有的数据；

• 为了解决这些问题，就需要用到RAG了。

RAG原理

RAG 的核心原理是将检索技术与生成模型相结合，结合外部知识库来检索相关信息来增强模型的输出，其实就是给大模型挂一个知识库

其核心工作流程分为三个阶段：

1. 接收请求: 首先，系统接收到用户的请求(例如提出一个问题)
2. 信息检索®: 系统从一个大型文档库中检索出与查询最相关的文档片段。这一步的目标是找到那些可能包含答案或相关信息的文档。这里不一定是从向量数据库中检索，但是向量数据库能反应相似度最高的几个文档(比如说法不同，意思相同)，而不是精确查找
3. 生成增强(A): 将检索到的文档片段与原始查询一起输入到大模型(如chatGPT)中，注意使用合适的提示词，比如原始的问题是XXX，检索到的信息是YY，给大模型的输入应该类似于: 请基于YYY回答XXXX。
4. 输出生成(G): 大模型LLM 基于输入的査询和检索到的文档片段生成最终的文本答案，并返回给用户

注意：知识库不能写在提示词中，因为通常知识库数据量都是非常大的，而大模型的上下文是有大小限制的，那怎么办呢？

只要想办法从庞大的知识库中找到与用户问题相关的一小部分，组装成提示词，发送给大模型就可以了；那么该如何从知识库中找到与用户问题相关的内容呢？

• 全文检索？但在这里是不合适的，因为全文检索是文字匹配，而这里要求的是内容上的相似度；
• 而要从内容相似度来判断，这就不得不提到向量模型的知识了。

向量模型

向量是空间中有方向和长度的量，空间可以是二维，也可以是多维；向量既然是在空间中，那么两个向量之间就一定能计算距离；

向量之间的距离一般有两种计算方法：

欧几里得距离

在n维空间中，两点间的直线距离。它是两点间最直接的距离测量方式。很适合用于RGB色彩空间中衡量两种颜色之间的差异

颜色可以用 RGB 值表示，然后通过计算两种颜色 RGB 值之间的欧几里得距离来判断它们的相似度。

• R G B: 两个颜色的 RGB 分量(红色、绿色、蓝色)
• d: 两个颜色之间的欧几里得距离。
• 距离越小，表示颜色越相似; 距离越大，表示颜色越不同

余弦相似度

通过比较两个向量之间的夹角余弦值来衡量它们的方向是否相似，如果夹角余弦值越小，说明它们越相似，但这种方法不能考虑到向量的大小。

在颜色分析中，它可以用来比较颜色 色调的相似性，但是它对于亮度和饱和度的变化不敏感。

综上，如果能把文本转为向量，就可以通过向量距离来判断文本的相似度了；

现在有不少的专门的向量模型，就可以实现将文本向量化。一个好的向量模型，就是要尽可能让文本含义相似的向量，在空间中距离更近：

阿里云百炼平台就提供了这样的模型，用于将文本向量化：

这里选择通用文本向量-v3，这个模型兼容OpenAI，所以我们依然采用OpenAI的配置；修改yml配置

spring:application:name: chart-robotai:ollama:# Ollama服务地址base-url: http://localhost:11434chat:# 模型名称，可更改model: deepseek-r1:14boptions:# 模型温度，值越大，输出结果越随机temperature: 0.8openai:base-url: https://dashscope.aliyuncs.com/compatible-modeapi-key: ${OPENAI_API_KEY} #API keychat:options:# 可选择的模型列表 https://help.aliyun.com/zh/model-studio/getting-started/modelsmodel: qwen-plusembedding:options:model: text-embedding-v3  #通用文本向量-v3dimensions: 1024

向量模型测试

文本向量化以后，就可以通过向量之间的距离来判断文本相似度；接下来，我们来测试下阿里百炼提供的向量大模型；

在项目中写一个工具类，用以计算向量之间的欧氏距离和**余弦距离。**新建一个ai.util包，在其中新建一个VectorDistanceUtils类：

public class VectorDistanceUtils {// 私有构造函数：防止该工具类被实例化。private VectorDistanceUtils() {}// 浮点数计算精度阈值，用于判断浮点数是否接近零。private static final double EPSILON = 1e-12;/*** 计算欧氏距离（Euclidean Distance）* 欧氏距离是两个向量之间的直线距离，常用于衡量多维空间中两点的距离。* @param vectorA 向量A（非空且与B等长）* @param vectorB 向量B（非空且与A等长）*/public static double euclideanDistance(float[] vectorA, float[] vectorB) {// 校验输入向量的合法性validateVectors(vectorA, vectorB);double sum = 0.0; // 用于累加差值平方for (int i = 0; i < vectorA.length; i++) {double diff = vectorA[i] - vectorB[i]; // 计算对应维度上的差值sum += diff * diff; // 累加差值的平方}return Math.sqrt(sum); // 返回平方和的平方根，即欧氏距离}/*** 计算余弦距离（Cosine Distance）* 余弦距离基于余弦相似度计算，表示两个向量在方向上的差异。距离范围为[0, 2]，* 其中0表示完全相同，2表示完全相反。*/public static double cosineDistance(float[] vectorA, float[] vectorB) {// 校验输入向量的合法性validateVectors(vectorA, vectorB);double dotProduct = 0.0; // 点积double normA = 0.0;      // 向量A的模double normB = 0.0;      // 向量B的模// 遍历向量的每个维度，计算点积和模的平方for (int i = 0; i < vectorA.length; i++) {dotProduct += vectorA[i] * vectorB[i]; // 点积累加normA += vectorA[i] * vectorA[i];     // A模的平方累加normB += vectorB[i] * vectorB[i];     // B模的平方累加}// 计算向量的模normA = Math.sqrt(normA);normB = Math.sqrt(normB);// 如果任意一个向量为零向量，则无法计算余弦距离，抛出异常if (normA < EPSILON || normB < EPSILON) {throw new IllegalArgumentException("Vectors cannot be zero vectors");}// 计算余弦相似度，确保结果在[-1, 1]范围内（处理浮点误差）double similarity = dotProduct / (normA * normB);similarity = Math.max(Math.min(similarity, 1.0), -1.0);// 余弦距离 = 1 - 相似度，范围为[0, 2]return 1.0 - similarity;}/*** 参数校验统一方法* 确保输入向量满足以下条件：* 1. 不为空（null）；* 2. 长度相等；* 3. 非空数组。*/private static void validateVectors(float[] a, float[] b) {if (a == null || b == null) {throw new IllegalArgumentException("Vectors cannot be null");}if (a.length != b.length) {throw new IllegalArgumentException("Vectors must have same dimension");}if (a.length == 0) {throw new IllegalArgumentException("Vectors cannot be empty");}}
}

由于SpringBoot的自动装配能力，刚才配置的向量模型可以直接使用；

@SpringBootTest
...
// 自动注入向量模型
@Autowired
private OpenAiEmbeddingModel embeddingModel;
@Test
void contextLoads() {// 1.测试数据// 1.1.用来查询的文本，国际冲突String query = "global conflicts";// 1.2.用来做比较的文本String[] texts = new String[]{"哈马斯称加沙下阶段停火谈判仍在进行 以方尚未做出承诺","土耳其、芬兰、瑞典与北约代表将继续就瑞典“入约”问题进行谈判","日本航空基地水井中检测出有机氟化物超标","国家游泳中心（水立方）：恢复游泳、嬉水乐园等水上项目运营","我国首次在空间站开展舱外辐射生物学暴露实验",};// 2.向量化// 2.1.先将查询文本向量化float[] queryVector = embeddingModel.embed(query);// 2.2.再将比较文本向量化，放到一个数组List<float[]> textVectors = embeddingModel.embed(Arrays.asList(texts));// 3.比较欧氏距离// 3.1.把查询文本自己与自己比较，肯定是相似度最高的System.out.println(VectorDistanceUtils.euclideanDistance(queryVector, queryVector));// 3.2.把查询文本与其它文本比较for (float[] textVector : textVectors) {System.out.println(VectorDistanceUtils.euclideanDistance(queryVector, textVector));}System.out.println("------------------");// 4.比较余弦距离// 4.1.把查询文本自己与自己比较，肯定是相似度最高的System.out.println(VectorDistanceUtils.cosineDistance(queryVector, queryVector));// 4.2.把查询文本与其它文本比较for (float[] textVector : textVectors) {System.out.println(VectorDistanceUtils.cosineDistance(queryVector, textVector));}
}

运行结果：

可以看到，向量相似度确实符合我们的预期。有了比较文本相似度的办法，知识库的问题就可以解决了；前面说了，知识库数据量很大，无法全部写入提示词，而且庞大的知识库中与用户问题相关的其实并不多；

所以，我们需要想办法从庞大的知识库中找到与用户问题相关的一小部分，组装成提示词，发送给大模型就可以了；

现但是新的问题来了：向量模型是生成向量的，如此庞大的知识库，谁来从中比较和检索数据呢？ 这就需要用到向量数据库了

向量数据库

文本向量化

由于需要将已拆分的知识片段文本存储向量库，以便后续可以进行检索，而向量库存储的数据是向量不是文本

因此需要将文本进行向量化，即将一个字符串转换为一个N维数组，这个过程在自然语言处理（NLP）领域称为文本嵌入

不同的LLM对于文本嵌入的实现是不同的，ChatGPT的实现是基于transformer架构的，相关实现存储在服务端，每次嵌入都需要访问OpenAI的HTTP接口。

通过下面的例子可以看到OpenAi使用的模型是：text-embedding-ada-002，向量的维度是：1536

OpenAiEmbeddingModel embeddingModel = new OpenAiEmbeddingModel.OpenAiEmbeddingModelBuilder().apiKey(API_KEY).baseUrl(BASE_URL).build();
log.info("当前的模型是: {}", embeddingModel.modelName());
String text = "两只眼睛";
Embedding embedding = embeddingModel.embed(text).content();
log.info("文本:{}的嵌入结果是:\n{}", text, embedding.vectorAsList());
log.info("它是{}维的向量", embedding.dimension());

向量库存储

向量数据库，也称为向量存储或向量搜索引擎，是一种专门设计用于存储和管理向量（固定长度的数字列表）及其他数据项的数据库。

这些向量是数据点在高维空间中的数学表示，其中每个维度对应数据的一个特征。向量数据库的主要目的是通过近似最近邻（ANN）算法实现高效的相似性搜索。

向量数据库的主要作用有两个：

• 存储向量数据；
• 基于相似度检索数据；

SpringAI支持很多向量数据库，并且都进行了封装，可以用统一的API去访问：

• Azure Vector Search - The Azure vector store
• Apache Cassandra - The Apache Cassandra vector store
• Chroma Vector Store - The Chroma vector store
• Elasticsearch Vector Store - The Elasticsearch vector store
• GemFire Vector Store - The GemFire vector store
• MariaDB Vector Store - The MariaDB vector store
• Milvus Vector Store - The Milvus vector store
• MongoDB Atlas Vector Store - The MongoDB Atlas vector store
• Neo4j Vector Store - The Neo4j vector store
• OpenSearch Vector Store - The OpenSearch vector store
• Oracle Vector Store - The Oracle Database vector store
• PgVector Store - The PostgreSQL/PGVector vector store
• Pinecone Vector Store - PineCone vector store
• Qdrant Vector Store - Qdrant vector store
• Redis Vector Store - The Redis vector store
• SAP Hana Vector Store - The SAP HANA vector store
• Typesense Vector Store - The Typesense vector store
• Weaviate Vector Store - The Weaviate vector store
• SimpleVectorStore - A simple implementation of persistent vector storage, good for educational purposes

这些库都实现了统一的接口：VectorStore，因此操作方式一模一样，只要学会任意一个，其它就都不是问题；

注意：除了最后一个库，其它所有向量数据库都是需要安装部署的，而且每个企业用的向量库都不一样。

SimpleVectorStore

• 最后一个SimpleVectorStore向量库是基于内存实现，是一个专门用来测试、教学用的库，非常适合此处案例的使用；
• 修改CommonConfiguration，添加一个VectorStore的Bean

@Bean
public VectorStore vectorStore(OpenAiEmbeddingModel embeddingModel) {return SimpleVectorStore.builder(embeddingModel).build();
}

VectorStore接口

• 接下来就可以使用VectorStore接口中的各种功能了，可以参考SpringAI官方文档：Vector Databases :: Spring AI Reference；
• 这是VectorStore接口中声明的方法：

public interface VectorStore extends DocumentWriter {default String getName() {return this.getClass().getSimpleName();}// 保存文档到向量库void add(List<Document> documents);// 根据文档id删除文档void delete(List<String> idList);void delete(Filter.Expression filterExpression);default void delete(String filterExpression) {SearchRequest searchRequest = SearchRequest.builder().filterExpression(filterExpression).build();Filter.Expression textExpression = searchRequest.getFilterExpression();Assert.notNull(textExpression, "Filter expression must not be null");this.delete(textExpression);}// 根据条件检索文档@NullableList<Document> similaritySearch(String query);// 根据条件检索文档@NullableList<Document> similaritySearch(SearchRequest request);default <T> Optional<T> getNativeClient() {return Optional.empty();}
}

注意，VectorStore操作向量化的基本单位是Document，在使用时需要将自己的知识库分割转换为一个个的Document，然后写入VectorStore；

那么问题来了，该如何把各种不同的知识库文件转为Document呢？

文件读取和转换

由于知识库太大，所以要将知识库拆分成文档片段，然后再做向量化。而且SpringAI中向量库接收的是Document类型的文档，即我们处理文档还要转成Document格式

不过，文档读取、拆分、转换的动作并不需要我们亲自完成。在SpringAI中提供了各种文档读取的工具，可以参考官网：Spring AI Reference

比如PDF文档读取和拆分，SpringAI提供了两种默认的拆分原则：

• PagePdfDocumentReader：按页拆分，推荐使用；
• ParagraphPdfDocumentReader ：按pdf的目录拆分，不推荐，因为很多PDF不规范，没有章节标签；

此处选择使用PagePdfDocumentReader。首先，在pom.xml中引入依赖：

<dependency><groupId>org.springframework.ai</groupId><artifactId>spring-ai-pdf-document-reader</artifactId>
</dependency>

然后就可以利用工具把PDF文件读取并处理成Document了；

编写一个单元测试

@Test
public void testVectorStore(){Resource resource = new FileSystemResource("中二知识笔记.pdf");// 1.创建PDF的读取器PagePdfDocumentReader reader = new PagePdfDocumentReader(resource, // 文件源PdfDocumentReaderConfig.builder().withPageExtractedTextFormatter(ExtractedTextFormatter.defaults()).withPagesPerDocument(1) // 每1页PDF作为一个Document.build());// 2.读取PDF文档，拆分为DocumentList<Document> documents = reader.read();// 3.写入向量库vectorStore.add(documents);// 4.构建一个搜索请求SearchRequest request = SearchRequest.builder().query("论语中教育的目的是什么").topK(1)  //返回最相关的前 1 个结果.similarityThreshold(0.6) //只有相似度大于等于 0.6 的结果才会被返回.filterExpression("file_name == '中二知识笔记.pdf'").build();List<Document> docs = vectorStore.similaritySearch(request);  //搜索if (docs == null) {System.out.println("没有搜索到任何内容");return;}//遍历搜索结果，打印每个文档的相关信息for (Document doc : docs) {System.out.println(doc.getId());System.out.println(doc.getScore());System.out.println(doc.getText());}
}

注意：启动测试之前，要将中二知识笔记.pdf文件放到工程目录结构下；结果如下

RAG原理总结

目前已经有了以下这些工具

• PDFReader：读取文档并拆分为片段；
• 向量大模型：将文本片段向量化；
• 向量数据库：存储向量，检索向量；

接下来梳理一下要解决的问题和解决思路：

1. 要解决大模型的知识限制问题，需要外挂知识库；
2. 受到大模型上下文限制，知识库不能直接拼接在提示词中；
3. 需要从庞大的外挂知识库中找到与用户问题相关的一小部分，再组装成提示词；
4. 这些可以利用文档读取器、向量大模型、向量数据库来解决；
5. RAG要做的事情就是将知识库分割==>利用向量模型做向量化==>存入向量数据库==>查询的时候去检索；
6. 每当用户询问AI时，将用户问题向量化==>拿着问题向量==>去向量数据库检索最相关的片段
7. 对话大模型：将检索到的片段、用户的问题一起拼接为提示词==> 发送提示词给大模型，得到响应。

目标

接下来就来实现一个非常火爆的个人知识库AI应用——ChatPDF，原网站如下：

这个网站其实就是把个人的PDF文件作为知识库，让AI基于PDF内容来回答问题，对于大学生、研究人员、专业人士来说，非常方便。

PDF上传下载向量化

既然是ChatPDF，即所有知识库都是PDF形式的，由用户提交给服务器。所以，需要先实现一个上传PDF的接口，在接口中实现下列功能：

• 校验文件格式是否为PDF；
• 保存文件信息；
  • 保存文件（可以是oss或本地保存）；
  • 保存会话ID和文件路径的映射关系（方便查询会话历史的时候再次读取文件）；
• 文档拆分和向量化（文档太大，需要拆分为一个个片段，分别向量化）；

另外，将来用户查询会话历史，还需要返回pdf文件给前端用于预览，所以需要实现一个下载PDF接口，包含下面功能：

• 读取文件
• 返回文件给前端

PDF文件管理

由于将来要实现PDF下载功能，就需要记住每一个chatId对应的PDF文件名称；

所以定义一个类，记录chatId与pdf文件的映射关系，同时实现基本的文件保存功能。在repository包中定义FileRepository接口

public interface FileRepository {/*** 保存文件,还要记录chatId与文件的映射关系* @param chatId 会话id* @param resource 文件* @return 上传成功，返回true； 否则返回false*/boolean save(String chatId, Resource resource);/*** 根据chatId获取文件* @param chatId 会话id* @return 找到的文件*/Resource getFile(String chatId);
}

@Slf4j
@Component
@RequiredArgsConstructor
public class LocalPdfFileRepository implements FileRepository {private final VectorStore vectorStore; // 向量存储组件// 会话id 与 文件名的对应关系，方便查询会话历史时重新加载文件private final Properties chatFiles = new Properties();/*** 保存资源到本地磁盘，并记录会话 ID 与文件名的映射关系。*/@Overridepublic boolean save(String chatId, Resource resource) {// 1. 获取文件名并检查是否已存在String filename = resource.getFilename();File target = new File(Objects.requireNonNull(filename));if (!target.exists()) {try {// 将资源内容复制到目标文件Files.copy(resource.getInputStream(), target.toPath());} catch (IOException e) {log.error("Failed to save PDF resource.", e);return false;}}// 2. 保存会话 ID 与文件名的映射关系chatFiles.put(chatId, filename);return true;}/*** 根据会话 ID 获取对应的文件资源。*/@Overridepublic Resource getFile(String chatId) {// 根据会话 ID 查找文件名String filename = chatFiles.getProperty(chatId);if (filename == null) {log.warn("No file found for chatId: {}", chatId);return null;}return new FileSystemResource(filename);}/*** 初始化方法，在 Spring 容器启动时执行。* 加载 `chat-pdf.properties` 文件中的会话 ID 映射关系，* 并加载 `chat-pdf.json` 中的向量数据。*/@PostConstructprivate void init() {// 加载会话 ID 映射关系FileSystemResource pdfResource = new FileSystemResource("chat-pdf.properties");if (pdfResource.exists()) {  //如果文件存在try (BufferedReader reader = new BufferedReader(new InputStreamReader(pdfResource.getInputStream(), StandardCharsets.UTF_8))) {chatFiles.load(reader);  //加载chatFiles到本地文件} catch (IOException e) {throw new RuntimeException("Failed to load chat-pdf.properties", e);}}// 加载向量存储数据FileSystemResource vectorResource = new FileSystemResource("chat-pdf.json");if (vectorResource.exists()) {SimpleVectorStore simpleVectorStore = (SimpleVectorStore) vectorStore;try {simpleVectorStore.load(vectorResource);} catch (Exception e) {throw new RuntimeException("Failed to load chat-pdf.json", e);}}}/*** 销毁方法，在 Spring 容器关闭时执行。* 持久化会话 ID 映射关系和向量存储数据到磁盘。*/@PreDestroyprivate void persistent() {try {// 持久化会话 ID 映射关系try (FileWriter writer = new FileWriter("chat-pdf.properties")) {chatFiles.store(writer, "Persisted at " + LocalDateTime.now());}// 持久化向量存储数据SimpleVectorStore simpleVectorStore = (SimpleVectorStore) vectorStore;simpleVectorStore.save(new File("chat-pdf.json"));} catch (IOException e) {throw new RuntimeException("Failed to persist data", e);}}
}

此处选择了基于内存的SimpleVectorStore，重启就会丢失向量数据。所以这里是将pdf文件与chatId的对应关系、VectorStore都持久化到了磁盘；

实际开发中，如果选择了RedisVectorStore，或者CassandraVectorStore，则无需自己持久化。但是chatId和PDF文件之间的对应关系，还是需要自己维护的。

上传文件相应结果

由于前端文件上传给后端后，后端需要返回响应结果，在ai.entity.vo中定义一个Result类：

import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
public class Result {private Integer ok;private String msg;private Result(Integer ok, String msg) {this.ok = ok;this.msg = msg;}public static Result ok() {return new Result(1, "ok");}public static Result fail(String msg) {return new Result(0, msg);}
}

文件上传下载

在ai.controller中创建一个PdfController：

@Slf4j
@RequiredArgsConstructor  //配合final实现自动注入
@RestController
@RequestMapping("/ai/pdf")
public class PdfController {private final FileRepository fileRepository;  //文件存储组件private final VectorStore vectorStore; //向量存储组件private final ChatClient pdfChatClient;  //问答模型客户端private final ChatHistoryRepository chatHistoryRepository; //会话历史记录/*** 对话*/@RequestMapping(value = "/chat", produces = "text/html;charset=utf-8")public Flux<String> chat(String prompt, String chatId) {// 1.找到会话文件Resource file = fileRepository.getFile(chatId);if (!file.exists()) {// 文件不存在，不回答throw new RuntimeException("会话文件不存在！");}// 2.保存会话idchatHistoryRepository.save("pdf", chatId);// 3.请求模型return pdfChatClient.prompt().user(prompt).advisors(a -> a.param(CHAT_MEMORY_CONVERSATION_ID_KEY, chatId)).advisors(a -> a.param(FILTER_EXPRESSION, "file_name == '" + file.getFilename() + "'")).stream().content();}/*** 文件上传*/@RequestMapping("/upload/{chatId}")public Result uploadPdf(@PathVariable String chatId, @RequestParam("file") MultipartFile file) {try {// 1. 校验文件是否为PDF格式if (!Objects.equals(file.getContentType(), "application/pdf")) {return Result.fail("只能上传PDF文件！");}// 2.保存文件boolean success = fileRepository.save(chatId, file.getResource());if (!success) {return Result.fail("保存文件失败！");}// 3.写入向量库this.writeToVectorStore(file.getResource());return Result.ok();} catch (Exception e) {log.error("Failed to upload PDF.", e);return Result.fail("上传文件失败！");}}/*** 文件下载*/@GetMapping("/file/{chatId}")public ResponseEntity<Resource> download(@PathVariable("chatId") String chatId) throws IOException {// 1.读取文件Resource resource = fileRepository.getFile(chatId);if (!resource.exists()) {return ResponseEntity.notFound().build();}// 2.文件名编码，写入响应头String filename = URLEncoder.encode(Objects.requireNonNull(resource.getFilename()), StandardCharsets.UTF_8);// 3.返回文件return ResponseEntity.ok().contentType(MediaType.APPLICATION_OCTET_STREAM).header("Content-Disposition", "attachment; filename=\"" + filename + "\"").body(resource);}/*** 写入向量库*/private void writeToVectorStore(Resource resource) {// 1.创建PDF的读取器PagePdfDocumentReader reader = new PagePdfDocumentReader(resource, // 文件源PdfDocumentReaderConfig.builder().withPageExtractedTextFormatter(ExtractedTextFormatter.defaults()).withPagesPerDocument(1) // 每1页PDF作为一个Document.build());// 2.读取PDF文档，拆分为DocumentList<Document> documents = reader.read();// 3.写入向量库vectorStore.add(documents);}
}

上传大小限制

SpringMVC有默认的文件大小限制，只有10M，很多知识库文件都会超过这个值，所以我们需要修改配置，增加文件上传允许的上限；

修改application.yaml文件，添加配置：

spring:servlet:multipart:# 单个文件的最大大小为100MBmax-file-size: 104857600# 整个请求的最大大小为100MBmax-request-size: 104857600

配置ChatClient

理论上来说，每次与AI对话的完整流程是这样的：

1. 将用户的问题利用向量大模型做向量化OpenAiEmbeddingModel；
2. 去向量数据库检索相关的文档 VectorStore；
3. 拼接提示词，发送给大模型；
4. 解析响应结果；
   
   不过，SpringAI同样基于AOP技术帮我们完成了全部流程，用的是一个名为QuestionAnswerAdvisor的Advisor。我们只需要把VectorStore配置到Advisor即可。在CommonConfiguration类中给ChatPDF也单独定义一个ChatClient：

@Bean
public ChatClient pdfChatClient(OpenAiChatModel model, ChatMemory chatMemory, VectorStore vectorStore) {return ChatClient.builder(model).defaultSystem("请根据上下文回答问题，遇到上下文没有的问题，不要随意编造。").defaultAdvisors(new SimpleLoggerAdvisor(),new MessageChatMemoryAdvisor(chatMemory),  // 会话记忆new QuestionAnswerAdvisor(  vectorStore,    // 向量库SearchRequest.builder()  // 向量检索的请求参数.similarityThreshold(0.6)   // 相似度阈值.topK(2)     // 返回的文档片段数量.build())).build();
}

也可以自己自定义RAG查询的流程，不使用Advisor，具体可参考官网

对话接口

最后，对接前端与大模型对话。修改PdfController，添加一个接口：

/*** 对话
*/
@RequestMapping(value = "/chat", produces = "text/html;charset=utf-8")
public Flux<String> chat(String prompt, String chatId) {// 1.找到会话文件Resource file = fileRepository.getFile(chatId);if (!file.exists()) {// 文件不存在，不回答throw new RuntimeException("会话文件不存在！");}// 2.保存会话idchatHistoryRepository.save("pdf", chatId);// 3.请求模型return pdfChatClient.prompt().user(prompt).advisors(a -> a.param(CHAT_MEMORY_CONVERSATION_ID_KEY, chatId)).advisors(a -> a.param(FILTER_EXPRESSION, "file_name == '" + file.getFilename() + "'")).stream().content();
}

测试

持久化VectorStore

SpringAI提供了很多持久化的VectorStore，下面以其中两个为例来介绍：

• RedisVectorStore ： 目前测试metafiled过滤有异常；
• CassandraVectorStore。

RedisVectorStore

• 需要安装一个Redis Stack，这是Redis官方提供的拓展版本，其中有向量库的功能；
• 可以使用Docker安装：

docker run -d --name redis-stack -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
#通过命令行访问
docker exec -it redis-stack redis-cli
#也可以通过浏览器访问控制台：http://localhost:8001  ip换成自己配置的

在项目中引入RedisVectorStore的依赖：

<dependency><groupId>org.springframework.ai</groupId><artifactId>spring-ai-redis-store-spring-boot-starter</artifactId>
</dependency>

在application.yml配置Redis：

spring:ai:vectorstore:redis:index: spring_ai_index # 向量库索引名initialize-schema: true # 是否初始化向量库索引结构prefix: "doc:" # 向量库key前缀data:redis:host: XXX # redis地址

接下来，无需声明bean，直接就可以直接使用VectorStore了。

CassandraVectorStore

首先，需要安装一个Cassandra访问，使用Docker安装：

docker run -d --name cas -p 9042:9042  cassandra

在项目中添加cassandra依赖：

<dependency><groupId>org.springframework.ai</groupId><artifactId>spring-ai-cassandra-store-spring-boot-starter</artifactId>
</dependency>

配置Cassandra地址：

spring:cassandra:contact-points: xxx:9042local-datacenter: datacenter1

配置VectorStore：

public CassandraVectorStore vectorStore(OpenAiEmbeddingModel embeddingModel, CqlSession cqlSession) {return CassandraVectorStore.builder(embeddingModel).session(cqlSession).addMetadataColumn(new CassandraVectorStore.SchemaColumn("file_name", DataTypes.TEXT, CassandraVectorStore.SchemaColumnTags.INDEXED)).build();
}