企业级智能体系统 RAG的分片优化逻辑

失踪人口回归,这段时间很忙,不仅是在做项目优化还得探索所谓的口播自动化编程,后面可以跟大家一起交流。

分片优化

最简单有效非demo的手段

云厂商永远是你值得信赖的伙伴,花点钱可以解决的问题没必要写代码。

本期优化

使用策略模式 实现了三种方式,固定窗口,语义,命题三种策略。在实际的开发过程中可以参考并延伸。

文件
路径
说明
ChunkingStrategyType
bootstrap/rag/chunking/ChunkingStrategyType.java
策略类型枚举
ChunkingStrategy
bootstrap/rag/chunking/ChunkingStrategy.java
策略接口
ChunkingStrategyFactory
bootstrap/rag/chunking/ChunkingStrategyFactory.java
策略工厂
ChunkingRequest
bootstrap/rag/chunking/ChunkingRequest.java
分块请求
ChunkingResult
bootstrap/rag/chunking/ChunkingResult.java
分块结果
DocumentChunk
bootstrap/rag/chunking/DocumentChunk.java
文档分块
SlidingWindowChunkingStrategy
bootstrap/rag/chunking/impl/SlidingWindowChunkingStrategy.java
滑动窗口实现
SemanticChunkingStrategy
bootstrap/rag/chunking/impl/SemanticChunkingStrategy.java
语义切分实现
PropositionChunkingStrategy
bootstrap/rag/chunking/impl/PropositionChunkingStrategy.java
命题切分实现
MultimodalChunkBuilder
bootstrap/rag/chunking/MultimodalChunkBuilder.java
多模态分块构建
ChunkingService
bootstrap/admin/service/ChunkingService.java
分块业务服务
DocumentProcessingJobService
bootstrap/admin/service/DocumentProcessingJobService.java
文档处理管线
KnowledgeController
bootstrap/admin/controller/KnowledgeController.java
API 控制器

1. 为什么需要分片优化

在 RAG(Retrieval-Augmented Generation)系统中,文档分片是影响检索质量的第一道关卡。分片质量直接决定了:

  • 召回率:分片太粗,关键信息被淹没在噪音中;分片太细,上下文丢失
  • 精确度:分片边界不当,跨边界的信息在检索时可能遗漏
  • 语义完整性:理想情况下,每个分片应该是一个语义自洽的单元

传统固定切分的问题

最简单的做法是按固定字符数切割,但会带来严重问题:

原文:"...2024年公司营收达到50亿元。其中,|华东区域贡献了32%的份额,华|南区域贡献了28%..."
                                              ↑ 粗暴切割点           ↑

切割后,"华东区域贡献了32%的份额" 被拆成两半,检索 "华东区域营收占比" 时无法精准命中。

本项目的优化思路

本项目实现了三种由粗到细的分片策略:

策略
核心思想
适用场景
依赖
SLIDING_WINDOW
固定窗口 + 重叠区域 + 段落感知
通用场景,无需额外依赖
无
SEMANTIC
嵌入向量相似度下降点作为切分边界
语义结构丰富的文档
EmbeddingModel
PROPOSITION
LLM 拆解为原子级命题再重组
需要精细事实检索的场景
ChatModel

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) 管理策略注册与获取。

关键设计决策:

  1. Spring 自动注册:所有 ChunkingStrategy 实现类标注 @Component,Spring 自动注入 List,工厂在构造时自动完成注册
  2. 配置驱动:每种策略的参数通过 Map 传入,支持灵活配置
  3. 策略降级:PROPOSITION 策略在 ChatModel 不可用时自动降级为 SLIDING_WINDOW
  4. 版本追踪:每个策略有版本号,生成的 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 枚举值说明:

chunkType
来源策略
说明
TEXT
SLIDING_WINDOW
普通文本分块
SEMANTIC_SEGMENT
SEMANTIC
语义段落分块
PROPOSITION
PROPOSITION
命题分块
IMAGE
MultimodalChunkBuilder
图片描述分块
TABLE_IMAGE
MultimodalChunkBuilder
表格/图表描述分块

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 步长强制切分
        }
    }
}

关键逻辑解析:

  1. 段落边界优先:只在段落之间切分,不把一个段落从中间切断
  2. 超长段落兜底:当单个段落超过 chunkSize * 1.5 时,退化为固定大小切分
  3. 最小块过滤: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…
— 以上为试看内容(约 40%),开通会员后阅读全文 —