夜雨聆风学习资料网

ARTICLE · 1397573

RAG效果差?LangChain4j文档切分实战

RAG效果差?LangChain4j文档切分实战

摘要: 知识库问答答不准,很多人先怀疑模型和 Embedding,其实问题常常出在最早那一步——文档切分。本文讲清切分器的工作原理,用 LangChain4j 的字符窗口、递归切分、按 Markdown 标题切分三种策略做对比,并给出切分、入库、检索、回答的完整可运行代码。

知识库问答上线一周,最扎心的反馈来了:用户问「住宿费上限多少」,AI 答「建议咨询财务」。换模型、换 Embedding、加 Rerank,折腾一圈还是不行。把喂给模型的上下文打出来才发现,整篇差旅制度被当成一个块存进了向量库,一段近千字的内容里,真正相关的那三十个字被稀释得干干净净。

切分(chunking)是 RAG 链路的第一步,也是最容易做错、最难被发现的一步。这篇把它讲透。

一、切分到底在解决什么问题

结论:切分决定了检索的最小单位,它比换模型便宜得多,效果却常常更明显。

先把 RAG 这条链路摊开看。用户提一个问题,系统做的事情其实只有这几步:

步骤
在干什么
做错了会怎样
切分
把长文档拆成小块
检索抓不到重点,答案被拦腰截断
向量化
给每块算出一个向量
语义相近的问题搜不到目标
存库
向量 + 原文一起落库
检索到内容却引不出出处
检索
找出跟问题最像的几块
召回一堆无关内容
拼 Prompt
把块塞进模型上下文
模型被噪声带偏,开始瞎编

注意顺序:切分在最前面。后面几步做得再好,也只是在切分的结果上打转。

什么是「块」。 模型没法一次吞下整本手册,所以先把文档拆成很多小块,每块单独算一个向量。检索的时候,拿用户的问题去比这些向量,挑出最像的几块塞给模型。用个不严谨但好记的类比:把一本厚书拆成一叠卡片,检索就是抽卡片。抽哪张卡片,取决于你当初怎么裁。

在 LangChain4j 里,这两个角色的名字是:

  • Document
    :一整篇原始文档,外加它的元数据(比如文件名叫什么、来自哪个目录)。
  • TextSegment
    :切分之后的一小块文本,同样带元数据。进向量库的、被检索出来的、最终拼进 Prompt 的,都是 TextSegment。

所以「切分」在代码层面就是一件事:Document → 一堆 TextSegment。

切分没做好会长什么样。 下面这些症状我几乎在每个做砸的 RAG 项目里都见过:

  • 明明召回了相关文档,答案却不在里面。原因是块太大,一段里九成内容跟问题无关,向量被这些无关内容「平均」掉了。
  • 答案被切断。前半句「住宿费上限」在上一块,具体数字「600 元」掉到了下一块。模型手里只有半句话,只能瞎猜。
  • 召回一堆重复内容。重叠(overlap)留得太多,同一段话在好几个块里反复出现,白白占满上下文。
  • 目录、页眉、版权声明也被切成块。这些块跟什么问题都「有点相关」,于是总排在前面挤掉真正有用的内容。

中文文档还要额外加一层麻烦。 英文按空格分词,切成什么词基本不影响语义;中文没有空格,很多切分逻辑按「词」下刀,一刀下去可能把「住宿标准」切成「住宿」「标准」。再叠上 Markdown 语法(#、|、-)和表格,纯按长度硬切几乎必然切碎。

判断你的项目要不要动切分,有个很土但很准的办法:从向量库里随机抽五段出来,人眼看一眼。如果五段里有超过一段读着不成话,别犹豫,问题就在这儿。

二、底层原理:切分器是怎么工作的

结论:LangChain4j 的切分器是一棵「降级树」——优先按大单位切,切不动才降级到更小的单位。

切分入口只有一个方法

DocumentSplitter 接口非常干净,真正需要实现的只有一个方法:

List<TextSegment> split(Document document);

另外还有一个带默认实现的方法 splitAll(List<Document> documents),作用是把多篇文档依次切一遍再合并成一个列表,你不用管它。

也就是说,任何切分逻辑——不管多复杂——最终都是「一篇文档进去,一串小块出来」。这一点对后面写自定义切分器很关键:你不需要继承什么基类,实现一个方法就够了。

层级降级:段落 → 行 → 句子 → 词 → 字符

日常最常用的 DocumentSplitters.recursive(...),本质是把几个切分器串成一条链:

DocumentByParagraphSplitter(按段落切)    └── DocumentByLineSplitter(段落还是太长,按行切)            └── DocumentBySentenceSplitter(行还是太长,按句子切)                    └── DocumentByWordSplitter(句子还是太长,按词切)

工作方式是这样的:先按空行把文档切成段落,然后从前往后把段落往一块里塞,塞到接近上限就封口。如果某个段落本身就超长(比如一段没换行的三千字),就把它交给下一级——按行切;行还长,再按句子切。逐级下降,直到每块都能放下为止。

这个设计的好处很实在:只要文档本身有结构,切出来的块边界就贴着语义边界。段落完整、句子完整,模型读到的就不是半截话。

DocumentSplitters.recursive(int maxSegmentSizeInChars, int maxOverlapSizeInChars) 用的是字符单位,不需要额外的分词器;带 TokenCountEstimator 参数的重载才是按 token 计数的版本。

两个参数:段长和重叠

所有层级切分器的构造参数都是两个数:段长上限和重叠大小。

段长上限好理解,就是一块最多装多少。重叠要稍微绕一下,但它是整个切分环节里性价比最高的一个参数。

想象答案正好压在两个块的边界上:

块 1:[……住宿标准按城市分级:一线城市每晚不超过 600 元,二线]块 2:[城市每晚不超过 400 元,其他城市每晚不超过 300 元……]

如果用户问「二线城市住宿上限」,块 1 里有「二线」没数字,块 2 里有数字没主语,两块都不完整。加上重叠之后,同一个片段会同时出现在相邻两个块里:

块 1:[……住宿标准按城市分级:一线城市每晚不超过 600 元,二线城市每晚不超过 400 元……]块 2:[城市分级:一线城市每晚不超过 600 元,二线城市每晚不超过 400 元,其他城市不超过 300 元……]

这样至少有一个块包含完整答案。代价是存储和向量计算变多,所以重叠一般取段长的 10% 到 20%,不要贪多。

有个细节值得记一下:recursive 的重叠只按完整句子计算,不会为了凑够重叠长度把半句话硬塞进来。源码注释里写得很清楚(见文末参考链接)。

按 token 还是按字符

两种都能用,区别在准不准:

  • 按字符
    :recursive(300, 50) 就是「每块最多 300 个字符」。简单、无依赖,中文场景下很直观——中文一个字大致就是一个 token 量级。缺点是不同分词器对英文、代码、数字的切法差别很大,字符数不等于模型实际消耗的 token 数。
  • 按 token
    :需要传一个 TokenCountEstimator 实现,比如 OpenAI 的分词器实现。计量精确,代价是多一个对象、切分时多算一遍。

我的建议:面向中文知识库的常规文档,先用字符版把效果调顺,等你要严控 token 成本的时候再换成 token 版。别一上来就纠结分词器。

结构感知切分:正则切分器

如果文档本身有明确的结构标记(Markdown 标题、条款编号、FAQ 的问答分隔),最省事的做法是按结构切。DocumentByRegexSplitter 就是干这个的,构造参数是:

new DocumentByRegexSplitter(String regex, String joinDelimiter,                            int maxSegmentSizeInChars, int maxOverlapSizeInChars)

regex 用来决定在哪里下刀,joinDelimiter 决定切出来的碎片用什么拼回去。比如按 Markdown 的二级标题切,可以用 "\n(?=## )"——这是一个零宽断言,含义是「在换行符处下刀,但换行后面必须紧跟 ## 」,于是每个 ## 标题和它的正文会待在同一块里。

为什么按结构切通常效果最好:块的边界跟人读文档的边界一致。一块就是完整的一节,检索命中之后,模型看到的是一节完整的内容,而不是一段被截断的中间部分。

元数据是白送的信息

TextSegment 除了文本还带 Metadata。切分的时候顺手把「来源文件」「所属章节」写进去,后面有两个用处:

  1. 回答时能告诉用户信息出自哪一节,可信度立刻不一样。
  2. 检索可以按元数据过滤,比如只在「财务制度」这一部分里找。

元数据不用复杂,一两个键就够。别一上来设计十几个字段,那属于自我感动。

三、实战:手把手写代码

先备好依赖。这是个普通 Maven 项目,不需要 Spring Boot:

<?xml version="1.0" encoding="UTF-8"?><projectxmlns="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>    <groupId>com.tuofan</groupId>    <artifactId>l4j-chunk-demo</artifactId>    <version>1.0.0</version>    <packaging>jar</packaging>    <properties>        <maven.compiler.release>21</maven.compiler.release>        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>    </properties>    <dependencies>        <dependency>            <groupId>dev.langchain4j</groupId>            <artifactId>langchain4j</artifactId>            <version>1.20.0</version>        </dependency>        <dependency>            <groupId>dev.langchain4j</groupId>            <artifactId>langchain4j-open-ai</artifactId>            <version>1.20.0</version>        </dependency>        <dependency>            <groupId>org.slf4j</groupId>            <artifactId>slf4j-simple</artifactId>            <version>2.0.20</version>        </dependency>    </dependencies>    <build>        <plugins>            <plugin>                <groupId>org.codehaus.mojo</groupId>                <artifactId>exec-maven-plugin</artifactId>                <version>3.6.4</version>            </plugin>        </plugins>    </build></project>

dev.langchain4j:langchain4j 里已经包含核心抽象、切分器和内存向量库,langchain4j-open-ai 提供兼容 OpenAI 协议的模型客户端(通义千问、DeepSeek、硅基流动这类国产服务走兼容模式,都能用)。

编译命令:mvn -q clean compile;运行用 mvn -q exec:java -Dexec.mainClass=com.tuofan.chunk.SplitterCompare。下面三段代码放在 src/main/java/com/tuofan/chunk/ 目录下。

示例一:三种切分策略放一起对比(不需要 API Key)

这个例子完全不联网,目的很单纯——让你亲眼看到同一篇文档在不同切法下会碎成什么样。

package com.tuofan.chunk;import dev.langchain4j.data.document.Document;import dev.langchain4j.data.document.Metadata;import dev.langchain4j.data.document.splitter.DocumentByRegexSplitter;import dev.langchain4j.data.document.splitter.DocumentSplitters;import dev.langchain4j.data.segment.TextSegment;import java.util.ArrayList;import java.util.List;public class SplitterCompare {    /** 假装这是从知识库导出的文档,Markdown 格式,两个二级标题 */    private static final String DOC = """            ## 差旅报销标准            员工出差产生的交通费、住宿费凭发票实报实销。市内交通每天上限 100 元,超过部分需要部门经理审批,审批单要附在报销单后面。            住宿费按城市分级:一线城市每晚不超过 600 元,二线城市每晚不超过 400 元,其他城市每晚不超过 300 元。同性别同事同行原则上合住一间。            出差补贴按天计算,一线城市每天 150 元,其他城市每天 100 元,出发和返程当天都算。            如果因为航班延误导致多住一晚,凭航空公司出具的延误证明可以额外报销一晚住宿费。            ## 报销流程            员工在出差结束后 15 个工作日内,在财务系统提交报销单并上传发票照片,照片要能看清发票代码和金额。            报销单需要经过直属主管、部门负责人两级审批,审批通过后 5 个工作日内打款到工资卡。            单笔金额超过 5000 元的报销,还需要财务总监签字,周期通常延长 3 个工作日。            ## 常见问题            问:发票丢了还能报销吗?            答:不能。发票是唯一的报销凭证,丢失后需要联系商家重新开具,或者使用电子发票重新下载。            """;    public static void main(String[] args) {        Metadata metadata = new Metadata().put("source", "差旅制度.md");        Document document = Document.from(DOC, metadata);        // 1. 最笨的办法:每 300 字一刀,不留重叠        compare("按字符硬切 300/0", rawChunks(document, 300, 0));        // 2. 官方推荐的通用切分器:段落优先,段长 300 字,重叠 50 字        compare("recursive 300/50", DocumentSplitters.recursive(300, 50).split(document));        // 3. 结构感知:在「换行 + ## 」的位置下刀,每个标题下的一节自成一块        compare("按 Markdown 标题切", new DocumentByRegexSplitter("\n(?=## )", "\n", 400, 0).split(document));    }    /** 按固定长度硬切,纯粹用来做对照,实际项目别这么干 */    private static List<TextSegment> rawChunks(Document document, int size, int overlap) {        String text = document.text();        List<TextSegment> segments = new ArrayList<>();        int start = 0;        while (start < text.length()) {            int end = Math.min(start + size, text.length());            segments.add(TextSegment.from(text.substring(start, end), document.metadata()));            if (end == text.length()) {                break;            }            start = end - overlap;        }        return segments;    }    private static void compare(String name, List<TextSegment> segments) {        int total = segments.stream().mapToInt(s -> s.text().length()).sum();        System.out.printf("切分方式:%-20s 段数:%2d  平均长度:%3d 字%n",                name, segments.size(), total / Math.max(segments.size(), 1));        System.out.println("  第一段:" + oneLine(segments.get(0).text()));        System.out.println("  元数据:" + segments.get(0).metadata().toMap());        System.out.println();    }    private static String oneLine(String text) {        String flat = text.replaceAll("\\s+", " ").trim();        return flat.length() > 46 ? flat.substring(0, 46) + "..." : flat;    }}

代码里几个点值得说清:

  • Document.from(DOC, metadata)
     把纯文本包成一篇文档,顺手挂了来源信息。后面每个 TextSegment 都会带上这份元数据。
  • rawChunks
     是我故意写的反面教材:它只认长度,不看语义。中文文档按 300 字硬切,很容易切在句子中间。
  • DocumentSplitters.recursive(300, 50)
     是官方推荐的通用切法,先按段落装块,装不下再降级。
  • DocumentByRegexSplitter("\n(?=## )", "\n", 400, 0)
     只在标题前下刀,切出来的块跟文档的章节一一对应。
  • compare
     打印段数、平均长度和第一段内容,你要调参就盯这三个数。

跑完大致是这样的输出(具体数字取决于你的文档):

切分方式:按字符硬切 300/0          段数: 3  平均长度:300 字  第一段:## 差旅报销标准 员工出差产生的交通费、住宿费凭发票实报实销。市内交通每天上限 100 元...  元数据:{source=差旅制度.md}切分方式:recursive 300/50         段数: 4  平均长度:257 字  第一段:## 差旅报销标准 员工出差产生的交通费、住宿费凭发票实报实销...  元数据:{source=差旅制度.md}切分方式:按 Markdown 标题切          段数: 3  平均长度:341 字  第一段:## 差旅报销标准 员工出差产生的交通费、住宿费凭发票实报实销...  元数据:{source=差旅制度.md}

别只看段数,重点读第一段的收尾。硬切那版经常停在句子中间,按标题切那版每段都是一个完整章节——这个差别就是检索质量的差别。

示例二:自己写一个按标题切分、还带章节元数据的切分器

DocumentByRegexSplitter 够用,但它有个短板:切完的文本里虽然带着 ## 标题,元数据里却没有章节名。想要「回答时附带出处」,得自己写一个。前面说过,实现 DocumentSplitter 接口只需要一个方法。

package com.tuofan.chunk;import dev.langchain4j.data.document.Document;import dev.langchain4j.data.document.DocumentSplitter;import dev.langchain4j.data.document.Metadata;import dev.langchain4j.data.segment.TextSegment;import java.util.ArrayList;import java.util.List;import java.util.regex.Matcher;import java.util.regex.Pattern;/** * 按 Markdown 的二三级标题切分,并把章节名写进每一块的元数据。 * 超过 maxSegmentSizeInChars 的章节再按字符切成多块,块之间保留重叠。 */public class MarkdownHeadingSplitter implements DocumentSplitter {    private static final Pattern HEADING = Pattern.compile("(?m)^(#{2,3})\\s+(.+) 扫出所有二三级标题。(?m) 打开多行模式,^ 才能匹配每行的行首。每个标题到下一个标题之间是一节,整节取出来。因为块边界就是章节边界,语义天然完整。定位下一节的办法是反着找:从标题起始位置往回找最近的一个换行符,那就是上一节的结尾。章节太长时才按字符继续切,并且保留重叠。把章节名拼进正文开头,再写进 Metadata。这一步的收益很直接:模型看到的内容自带标题,回答时能说出「根据差旅报销标准……」。document.metadata().copy() 先复制再 put,避免改到别的块共用的那份元数据。示例三:完整跑一遍入库、检索、回答前两步是切分本身,这一步把整条链路接起来:读文件 → 切分 → 存向量库 → 检索 → 让模型回答。这里用内存向量库,方便本地验证;线上换成 Redis、Milvus、pgvector 都只是把 EmbeddingStore 换掉,其余代码不用动。package com.tuofan.chunk;import dev.langchain4j.data.document.Document;import dev.langchain4j.data.embedding.Embedding;import dev.langchain4j.data.message.ChatMessage;import dev.langchain4j.data.message.SystemMessage;import dev.langchain4j.data.message.UserMessage;import dev.langchain4j.data.segment.TextSegment;import dev.langchain4j.model.chat.ChatModel;import dev.langchain4j.model.embedding.EmbeddingModel;import dev.langchain4j.model.openai.OpenAiChatModel;import dev.langchain4j.model.openai.OpenAiEmbeddingModel;import dev.langchain4j.rag.content.Content;import dev.langchain4j.rag.content.retriever.ContentRetriever;import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;import dev.langchain4j.rag.query.Query;import dev.langchain4j.store.embedding.EmbeddingStore;import dev.langchain4j.store.embedding.EmbeddingStoreIngestor;import dev.langchain4j.store.embedding.inmemory.InMemoryEmbeddingStore;import java.util.List;import java.util.stream.Collectors;public class ChunkRagPipeline {    /** 通义千问 OpenAI 兼容模式的地址;换成其他兼容服务只改这一行 */    private static final String BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";    public static void main(String[] args) {        String apiKey = System.getenv("DASHSCOPE_API_KEY");        if (apiKey == null || apiKey.isBlank()) {            throw new IllegalStateException("请先设置环境变量 DASHSCOPE_API_KEY");        }        EmbeddingModel embeddingModel = OpenAiEmbeddingModel.builder()                .baseUrl(BASE_URL)                .apiKey(apiKey)                .modelName("text-embedding-v3")                .dimensions(1024)                .build();        ChatModel chatModel = OpenAiChatModel.builder()                .baseUrl(BASE_URL)                .apiKey(apiKey)                .modelName("qwen-plus")                .build();        // 1. 准备文档。真实项目里换成 FileSystemDocumentLoader.loadDocument(Path.of("差旅制度.md"))        Document document = Document.from(SPLIT_DEMO_TEXT);        // 2. 向量库 + 入库器,切分策略在这里指定        EmbeddingStore<TextSegment> store = new InMemoryEmbeddingStore<>();        EmbeddingStoreIngestor ingestor = EmbeddingStoreIngestor.builder()                .documentSplitter(new MarkdownHeadingSplitter(500, 100))                .embeddingModel(embeddingModel)                .embeddingStore(store)                .build();        ingestor.ingest(document);        // 3. 检索器:取最像的 3 块,相似度低于 0.5 的直接丢掉        ContentRetriever retriever = EmbeddingStoreContentRetriever.builder()                .embeddingStore(store)                .embeddingModel(embeddingModel)                .maxResults(3)                .minScore(0.5)                .build();        String question = "二线城市住宿费每晚最多报多少?";        List<Content> contents = retriever.retrieve(Query.from(question));        if (contents.isEmpty()) {            System.out.println("没检索到相关内容,检查切分和 minScore 设置");            return;        }        // 4. 把检索到的块拼成上下文,交回给模型组织语言        String context = contents.stream()                .map(c -> "【" + c.textSegment().metadata().getString("section") + "】\n"                        + c.textSegment().text())                .collect(Collectors.joining("\n\n"));        List<ChatMessage> messages = List.of(                SystemMessage.from("你是公司制度问答助手。只根据下面的资料回答,资料里没有的信息就说不知道,不要编。\n\n" + context),                UserMessage.from(question));        String answer = chatModel.chat(messages).aiMessage().text();        System.out.println("问题:" + question);        System.out.println("回答:" + answer);        System.out.println("\n本次命中的块:");        contents.forEach(c -> System.out.println("  - " + c.textSegment().metadata().getString("section")));    }    /** 示例文档,实际项目从文件或数据库读 */    private static final String SPLIT_DEMO_TEXT = """            ## 差旅报销标准            员工出差产生的交通费、住宿费凭发票实报实销。市内交通每天上限 100 元。            住宿费按城市分级:一线城市每晚不超过 600 元,二线城市每晚不超过 400 元,其他城市每晚不超过 300 元。            出差补贴按天计算,一线城市每天 150 元,其他城市每天 100 元。            ## 报销流程            员工在出差结束后 15 个工作日内,在财务系统提交报销单并上传发票照片。            报销单需要经过直属主管、部门负责人两级审批,审批通过后 5 个工作日内打款。            ## 常见问题            问:发票丢了还能报销吗?            答:不能。发票是唯一的报销凭证,丢失后需要联系商家重新开具。            """;}这段代码的每一步都值得说明:EmbeddingModel 负责把文本变成向量。这里用通义千问的 text-embedding-v3,dimensions(1024) 指定向量维度,用 OpenAI 官方服务就把 modelName 换成 text-embedding-3-small。EmbeddingStoreIngestor 是「切分 + 向量化 + 入库」三合一的封装。documentSplitter(...) 这一步是全文的重点,不显式指定的话它用的是内置默认切分器,那套参数是按英文语料定的,中文 Markdown 很容易切歪。EmbeddingStoreContentRetriever 把「问题转向量 → 找最像的块 → 转成 Content」包好了。maxResults 控制拿几块,minScore 是相似度门槛,太低会把无关内容放进来。SystemMessage 里明确要求「只根据资料回答,不知道就说不知道」,这是压制幻觉最省事的一招。检索结果打印了 section 字段,因为示例二的切分器把章节名写进了元数据——没有这一步,这行打印就是 null。四、踩坑经验和最佳实践段长别凭感觉设。 我见过最离谱的一版是每块 4000 字,理由是「怕信息不全」。结果模型拿到的上下文里 90% 是噪声,回答质量还不如只给一段。中文知识库的经验区间是 200 到 500 字,先从 300 字起步,重叠取 10% 到 20%。表格、条款这类密集结构可以再小一些。重叠不是越大越好。 重叠等于额外存储和额外向量计算,超过段长的三分之一之后,向量库里全是重复内容,检索出来的三块可能讲的是同一件事。钱花了,效果没涨。别拿默认切分器糊弄中文。 内置默认值是按英文语料调的,英文一句话几个词、中文一句话十几个字,长度分布完全不同。你要么显式传切分器,要么自己写一个。有结构就别按长度切。 文档里有标题、编号、问答标记,就是自带的分节线。按结构切的块读起来是完整的一节,按长度切的块读起来是「上不着天下不着地」的半段。这是全文我最想让你记住的一条。表格和代码块单独处理。 Markdown 表格被切两半之后,模型看到的是残缺的对齐符号,基本没法用。稳妥做法是先做一次文档转换,把表格转成「表头:单元格」这种自然语言形式,再进切分流程。元数据一定要打。source 和 section 两个字段就够了,多花的成本几乎为零,换来的好处是——回答能说出出处,用户立刻更信你。改完切分先做一次肉眼验收。 写个 main 方法把切分结果全打印出来,抽五段读一遍。这十分钟能省掉后面调 Embedding 模型的两天。日志刷屏的问题。 第一次跑通常满屏 SLF4J: No SLF4J providers were found,加上 slf4j-simple 就干净了,前面 pom 里已经带了。检索为空不一定是切分的错。 如果 contents 是空的,先把 minScore 去掉重试一次。很多时候块找到了,只是相似度没过门槛——门槛设太高也是常见病。五、策略对比和怎么选三种策略的差别,落到一张表里:切分策略块边界适合的文档主要代价固定长度硬切任意位置,可能断开句子几乎没有,仅当文档毫无结构语义被切碎,检索质量最差recursive 递归切分段落/句子边界通用文本、FAQ、纯文本手册块边界跟章节不完全对齐按结构(标题/条款)切分章、节、条款边界Markdown、技术文档、制度、合同需要文档本身有结构,要自己写一点代码选型没什么可纠结的,按这个顺序判断就行:文档有明确结构(标题、条款编号)→ 走结构感知切分,超长章节再用 recursive 兜底。这是默认答案。文档是一堆杂乱文本,没有结构 → 用 DocumentSplitters.recursive(300, 50),靠段落和句子边界保底。语料本身就是短问答,一条一个块 → 一条一块,别再切,切了反而破坏完整性。几个常见误区也说一下:以为块越大信息越全。 信息全不全看的是「相关的那些字有没有完整地被包含」,跟块的总长度无关。块越大,向量越被无关内容稀释。以为块越小检索越准。 块太小会丢上下文,一句「上限 600 元」被单独切出来,模型不知道这是住宿费还是餐补。语义完整比长度更重要。只调 Embedding 模型不动切分。 检索结果列表长得像「都沾点关系但都不对」,问题多半在切分,不在模型。六、总结RAG 效果差,先别急着换模型。把切分结果打出来读一遍,十有八九问题就在那儿。整件事的核心逻辑一句话:切分决定检索的最小单位,最小单位必须语义完整。围绕这句话,LangChain4j 给了三层工具——DocumentSplitters.recursive 负责通用场景的段落级切分,DocumentByRegexSplitter 负责按结构下刀,DocumentSplitter 接口则让你在结构性特别强的文档上随便定制。我的建议是:文档有标题有编号,就直接实现一个结构感知的切分器,把章节名写进元数据;文档乱得像一锅粥,再退回递归切分。段长从 300 字、重叠 50 字开始调,改一次看一眼抽样的块。切分这一步花的时间,是整个 RAG 项目里回报率最高的。文 / 会编程的吕洞宾参考资料Retrieval Augmented Generation (RAG) :: LangChain4j 官方文档DocumentSplitters 源码(langchain4j 模块)DocumentSplitter 接口源码(langchain4j-core)HierarchicalDocumentSplitter 源码(层级切分器的实现基类)EmbeddingStoreIngestor 源码(切分与入库的封装)LangChain4j Releases(版本与变更记录)

回首页,搜索你想要的文档

在首页搜索框输入关键词,快速定位资料

文库首页搜索指引 立即搜索

相关学习资料