用户指南：知识图谱构建器¶
本页提供了如何从非结构化数据创建知识图谱的信息。
警告
此功能仍在实验中。API 可能会更改，并预计会有错误修复。
管道结构¶
知识图谱 (KG) 构建管道需要以下几个组件（部分组件是可选的）
数据加载器：从文件（PDF 等）中提取文本。
文本分割器：将文本分割成更小的文本片段（块），以便 LLM 上下文窗口（令牌限制）处理。
块嵌入器（可选）：计算块嵌入。
模式构建器：提供一个模式，用于根据 LLM 提取的实体和关系进行验证，并获得易于导航的知识图谱。
词汇图谱构建器：构建词汇图谱（文档、块及其关系）（可选）。
实体和关系提取器：从文本中提取相关实体和关系。
知识图谱写入器：保存已识别的实体和关系。
实体解析器：将相似实体合并为单个节点。
此软件包包含每个组件的接口和实现，这些将在以下章节中详细介绍。
要查看知识图谱构建管道的端到端示例，请访问项目 GitHub 存储库中的示例文件夹。
简单知识图谱管道¶
使用此软件包从非结构化数据开始构建知识图谱的最简单方法是利用 SimpleKGPipeline 接口
from neo4j_graphrag.experimental.pipeline.kg_builder import SimpleKGPipeline
kg_builder = SimpleKGPipeline(
llm=llm, # an LLMInterface for Entity and Relation extraction
driver=neo4j_driver, # a neo4j driver to write results to graph
embedder=embedder, # an Embedder for chunks
from_pdf=True, # set to False if parsing an already extracted text
)
await kg_builder.run_async(file_path=str(file_path))
# await kg_builder.run_async(text="my text") # if using from_pdf=False
参见
使用另一个 LLM 模型，了解如何实例化 llm
嵌入器，了解如何实例化 embedder
以下部分概述了此类的配置参数。
定制 SimpleKGPipeline¶
图谱模式¶
可以通过提供实体、关系列表以及如何连接它们的说明来指导 LLM。但请注意，提取的图谱可能不完全符合这些指南。实体和关系可以表示为简单的字符串（用于其标签）或字典。如果使用字典，它必须包含一个标签键，并且可以选择包含描述和属性键，如下所示
ENTITIES = [
# entities can be defined with a simple label...
"Person",
# ... or with a dict if more details are needed,
# such as a description:
{"label": "House", "description": "Family the person belongs to"},
# or a list of properties the LLM will try to attach to the entity:
{"label": "Planet", "properties": [{"name": "weather", "type": "STRING"}]},
]
# same thing for relationships:
RELATIONS = [
"PARENT_OF",
{
"label": "HEIR_OF",
"description": "Used for inheritor relationship between father and sons",
},
{"label": "RULES", "properties": [{"name": "fromYear", "type": "INTEGER"}]},
]
potential_schema 由格式为：(source_node_label, relationship_label, target_node_label) 的三元组列表定义。例如
POTENTIAL_SCHEMA = [
("Person", "PARENT_OF", "Person"),
("Person", "HEIR_OF", "House"),
("House", "RULES", "Planet"),
]
此模式信息可以提供给 SimpleKGBuilder，如下所示
kg_builder = SimpleKGPipeline(
# ...
entities=ENTITIES,
relations=RELATIONS,
potential_schema=POTENTIAL_SCHEMA,
# ...
)
额外配置¶
这些参数是 EntityAndRelationExtractor 组件的一部分。有关详细信息，请参阅实体和关系提取器部分。它们也可以通过 SimpleKGPipeline 接口访问。
kg_builder = SimpleKGPipeline(
# ...
prompt_template="",
lexical_graph_config=my_config,
enforce_schema="STRICT"
on_error="RAISE",
# ...
)
跳过实体解析¶
默认情况下，每次运行后都会执行实体解析步骤，以合并具有相同标签和名称属性的节点。要禁用此行为，请调整以下参数
kg_builder = SimpleKGPipeline(
# ...
perform_entity_resolution=False,
# ...
)
Neo4j 数据库¶
要写入非默认 Neo4j 数据库，请使用此参数指定数据库名称
kg_builder = SimpleKGPipeline(
# ...
neo4j_database="myDb",
# ...
)
使用自定义组件¶
对于高级定制或使用自定义实现时，您可以将特定组件的实例传递给 SimpleKGPipeline。目前可定制的组件有
text_splitter：必须是 TextSplitter 的实例
pdf_loader：必须是 PdfLoader 的实例
kg_writer：必须是 KGWriter 的实例
例如，以下代码可用于定制文本分割器组件中的块大小和块重叠
from neo4j_graphrag.experimental.components.text_splitters.fixed_size_splitter import (
FixedSizeSplitter,
)
text_splitter = FixedSizeSplitter(chunk_size=500, chunk_overlap=100)
kg_builder = SimpleKGPipeline(
# ...
text_splitter=text_splitter,
# ...
)
使用配置文件¶
from neo4j_graphrag.experimental.pipeline.config.runner import PipelineRunner
file_path = "my_config.json"
pipeline = PipelineRunner.from_config_file(file_path)
await pipeline.run({"text": "my text"})
配置文件可以是 JSON 或 YAML 格式。
以下是一个 JSON 格式的基础配置文件的示例
{
"version_": 1,
"template_": "SimpleKGPipeline",
"neo4j_config": {},
"llm_config": {},
"embedder_config": {}
}
以及 YAML 格式的示例
version_: 1
template_: SimpleKGPipeline
neo4j_config:
llm_config:
embedder_config:
定义 Neo4j 驱动¶
以下是一个在 JSON 配置文件中配置 Neo4j 驱动的示例
{
"neo4j_config": {
"params_": {
"uri": "bolt://...",
"user": "neo4j",
"password": "password"
}
}
}
YAML 格式相同
neo4j_config:
params_:
uri: bolt://
user: neo4j
password: password
在某些情况下，可能需要避免硬编码敏感值（例如密码或 API 密钥），以确保安全性。为此，配置解析器支持参数解析方法。
参数解析¶
要指示配置解析器从环境变量读取参数，请使用以下语法
{
"neo4j_config": {
"params_": {
"uri": "bolt://...",
"user": "neo4j",
"password": {
"resolver_": "ENV",
"var_": "NEO4J_PASSWORD"
}
}
}
}
以及 YAML 格式
neo4j_config:
params_:
uri: bolt://
user: neo4j
password:
resolver_: ENV
var_: NEO4J_PASSWORD
resolver_=ENV 键是强制性的，其值不能更改。
var_ 键指定要读取的环境变量的名称。
此语法适用于所有参数。
定义 LLM¶
以下是一个在 JSON 配置文件中配置 LLM 的示例
{
"llm_config": {
"class_": "OpenAILLM",
"params_": {
"mode_name": "gpt-4o",
"api_key": {
"resolver_": "ENV",
"var_": "OPENAI_API_KEY",
},
"model_params": {
"temperature": 0,
"max_tokens": 2000,
"response_format": {"type": "json_object"}
}
}
}
}
以及等效的 YAML 格式
llm_config:
class_: OpenAILLM
params_:
model_name: gpt-4o
api_key:
resolver_: ENV
var_: OPENAI_API_KEY
model_params:
temperature: 0
max_tokens: 2000
response_format:
type: json_object
class_ 键指定要实例化的类的路径。
params_ 键包含要传递给类构造函数的参数。
当使用此软件包提供的 LLM 实现时，class_ 键中的完整路径可以省略（解析器将自动从 neo4j_graphrag.llm 导入）。对于自定义实现，必须明确指定完整路径，例如：my_package.my_llm.MyLLM。
警告
请查阅安装部分，确保在使用 LLM 时已安装所需的依赖项。
定义嵌入器¶
同样的原则适用于 embedder_config
{
"embedder_config": {
"class_": "OpenAIEmbeddings",
"params_": {
"mode": "text-embedding-ada-002",
"api_key": {
"resolver_": "ENV",
"var_": "OPENAI_API_KEY",
}
}
}
}
或者 YAML 版本
embedder_config:
class_: OpenAIEmbeddings
params_:
api_key:
resolver_: ENV
var_: OPENAI_API_KEY
对于此软件包中的嵌入器实现，class_ 键中的完整路径可以省略（解析器将从 neo4j_graphrag.embeddings 导入）。
对于自定义实现，必须提供完整路径，例如：my_package.my_embedding.MyEmbedding。
其他配置¶
SimpleKGPipeline 中公开的其他参数也可以在配置文件中进行配置。
{
"from_pdf": false,
"perform_entity_resolution": true,
"neo4j_database": "myDb",
"on_error": "IGNORE",
"prompt_template": "...",
"entities": [
"Person",
{
"label": "House",
"description": "Family the person belongs to",
"properties": [
{"name": "name", "type": "STRING"}
]
},
{
"label": "Planet",
"properties": [
{"name": "name", "type": "STRING"},
{"name": "weather", "type": "STRING"}
]
}
],
"relations": [
"PARENT_OF",
{
"label": "HEIR_OF",
"description": "Used for inheritor relationship between father and sons"
},
{
"label": "RULES",
"properties": [
{"name": "fromYear", "type": "INTEGER"}
]
}
],
"potential_schema": [
["Person", "PARENT_OF", "Person"],
["Person", "HEIR_OF", "House"],
["House", "RULES", "Planet"]
],
"lexical_graph_config": {
"chunk_node_label": "TextPart"
}
}
或在 YAML 中
from_pdf: false
perform_entity_resolution: true
neo4j_database: myDb
on_error: IGNORE
prompt_template: ...
entities:
- label: Person
- label: House
description: Family the person belongs to
properties:
- name: name
type: STRING
- label: Planet
properties:
- name: name
type: STRING
- name: weather
type: STRING
relations:
- label: PARENT_OF
- label: HEIR_OF
description: Used for inheritor relationship between father and sons
- label: RULES
properties:
- name: fromYear
type: INTEGER
potential_schema:
- ["Person", "PARENT_OF", "Person"]
- ["Person", "HEIR_OF", "House"]
- ["House", "RULES", "Planet"]
lexical_graph_config:
chunk_node_label: TextPart
也可以进一步定制组件，语法类似于用于 llm_config 或 embedder_config 的语法
{
"text_splitter": {
"class_": "text_splitters.FixedSizeSplitter",
"params_": {
"chunk_size": 500,
"chunk_overlap": 100
}
}
}
YAML 等效项
text_splitter:
class_: text_splitters.fixed_size_splitter.FixedSizeSplitter
params_:
chunk_size: 100
chunk_overlap: 10
如果需要，将自动添加 neo4j_graphrag.experimental.components 前缀。
知识图谱构建器组件¶
以下是此软件包中可用的不同组件及其使用方法列表。
这些组件中的每一个都可以单独运行
import asyncio
from neo4j_graphrag.experimental.components.pdf_loader import PdfLoader
my_component = PdfLoader()
asyncio.run(my_component.run("my_file.pdf"))
它们也可以在管道中使用
from neo4j_graphrag.experimental.pipeline import Pipeline
from neo4j_graphrag.experimental.components.pdf_loader import PdfLoader
pipeline = Pipeline()
my_component = PdfLoader()
pipeline.add_component(my_component, "component_name")
数据加载器¶
数据加载器从文件路径开始，并返回从该文件中提取的文本。
此软件包目前支持从 PDF 中提取文本
from pathlib import Path
from neo4j_graphrag.experimental.components.pdf_loader import PdfLoader
loader = PdfLoader()
await loader.run(path=Path("my_file.pdf"))
要实现您自己的加载器，请使用 DataLoader 接口
from pathlib import Path
from neo4j_graphrag.experimental.components.pdf_loader import DataLoader, PdfDocument
class MyDataLoader(DataLoader):
async def run(self, path: Path) -> PdfDocument:
# process file in `path`
return PdfDocument(text="text")
文本分割器¶
顾名思义，文档分割器将文档分割成更小的块，以便在 LLM 令牌限制内进行处理
from neo4j_graphrag.experimental.components.text_splitters.fixed_size_splitter import FixedSizeSplitter
splitter = FixedSizeSplitter(chunk_size=4000, chunk_overlap=200, approximate=False)
splitter.run(text="Hello World. Life is beautiful.")
注意
approximate 标志默认设置为 True，以确保在可能的情况下块的开始和结束是清晰的（即避免单词被切断）。
此软件包中包含 LangChain 和 LlamaIndex 文本分割器的包装器
from langchain_text_splitters import CharacterTextSplitter
from neo4j_graphrag.experimental.components.text_splitters.langchain import LangChainTextSplitterAdapter
splitter = LangChainTextSplitterAdapter(
CharacterTextSplitter(chunk_size=4000, chunk_overlap=200, separator=".")
)
await splitter.run(text="Hello World. Life is beautiful.")
另请参阅 LangChainTextSplitterAdapter 和 LlamaIndexTextSplitterAdapter。
要实现自定义文本分割器，可以使用 TextSplitter 接口
from neo4j_graphrag.experimental.components.text_splitters.base import TextSplitter
from neo4j_graphrag.experimental.components.types import TextChunks, TextChunk
class MyTextSplitter(TextSplitter):
def __init__(self, separator: str = ".") -> None:
self.separator = separator
async def run(self, text: str) -> TextChunks:
return TextChunks(
chunks=[
TextChunk(text=text_chunk)
for text_chunk in text.split(self.separator)
]
)
块嵌入器¶
为了嵌入块的文本（用于向量搜索 RAG），可以使用 TextChunkEmbedder 组件，该组件依赖于 Embedder 接口。
使用示例
from neo4j_graphrag.experimental.components.embedder import TextChunkEmbedder
from neo4j_graphrag.embeddings.openai import OpenAIEmbeddings
text_chunk_embedder = TextChunkEmbedder(embedder=OpenAIEmbeddings())
await text_chunk_embedder.run(text_chunks=TextChunks(chunks=[TextChunk(text="my_text")]))
注意
要使用 OpenAI（嵌入或 LLM），OPENAI_API_KEY 必须在环境变量中，例如使用
import os
os.environ["OPENAI_API_KEY"] = "sk-..."
如果 OpenAI 不是一个选项，请参阅 嵌入器，了解如何使用其他支持的嵌入器。
嵌入被添加到每个块的元数据中，如果 EntityRelationExtractor 中启用了 create_lexical_graph（继续阅读），则将作为块节点属性保存到图谱中。
词汇图谱构建器¶
一旦提取并嵌入（如果需要）了块，就可以创建图谱了。
词汇图谱包含
Document 节点：表示已处理的文档并具有 path 属性。
Chunk 节点：表示文本块。它们具有 text 属性，如果计算过，则具有 embedding 属性。
NEXT_CHUNK 关系：一个块节点与文档中下一个块节点之间的关系。它可用于增强 RAG 应用程序中的上下文。
FROM_DOCUMENT 关系：每个块与它所属的文档之间的关系。
使用示例
from neo4j_graphrag.experimental.pipeline.components.lexical_graph_builder import LexicalGraphBuilder
from neo4j_graphrag.experimental.pipeline.components.types import LexicalGraphConfig
lexical_graph_builder = LexicalGraphBuilder(config=LexicalGraphConfig())
graph = await lexical_graph_builder.run(
text_chunks=TextChunks(chunks=[
TextChunk(text="some text", index=0),
TextChunk(text="some text", index=1),
]),
document_info=DocumentInfo(path="my_document.pdf"),
)
请参阅 知识图谱写入器，了解如何将生成的节点和关系写入 Neo4j。
Neo4j 块读取器¶
Neo4j 块读取器组件用于从 Neo4j 读取文本块。文本块可以由词汇图谱构建器或其他进程创建。
import neo4j
from neo4j_graphrag.experimental.components.neo4j_reader import Neo4jChunkReader
from neo4j_graphrag.experimental.components.types import LexicalGraphConfig
reader = Neo4jChunkReader(driver)
result = await reader.run()
配置节点标签和关系类型¶
可选地，可以使用 LexicalGraphConfig 对象配置文档和块节点标签
from neo4j_graphrag.experimental.components.neo4j_reader import Neo4jChunkReader
from neo4j_graphrag.experimental.components.types import LexicalGraphConfig, TextChunks
# optionally, define a LexicalGraphConfig object
# shown below with the default values
config = LexicalGraphConfig(
chunk_node_label="Chunk",
document_node_label="Document",
chunk_to_document_relationship_type="PART_OF_DOCUMENT",
next_chunk_relationship_type="NEXT_CHUNK",
node_to_chunk_relationship_type="PART_OF_CHUNK",
chunk_embedding_property="embeddings",
)
reader = Neo4jChunkReader(driver)
result = await reader.run(lexical_graph_config=config)
模式构建器¶
该模式用于尝试将 LLM 限制在感兴趣的可能实体和关系列表中。到目前为止，模式必须通过指定以下内容手动创建
实体：LLM 应该在文本中查找的实体，包括它们的属性（名称和类型）。
关系：这些实体之间感兴趣的关系，包括关系属性（名称和类型）。
三元组：定义每种关系的起始（源）和结束（目标）实体类型。
以下代码块说明了这些概念
from neo4j_graphrag.experimental.components.schema import (
SchemaBuilder,
SchemaEntity,
SchemaProperty,
SchemaRelation,
)
schema_builder = SchemaBuilder()
await schema_builder.run(
entities=[
SchemaEntity(
label="Person",
properties=[
SchemaProperty(name="name", type="STRING"),
SchemaProperty(name="place_of_birth", type="STRING"),
SchemaProperty(name="date_of_birth", type="DATE"),
],
),
SchemaEntity(
label="Organization",
properties=[
SchemaProperty(name="name", type="STRING"),
SchemaProperty(name="country", type="STRING"),
],
),
],
relations=[
SchemaRelation(
label="WORKED_ON",
),
SchemaRelation(
label="WORKED_FOR",
),
],
possible_schema=[
("Person", "WORKED_ON", "Field"),
("Person", "WORKED_FOR", "Organization"),
],
)
验证后，此模式将保存到 SchemaConfig 对象中，其字典表示将传递给 LLM。
实体和关系提取器¶
此组件负责从每个文本块中提取相关实体和关系，并以模式作为指导。
此软件包包含一个基于 LLM 的实体和关系提取器：LLMEntityRelationExtractor。它可以通过这种方式使用
from neo4j_graphrag.experimental.components.entity_relation_extractor import (
LLMEntityRelationExtractor,
)
from neo4j_graphrag.llm import OpenAILLM
extractor = LLMEntityRelationExtractor(
llm=OpenAILLM(
model_name="gpt-4o",
model_params={
"max_tokens": 1000,
"response_format": {"type": "json_object"},
},
)
)
await extractor.run(chunks=TextChunks(chunks=[TextChunk(text="some text")]))
警告
使用 OpenAILLM 需要 openai Python 客户端。您可以使用 pip install “neo4j_graphrag[openai]” 进行安装。
警告
如果模型参数中包含 “response_format”: {“type”: “json_object”}，则 LLMEntityRelationExtractor 的效果会更好。
要使用的 LLM 可以自定义，唯一的限制是它必须符合 LLMInterface。
模式强制行为¶
默认情况下，即使提供了模式来指导 LLM 进行实体和关系提取，LLM 的响应也不会根据该模式进行验证。可以通过在 LLMEntityRelationExtractor 构造函数中使用 enforce_schema 标志来更改此行为
from neo4j_graphrag.experimental.components.entity_relation_extractor import LLMEntityRelationExtractor
from neo4j_graphrag.experimental.components.types import SchemaEnforcementMode
extractor = LLMEntityRelationExtractor(
# ...
enforce_schema=SchemaEnforcementMode.STRICT,
)
在此情况下，任何不属于所提供模式的提取节点/关系/属性都将被剪枝。任何起始节点或结束节点不符合 potential_schema 中提供的元组的关系都将被剪枝。如果关系的起始/结束节点有效但方向不正确，则会反转方向。如果节点没有留下任何属性，它也将被剪枝。
警告
请注意，如果模式强制模式开启但未提供模式，则不会应用任何模式强制。
错误行为¶
默认情况下，如果一个块的提取失败，它将被忽略，非失败的块将被保存。可以通过在 LLMEntityRelationExtractor 构造函数中使用 on_error 标志来更改此行为
from neo4j_graphrag.experimental.components.entity_relation_extractor import (
LLMEntityRelationExtractor,
OnError,
)
extractor = LLMEntityRelationExtractor(
# ...
on_error=OnError.RAISE,
)
在这种情况下，任何失败的块都将导致整个管道（所有块）失败，并且不会将任何数据保存到 Neo4j。
词汇图谱¶
默认情况下，LLMEntityRelationExtractor 还会创建词汇图谱。
如果不需要此“词汇图谱”，请在提取器构造函数中将 created_lexical_graph 设置为 False
extractor = LLMEntityRelationExtractor(
llm=....,
create_lexical_graph=False,
)
注意
如果 self.create_lexical_graph 设置为 True，则将创建完整的词汇图谱，包括文档和块节点，以及实体与其提取来源块之间的关系。
如果 self.create_lexical_graph 设置为 False 但提供了 lexical_graph_config，则不会创建文档和块节点。但是，块与从中提取的实体之间的关系仍将添加到图谱中。
警告
如果省略 self.create_lexical_graph 且块不存在，这将导致写入器不会在数据库中创建任何关系。
定制提示¶
默认提示使用 ERExtractionTemplate。可以提供自定义提示作为字符串
extractor = LLMEntityRelationExtractor(
llm=....,
prompt="Extract entities from {text}",
)
以下变量可在提示中使用
text (str)：待分析文本（必需）。
schema (str)：要使用的图谱模式。
examples (str)：用于少样本学习的示例。
子类化 EntityRelationExtractor¶
如果需要更多定制，可以子类化 EntityRelationExtractor 接口
from pydantic import validate_call
from neo4j_graphrag.experimental.components.entity_relation_extractor import EntityRelationExtractor
from neo4j_graphrag.experimental.components.schema import SchemaConfig
from neo4j_graphrag.experimental.components.types import (
Neo4jGraph,
Neo4jNode,
Neo4jRelationship,
TextChunks,
)
class MyExtractor(EntityRelationExtractor):
@validate_call
async def run(self, chunks: TextChunks, **kwargs: Any) -> Neo4jGraph:
return Neo4jGraph(
nodes=[
Neo4jNode(id="0", label="Person", properties={"name": "A. Einstein"}),
Neo4jNode(id="1", label="Concept", properties={"name": "Theory of relativity"}),
],
relationships=[
Neo4jRelationship(type="PROPOSED_BY", start_node_id="1", end_node_id="0", properties={"year": 1915})
],
)
知识图谱写入器¶
知识图谱写入器用于保存 EntityRelationExtractor 的结果。主要的实现是 Neo4jWriter，它将节点和关系写入 Neo4j 数据库
import neo4j
from neo4j_graphrag.experimental.components.kg_writer import Neo4jWriter
from neo4j_graphrag.experimental.components.types import Neo4jGraph
with neo4j.GraphDatabase.driver(
"bolt://localhost:7687", auth=("neo4j", "password")
) as driver:
writer = Neo4jWriter(driver)
graph = Neo4jGraph(nodes=[], relationships=[])
await writer.run(graph)
调整 Neo4jWriter 的 batch_size 参数以优化插入性能。此参数控制每个批次插入的节点或关系数量，默认值为 1000。
参见 Neo4jGraph。
可以使用 KGWriter 接口创建自定义写入器
import json
from pydantic import validate_call
from neo4j_graphrag.experimental.components.kg_writer import KGWriter
class JsonWriter(KGWriter):
def __init__(self, file_name: str) -> None:
self.file_name = file_name
@validate_call
async def run(self, graph: Neo4jGraph) -> KGWriterModel:
try:
with open(self.file_name, "w") as f:
json.dump(graph.model_dump(), f, indent=2)
return KGWriterModel(status="SUCCESS")
except Exception:
return KGWriterModel(status="FAILURE")
注意
当输入参数包含 Pydantic 模型时，需要 validate_call 装饰器。
请参阅 API 参考中的 KGWriterModel 和 KGWriter。
实体解析器¶
知识图谱写入器组件为每个识别出的实体创建新节点，而不对实体相似性做出假设。实体解析器负责通过合并代表同一真实世界对象的实体节点来完善所创建的知识图谱。
实际上，此软件包实现了三个解析器
一个简单的解析器，用于合并具有相同标签和相同“名称”属性的节点；
两个基于相似性的解析器，用于合并具有相同标签和相似文本属性集（默认情况下使用“名称”属性）的节点
一个语义匹配解析器，基于 spaCy 嵌入和嵌入向量的余弦相似度。此解析器是使用静态嵌入进行高质量知识图谱解析的理想选择。
一个模糊匹配解析器，基于 RapidFuzz 使用 Levenshtein 距离进行快速模糊字符串匹配。此解析器通过使用字符串相似度度量来提供更快的摄取速度，但可能以解析精度为代价。
警告
SinglePropertyExactMatchResolver、SpaCySemanticMatchResolver 和 FuzzyMatchResolver 替换由知识图谱写入器创建的节点。
请查阅安装部分，确保在使用 SpaCySemanticMatchResolver 和 FuzzyMatchResolver 时已安装所需的依赖项。
解析器可以这样使用
from neo4j_graphrag.experimental.components.resolver import (
SinglePropertyExactMatchResolver,
# SpaCySemanticMatchResolver,
# FuzzyMatchResolver,
)
resolver = SinglePropertyExactMatchResolver(driver) # exact match resolver
# resolver = SpaCySemanticMatchResolver(driver) # semantic match with spaCy
# resolver = FuzzyMatchResolver(driver) # fuzzy match with RapidFuzz
res = await resolver.run()
警告
默认情况下，所有带有 __Entity__ 标签的节点都将被解析。此行为可以通过下面描述的 filter_query 参数进行控制。
过滤查询参数¶
要将特定节点排除在解析之外，可以将 filter_query 添加到查询中。例如，如果已解析的实体在图谱中应用了 :Resolved 标签，则可以使用以下方法排除这些实体
from neo4j_graphrag.experimental.components.resolver import (
SinglePropertyExactMatchResolver,
)
filter_query = "WHERE NOT entity:Resolved"
resolver = SinglePropertyExactMatchResolver(driver, filter_query=filter_query)
res = await resolver.run()
类似的方法可用于排除在同一文档上先前管道运行中创建的实体，假设已将标签 OldDocument 分配给先前创建的文档节点
filter_query = "WHERE NOT EXISTS((entity)-[:FROM_DOCUMENT]->(:OldDocument))"