基于文件的节点解析器

有多种基于文件的节点解析器，它们会依据所解析内容的类型（JSON、Markdown 等）来创建节点。

最简单的流程是把 FlatFileReader 与 SimpleFileNodeParser 组合起来，从而针对每类内容自动选用最合适的节点解析器。之后你可能还想把这个基于文件的解析器再串上一个基于文本的解析器，以照顾文本的实际长度。

SimpleFileNodeParser

from llama_index.core.node_parser import SimpleFileNodeParser
from llama_index.readers.file import FlatReader
from pathlib import Path

md_docs = FlatReader().load_data(Path("./test.md"))

parser = SimpleFileNodeParser()
md_nodes = parser.get_nodes_from_documents(md_docs)

HTMLNodeParser

该节点解析器用 beautifulsoup 解析原始 HTML。

默认只解析一部分 HTML 标签，但可以覆盖这一设置。

默认标签为：["p", "h1", "h2", "h3", "h4", "h5", "h6", "li", "b", "i", "u", "section"]

from llama_index.core.node_parser import HTMLNodeParser

parser = HTMLNodeParser(tags=["p", "h1"])  # optional list of tags
nodes = parser.get_nodes_from_documents(html_docs)

JSONNodeParser

JSONNodeParser 解析原始 JSON。

from llama_index.core.node_parser import JSONNodeParser

parser = JSONNodeParser()

nodes = parser.get_nodes_from_documents(json_docs)

MarkdownNodeParser

MarkdownNodeParser 解析原始 Markdown 文本。

from llama_index.core.node_parser import MarkdownNodeParser

parser = MarkdownNodeParser()

nodes = parser.get_nodes_from_documents(markdown_docs)

文本切分器（Text-Splitters）

CodeSplitter

按代码所使用的语言来切分原始代码文本。

支持的语言完整清单见这里。

from llama_index.core.node_parser import CodeSplitter

splitter = CodeSplitter(
    language="python",
    chunk_lines=40,  # lines per chunk
    chunk_lines_overlap=15,  # lines overlap between chunks
    max_chars=1500,  # max chars per chunk
)
nodes = splitter.get_nodes_from_documents(documents)

LangchainNodeParser

你也可以把 langchain 里已有的任意文本切分器包装成节点解析器。

from langchain.text_splitter import RecursiveCharacterTextSplitter
from llama_index.core.node_parser import LangchainNodeParser

parser = LangchainNodeParser(RecursiveCharacterTextSplitter())
nodes = parser.get_nodes_from_documents(documents)

Chunker

Chunker 是一个多用途节点解析器，它包装了 chonkie 的切分器。你可以用任意一种 chonkie 切分策略对应的别名来初始化解析器；全部合法别名可通过 Chunker.valid_chunker_types 属性获取。

from llama_index.node_parser.chonkie import Chunker

parser = Chunker("recursive", chunk_size=2048)
nodes = parser.get_nodes_from_documents(documents)

也可以直接把一个 chonkie 切分器实例传进来初始化解析器。

from chonkie import RecursiveChunker
from llama_index.node_parser.chonkie import Chunker

chonkie_chunker = RecursiveChunker()
parser = Chunker(chonkie_chunker)
nodes = parser.get_nodes_from_documents(documents)

SentenceSplitter

SentenceSplitter 在切分文本时尽量尊重句子边界。

from llama_index.core.node_parser import SentenceSplitter

splitter = SentenceSplitter(
    chunk_size=1024,
    chunk_overlap=20,
)
nodes = splitter.get_nodes_from_documents(documents)

SentenceWindowNodeParser

SentenceWindowNodeParser 与其他节点解析器类似，不同之处在于它把每个文档切成一个个单独的句子，并在元数据里为每个节点保留其周围的“窗口”句群。注意这部分元数据对 LLM 和嵌入模型都是不可见的。

它最适合生成范围非常具体的嵌入。再配合 MetadataReplacementNodePostProcessor，你就可以在把节点送给 LLM 之前，用其周围上下文替换掉那句孤立的句子。

下面是在默认设置下配置该解析器的例子。实践中你通常只需要调整句子窗口的大小。

from llama_index.core.node_parser import SentenceWindowNodeParser

node_parser = SentenceWindowNodeParser.from_defaults(
    # how many sentences on either side to capture
    window_size=3,
    # the metadata key that holds the window of surrounding sentences
    window_metadata_key="window",
    # the metadata key that holds the original sentence
    original_text_metadata_key="original_sentence",
)

与 MetadataReplacementNodePostProcessor 配合使用的完整示例见这里。

SemanticSplitterNodeParser

“语义分块”是 Greg Kamradt 在他关于嵌入分块五个层次的视频教程中提出的新概念：https://youtu.be/8OJC21T2SL4?t=1933。

语义切分器不再用固定的分块大小，而是借助嵌入相似度自适应地在句子之间挑选切分点。这样每个“块”里的句子在语义上都是彼此相关的。

我们把它改造成了 LlamaIndex 的一个模块。

来看看我们的 notebook！

注意事项：

• 该正则主要适用于英文句子
• 你可能需要调整切分点的百分位阈值。

from llama_index.core.node_parser import SemanticSplitterNodeParser
from llama_index.embeddings.openai import OpenAIEmbedding

embed_model = OpenAIEmbedding()
splitter = SemanticSplitterNodeParser(
    buffer_size=1, breakpoint_percentile_threshold=95, embed_model=embed_model
)

完整示例见我们的《使用 SemanticSplitterNodeParser 指南》。

TokenTextSplitter

TokenTextSplitter 力求按原始 token 数切分出大小一致的块。

from llama_index.core.node_parser import TokenTextSplitter

splitter = TokenTextSplitter(
    chunk_size=1024,
    chunk_overlap=20,
    separator=" ",
)
nodes = splitter.get_nodes_from_documents(documents)

基于关系的节点解析器

HierarchicalNodeParser

该节点解析器会把节点切分成层级结构的节点：单个输入会被切成若干种块大小的层级，且每个节点都持有对其父节点的引用。

与 AutoMergingRetriever 配合时，就能在一个父节点的多数子节点都被检索到时，自动用父节点替换这些子节点。这个过程为 LLM 提供了更完整的上下文用于响应合成。

from llama_index.core.node_parser import HierarchicalNodeParser

node_parser = HierarchicalNodeParser.from_defaults(
    chunk_sizes=[2048, 512, 128]
)

与 AutoMergingRetriever 配合使用的完整示例见这里。