Spring Boot 整合 Spring AI 与 Milvus 基础教程
目录
项目介绍
本项目是一个基于 Spring Boot 3.5.9、Spring AI 1.1.2 和 Milvus 的 RAG（检索增强生成）系统。主要功能包括：
- 📝 文档管理：支持单个和批量添加文档到向量数据库
- 🔍 向量检索：基于语义相似度的文档搜索
- 🤖 RAG 生成：结合向量检索和大语言模型的智能问答
技术栈
- Spring Boot: 3.5.9
- Spring AI: 1.1.2
- Milvus: 向量数据库
- DashScope（阿里千问）: Embedding 模型和 Chat 模型
- Java: 17+
核心概念
- 向量（Embedding）：将文本转换为数值向量，用于语义相似度计算
- 向量数据库（Milvus）：存储和检索高维向量数据
- RAG（Retrieval-Augmented Generation）：检索增强生成，结合知识库检索和 LLM 生成
环境准备
1. 基础环境
- JDK: 17 或更高版本
- Maven: 3.6+
- Milvus: 2.6+（可通过 Docker 部署）
2. Milvus 安装（Docker 方式）
curl -sfL https://raw.githubusercontent.com/milvus-io/milvus/master/scripts/standalone_embed.sh -o standalone_embed.sh
增加可执行权限并运行脚本
chmod +x standalone_embed.sh && bash standalone_embed.sh start
3. Attu 管理工具安装（可选但推荐）
Attu 是 Milvus 的官方可视化管理工具，可以方便地管理集合、查看数据、执行查询等操作。
3.1 Docker 方式安装 Attu
# 拉取 Attu 镜像
docker pull zilliz/attu:latest
# 启动 Attu（连接到 Milvus）
docker run -d \
--name attu \
-p 8000:3000 \
-e MILVUS_URL=172.30.34.12:19530 \
zilliz/attu:latest
参数说明:
-p 8000:3000: 将 Attu 的 Web 界面映射到本地 8000 端口-e MILVUS_URL: Milvus 服务器地址和端口（根据实际情况修改）
3.2 访问 Attu
安装完成后，在浏览器中访问：
http://172.30.34.12:8000
首次访问需要：
- 输入 Milvus 服务器地址（如：
172.30.34.12:19530） - 如果 Milvus 启用了认证，输入用户名和密码【默认root/123456】
- 点击连接
3.3 Attu 主要功能
- 集合管理: 创建、删除、查看集合信息
- 数据浏览: 查看集合中的数据，包括文档内容、元数据、向量等
- 数据查询: 执行向量相似度搜索
- 索引管理: 查看和管理向量索引
- 统计信息: 查看集合的统计信息（文档数量、索引状态等）
4. 获取 DashScope API Key
访问 阿里云 DashScope 控制台 获取 API Key。
项目搭建
1. 创建 Spring Boot 项目
使用 Spring Initializr 创建项目，或直接使用本项目。请参考项目代码
2. 添加依赖
在 pom.xml 中添加以下依赖：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.5.9</version>
</parent>
<groupId>com.jianjang.rag.milvus</groupId>
<artifactId>springboot-rag-milvus</artifactId>
<version>1.0.0</version>
<properties>
<java.version>17</java.version>
<spring-ai.version>1.1.2</spring-ai.version>
<spring-ai-alibaba.version>1.1.0.0-RC2</spring-ai-alibaba.version>
</properties>
<dependencyManagement>
<dependencies>
<!-- Spring AI BOM -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-bom</artifactId>
<version>${spring-ai.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- Spring AI Alibaba BOM -->
<dependency>
<groupId>com.alibaba.cloud.ai</groupId>
<artifactId>spring-ai-alibaba-bom</artifactId>
<version>${spring-ai-alibaba.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- Spring Boot Web -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- Spring AI Milvus Vector Store -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-starter-vector-store-milvus</artifactId>
</dependency>
<!-- Spring AI DashScope (阿里千问) -->
<dependency>
<groupId>com.alibaba.cloud.ai</groupId>
<artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
</dependency>
<!-- Lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
</project>
3. 项目结构
src/main/java/com/jianjang/rag/milvus/
├── controller/
│ └── RagController.java # REST API 控制器
├── service/
│ └── RagService.java # RAG 核心服务
├── dto/
│ ├── DocumentRequest.java # 文档请求 DTO
│ ├── RagRequestDto.java # RAG 请求 DTO
│ ├── RagResponse.java # RAG 响应 DTO
│ ├── SearchRequestDto.java # 搜索请求 DTO
│ └── SearchResponse.java # 搜索响应 DTO
└── SpringbootRagMilvusApplication.java
核心配置
1. application.yml 配置
spring:
application:
name: springboot-rag-milvus
# Milvus 配置
ai:
vectorstore:
milvus:
client:
host: 172.30.34.12 # Milvus 服务器地址
port: 19530 # Milvus 端口
username: root # 用户名（可选）
password: 123456 # 密码（可选）
database-name: default # 数据库名称
collection-name: vector_store # 集合名称
embedding-dimension: 1536 # 向量维度（与 Embedding 模型一致）
index-type: IVF_FLAT # 索引类型
metric-type: COSINE # 相似度度量方式（余弦相似度）
id-field-name: id # ID 字段名
# DashScope 配置（阿里千问）
dashscope:
api-key: ${AI_DASHSCOPE_API_KEY:your-api-key} # API Key（建议使用环境变量）
embedding:
options:
model: text-embedding-v2 # Embedding 模型
chat:
options:
model: qwen-turbo # Chat 模型
temperature: 0.7 # 温度参数
topP: 0.8 # Top-P 参数
2. 配置说明
Milvus 配置
- host/port: Milvus 服务器地址和端口
- embedding-dimension: 向量维度，必须与 Embedding 模型输出的维度一致（阿里
text-embedding-v2为 1536） - index-type: 索引类型，
IVF_FLAT适合中小规模数据 - metric-type: 相似度度量方式，
COSINE表示余弦相似度 - id-field-name: ID 字段名，必须与集合创建时的字段名一致
DashScope 配置
- api-key: 从阿里云 DashScope 控制台获取
- embedding.model: Embedding 模型，用于将文本转换为向量
- chat.model: Chat 模型，用于生成回答
3. 环境变量配置（推荐）
在系统环境变量或 .env 文件中设置：
export AI_DASHSCOPE_API_KEY=your-actual-api-key
核心代码解析
1. RagService - 核心服务类
RagService 是 RAG 系统的核心，负责文档管理和向量检索。
1.1 依赖注入
@Service
public class RagService {
private final VectorStore vectorStore; // Milvus 向量存储
private final EmbeddingModel embeddingModel; // Embedding 模型
private final ChatModel chatModel; // Chat 模型
public RagService(VectorStore vectorStore,
EmbeddingModel embeddingModel,
ChatModel chatModel) {
this.vectorStore = vectorStore;
this.embeddingModel = embeddingModel;
this.chatModel = chatModel;
}
}
Spring AI 会自动注入这些 Bean，无需手动配置。
1.2 创建 Milvus 集合
public boolean createCollection(String collectionName,
String databaseName,
boolean dropIfExists) {
// 1. 获取 Milvus 原生客户端
MilvusServiceClient milvusClient =
(MilvusServiceClient) vectorStore.getNativeClient()
.orElseThrow(() -> new IllegalStateException("Milvus client is not available"));
// 2. 检查集合是否存在
// 3. 定义集合 Schema（包含 id、content、metadata、embedding 字段）
// 4. 创建集合
// 5. 创建索引（IVF_FLAT，COSINE 相似度）
}
重要提示：
- 集合中的
id字段名必须与配置文件中的id-field-name一致 - 向量字段
embedding的维度必须与embedding-dimension一致（1536）
1.3 添加文档
public void addDocument(String content, Map<String, Object> metadataMap) {
// 1. 生成文档 ID
String documentId = UUID.randomUUID().toString();
// 2. 【关键】使用 EmbeddingModel 将文档内容转换为向量
float[] embeddingArray = embeddingModel.embed(content);
// 3. 验证向量维度（必须是 1536）
if (embeddingArray.length != 1536) {
throw new IllegalArgumentException("向量维度不匹配");
}
// 4. 转换为 List<Float>（Milvus 需要）
List<Float> embeddingVector = Arrays.stream(embeddingArray)
.boxed()
.collect(Collectors.toList());
// 5. 插入到 Milvus（包含 id、content、metadata、embedding）
// ...
}
向量生成流程：
- 调用
embeddingModel.embed(content)将文本转换为 1536 维向量 - 向量代表文档的语义信息，相似的文档会有相似的向量
- 向量存储到 Milvus 的
embedding字段，用于后续相似度搜索
1.4 相似度搜索
public List<Document> similaritySearch(String query, int topK) {
// 【关键】调用 vectorStore.similaritySearch(query)
// 内部会自动：
// 1. 将 query 文本转换为向量（使用 EmbeddingModel）
// 2. 在 Milvus 中使用该向量与存储的文档向量进行余弦相似度计算
// 3. 返回相似度最高的 topK 个文档
List<Document> results = vectorStore.similaritySearch(query);
return results.stream()
.limit(topK)
.collect(Collectors.toList());
}
向量检索流程：
- 查询文本 → 向量：
embeddingModel.embed(query)转换为 1536 维向量 - 向量搜索：在 Milvus 中使用查询向量与文档向量进行余弦相似度计算
- 结果排序：按相似度从高到低排序，返回最相似的文档
- 核心代码如下图【代码：org.springframework.ai.vectorstore.milvus.MilvusVectorStore#doSimilaritySearch】
1.5 RAG 检索增强生成
public RagResult ragSearch(String query, int topK,
Double similarityThreshold,
Map<String, Object> metadataFilter) {
// 步骤1: 从 Milvus 中检索相关文档（知识召回）
List<Document> retrievedDocuments = similaritySearch(query, topK);
// 步骤2: 构建上下文 prompt
StringBuilder contextBuilder = new StringBuilder();
contextBuilder.append("基于以下知识库内容回答问题：\n\n");
for (Document doc : retrievedDocuments) {
contextBuilder.append(doc.getText()).append("\n\n");
}
String promptText = contextBuilder.toString() +
"问题：" + query + "\n\n" +
"请根据上述知识库内容回答问题。";
// 步骤3: 使用 ChatModel 生成回答
Prompt prompt = new Prompt(new UserMessage(promptText));
ChatResponse response = chatModel.call(prompt);
String answer = response.getResult().getOutput().getText();
return new RagResult(query, answer, retrievedDocuments);
}
RAG 流程：
- 检索（Retrieval）：从 Milvus 中检索与查询相关的文档
- 增强（Augmentation）：将检索到的文档作为上下文
- 生成（Generation）：使用 LLM 基于上下文生成回答
2. RagController - REST API 控制器
@RestController
@RequestMapping("/api/rag")
public class RagController {
private final RagService ragService;
// 添加单个文档
@PostMapping("/documents")
public ResponseEntity<Map<String, String>> addDocument(
@RequestBody DocumentRequest request) {
ragService.addDocument(request.getContent(), request.getMetadata());
return ResponseEntity.ok(Map.of("message", "文档添加成功"));
}
// 相似度搜索
@PostMapping("/search")
public ResponseEntity<SearchResponse> search(
@RequestBody SearchRequestDto request) {
List<Document> documents = ragService.similaritySearch(
request.getQuery(), request.getTopK());
// 构建响应...
}
// RAG 检索增强生成
@PostMapping("/rag")
public ResponseEntity<RagResponse> rag(
@RequestBody RagRequestDto request) {
RagService.RagResult result = ragService.ragSearch(
request.getQuery(), request.getTopK(),
request.getSimilarityThreshold(),
request.getMetadataFilter());
// 构建响应...
}
}
使用示例
1. 启动应用
# 确保 Milvus 已启动
docker ps | grep milvus
# 启动 Spring Boot 应用
mvn spring-boot:run
2. 创建 Milvus 集合
首次使用需要创建集合：
curl http://localhost:8080/api/rag/create-collection
3. 使用 Attu 管理工具
3.1 查看集合信息
- 打开浏览器访问
http://172.30.34.12:8000 - 连接到 Milvus 服务器（输入地址：
172.30.34.12:19530） - 在左侧导航栏选择 Collections
- 可以看到集合列表，包括：
- 集合名称（如：
vector_store） - 文档数量
- 索引状态
- 向量维度（1536）
- 集合名称（如：
3.2 查看集合 Schema
点击集合名称进入详情页，可以查看：
- Fields: 字段信息
id: 文档 ID（VarChar 类型，主键）content: 文档内容（VarChar 类型）metadata: 元数据（JSON 类型）embedding: 向量字段（FloatVector 类型，1536 维）
- Indexes: 索引信息
- 向量字段的索引类型（IVF_FLAT）
- 相似度度量方式（COSINE）
- Statistics: 统计信息
- 文档总数
- 索引状态
3.3 浏览数据
- 在集合详情页，点击 Data 标签
- 可以查看集合中的所有文档，包括：
- 文档 ID
- 文档内容（content 字段）
- 元数据（metadata 字段，JSON 格式）
- 向量（embedding 字段，显示为数组）
注意: 向量数据通常很长（1536 维），Attu 会以数组形式显示，可以展开查看。
3.4 执行向量搜索
在 Attu 中可以手动执行向量相似度搜索：
- 在集合详情页，点击 Search 标签
- 选择搜索方式：
- Vector Search: 使用向量进行相似度搜索
- Expression Search: 使用表达式进行过滤
- 对于向量搜索：
- 需要提供一个查询向量（1536 维）
- 设置
topK值（返回最相似的前 K 个结果） - 选择相似度度量方式（COSINE）
- 点击 Search 执行搜索
- 查看搜索结果，包括：
- 文档内容
- 元数据
- 相似度分数
提示: 在实际使用中，通常通过 API 接口进行搜索，因为 API 会自动将查询文本转换为向量。
3.5 验证数据
添加文档后，可以在 Attu 中验证：
- 添加文档后，刷新 Attu 页面
- 查看集合的统计信息，确认文档数量增加
- 在 Data 标签中查看新添加的文档
- 检查文档内容、元数据和向量是否正确存储
3.6 常见操作
- 删除集合: 在集合列表中，点击集合右侧的删除按钮（谨慎操作）
- 清空数据: 在集合详情页，可以删除特定文档
- 导出数据: 可以将集合数据导出为 JSON 格式
- 查看索引: 在 Indexes 标签中查看索引状态和参数
4. 添加文档
单个文档
curl -X POST http://localhost:8080/api/rag/documents \
-H "Content-Type: application/json" \
-d '{
"content": "Spring AI 是一个强大的框架，用于构建 AI 应用程序。它提供了与各种 AI 模型和向量数据库的集成。",
"metadata": {
"category": "技术文档",
"author": "张三",
"date": "2024-01-15",
"tags": ["AI", "Spring", "框架"]
}
}'
响应:
{
"message": "文档添加成功"
}
批量添加文档
curl -X POST http://localhost:8080/api/rag/documents/batch \
-H "Content-Type: application/json" \
-d '[
{
"content": "Milvus 是一个开源的向量数据库，专为 AI 应用设计。",
"metadata": {
"category": "数据库",
"type": "向量数据库"
}
},
{
"content": "向量相似度搜索是 RAG 系统的核心功能之一。",
"metadata": {
"category": "AI",
"type": "技术概念"
}
},
{
"content": "Spring Boot 简化了 Java 应用的开发过程。",
"metadata": {
"category": "框架",
"type": "开发框架"
}
}
]'
响应:
{
"message": "批量文档添加成功，共 3 条"
}
5. 相似度搜索
基础搜索
curl -X POST http://localhost:8080/api/rag/search \
-H "Content-Type: application/json" \
-d '{
"query": "什么是向量数据库？",
"topK": 5
}'
响应:
{
"query": "什么是向量数据库？",
"count": 3,
"results": [
{
"content": "Milvus 是一个开源的向量数据库，专为 AI 应用设计。",
"metadata": {
"category": "数据库",
"type": "向量数据库"
}
},
{
"content": "向量相似度搜索是 RAG 系统的核心功能之一。",
"metadata": {
"category": "AI",
"type": "技术概念"
}
}
]
}
带相似度阈值和元数据过滤的搜索
curl -X POST http://localhost:8080/api/rag/search \
-H "Content-Type: application/json" \
-d '{
"query": "Spring 框架",
"topK": 5,
"similarityThreshold": 0.7,
"metadataFilter": {
"category": "框架"
}
}'
6. RAG 检索增强生成
curl -X POST http://localhost:8080/api/rag/rag \
-H "Content-Type: application/json" \
-d '{
"query": "什么是向量数据库？它有什么用途？",
"topK": 5
}'
响应:
{
"query": "什么是向量数据库？它有什么用途？",
"answer": "向量数据库是一种专门用于存储和检索高维向量数据的数据库系统...",
"retrievedCount": 3,
"retrievedContexts": [
{
"content": "Milvus 是一个开源的向量数据库，专为 AI 应用设计。",
"metadata": {
"category": "数据库",
"type": "向量数据库"
}
},
{
"content": "向量相似度搜索是 RAG 系统的核心功能之一。",
"metadata": {
"category": "AI",
"type": "技术概念"
}
}
]
}
7. 健康检查
curl -X GET http://localhost:8080/api/rag/health
响应:
{
"status": "UP",
"message": "RAG服务运行正常"
}
常见问题
1. 向量维度不匹配
问题: 报错 "向量维度不匹配: 期望 1536，实际 xxx"
原因:
- Embedding 模型输出的向量维度与配置中的
embedding-dimension不一致 - 阿里
text-embedding-v2模型输出 1536 维向量
解决方案:
- 确保配置中的
embedding-dimension: 1536 - 确保使用的 Embedding 模型是
text-embedding-v2
2. ID 字段名不匹配
问题: 报错 "The field: id is not provided"
原因:
- 集合中的
id字段名与配置文件中的id-field-name不一致 - Spring AI 的 MilvusVectorStore 无法识别 ID 字段
解决方案:
- 确保配置中的
id-field-name: id与集合创建时的字段名一致 - 如果使用默认值，集合中的字段名应该是
doc_id
3. Milvus 连接失败
问题: 无法连接到 Milvus 服务器
原因:
- Milvus 服务未启动
- 网络连接问题
- 配置的 host/port 不正确
解决方案:
# 检查 Milvus 是否运行
docker ps | grep milvus
# 检查 Milvus 端口是否开放
telnet 172.30.34.12 19530
# 检查配置文件中的 host 和 port
4. Embedding 模型调用失败
问题: Embedding 模型返回空向量或调用失败
原因:
- API Key 未配置或无效
- 网络问题导致无法访问 DashScope API
- API 配额已用完
解决方案:
- 检查环境变量
AI_DASHSCOPE_API_KEY是否正确设置 - 访问 DashScope 控制台 检查 API Key 状态
- 检查网络连接和防火墙设置
5. 搜索结果为空
问题: 搜索时返回空结果
原因:
- 向量数据库中还没有文档
- 查询文本与文档内容语义差异太大
- 相似度阈值设置过高
解决方案:
- 确保已添加文档到向量数据库
- 尝试降低
similarityThreshold值 - 检查查询文本是否与文档内容相关
6. RAG 回答质量不佳
问题: RAG 生成的回答不准确或不相关
原因:
- 检索到的文档与查询不相关
- 检索的文档数量（topK）太少
- Prompt 构建不合理
解决方案:
- 增加
topK值，检索更多相关文档 - 优化文档内容，确保文档质量
- 调整 Prompt 模板，提供更清晰的指令
7. 批量添加文档性能问题
问题: 批量添加文档时速度慢或超时
原因:
- 单次批量添加的文档数量过多
- Embedding 模型调用频率过高
- 网络延迟
解决方案:
- 建议每批不超过 100 条文档
- 可以分批添加，每批之间稍作延迟
- 考虑使用异步处理
8. Attu 连接问题
问题: Attu 无法连接到 Milvus 服务器
原因:
- Milvus 服务器地址配置错误
- 网络连接问题
- Milvus 服务未启动
- 端口被防火墙阻止
解决方案:
# 1. 检查 Milvus 是否运行
docker ps | grep milvus
# 2. 检查 Milvus 端口是否可访问
telnet 172.30.34.12 19530
# 3. 检查 Attu 容器日志
docker logs attu
# 4. 确认 Attu 启动时的 MILVUS_URL 环境变量正确
docker inspect attu | grep MILVUS_URL
# 5. 如果 Milvus 在远程服务器，确保防火墙开放 19530 端口
9. Attu 中看不到数据
问题: 通过 API 添加了文档，但在 Attu 中看不到
原因:
- 数据还未刷新到磁盘（需要 flush）
- 查看的集合名称不正确
- 数据插入失败但未报错
解决方案:
- 在 Attu 中点击集合，然后点击 Refresh 按钮刷新数据
- 确认查看的集合名称与配置中的
collection-name一致（默认是vector_store） - 检查 API 返回的响应，确认文档添加成功
- 在 Attu 的 Statistics 标签中查看文档数量
10. Attu 中向量显示问题
问题: 在 Attu 中查看向量数据时显示异常或无法查看
原因:
- 向量维度太大（1536 维），Attu 可能无法完整显示
- 浏览器性能问题
- 数据格式问题
解决方案:
- 向量数据通常很长，Attu 会以数组形式显示，可以展开查看前几个值
- 如果不需要查看完整向量，可以只查看文档内容和元数据
- 使用 API 接口查询时，向量数据不会返回，只返回文档内容和元数据
最佳实践
1. 文档预处理
- 分块: 将长文档分割成较小的块（建议 200-500 字），提高检索精度
- 去重: 避免添加重复的文档内容
- 清理: 移除无关的格式和特殊字符
2. 元数据设计
- 结构化: 使用结构化的元数据，便于后续过滤和检索
- 一致性: 保持元数据字段名和值的一致性
- 丰富性: 添加足够的元数据信息（如分类、标签、作者等）
3. 检索优化
- topK 选择: 根据场景选择合适的 topK 值（通常 5-10）
- 相似度阈值: 设置合理的相似度阈值，过滤低质量结果
- 元数据过滤: 使用元数据过滤缩小搜索范围
4. RAG Prompt 优化
- 上下文组织: 合理组织检索到的文档上下文
- 指令清晰: 在 Prompt 中提供清晰的指令和格式要求
- 长度控制: 控制 Prompt 总长度，避免超出模型限制
5. 性能优化
- 批量操作: 使用批量接口添加文档，提高效率
- 索引优化: 根据数据规模选择合适的索引类型
- 缓存策略: 对频繁查询的结果进行缓存
6. 使用 Attu 进行数据管理
- 定期检查: 使用 Attu 定期检查集合状态和文档数量
- 数据验证: 添加文档后，在 Attu 中验证数据是否正确存储
- 索引监控: 在 Attu 中查看索引状态，确保索引已正确创建
- 元数据检查: 使用 Attu 查看元数据格式，确保符合预期
- 性能监控: 通过 Attu 的统计信息监控集合的健康状态
- 调试工具: 当 API 查询结果异常时，使用 Attu 手动执行搜索进行对比验证
总结
本教程介绍了如何使用 Spring Boot、Spring AI 和 Milvus 构建一个完整的 RAG 系统。核心要点包括：
- 向量生成: 使用 EmbeddingModel 将文本转换为向量
- 向量存储: 将向量存储到 Milvus 向量数据库
- 向量检索: 使用向量相似度搜索相关文档
- RAG 生成: 结合检索结果和 LLM 生成回答
通过本教程，你应该能够：
- ✅ 搭建完整的 RAG 系统环境
- ✅ 理解向量在 RAG 系统中的作用
- ✅ 使用 Spring AI 进行文档管理和向量检索
- ✅ 实现完整的 RAG 检索增强生成流程
