Spring AI实现RAG技术详解：解决大模型幻觉问题，附电商客服实战（建议收藏）

原创于 2025-12-01 14:28:55 发布 · 826 阅读

CC 4.0 BY-SA版权

文章标签：

在生成式 AI 落地企业级场景的过程中，大语言模型（LLM）的事实准确性不足、知识更新滞后等问题始终是技术痛点。检索增强生成（RAG）技术通过 “检索外部知识库 + 模型精准生成” 的链路，成为破解这一难题的核心方案。Spring AI 作为 Java 生态的 AI 开发利器，以其模块化架构、多生态兼容特性，大幅降低了 RAG 的集成门槛。

本指南基于 Spring AI 2.0 与 Spring Boot 3.2，从环境搭建、数据处理到高级组件配置，系统拆解 RAG 全流程实现逻辑。无论是基础的向量存储集成，还是复杂的混合检索优化，亦或是电商客服等实战场景落地，均提供可直接复用的代码示例与最佳实践，助力开发者快速构建高准确率、低延迟的生产级 RAG 服务。

1. 概述

检索增强生成（RAG）是一种通过检索外部数据增强大语言模型（LLM）能力的技术，可有效解决 LLM 在长文本处理、事实准确性、上下文感知方面的局限性。

Spring AI 对 RAG 提供原生支持，核心特性包括：

模块化架构：支持自定义 RAG 流程
开箱即用 API：通过 Advisor 组件快速集成
可扩展组件：覆盖检索、过滤、生成全链路
多生态兼容：支持 20 + 向量数据库与主流 LLM（如 GPT-4、文心一言）

2. 前置准备：环境搭建与数据处理

2.1 项目初始化（Spring Boot 3.2+Spring AI 2.0）

核心依赖

<!-- 基础RAG支持 -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-advisors-vector-store</artifactId>
</dependency>
<!-- Redis向量数据库集成（以Redis为例） -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-redis-spring-boot-starter</artifactId>
</dependency>
<!-- OpenAI LLM集成 -->
<dependency>
<groupId>org.springframework.ai</groupId>
<artifactId>spring-ai-openai-spring-boot-starter</artifactId>
</dependency>

配置文件（application.yml）

spring:
ai:
openai:
api-key: sk-xxx  # 替换为实际API密钥
chat:
model: gpt-4-turbo-2025
temperature: 0.0  # 查询转换建议低温度确保确定性
redis:
vector:
uri: redis://localhost:6379  # Redis向量库地址
index-name: product_knowledge  # 向量索引名称

2.2 文档加载与分块

在这里插入图片描述

支持的文档类型

Spring AI 内置DocumentLoader支持 PDF、Word、Markdown 等主流格式，核心示例：

// 加载PDF产品手册
List<Document> rawDocs = DocumentLoader.load(new File("product-manual.pdf"));
// 智能分块（避免语义割裂）
TextSplitter splitter = new TokenTextSplitter(
512,  // 块大小（Token）
64    // 重叠区（确保上下文连贯）
);
List<TextChunk> chunks = splitter.split(rawDocs);

分块策略对比

策略	配置参数	适用场景
固定长度分块	FixedTextSplitter	无明显结构的纯文本
Token 分块	TokenTextSplitter	需适配 LLM 上下文窗口
语义分块	SemanticSplitter	含段落、表格的结构化文档

2.3 向量嵌入与存储

基础实现

// 初始化嵌入模型（OpenAI）
EmbeddingModel embeddingModel = new OpenAIEmbeddingModel();
// 生成向量并附加元数据
List<VectorDocument> vectorDocs = chunks.stream()
.map(chunk -> VectorDocument.builder()
.content(chunk.getText())
.metadata(Map.of(
"product", "smartphone-X",  // 商品标识
"updateTime", "2025-10-01", // 更新时间
"type", "manual"            // 文档类型
))
.embedding(embeddingModel.embed(chunk.getText()))
.build())
.collect(Collectors.toList());
// 批量写入向量库（性能优化：千级批次插入）
VectorStore vectorStore = VectorStore.builder()
.vectorDatabase(new RedisVectorDatabase())
.build();
vectorStore.addAll(vectorDocs);

元数据设计最佳实践

必选字段：source（文档来源）、type（文档类型）、timestamp（更新时间）
业务字段：如电商场景的productId、category；知识库场景的department

3. Spring AI Advisor API 支持

3.1 QuestionAnswerAdvisor

基于向量数据库的基础 RAG 实现，自动检索相关文档并增强 prompt。

3.1.1 基本使用

需预先加载数据至VectorStore，核心示例：

// 构建QuestionAnswerAdvisor（相似度阈值0.8，返回前6条结果）
var qaAdvisor = QuestionAnswerAdvisor.builder(vectorStore)
.searchRequest(SearchRequest.builder()
.similarityThreshold(0.8d)
.topK(6)
.build())
.build();
// 执行RAG查询
ChatResponse response = ChatClient.builder(chatModel)
.build()
.prompt()
.advisors(qaAdvisor)
.user(userText)
.call()
.chatResponse();

3.1.2 动态过滤表达式

支持运行时通过FILTER_EXPRESSION参数筛选文档：

ChatClient chatClient = ChatClient.builder(chatModel)
.defaultAdvisors(QuestionAnswerAdvisor.builder(vectorStore).build())
.build();
// 运行时过滤"product == 'smartphone-X'且type == 'manual'"的文档
String content = chatClient.prompt()
.user("智能手机X的电池续航是多少？")
.advisors(a -> a.param(
QuestionAnswerAdvisor.FILTER_EXPRESSION,
"product == 'smartphone-X' AND type == 'manual'"
))
.call()
.content();

3.1.3 自定义 Prompt 模板

通过promptTemplate()自定义上下文与查询的合并逻辑（需包含必要占位符）：

// 构建自定义模板
PromptTemplate customPromptTemplate = PromptTemplate.builder()
.renderer(StTemplateRenderer.builder().startDelimiterToken('$').build())
.template("""
上下文信息如下。
---------------------
$context
---------------------
根据上下文信息且没有先验知识，回答查询。
规则：
1. 答案不在上下文中则说"不知道"
2. 避免使用"根据上下文"等表述
3. 数值类问题需附单位（如小时、mAh）
问题：$question
""")
.build();
// 应用自定义模板
QuestionAnswerAdvisor qaAdvisor = QuestionAnswerAdvisor.builder(vectorStore)
.promptTemplate(customPromptTemplate)
.build();

⚠️ 注意：userTextAdvise()方法已弃用，推荐使用promptTemplate()

3.2 RetrievalAugmentationAdvisor

模块化 RAG 实现，支持自定义检索器、查询转换器等组件，适用于复杂场景。

3.2.1 朴素 RAG 流程

基础检索 - 生成链路：

// 构建检索增强Advisor
Advisor retrievalAdvisor = RetrievalAugmentationAdvisor.builder()
.documentRetriever(VectorStoreDocumentRetriever.builder()
.similarityThreshold(0.50)
.vectorStore(vectorStore)
.build())
.build();
// 执行查询
String answer = chatClient.prompt()
.advisors(retrievalAdvisor)
.user(question)
.call()
.content();

3.2.2 空上下文配置

默认禁止空上下文回答，可通过allowEmptyContext开启：

Advisor retrievalAdvisor = RetrievalAugmentationAdvisor.builder()
.documentRetriever(VectorStoreDocumentRetriever.builder()
.similarityThreshold(0.50)
.vectorStore(vectorStore)
.build())
.queryAugmenter(ContextualQueryAugmenter.builder()
.allowEmptyContext(true) // 允许空上下文生成回答
.build())
.build();

3.2.3 高级 RAG 配置

集成查询重写、文档后处理等增强能力：

Advisor advancedAdvisor = RetrievalAugmentationAdvisor.builder()
// 查询重写转换器（优化模糊查询）
.queryTransformers(RewriteQueryTransformer.builder()
.chatClientBuilder(chatClientBuilder.build().mutate())
.build())
// 混合检索器（向量+关键词）
.documentRetriever(HybridRetriever.builder()
.vectorStore(vectorStore)
.keywordIndex(new RedisKeywordIndex())
.weight(0.7, 0.3) // 向量检索权重70%，关键词30%
.build())
// 文档后处理器（去重+排序）
.documentPostProcessors(
new DuplicateRemoverPostProcessor(), // 基于内容哈希去重
new RelevanceRankerPostProcessor(0.8) // 相关性阈值过滤
)
.build();

4. Spring AI 模块化 RAG 架构

基于论文Modular RAG实现，分为预检索、检索、后检索、生成四大模块。

4.1 预检索模块

处理用户查询以优化检索效果，核心组件包括查询转换与查询扩展。

4.1.1 查询转换

组件	功能	适用场景
CompressionQueryTransformer	压缩对话历史与查询为独立语句	长对话上下文
RewriteQueryTransformer	重写模糊 / 冗长查询	查询表述不规范
TranslationQueryTransformer	转换查询至嵌入模型支持语言	多语言查询

使用示例（RewriteQueryTransformer）：

Query query = new Query("我正在学习机器学习。什么是 LLM？");
QueryTransformer transformer = RewriteQueryTransformer.builder()
.chatClientBuilder(chatClientBuilder)
.build();
Query transformedQuery = transformer.transform(query); // 输出："什么是LLM（大语言模型）？"

⚠️ 重要：查询转换需配置低温度（如 0.0）确保结果确定性

4.1.2 查询扩展

MultiQueryExpander：生成多语义变体查询，提升检索覆盖率：

MultiQueryExpander expander = MultiQueryExpander.builder()
.chatClientBuilder(chatClientBuilder)
.numberOfQueries(3) // 生成3个变体
.includeOriginal(true) // 包含原始查询
.build();
List<Query> queries = expander.expand(new Query("如何运行 Spring Boot 应用？"));
// 输出：["如何运行Spring Boot应用？", "Spring Boot应用启动命令", "Spring Boot项目运行步骤"]

4.2 检索模块

从数据源获取相关文档，核心包含文档搜索与文档连接。

4.2.1 文档搜索

1. 向量检索（VectorStoreDocumentRetriever）

支持相似度阈值、Top-K、元数据过滤的向量检索：

// 静态过滤：仅检索童话类文档
DocumentRetriever retriever = VectorStoreDocumentRetriever.builder()
.vectorStore(vectorStore)
.similarityThreshold(0.73)
.topK(5)
.filterExpression(new FilterExpressionBuilder()
.eq("genre", "fairytale")
.build())
.build();
// 动态过滤：按租户检索
DocumentRetriever tenantRetriever = VectorStoreDocumentRetriever.builder()
.vectorStore(vectorStore)
.filterExpression(() -> new FilterExpressionBuilder()
.eq("tenant", TenantContextHolder.getTenantIdentifier())
.build())
.build();

2. 混合检索（HybridRetriever）

结合向量语义检索与关键词精确匹配，提升复杂场景准确率：

// 构建混合检索器
HybridRetriever hybridRetriever = HybridRetriever.builder()
.vectorStore(vectorStore) // 向量检索组件
.keywordIndex(new ElasticsearchKeywordIndex()) // 关键词索引
.weight(0.7, 0.3) // 权重分配
.build();
// 语义路由优化（按问题类型选择检索方式）
QueryRouter router = (query) -> {
if (query.getText().matches(".*[0-9A-Za-z]{8,16}.*")) { // 匹配商品ID
return hybridRetriever.getKeywordIndex().search(query);
} else { // 语义查询
return hybridRetriever.getVectorStore().similaritySearch(query);
}
};

📌 效果：电商场景中，语义路由使检索准确率提升 40%

4.2.2 文档连接（ConcatenationDocumentJoiner）

合并多查询 / 多数据源文档，去重并保留排序：

// 多查询结果集（如原始查询+扩展查询）
Map<String, List<Document>> documentsForQuery = new HashMap<>();
documentsForQuery.put("original", vectorStore.similaritySearch(originalQuery));
documentsForQuery.put("expanded", vectorStore.similaritySearch(expandedQuery));
// 合并去重
DocumentJoiner joiner = new ConcatenationDocumentJoiner();
List<Document> mergedDocs = joiner.join(documentsForQuery);

4.3 后检索模块

优化检索文档质量，解决上下文冗余、长度超限问题。

4.3.1 内置后处理器

处理器	功能	代码示例
DuplicateRemoverPostProcessor	基于内容哈希去重	new DuplicateRemoverPostProcessor()
RelevanceRankerPostProcessor	按相似度重新排序	new RelevanceRankerPostProcessor(0.7)
ContentCompressorPostProcessor	提取核心信息	new ContentCompressorPostProcessor(embeddingModel)

4.3.2 自定义后处理器

实现DocumentPostProcessor接口：

// 按文档更新时间过滤（仅保留30天内的文档）
public class FreshnessFilterPostProcessor implements DocumentPostProcessor {
private final Duration maxAge = Duration.ofDays(30);
@Override
public List<Document> process(List<Document> documents) {
Instant cutoff = Instant.now().minus(maxAge);
return documents.stream()
.filter(doc -> {
String updateTime = doc.getMetadata().get("updateTime");
return Instant.parse(updateTime).isAfter(cutoff);
})
.collect(Collectors.toList());
}
}
// 应用自定义后处理器
Advisor advisor = RetrievalAugmentationAdvisor.builder()
.documentRetriever(retriever)
.documentPostProcessors(new FreshnessFilterPostProcessor())
.build();

4.4 生成模块

通过查询增强组件为 LLM 提供上下文：

// 上下文增强器（支持空上下文配置）
QueryAugmenter augmenter = ContextualQueryAugmenter.builder()
.allowEmptyContext(false) // 空上下文时禁止回答
.promptTemplate(customPromptTemplate) // 自定义增强模板
.emptyContextPromptTemplate("""
无法找到相关信息，请提供更多上下文。
""") // 空上下文提示
.build();

5. 实战案例：电商客服 RAG 服务

5.1 业务场景

基于商品手册构建智能客服，支持：

商品参数查询（如续航、尺寸）
售后政策解答（如退换货条件）
操作指南咨询（如连接蓝牙）

5.2 核心实现

@Service
public class EcommerceRagService {
private final ChatClient chatClient;
// 构造函数注入依赖
public EcommerceRagService(ChatModel chatModel, VectorStore vectorStore) {
// 1. 构建混合检索器
DocumentRetriever hybridRetriever = HybridRetriever.builder()
.vectorStore(vectorStore)
.keywordIndex(new RedisKeywordIndex())
.weight(0.7, 0.3)
.build();
// 2. 配置高级Advisor
Advisor ragAdvisor = RetrievalAugmentationAdvisor.builder()
.queryTransformers(new RewriteQueryTransformer(chatClientBuilder))
.documentRetriever(hybridRetriever)
.documentPostProcessors(
new DuplicateRemoverPostProcessor(),
new FreshnessFilterPostProcessor()
)
.queryAugmenter(ContextualQueryAugmenter.builder()
.allowEmptyContext(false)
.build())
.build();
// 3. 构建ChatClient
this.chatClient = ChatClient.builder(chatModel)
.defaultAdvisors(ragAdvisor)
.build();
}
// 客服查询接口
public String answerCustomerQuery(String question, String productId) {
return chatClient.prompt()
.user(question)
.advisors(a -> a.param(
VectorStoreDocumentRetriever.FILTER_EXPRESSION,
"productId == '" + productId + "'"
))
.call()
.content();
}
}

5.3 测试效果

用户问题	检索逻辑	回答结果
“手机 X 能待机多久？”	向量检索 + productId 过滤	“智能手机 X 的待机时间为 72 小时，连续通话时长可达 15 小时。”
“12345678 的退换货政策”	关键词检索（匹配商品 ID）	“商品 12345678 支持 7 天无理由退换货，需保持包装完好且未激活。”

6. 性能优化与问题排查

6.1 性能优化策略

检索层优化

批量插入：向量数据按 1000 条 / 批次写入，减少 I/O 次数
索引优化：Redis 向量库设置合适的distance metric（如余弦相似度）
缓存机制：缓存高频查询结果（如热门商品参数）

生成层优化

上下文裁剪：通过ContentCompressorPostProcessor压缩文档内容
流式输出：启用chatClient.stream()减少响应延迟
模型选择：简单查询使用 GPT-3.5，复杂查询切换至 GPT-4

6.2 常见问题排查

问题现象	可能原因	解决方案
检索结果为空	1. 向量库无数据2. 过滤条件过严3. 相似度阈值过高	1. 检查vectorStore.addAll()执行情况2. 放宽FILTER_EXPRESSION3. 降低similarityThreshold至 0.6
回答出现幻觉	1. 上下文不足2. Prompt 模板无约束	1. 增大topK至 82. 模板添加 “严格基于上下文” 约束
响应延迟高	1. 检索未命中索引2. 文档块过大	1. 重建向量索引2. 减小分块大小至 256 Token

7. 结语

至此，我们已完成 Spring AI 实现 RAG 的全链路指南梳理 —— 从文档分块、向量嵌入的前置准备，到 Advisor 组件的灵活配置，再到模块化架构的深度优化，每个环节均围绕 “实用性” 与 “可扩展性” 展开。电商客服案例的落地实践验证了技术方案的业务价值，而性能优化与问题排查技巧则为服务稳定运行提供保障。

RAG 技术正朝着多模态检索、自优化架构等方向演进（如校正型 RAG、Fast GraphRAG 等），建议结合文末参考链接深入探索 Spring AI 官方组件生态，尝试集成知识图谱、本地开源 LLM 等扩展能力。期待这份指南能成为您落地 AI 应用的起点，在实际开发中不断打磨检索精度与生成质量，让 RAG 技术真正赋能业务增长。