企业级智能体系统 RAG的分片优化逻辑
失踪人口回归,这段时间很忙,不仅是在做项目优化还得探索所谓的口播自动化编程,后面可以跟大家一起交流。
分片优化
最简单有效非demo的手段
云厂商永远是你值得信赖的伙伴,花点钱可以解决的问题没必要写代码。
本期优化
使用策略模式 实现了三种方式,固定窗口,语义,命题三种策略。在实际的开发过程中可以参考并延伸。
bootstrap/rag/chunking/ChunkingStrategyType.java | ||
bootstrap/rag/chunking/ChunkingStrategy.java | ||
bootstrap/rag/chunking/ChunkingStrategyFactory.java | ||
bootstrap/rag/chunking/ChunkingRequest.java | ||
bootstrap/rag/chunking/ChunkingResult.java | ||
bootstrap/rag/chunking/DocumentChunk.java | ||
bootstrap/rag/chunking/impl/SlidingWindowChunkingStrategy.java | ||
bootstrap/rag/chunking/impl/SemanticChunkingStrategy.java | ||
bootstrap/rag/chunking/impl/PropositionChunkingStrategy.java | ||
bootstrap/rag/chunking/MultimodalChunkBuilder.java | ||
bootstrap/admin/service/ChunkingService.java | ||
bootstrap/admin/service/DocumentProcessingJobService.java | ||
bootstrap/admin/controller/KnowledgeController.java |
1. 为什么需要分片优化
在 RAG(Retrieval-Augmented Generation)系统中,文档分片是影响检索质量的第一道关卡。分片质量直接决定了:
召回率:分片太粗,关键信息被淹没在噪音中;分片太细,上下文丢失 精确度:分片边界不当,跨边界的信息在检索时可能遗漏 语义完整性:理想情况下,每个分片应该是一个语义自洽的单元
传统固定切分的问题
最简单的做法是按固定字符数切割,但会带来严重问题:
原文:"...2024年公司营收达到50亿元。其中,|华东区域贡献了32%的份额,华|南区域贡献了28%..."
↑ 粗暴切割点 ↑
切割后,"华东区域贡献了32%的份额" 被拆成两半,检索 "华东区域营收占比" 时无法精准命中。
本项目的优化思路
本项目实现了三种由粗到细的分片策略:
| SLIDING_WINDOW | |||
| SEMANTIC | |||
| PROPOSITION |
2. 整体架构设计
2.1 类图总览
┌──────────────────────┐
│ ChunkingStrategy │ ◄── 策略接口
│──────────────────────│
│ + type() │
│ + chunk(request) │
│ + validate(config) │
│ + getDefaultConfig() │
│ + getVersion() │
└──────────┬───────────┘
│ implements
┌────────────────┼────────────────┐
│ │ │
┌──────────▼─────┐ ┌───────▼──────┐ ┌──────▼────────┐
│ SlidingWindow │ │ Semantic │ │ Proposition │
│ ChunkingStrat. │ │ ChunkingStr.│ │ ChunkingStr. │
└────────────────┘ └──────────────┘ └───────────────┘
┌──────────────────────┐
│ ChunkingStrategyFactory │ ◄── 策略工厂
│──────────────────────│
│ - strategyMap │
│ + getStrategy(type) │
│ + listStrategies() │
│ + validateConfig() │
└──────────┬───────────┘
│ used by
┌──────────▼───────────┐
│ ChunkingService │ ◄── 业务服务层
│──────────────────────│
│ + chunk() │
│ + preview() │
│ + validateConfig() │
│ + listStrategies() │
└──────────────────────┘
2.2 设计模式:策略模式 + 工厂模式
本模块采用 策略模式(Strategy Pattern) 定义算法族,用 工厂模式(Factory Pattern) 管理策略注册与获取。
关键设计决策:
Spring 自动注册:所有 ChunkingStrategy实现类标注@Component,Spring 自动注入List,工厂在构造时自动完成注册配置驱动:每种策略的参数通过 Map传入,支持灵活配置策略降级:PROPOSITION 策略在 ChatModel 不可用时自动降级为 SLIDING_WINDOW 版本追踪:每个策略有版本号,生成的 chunk 携带 strategyVersion,便于后续升级迁移
3. 核心数据模型
3.1 ChunkingRequest — 分块请求
文件:
com.isy.rag.bootstrap.rag.chunking.ChunkingRequest
@Data
@Builder
public class ChunkingRequest {
private String content; // 文档文本内容
private ChunkingStrategyType strategyType; // 分块策略枚举
private Map// 策略专属配置
// 类型安全的配置读取方法
public T getConfigValue(String key, Class;
}
设计亮点 — getConfigValue 方法:
该方法实现了类型安全的配置读取,支持:
自动 Number 子类转换(Integer/Long/Double/Float) String 类型自动转换 Boolean 类型智能解析 默认值兜底
这意味着前端传入的 JSON 数值(如 500 可能被 Jackson 解析为 Integer 或 Long)都能被正确处理。
3.2 DocumentChunk — 文档分块
文件:
com.isy.rag.bootstrap.rag.chunking.DocumentChunk
@Data
@Builder
public class DocumentChunk {
// ===== 基础字段 =====
private String content; // 分块内容
private int index; // 分块索引
private int charCount; // 字符数
private Integer tokenCount; // token数(估算)
private Integer startOffset; // 原文起始偏移
private Integer endOffset; // 原文结束偏移
private String chunkType; // TEXT / PROPOSITION / SEMANTIC_SEGMENT / IMAGE / TABLE_IMAGE
private String strategyVersion; // 策略版本
private Map// 策略专属元数据
// ===== 多模态扩展字段 =====
private List// 关联资产ID列表
private Integer blockIndex; // 文档内顺序索引(多模态混合排序用)
private String sectionTitle; // 所属章节标题
private Integer pageNum; // 页码
private String pipelineStatus; // 管线状态
}
chunkType 枚举值说明:
TEXT | ||
SEMANTIC_SEGMENT | ||
PROPOSITION | ||
IMAGE | ||
TABLE_IMAGE |
metadata 策略专属字段:
// SEMANTIC 策略 metadata 示例
{
"breakpointType": "percentile",
"boundaryScore": 0.35, // 断点处的相似度
"mergedFromSmallChunks": true // 是否由小chunk合并而来
}
// PROPOSITION 策略 metadata 示例
{
"propositionRange": "3-7", // 命题索引范围
"propositionCount": 5 // 包含的命题数量
}
3.3 ChunkingResult — 分块结果
@Data
public class ChunkingResult {
private List// 分块文档列表
private ChunkingStrategyType strategyType; // 使用的策略类型
private String strategyVersion; // 策略版本
private long durationMs; // 处理耗时(毫秒)
private int totalChars; // 原始文档总字符数
private Map// 额外元数据
}
3.4 ChunkingStrategyType — 策略类型枚举
public enum ChunkingStrategyType {
SLIDING_WINDOW("SLIDING_WINDOW", "滑动窗口切分", "固定窗口+重叠区域,确保跨边界信息不丢失"),
SEMANTIC("SEMANTIC", "语义切分", "按语义边界切分,用嵌入向量相似度下降点作为切分边界"),
PROPOSITION("PROPOSITION", "命题切分", "用LLM将文档拆解为原子级命题,每个命题是独立可验证的事实陈述");
// fromCode() 方法:code 为 null 或无效时默认返回 SLIDING_WINDOW
}
4. 策略模式详解
4.1 ChunkingStrategy 接口
文件:
com.isy.rag.bootstrap.rag.chunking.ChunkingStrategy
public interface ChunkingStrategy {
ChunkingStrategyType type(); // 策略类型标识
ChunkingResult chunk(ChunkingRequest request); // 执行分块(核心方法)
void validate(Map; // 校验配置参数
MapgetDefaultConfig(); // 获取默认配置
default String getVersion() { return "v1"; } // 策略版本号
}
接口设计原则:
type()用于工厂注册和查找,每个实现类返回唯一标识validate()在执行分块前校验参数,防止运行时异常getDefaultConfig()让前端可以展示推荐配置,降低使用门槛getVersion()默认返回"v1",策略升级时覆写
4.2 ChunkingStrategyFactory — 策略工厂
文件:
com.isy.rag.bootstrap.rag.chunking.ChunkingStrategyFactory
@Slf4j
@Component
public class ChunkingStrategyFactory {
private final Mapnew HashMap<>();
// Spring 自动注入所有 ChunkingStrategy 实现类
public ChunkingStrategyFactory(List {
for (ChunkingStrategy strategy : strategies) {
strategyMap.put(strategy.type(), strategy);
log.info("注册分块策略: {} - {}", strategy.type().getCode(), strategy.type().getName());
}
}
public ChunkingStrategy getStrategy(ChunkingStrategyType type) { ... }
public ChunkingStrategy getStrategy(String strategyCode) { ... }
public List
public void validateConfig(String strategyCode, Map { ... }
public boolean hasStrategy(ChunkingStrategyType type) { ... }
}
自动注册机制:
Spring 容器启动时,SlidingWindowChunkingStrategy、SemanticChunkingStrategy、PropositionChunkingStrategy 三者都标注了 @Component,Spring 自动收集到 List 中注入给工厂。工厂在构造函数中遍历并注册到 strategyMap。
好处:新增策略只需实现接口并加 @Component,零修改工厂代码即可自动注册。
4.3 ChunkingService — 业务服务层
文件:
com.isy.rag.bootstrap.admin.service.ChunkingService
@Slf4j
@Service
@RequiredArgsConstructor
public class ChunkingService {
private final ChunkingStrategyFactory chunkingStrategyFactory;
public ChunkingResult chunk(String content, String strategyCode, String configJson) {
ChunkingStrategyType strategyType = ChunkingStrategyType.fromCode(strategyCode);
ChunkingStrategy strategy = chunkingStrategyFactory.getStrategy(strategyType);
Map
strategy.validate(config); // 先校验
ChunkingRequest request = ChunkingRequest.builder()
.content(content).strategyType(strategyType).config(config).build();
return strategy.chunk(request); // 再执行
}
public ChunkingResult preview(String content, String strategyCode, String configJson) {
return chunk(content, strategyCode, configJson); // 预览与正式分块逻辑相同
}
}
调用链路:
Controller → ChunkingService.chunk() → Factory.getStrategy() → Strategy.chunk()
↓
parseConfig() (JSON → Map)
↓
Strategy.validate()
5. 三种分片策略深度剖析
5.1 滑动窗口切分(SLIDING_WINDOW)
文件:
com.isy.rag.bootstrap.rag.chunking.impl.SlidingWindowChunkingStrategy
5.1.1 核心思想
文档: [AAAAAA|BBBBBB|CCCCCC|DDDDDD|EEEEEE]
固定窗口无重叠:
Chunk 0: [AAAAAA]
Chunk 1: [BBBBBB] ← 边界处信息可能丢失
Chunk 2: [CCCCCC]
滑动窗口有重叠(overlap=2):
Chunk 0: [AAAAAA]
Chunk 1: [AABBBBBB] ← 重叠区保留跨边界信息
Chunk 2: [BBCCCCCC]
Chunk 3: [CCDDDDDD]
5.1.2 两种子模式
模式一:段落感知(paragraphAware=true,默认)
private ListsplitByParagraph(String content, int chunkSize, int overlap, int minChunkSize) {
String[] paragraphs = content.split("\n\n+"); // 按双换行分割段落
StringBuilder currentChunk = new StringBuilder();
for (String paragraph : paragraphs) {
// 如果加入当前段落会超过 chunkSize → 先保存当前块
if (currentChunk.length() + paragraph.length() > chunkSize && currentChunk.length() > 0) {
// 保存 & 处理重叠部分
String overlapText = currentChunk.substring(currentChunk.length() - overlap);
currentChunk = new StringBuilder(overlapText);
}
currentChunk.append(paragraph).append("\n\n");
// 超长段落强制分割
if (currentChunk.length() > chunkSize * 1.5) {
// 按 chunkSize - overlap 步长强制切分
}
}
}
关键逻辑解析:
段落边界优先:只在段落之间切分,不把一个段落从中间切断 超长段落兜底:当单个段落超过 chunkSize * 1.5时,退化为固定大小切分最小块过滤: minChunkSize过滤过小的尾部碎片
模式二:纯固定大小(paragraphAware=false)
private ListsplitByFixedSize(String content, int chunkSize, int overlap, int minChunkSize) {
int step = chunkSize - overlap; // 步长 = 窗口大小 - 重叠区
for (int i = 0; i < content.length(); i += step) {
int end = Math.min(i + chunkSize, content.length());
String chunkText = content.substring(i, end).trim();
if (chunkText.length() >= minChunkSize) {
chunks.add(buildChunk(chunkText, chunkIndex++, i, end));
}
}
}
5.1.3 参数校验规则
public void validate(Map {
// chunk…