API 文档

组件

KGWriter

class neo4j_graphrag.experimental.components.kg_writer.KGWriter

用于将知识图谱写入数据存储的抽象类。

abstract run(graph, lexical_graph_config=LexicalGraphConfig(id_prefix='', document_node_label='Document', chunk_node_label='Chunk', chunk_to_document_relationship_type='FROM_DOCUMENT', next_chunk_relationship_type='NEXT_CHUNK', node_to_chunk_relationship_type='FROM_CHUNK', chunk_index_property='index', chunk_text_property='text', chunk_embedding_property='embedding'))

将图写入数据存储。

参数：

• graph (Neo4jGraph) – 要写入数据存储的知识图谱。

• lexical_graph_config (LexicalGraphConfig) – 词汇图中的节点标签和关系类型。

返回类型：

KGWriterModel

Neo4jWriter

class neo4j_graphrag.experimental.components.kg_writer.Neo4jWriter(driver, neo4j_database=None, batch_size=1000)

将知识图谱写入 Neo4j 数据库。

参数：

• driver (neo4j.driver) – 用于连接到数据库的 Neo4j 驱动程序。

• neo4j_database (Optional[str]) – 要写入的 Neo4j 数据库的名称。如果未提供，则默认为“neo4j”。

• batch_size (int) – 要批量写入数据库的节点或关系的数量。默认为 1000。

示例

from neo4j import GraphDatabase
from neo4j_graphrag.experimental.components.kg_writer import Neo4jWriter
from neo4j_graphrag.experimental.pipeline import Pipeline

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")
DATABASE = "neo4j"

driver = GraphDatabase.driver(URI, auth=AUTH, database=DATABASE)
writer = Neo4jWriter(driver=driver, neo4j_database=DATABASE)

pipeline = Pipeline()
pipeline.add_component(writer, "writer")

run(graph, lexical_graph_config=LexicalGraphConfig(id_prefix='', document_node_label='Document', chunk_node_label='Chunk', chunk_to_document_relationship_type='FROM_DOCUMENT', next_chunk_relationship_type='NEXT_CHUNK', node_to_chunk_relationship_type='FROM_CHUNK', chunk_index_property='index', chunk_text_property='text', chunk_embedding_property='embedding'))

将知识图谱更新插入到 Neo4j 数据库中。

参数：

• graph (Neo4jGraph) – 要更新插入到数据库中的知识图谱。

• lexical_graph_config (LexicalGraphConfig)

返回类型：

KGWriterModel

TextSplitter

class neo4j_graphrag.experimental.components.text_splitters.base.TextSplitter

文本分割器的接口。

abstract async run(text)

将一段文本分割成块。

参数：

text (str) – 要分割的文本。

返回值：

块列表。

返回类型：

TextChunks

FixedSizeSplitter

class neo4j_graphrag.experimental.components.text_splitters.fixed_size_splitter.FixedSizeSplitter(chunk_size=4000, chunk_overlap=200)

文本分割器，它将输入文本分割成固定大小的块，并可以选择重叠。

参数：

• chunk_size (int) – 每个块中的字符数。

• chunk_overlap (int) – 前一个块与每个块重叠的字符数。必须小于chunk_size。

示例

from neo4j_graphrag.experimental.components.text_splitters.fixed_size_splitter import FixedSizeSplitter
from neo4j_graphrag.experimental.pipeline import Pipeline

pipeline = Pipeline()
text_splitter = FixedSizeSplitter(chunk_size=4000, chunk_overlap=200)
pipeline.add_component(text_splitter, "text_splitter")

run(text)

将一段文本分割成块。

参数：

text (str) – 要分割的文本。

返回值：

块列表。

返回类型：

TextChunks

LangChainTextSplitterAdapter

LlamaIndexTextSplitterAdapter

TextChunkEmbedder

class neo4j_graphrag.experimental.components.embedder.TextChunkEmbedder(embedder)

用于从文本块创建嵌入的组件。

参数：

embedder (Embedder) – 用于创建嵌入的嵌入器。

示例

from neo4j_graphrag.experimental.components.embedder import TextChunkEmbedder
from neo4j_graphrag.embeddings.openai import OpenAIEmbeddings
from neo4j_graphrag.experimental.pipeline import Pipeline

embedder = OpenAIEmbeddings(model="text-embedding-3-large")
chunk_embedder = TextChunkEmbedder(embedder)
pipeline = Pipeline()
pipeline.add_component(chunk_embedder, "chunk_embedder")

run(text_chunks)

嵌入文本块列表。

参数：

text_chunks (TextChunks) – 要嵌入的文本块。

返回值：

每个输入文本块都添加了一个嵌入。

返回类型：

TextChunks

LexicalGraphBuilder

Neo4jChunkReader

class neo4j_graphrag.experimental.components.neo4j_reader.Neo4jChunkReader(driver, fetch_embeddings=False)

参数：

• driver (neo4j.Driver)

• fetch_embeddings (bool)

run(lexical_graph_config=LexicalGraphConfig(id_prefix='', document_node_label='Document', chunk_node_label='Chunk', chunk_to_document_relationship_type='FROM_DOCUMENT', next_chunk_relationship_type='NEXT_CHUNK', node_to_chunk_relationship_type='FROM_CHUNK', chunk_index_property='index', chunk_text_property='text', chunk_embedding_property='embedding'))

参数：

lexical_graph_config (LexicalGraphConfig)

返回类型：

TextChunks

SchemaBuilder

class neo4j_graphrag.experimental.components.schema.SchemaBuilder

一个用于从给定实体、关系及其在潜在模式中定义的相互关系构建 SchemaConfig 对象的构建器类。

示例

from neo4j_graphrag.experimental.components.schema import (
    SchemaBuilder,
    SchemaEntity,
    SchemaProperty,
    SchemaRelation,
)
from neo4j_graphrag.experimental.pipeline import Pipeline

entities = [
    SchemaEntity(
        label="PERSON",
        description="An individual human being.",
        properties=[
            SchemaProperty(
                name="name", type="STRING", description="The name of the person"
            )
        ],
    ),
    SchemaEntity(
        label="ORGANIZATION",
        description="A structured group of people with a common purpose.",
        properties=[
            SchemaProperty(
                name="name", type="STRING", description="The name of the organization"
            )
        ],
    ),
]
relations = [
    SchemaRelation(
        label="EMPLOYED_BY", description="Indicates employment relationship."
    ),
]
potential_schema = [
    ("PERSON", "EMPLOYED_BY", "ORGANIZATION"),
]
pipe = Pipeline()
schema_builder = SchemaBuilder()
pipe.add_component(schema_builder, "schema_builder")
pipe_inputs = {
    "schema": {
        "entities": entities,
        "relations": relations,
        "potential_schema": potential_schema,
    },
    ...
}
pipe.run(pipe_inputs)

run(entities, relations=None, potential_schema=None)

异步构建并返回一个 SchemaConfig 对象。

参数：

• entities (List[SchemaEntity]) – 实体对象列表。

• relations (List[SchemaRelation]) – 关系对象列表。

• potential_schema (Dict[str, List[str]]) – 将实体名称映射到关系名称列表的字典。

返回值：

一个配置好的模式对象，异步构建。

返回类型：

SchemaConfig

EntityRelationExtractor

LLMEntityRelationExtractor

SinglePropertyExactMatchResolver

class neo4j_graphrag.experimental.components.resolver.SinglePropertyExactMatchResolver(driver, filter_query=None, resolve_property='name', neo4j_database=None)

解析具有相同标签和完全相同属性（默认值为“name”）的实体。

参数：

• driver (neo4j.Driver) – 用于连接数据库的 Neo4j 驱动程序。

• filter_query (Optional[str]) – 若要缩小解析范围，请添加 Cypher WHERE 子句。

• resolve_property (str) – 将要比较的属性（默认值：“name”）。如果值完全匹配，则合并实体。

• neo4j_database (Optional[str]) – 要写入的 Neo4j 数据库的名称。如果未提供，则默认为“neo4j”。

示例

from neo4j import GraphDatabase
from neo4j_graphrag.experimental.components.resolver import SinglePropertyExactMatchResolver

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")
DATABASE = "neo4j"

driver = GraphDatabase.driver(URI, auth=AUTH, database=DATABASE)
resolver = SinglePropertyExactMatchResolver(driver=driver, neo4j_database=DATABASE)
await resolver.run()  # no expected parameters

async run()

基于以下规则解析实体：对于每个实体标签，将具有相同“resolve_property”值的实体（完全匹配）分组到单个节点中。

• 属性：如果已设置，则保留第一个节点的属性，否则将写入列表中的第一个属性。

• 关系：合并具有相同类型和目标节点的关系。

有关更多详细信息，请参阅 apoc.refactor.mergeNodes 文档。

返回类型：

ResolutionStats

Pipelines

Pipeline

class neo4j_graphrag.experimental.pipeline.Pipeline(store=None)

这是主管道，其中定义了组件及其执行顺序。

参数：

store (Optional[ResultStore])

draw(path, layout='dot', hide_unused_outputs=True)

参数：

• path (str)

• layout (str)

• hide_unused_outputs (bool)

返回类型：

Any

add_component(component, name)

添加一个新组件。组件通过其名称唯一标识。如果“name”已存在于管道中，则会引发 ValueError。

参数：

• component (Component)

• name (str)

返回类型：

None

connect(start_component_name, end_component_name, input_config=None)

将一个组件连接到另一个组件。

参数：

• start_component_name (str) – 在 add_component 方法中定义的组件名称。

• end_component_name (str) – 在 add_component 方法中定义的组件名称。

• input_config (Optional[dict[str, str]]) – 结束组件输入配置：传播先前组件的输出。

引发:

PipelineDefinitionError – 如果提供的组件不在管道中，或者此连接将创建的图是循环图。

返回类型：

None

async run(data)

参数：

data (dict[str, Any])

返回类型：

PipelineResult

SimpleKGPipeline

Retrievers

RetrieverInterface

类 neo4j_graphrag.retrievers.base.Retriever(driver, neo4j_database=None)

Neo4j检索器的抽象类

参数：

• driver (neo4j.Driver)

• **neo4j_database** (可选[str])

index_name: str

VERIFY_NEO4J_VERSION = True

search(*args, **kwargs)

搜索方法。调用返回 neo4j.Record 列表的 get_search_results 方法，并使用 get_result_formatter 返回的函数格式化它们以返回 RetrieverResult。

参数：

• **args** (Any)

• **kwargs** (Any)

返回类型：

RetrieverResult

抽象 get_search_results(*args, **kwargs)

此方法必须在每个子类中实现。它将接收通过 search 方法提供给公共接口的相同参数，并在验证后。它返回一个 RawSearchResult 对象，该对象包含 neo4j.Record 对象列表和一个可选的 metadata 字典，该字典可以包含检索器级别的信息。

请注意，即使此方法不打算从类外部调用，我们也将其公开，以便使开发人员更清楚地了解它应该在子类中实现。

返回值：

Neo4j 记录列表和可选的元数据字典

返回类型：

RawSearchResult

参数：

• **args** (Any)

• **kwargs** (Any)

get_result_formatter()

返回用于将 neo4j.Record 转换为 RetrieverResultItem 的函数。

返回类型：

Callable[[Record], RetrieverResultItem]

default_record_formatter(record)

尽力猜测节点到文本的方法。继承的类可以重写此方法以实现自定义文本格式化。

参数：

**record** (Record)

返回类型：

RetrieverResultItem

VectorRetriever

类 neo4j_graphrag.retrievers.VectorRetriever(driver, index_name, embedder=None, return_properties=None, result_formatter=None, neo4j_database=None)

提供使用向量搜索嵌入的检索方法。如果提供了嵌入器，则它需要具有所需的 Embedder 类型。

示例

import neo4j
from neo4j_graphrag.retrievers import VectorRetriever

driver = neo4j.GraphDatabase.driver(URI, auth=AUTH)

retriever = VectorRetriever(driver, "vector-index-name", custom_embedder)
retriever.search(query_text="Find me a book about Fremen", top_k=5)

或者如果查询文本的向量嵌入可用

retriever.search(query_vector=..., top_k=5)

参数：

• **driver** (neo4j.Driver) – Neo4j Python 驱动程序。

• **index_name** (str) – 向量索引名称。

• **embedder** (可选[Embedder]) – 用于嵌入查询文本的 Embedder 对象。

• **return_properties** (可选[list[str]]) – 要返回的节点属性列表。

• **result_formatter** (可选[Callable[[neo4j.Record], RetrieverResultItem]]) –

  提供的自定义函数，用于将 neo4j.Record 转换为 RetrieverResultItem。

  在 neo4j.Record 中提供了两个变量

  • node：表示从向量索引搜索中检索到的节点。

  • score：表示相似度得分。

• **neo4j_database** (可选[str]) – Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

引发:

RetrieverInitializationError – 如果输入参数验证失败。

search(query_vector=None, query_text=None, top_k=5, filters=None)

获取提供的 query_vector 或 query_text 的前 top_k 个最近邻嵌入。有关更多详细信息，请参阅以下文档

• 查询向量索引

• db.index.vector.queryNodes()

要通过文本查询，必须在实例化类时提供嵌入器。如果传递了 query_vector，则不需要嵌入器。

参数：

• **query_vector** (可选[list[float]]) – 要获取其最近邻的向量嵌入。默认为 None。

• **query_text** (可选[str]) – 要获取其最近邻的文本。默认为 None。

• **top_k** (int) – 要返回的邻居数量。默认为 5。

• **filters** (可选[dict[str, Any]]) – 用于元数据预过滤的过滤器。默认为 None。

引发:

• SearchValidationError – 如果输入参数验证失败。

• EmbeddingRequiredError – 如果未提供嵌入器。

返回值：

搜索查询的结果，作为 neo4j.Record 列表和可选的元数据字典

返回类型：

RawSearchResult

VectorCypherRetriever

类 neo4j_graphrag.retrievers.VectorCypherRetriever(driver, index_name, retrieval_query, embedder=None, result_formatter=None, neo4j_database=None)

提供使用向量相似性并通过 Cypher 查询进行增强的检索方法。此检索器建立在 VectorRetriever 的基础上。如果提供了嵌入器，则它需要具有所需的 Embedder 类型。

注意：node 是来自基本查询的变量，可以在 retrieval_query 中使用，如下面的示例所示。

retrieval_query 是可以在检索 node 后允许进行图遍历的其他 Cypher。

示例

import neo4j
from neo4j_graphrag.retrievers import VectorCypherRetriever

driver = neo4j.GraphDatabase.driver(URI, auth=AUTH)

retrieval_query = "MATCH (node)-[:AUTHORED_BY]->(author:Author)" "RETURN author.name"
retriever = VectorCypherRetriever(
  driver, "vector-index-name", retrieval_query, custom_embedder
)
retriever.search(query_text="Find me a book about Fremen", top_k=5)

参数：

• **driver** (neo4j.Driver) – Neo4j Python 驱动程序。

• **index_name** (str) – 向量索引名称。

• **retrieval_query** (str) – 附加的 Cypher 查询。

• **embedder** (可选[Embedder]) – 用于嵌入查询文本的 Embedder 对象。

• **result_formatter** (可选[Callable[[neo4j.Record], RetrieverResultItem]]) – 提供的自定义函数，用于将 neo4j.Record 转换为 RetrieverResultItem。

• **neo4j_database** (可选[str]) –

  Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

在 用户指南 中了解更多信息。

search(query_vector=None, query_text=None, top_k=5, query_params=None, filters=None)

获取提供的 query_vector 或 query_text 的前 top_k 个最近邻嵌入。有关更多详细信息，请参阅以下文档

• 查询向量索引

• db.index.vector.queryNodes()

要通过文本查询，必须在实例化类时提供嵌入器。如果传递了 query_vector，则不需要嵌入器。

参数：

• **query_vector** (可选[list[float]]) – 要获取其最近邻的向量嵌入。默认为 None。

• **query_text** (可选[str]) – 要获取其最近邻的文本。默认为 None。

• **top_k** (int) – 要返回的邻居数量。默认为 5。

• query_params (可选[dict[str, Any]]) – Cypher 查询的参数。默认为 None。

• **filters** (可选[dict[str, Any]]) – 用于元数据预过滤的过滤器。默认为 None。

引发:

• SearchValidationError – 如果输入参数验证失败。

• EmbeddingRequiredError – 如果未提供嵌入器。

返回值：

搜索查询的结果，作为 neo4j.Record 列表和可选的元数据字典

返回类型：

RawSearchResult

混合检索器

class neo4j_graphrag.retrievers.HybridRetriever(driver, vector_index_name, fulltext_index_name, embedder=None, return_properties=None, result_formatter=None, neo4j_database=None)

提供使用向量嵌入搜索和全文搜索相结合的检索方法。如果提供了嵌入器，则它需要具有所需的 Embedder 类型。

示例

import neo4j
from neo4j_graphrag.retrievers import HybridRetriever

driver = neo4j.GraphDatabase.driver(URI, auth=AUTH)

retriever = HybridRetriever(
    driver, "vector-index-name", "fulltext-index-name", custom_embedder
)
retriever.search(query_text="Find me a book about Fremen", top_k=5)

参数：

• **driver** (neo4j.Driver) – Neo4j Python 驱动程序。

• vector_index_name (str) – 向量索引名称。

• fulltext_index_name (str) – 全文索引名称。

• **embedder** (可选[Embedder]) – 用于嵌入查询文本的 Embedder 对象。

• **return_properties** (可选[list[str]]) – 要返回的节点属性列表。

• **neo4j_database** (可选[str]) –

  Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

• **result_formatter** (可选[Callable[[neo4j.Record], RetrieverResultItem]]) –

  提供的自定义函数，用于将 neo4j.Record 转换为 RetrieverResultItem。

  在 neo4j.Record 中提供了两个变量

  • node：表示从向量索引搜索中检索到的节点。

  • score：表示相似度得分。

search(query_text, query_vector=None, top_k=5)

获取提供的 query_vector 或 query_text 的前 top_k 个最近邻嵌入。可以同时提供 query_vector 和 query_text。如果提供了 query_vector，则在向量搜索中将优先于嵌入的 query_text。

有关更多详细信息，请参阅以下文档

• 查询向量索引

• db.index.vector.queryNodes()

• db.index.fulltext.queryNodes()

要按文本查询，在实例化类时必须提供嵌入器。

参数：

• query_text (str) – 获取最接近邻居的文本。

• query_vector (可选[list[float]], 可选) – 获取最接近邻居的向量嵌入。默认为 None。

• top_k (int, 可选) – 要返回的邻居数量。默认为 5。

引发:

• SearchValidationError – 如果输入参数验证失败。

• EmbeddingRequiredError – 如果未提供嵌入器。

返回值：

搜索查询的结果，作为 neo4j.Record 列表和可选的元数据字典

返回类型：

RawSearchResult

混合 Cypher 检索器

class neo4j_graphrag.retrievers.HybridCypherRetriever(driver, vector_index_name, fulltext_index_name, retrieval_query, embedder=None, result_formatter=None, neo4j_database=None)

提供使用向量嵌入搜索和全文搜索相结合的检索方法，并通过 Cypher 查询进行增强。此检索器建立在 HybridRetriever 的基础上。如果提供了嵌入器，则它需要具有所需的 Embedder 类型。

注意：node 是来自基本查询的变量，可以在 retrieval_query 中使用，如下面的示例所示。

示例

import neo4j
from neo4j_graphrag.retrievers import HybridCypherRetriever

driver = neo4j.GraphDatabase.driver(URI, auth=AUTH)

retrieval_query = "MATCH (node)-[:AUTHORED_BY]->(author:Author)" "RETURN author.name"
retriever = HybridCypherRetriever(
    driver, "vector-index-name", "fulltext-index-name", retrieval_query, custom_embedder
)
retriever.search(query_text="Find me a book about Fremen", top_k=5)

要按文本查询，在实例化类时必须提供嵌入器。

参数：

• **driver** (neo4j.Driver) – Neo4j Python 驱动程序。

• vector_index_name (str) – 向量索引名称。

• fulltext_index_name (str) – 全文索引名称。

• **retrieval_query** (str) – 附加的 Cypher 查询。

• **embedder** (可选[Embedder]) – 用于嵌入查询文本的 Embedder 对象。

• **result_formatter** (可选[Callable[[neo4j.Record], RetrieverResultItem]]) – 提供的自定义函数，用于将 neo4j.Record 转换为 RetrieverResultItem。

• **neo4j_database** (可选[str]) –

  Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

引发:

RetrieverInitializationError – 如果输入参数验证失败。

search(query_text, query_vector=None, top_k=5, query_params=None)

获取提供的 query_vector 或 query_text 的前 top_k 个最近邻嵌入。可以同时提供 query_vector 和 query_text。如果提供了 query_vector，则在向量搜索中将优先于嵌入的 query_text。

有关更多详细信息，请参阅以下文档

• 查询向量索引

• db.index.vector.queryNodes()

• db.index.fulltext.queryNodes()

参数：

• query_text (str) – 获取最接近邻居的文本。

• **query_vector** (可选[list[float]]) – 要获取其最近邻的向量嵌入。默认为 None。

• **top_k** (int) – 要返回的邻居数量。默认为 5。

• query_params (可选[dict[str, Any]]) – Cypher 查询的参数。默认为 None。

引发:

• SearchValidationError – 如果输入参数验证失败。

• EmbeddingRequiredError – 如果未提供嵌入器。

返回值：

搜索查询的结果，作为 neo4j.Record 列表和可选的元数据字典

返回类型：

RawSearchResult

文本到 Cypher 检索器

class neo4j_graphrag.retrievers.Text2CypherRetriever(driver, llm, neo4j_schema=None, examples=None, result_formatter=None, custom_prompt=None)

允许使用自然语言从 Neo4j 数据库检索记录。使用 LLM 将用户的自然语言查询转换为 Cypher 查询，然后使用生成的 Cypher 查询从 Neo4j 数据库检索记录。

参数：

• **driver** (neo4j.Driver) – Neo4j Python 驱动程序。

• llm (neo4j_graphrag.generation.llm.LLMInterface) – 用于生成 Cypher 查询的 LLM 对象。

• neo4j_schema (可选[str]) – 用于生成 Cypher 查询的 Neo4j 模式。

• examples (可选[list[str], 可选) – LLM 可选使用的用户输入/查询对作为示例。

• custom_prompt (可选[str]) – 可选的自定义提示，用于代替自动生成的提示。如果提供了，则不包含 neo4j_schema 或 examples 参数。

• result_formatter (可选[Callable[[neo4j.Record], RetrieverResultItem]])

引发:

RetrieverInitializationError – 如果输入参数验证失败。

search(query_text, prompt_params=None)

使用 LLM 将 query_text 转换为 Cypher 查询。

使用生成的 Cypher 查询从 Neo4j 数据库检索记录。

参数：

• query_text (str) – 用于搜索 Neo4j 数据库的自然语言查询。

• prompt_params (Dict[str, Any]) – 要注入到自定义提示中的其他值（如果提供了）。例如：{‘schema’: ‘this is the graph schema’}。

引发:

• SearchValidationError – 如果输入参数验证失败。

• Text2CypherRetrievalError – 如果 LLM 无法生成正确的 Cypher 查询。

返回值：

搜索查询的结果，作为 neo4j.Record 列表和可选的元数据字典

返回类型：

RawSearchResult

外部检索器

本节包含与 Neo4j 外部数据库集成的检索器。

WeaviateNeo4j 检索器

PineconeNeo4j 检索器

QdrantNeo4j 检索器

嵌入器

class neo4j_graphrag.embeddings.base.Embedder

嵌入模型的接口。传递到检索器的嵌入器必须实现此接口。

abstract embed_query(text)

嵌入查询文本。

参数：

文本 (str) – 要转换为向量嵌入的文本

返回值：

向量嵌入。

返回类型：

list[float]

SentenceTransformerEmbeddings

class neo4j_graphrag.embeddings.sentence_transformers.SentenceTransformerEmbeddings(model='all-MiniLM-L6-v2', *args, **kwargs)

参数：

• model (str)

• **args** (Any)

• **kwargs** (Any)

embed_query(text)

嵌入查询文本。

参数：

文本 (str) – 要转换为向量嵌入的文本

返回值：

向量嵌入。

返回类型：

list[float]

OpenAIEmbeddings

class neo4j_graphrag.embeddings.openai.OpenAIEmbeddings(model='text-embedding-ada-002', **kwargs)

OpenAI 嵌入类。此类使用 OpenAI Python 客户端为文本数据生成嵌入。

参数：

• model (str) – 要使用的 OpenAI 嵌入模型的名称。默认为“text-embedding-ada-002”。

• kwargs (Any) – 所有其他参数都将传递给 openai.OpenAI 初始化。

AzureOpenAIEmbeddings

class neo4j_graphrag.embeddings.openai.AzureOpenAIEmbeddings(model='text-embedding-ada-002', **kwargs)

Azure OpenAI 嵌入类。此类使用 Azure OpenAI Python 客户端为文本数据生成嵌入。

参数：

• model (str) – 要使用的 Azure OpenAI 嵌入模型的名称。默认为“text-embedding-ada-002”。

• kwargs (Any) – 所有其他参数都将传递给 openai.AzureOpenAI 初始化。

VertexAIEmbeddings

class neo4j_graphrag.embeddings.vertexai.VertexAIEmbeddings(model='text-embedding-004')

Vertex AI 嵌入类。此类使用 Vertex AI Python 客户端为文本数据生成向量嵌入。

参数：

model (str) – 要使用的 Vertex AI 文本嵌入模型的名称。默认为“text-embedding-004”。

embed_query(text, task_type='RETRIEVAL_QUERY', **kwargs)

使用 Vertex AI 文本嵌入模型为给定查询生成嵌入。

参数：

• text (str) – 要生成嵌入的文本。

• task_type (str) – 文本嵌入任务的类型。默认为“RETRIEVAL_QUERY”。有关完整列表，请参见 https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/text-embeddings-api#tasktype。

• **kwargs (Any) – 要传递给 Vertex AI 客户端的 get_embeddings 方法的其他关键字参数。

返回类型：

list[float]

MistralAIEmbeddings

class neo4j_graphrag.embeddings.mistral.MistralAIEmbeddings(model='mistral-embed', **kwargs)

Mistral AI 嵌入类。此类使用 Mistral AI Python 客户端为文本数据生成向量嵌入。

参数：

• model (str) – 要使用的 Mistral AI 文本嵌入模型的名称。默认为“mistral-embed”。

• kwargs (Any)

embed_query(text, **kwargs)

使用 Mistral AI 文本嵌入模型为给定查询生成嵌入。

参数：

• text (str) – 要生成嵌入的文本。

• **kwargs (Any) – 要传递给 Mistral AI 客户端的其他关键字参数。

返回类型：

list[float]

CohereEmbeddings

class neo4j_graphrag.embeddings.cohere.CohereEmbeddings(model='', **kwargs)

参数：

• model (str)

• kwargs (Any)

embed_query(text, **kwargs)

嵌入查询文本。

参数：

• 文本 (str) – 要转换为向量嵌入的文本

• **kwargs** (Any)

返回值：

向量嵌入。

返回类型：

list[float]

生成

LLM

LLMInterface

class neo4j_graphrag.llm.LLMInterface(model_name, model_params=None, **kwargs)

大型语言模型的接口。

参数：

• model_name (str) – 语言模型的名称。

• model_params (Optional[dict], optional) – 将文本发送到模型时传递给模型的其他参数。默认为 None。

• **kwargs (Any) – 初始化类时传递给模型的参数。默认为 None。

abstract invoke(input)

将文本输入发送到 LLM 并检索响应。

参数：

input (str) – 发送到 LLM 的文本

返回值：

LLM 的响应。

返回类型：

LLMResponse

引发:

LLMGenerationError – 如果出现任何错误。

抽象 异步 ainvoke(input)

异步地将文本输入发送到LLM并检索响应。

参数：

input (str) – 发送到 LLM 的文本

返回值：

LLM 的响应。

返回类型：

LLMResponse

引发:

LLMGenerationError – 如果出现任何错误。

OpenAILLM

类 neo4j_graphrag.llm.openai_llm.OpenAILLM(model_name, model_params=None, **kwargs)

参数：

• model_name (字符串)

• model_params (可选[字典[字符串, 任意]])

• kwargs (Any)

AzureOpenAILLM

类 neo4j_graphrag.llm.openai_llm.AzureOpenAILLM(model_name, model_params=None, **kwargs)

参数：

• model_name (字符串)

• model_params (可选[字典[字符串, 任意]])

• kwargs (Any)

VertexAILLM

类 neo4j_graphrag.llm.vertexai_llm.VertexAILLM(model_name='gemini-1.5-flash-001', model_params=None, **kwargs)

Vertex AI 上大型语言模型的接口

参数：

• model_name (字符串, 可选) – 要使用的LLM的名称。默认为“gemini-1.5-flash-001”。

• model_params (Optional[dict], optional) – 将文本发送到模型时传递给模型的其他参数。默认为 None。

• **kwargs (Any) – 初始化类时传递给模型的参数。默认为 None。

引发:

LLMGenerationError – 如果模型生成响应时出错。

示例

from neo4j_graphrag.llm import VertexAILLM
from vertexai.generative_models import GenerationConfig

generation_config = GenerationConfig(temperature=0.0)
llm = VertexAILLM(
    model_name="gemini-1.5-flash-001", generation_config=generation_config
)
llm.invoke("Who is the mother of Paul Atreides?")

invoke(input)

将文本发送到LLM并返回响应。

参数：

input (字符串) – 要发送到LLM的文本。

返回值：

LLM 的响应。

返回类型：

LLMResponse

异步 ainvoke(input)

异步地将文本发送到LLM并返回响应。

参数：

input (字符串) – 要发送到LLM的文本。

返回值：

LLM 的响应。

返回类型：

LLMResponse

AnthropicLLM

类 neo4j_graphrag.llm.anthropic_llm.AnthropicLLM(model_name, model_params=None, **kwargs)

Anthropic 上大型语言模型的接口

参数：

• model_name (字符串, 可选) – 要使用的LLM的名称。默认为“gemini-1.5-flash-001”。

• model_params (Optional[dict], optional) – 将文本发送到模型时传递给模型的其他参数。默认为 None。

• **kwargs (Any) – 初始化类时传递给模型的参数。默认为 None。

引发:

LLMGenerationError – 如果模型生成响应时出错。

示例

from neo4j_graphrag.llm import AnthropicLLM

llm = AnthropicLLM(
    model_name="claude-3-opus-20240229",
    model_params={"max_tokens": 1000},
    api_key="sk...",   # can also be read from env vars
)
llm.invoke("Who is the mother of Paul Atreides?")

invoke(input)

将文本发送到LLM并返回响应。

参数：

input (字符串) – 要发送到LLM的文本。

返回值：

LLM 的响应。

返回类型：

LLMResponse

异步 ainvoke(input)

异步地将文本发送到LLM并返回响应。

参数：

input (字符串) – 要发送到LLM的文本。

返回值：

LLM 的响应。

返回类型：

LLMResponse

CohereLLM

类 neo4j_graphrag.llm.cohere_llm.CohereLLM(model_name='', model_params=None, **kwargs)

Cohere 平台上大型语言模型的接口

参数：

• model_name (字符串, 可选) – 要使用的LLM的名称。默认为“gemini-1.5-flash-001”。

• model_params (Optional[dict], optional) – 将文本发送到模型时传递给模型的其他参数。默认为 None。

• **kwargs (Any) – 初始化类时传递给模型的参数。默认为 None。

引发:

LLMGenerationError – 如果模型生成响应时出错。

示例

from neo4j_graphrag.llm import CohereLLM

llm = CohereLLM(api_key="...")
llm.invoke("Say something")

invoke(input)

将文本发送到LLM并返回响应。

参数：

input (字符串) – 要发送到LLM的文本。

返回值：

LLM 的响应。

返回类型：

LLMResponse

异步 ainvoke(input)

异步地将文本发送到LLM并返回响应。

参数：

input (字符串) – 要发送到LLM的文本。

返回值：

LLM 的响应。

返回类型：

LLMResponse

MistralAILLM

类 neo4j_graphrag.llm.mistralai_llm.MistralAILLM(model_name, model_params=None, **kwargs)

参数：

• model_name (字符串)

• model_params (可选[字典[字符串, 任意]])

• kwargs (Any)

get_messages(input)

参数：

input (字符串)

返回类型：

列表[MessageType]

invoke(input)

将文本输入发送到 Mistral 聊天完成模型并返回响应的内容。

参数：

input (str) – 发送到 LLM 的文本

返回值：

MistralAI 的响应。

返回类型：

LLMResponse

引发:

LLMGenerationError – 如果出现任何错误。

异步 ainvoke(input)

异步地将文本输入发送到 MistralAI 聊天完成模型并返回响应的内容。

参数：

input (str) – 发送到 LLM 的文本

返回值：

MistralAI 的响应。

返回类型：

LLMResponse

引发:

LLMGenerationError – 如果出现任何错误。

PromptTemplate

类 neo4j_graphrag.generation.prompts.PromptTemplate(template=None, expected_inputs=None)

此类用于生成参数化提示。它使用 Python 格式语法（花括号 {} 中的参数）和所需输入列表从字符串（模板）定义。在将指令发送到 LLM 之前，请调用 format 方法，该方法将用提供的值替换参数。如果缺少任何预期输入，则会引发 PromptMissingInputError。

参数：

• template (可选[str])

• expected_inputs (可选[list[str]])

DEFAULT_TEMPLATE: str = ''

EXPECTED_INPUTS: list[str] = []

format(*args, **kwargs)

此方法用于将参数替换为提供的值。必须提供参数： - 作为 kwargs - 如果使用与预期输入相同的顺序，则作为 args

示例

prompt_template = PromptTemplate(
    template='''Explain the following concept to {target_audience}:
    Concept: {concept}
    Answer:
    ''',
    expected_inputs=['target_audience', 'concept']
)
prompt = prompt_template.format('12 yo children', concept='graph database')
print(prompt)

# Result:
# '''Explain the following concept to 12 yo children:
# Concept: graph database
# Answer:
# '''

参数：

• **args** (Any)

• **kwargs** (Any)

返回类型：

str

RagTemplate

class neo4j_graphrag.generation.prompts.RagTemplate(template=None, expected_inputs=None)

参数：

• template (可选[str])

• expected_inputs (可选[list[str]])

DEFAULT_TEMPLATE: str = 'Answer the user question using the following context\n\nContext:\n{context}\n\nExamples:\n{examples}\n\nQuestion:\n{query_text}\n\nAnswer:\n'

EXPECTED_INPUTS: list[str] = ['context', 'query_text', 'examples']

format(query_text, context, examples)

此方法用于将参数替换为提供的值。必须提供参数： - 作为 kwargs - 如果使用与预期输入相同的顺序，则作为 args

示例

prompt_template = PromptTemplate(
    template='''Explain the following concept to {target_audience}:
    Concept: {concept}
    Answer:
    ''',
    expected_inputs=['target_audience', 'concept']
)
prompt = prompt_template.format('12 yo children', concept='graph database')
print(prompt)

# Result:
# '''Explain the following concept to 12 yo children:
# Concept: graph database
# Answer:
# '''

参数：

• query_text (str)

• context (str)

• examples (str)

返回类型：

str

ERExtractionTemplate

class neo4j_graphrag.generation.prompts.ERExtractionTemplate(template=None, expected_inputs=None)

参数：

• template (可选[str])

• expected_inputs (可选[list[str]])

DEFAULT_TEMPLATE: str = '\nYou are a top-tier algorithm designed for extracting\ninformation in structured formats to build a knowledge graph.\n\nExtract the entities (nodes) and specify their type from the following text.\nAlso extract the relationships between these nodes.\n\nReturn result as JSON using the following format:\n{{"nodes": [ {{"id": "0", "label": "Person", "properties": {{"name": "John"}} }}],\n"relationships": [{{"type": "KNOWS", "start_node_id": "0", "end_node_id": "1", "properties": {{"since": "2024-08-01"}} }}] }}\n\nUse only the following nodes and relationships (if provided):\n{schema}\n\nAssign a unique ID (string) to each node, and reuse it to define relationships.\nDo respect the source and target node types for relationship and\nthe relationship direction.\n\nDo not return any additional information other than the JSON in it.\n\nExamples:\n{examples}\n\nInput text:\n\n{text}\n'

EXPECTED_INPUTS: list[str] = ['text']

format(schema, examples, text='')

此方法用于将参数替换为提供的值。必须提供参数： - 作为 kwargs - 如果使用与预期输入相同的顺序，则作为 args

示例

prompt_template = PromptTemplate(
    template='''Explain the following concept to {target_audience}:
    Concept: {concept}
    Answer:
    ''',
    expected_inputs=['target_audience', 'concept']
)
prompt = prompt_template.format('12 yo children', concept='graph database')
print(prompt)

# Result:
# '''Explain the following concept to 12 yo children:
# Concept: graph database
# Answer:
# '''

参数：

• schema (dict[str, Any])

• examples (str)

• text (str)

返回类型：

str

RAG

GraphRAG

class neo4j_graphrag.generation.graphrag.GraphRAG(retriever, llm, prompt_template=<neo4j_graphrag.generation.prompts.RagTemplate object>)

使用特定的检索器和 LLM 执行 GraphRAG 搜索。

示例

import neo4j
from neo4j_graphrag.retrievers import VectorRetriever
from neo4j_graphrag.llm.openai_llm import OpenAILLM
from neo4j_graphrag.generation import GraphRAG

driver = neo4j.GraphDatabase.driver(URI, auth=AUTH)

retriever = VectorRetriever(driver, "vector-index-name", custom_embedder)
llm = OpenAILLM()
graph_rag = GraphRAG(retriever, llm)
graph_rag.search(query_text="Find me a book about Fremen")

参数：

• retriever (Retriever) – 用于查找相关上下文并传递给LLM的检索器。

• llm (LLMInterface) – 用于生成答案的LLM。

• prompt_template (RagTemplate) – 将使用上下文和用户问题进行格式化并传递给LLM的提示模板。

引发:

RagInitializationError – 如果输入参数验证失败。

search(query_text='', examples='', retriever_config=None, return_context=None)

警告

在未来版本中，“return_context”的默认值将从“False”更改为“True”。

此方法执行完整的RAG搜索

1. 检索：上下文检索

2. 增强：提示格式化

3. 生成：使用LLM生成答案

参数：

• query_text (str) – 用户问题

• examples (str) – 添加到LLM提示的示例。

• retriever_config (Optional[dict]) – 传递给检索器搜索方法的参数；例如：top_k

• return_context (bool) – 是否将检索器结果附加到最终结果（默认值：False）

返回值：

LLM生成的答案

返回类型：

RagResultModel

数据库交互

neo4j_graphrag.indexes.create_vector_index(driver, name, label, embedding_property, dimensions, similarity_fn, fail_if_exists=False, neo4j_database=None)

此方法构造一个Cypher查询并执行它，以在Neo4j中创建新的向量索引。

请参阅Cypher手册关于创建向量索引。

确保提供的索引名称在数据库上下文中是唯一的。

示例

from neo4j import GraphDatabase
from neo4j_graphrag.indexes import create_vector_index

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")

INDEX_NAME = "vector-index-name"

# Connect to Neo4j database
driver = GraphDatabase.driver(URI, auth=AUTH)

# Creating the index
create_vector_index(
    driver,
    INDEX_NAME,
    label="Document",
    embedding_property="vectorProperty",
    dimensions=1536,
    similarity_fn="euclidean",
    fail_if_exists=False,
)

参数：

• driver (neo4j.Driver) – Neo4j Python驱动程序实例。

• name (str) – 索引的唯一名称。

• label (str) – 要索引的节点标签。

• embedding_property (str) – 包含嵌入值的节点的属性键。

• dimensions (int) – 向量嵌入维度

• similarity_fn (str) – 向量相似度函数的不区分大小写的值：euclidean或cosine。

• fail_if_exists (bool) – 如果为True，则如果索引已存在则引发错误。默认为False。

• **neo4j_database** (可选[str]) –

  Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

引发:

• ValueError – 如果输入参数验证失败。

• neo4j.exceptions.ClientError – 如果向量索引创建失败。

返回类型：

None

neo4j_graphrag.indexes.create_fulltext_index(driver, name, label, node_properties, fail_if_exists=False, neo4j_database=None)

此方法构造一个Cypher查询并执行它，以在Neo4j中创建新的全文索引。

请参阅Cypher手册关于创建全文索引。

确保提供的索引名称在数据库上下文中是唯一的。

示例

from neo4j import GraphDatabase
from neo4j_graphrag.indexes import create_fulltext_index

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")

INDEX_NAME = "fulltext-index-name"

# Connect to Neo4j database
driver = GraphDatabase.driver(URI, auth=AUTH)

# Creating the index
create_fulltext_index(
    driver,
    INDEX_NAME,
    label="Document",
    node_properties=["vectorProperty"],
    fail_if_exists=False,
)

参数：

• driver (neo4j.Driver) – Neo4j Python驱动程序实例。

• name (str) – 索引的唯一名称。

• label (str) – 要索引的节点标签。

• node_properties (list[str]) – 要在其上创建全文索引的节点属性。

• fail_if_exists (bool) – 如果为True，则如果索引已存在则引发错误。默认为False。

• **neo4j_database** (可选[str]) –

  Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

引发:

• ValueError – 如果输入参数验证失败。

• neo4j.exceptions.ClientError – 如果全文索引创建失败。

返回类型：

None

neo4j_graphrag.indexes.drop_index_if_exists(driver, name, neo4j_database=None)

此方法构造一个Cypher查询并执行它，以删除Neo4j中的索引（如果索引存在）。请参阅Cypher手册关于删除向量索引。

示例

from neo4j import GraphDatabase
from neo4j_graphrag.indexes import drop_index_if_exists

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")

INDEX_NAME = "fulltext-index-name"

# Connect to Neo4j database
driver = GraphDatabase.driver(URI, auth=AUTH)

# Dropping the index if it exists
drop_index_if_exists(
    driver,
    INDEX_NAME,
)

参数：

• driver (neo4j.Driver) – Neo4j Python驱动程序实例。

• name (str) – 要删除的索引的名称。

• **neo4j_database** (可选[str]) –

  Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

引发:

neo4j.exceptions.ClientError – 如果索引删除失败。

返回类型：

None

neo4j_graphrag.indexes.upsert_vector(driver, node_id, embedding_property, vector, neo4j_database=None)

此方法构造一个Cypher查询并执行它，以在特定节点上更新（插入或更新）向量属性。

示例

from neo4j import GraphDatabase
from neo4j_graphrag.indexes import upsert_vector

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")

# Connect to Neo4j database
driver = GraphDatabase.driver(URI, auth=AUTH)

# Upsert the vector data
upsert_vector(
    driver,
    node_id="nodeId",
    embedding_property="vectorProperty",
    vector=...,
)

参数：

• driver (neo4j.Driver) – Neo4j Python驱动程序实例。

• node_id (int) – 节点的ID。

• embedding_property (str) – 用于存储向量的属性的名称。

• vector (list[float]) – 要存储的向量。

• **neo4j_database** (可选[str]) –

  Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

引发:

Neo4jInsertionError – 如果向量更新失败。

返回类型：

None

neo4j_graphrag.indexes.upsert_vector_on_relationship(driver, rel_id, embedding_property, vector, neo4j_database=None)

此方法构造一个Cypher查询并执行它，以在特定关系上更新（插入或更新）向量属性。

示例

from neo4j import GraphDatabase
from neo4j_graphrag.indexes import upsert_vector_on_relationship

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")

# Connect to Neo4j database
driver = GraphDatabase.driver(URI, auth=AUTH)

# Upsert the vector data
upsert_vector_on_relationship(
    driver,
    node_id="nodeId",
    embedding_property="vectorProperty",
    vector=...,
)

参数：

• driver (neo4j.Driver) – Neo4j Python驱动程序实例。

• rel_id (int) – 关系的ID。

• embedding_property (str) – 用于存储向量的属性的名称。

• vector (list[float]) – 要存储的向量。

• **neo4j_database** (可选[str]) –

  Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

引发:

Neo4jInsertionError – 如果向量更新失败。

返回类型：

None

async neo4j_graphrag.indexes.async_upsert_vector(driver, node_id, embedding_property, vector, neo4j_database=None)

此方法构造一个Cypher查询并异步执行它，以在特定节点上更新（插入或更新）向量属性。

示例

from neo4j import AsyncGraphDatabase
from neo4j_graphrag.indexes import upsert_vector

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")

# Connect to Neo4j database
driver = AsyncGraphDatabase.driver(URI, auth=AUTH)

# Upsert the vector data
async_upsert_vector(
    driver,
    node_id="nodeId",
    embedding_property="vectorProperty",
    vector=...,
)

参数：

• driver (neo4j.AsyncDriver) – Neo4j Python异步驱动程序实例。

• node_id (int) – 节点的ID。

• embedding_property (str) – 用于存储向量的属性的名称。

• vector (list[float]) – 要存储的向量。

• **neo4j_database** (可选[str]) –

  Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

引发:

Neo4jInsertionError – 如果向量更新失败。

返回类型：

None

async neo4j_graphrag.indexes.async_upsert_vector_on_relationship(driver, rel_id, embedding_property, vector, neo4j_database=None)

此方法构建一个 Cypher 查询并异步执行它，以对特定关系上的向量属性进行 upsert 操作（插入或更新）。

示例

from neo4j import AsyncGraphDatabase
from neo4j_graphrag.indexes import upsert_vector_on_relationship

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")

# Connect to Neo4j database
driver = AsyncGraphDatabase.driver(URI, auth=AUTH)

# Upsert the vector data
async_upsert_vector_on_relationship(
    driver,
    node_id="nodeId",
    embedding_property="vectorProperty",
    vector=...,
)

参数：

• driver (neo4j.AsyncDriver) – Neo4j Python异步驱动程序实例。

• rel_id (int) – 关系的ID。

• embedding_property (str) – 用于存储向量的属性的名称。

• vector (list[float]) – 要存储的向量。

• **neo4j_database** (可选[str]) –

  Neo4j 数据库的名称。如果未提供，则默认为数据库中的“neo4j”（请参阅文档参考）。

引发:

Neo4jInsertionError – 如果向量更新失败。

返回类型：

None

错误

• neo4j_graphrag.exceptions.Neo4jGraphRagError

  • neo4j_graphrag.exceptions.RetrieverInitializationError

  • neo4j_graphrag.exceptions.EmbeddingsGenerationError

  • neo4j_graphrag.exceptions.SearchValidationError

  • neo4j_graphrag.exceptions.FilterValidationError

  • neo4j_graphrag.exceptions.EmbeddingRequiredError

  • neo4j_graphrag.exceptions.InvalidRetrieverResultError

  • neo4j_graphrag.exceptions.Neo4jIndexError

  • neo4j_graphrag.exceptions.Neo4jVersionError

  • neo4j_graphrag.exceptions.Text2CypherRetrievalError

  • neo4j_graphrag.exceptions.SchemaFetchError

  • neo4j_graphrag.exceptions.RagInitializationError

  • neo4j_graphrag.exceptions.PromptMissingInputError

  • neo4j_graphrag.exceptions.LLMGenerationError

  • neo4j_graphrag.experimental.pipeline.exceptions.PipelineDefinitionError

  • neo4j_graphrag.experimental.pipeline.exceptions.PipelineMissingDependencyError

  • neo4j_graphrag.experimental.pipeline.exceptions.PipelineStatusUpdateError

Neo4jGraphRagError

class neo4j_graphrag.exceptions.Neo4jGraphRagError

基类: Exception

neo4j-graphrag 包使用的全局异常。

RetrieverInitializationError

class neo4j_graphrag.exceptions.RetrieverInitializationError(errors)

基类: Neo4jGraphRagError

检索器初始化失败时引发的异常。

参数：

errors (list[ErrorDetails])

SearchValidationError

class neo4j_graphrag.exceptions.SearchValidationError(errors)

基类: Neo4jGraphRagError

搜索期间验证错误引发的异常。

参数：

errors (list[ErrorDetails])

FilterValidationError

class neo4j_graphrag.exceptions.FilterValidationError

基类: Neo4jGraphRagError

元数据过滤的输入验证失败时引发的异常。

EmbeddingRequiredError

class neo4j_graphrag.exceptions.EmbeddingRequiredError

基类: Neo4jGraphRagError

需要嵌入方法但未提供时引发的异常。

InvalidRetrieverResultError

class neo4j_graphrag.exceptions.InvalidRetrieverResultError

基类: Neo4jGraphRagError

检索器无法返回结果时引发的异常。

Neo4jIndexError

class neo4j_graphrag.exceptions.Neo4jIndexError

基类: Neo4jGraphRagError

处理 Neo4j 索引失败时引发的异常。

Neo4jInsertionError

class neo4j_graphrag.exceptions.Neo4jInsertionError

基类: Neo4jGraphRagError

将数据插入 Neo4j 数据库失败时引发的异常。

Neo4jVersionError

class neo4j_graphrag.exceptions.Neo4jVersionError

基类: Neo4jGraphRagError

Neo4j 版本不满足最低要求时引发的异常。

Text2CypherRetrievalError

class neo4j_graphrag.exceptions.Text2CypherRetrievalError

基类: Neo4jGraphRagError

文本到 Cypher 检索失败时引发的异常。

SchemaFetchError

class neo4j_graphrag.exceptions.SchemaFetchError

基类: Neo4jGraphRagError

无法获取 Neo4jSchema 时引发的异常。

RagInitializationError

class neo4j_graphrag.exceptions.RagInitializationError(errors)

基类: Neo4jGraphRagError

参数：

errors (list[ErrorDetails])

PromptMissingInputError

class neo4j_graphrag.exceptions.PromptMissingInputError

基类: Neo4jGraphRagError

提示需要输入但缺少时引发的异常。

LLMGenerationError

class neo4j_graphrag.exceptions.LLMGenerationError

基类: Neo4jGraphRagError

LLM 答案生成失败时引发的异常。

PipelineDefinitionError

class neo4j_graphrag.experimental.pipeline.exceptions.PipelineDefinitionError

基类: Neo4jGraphRagError

管道图无效时引发。

PipelineMissingDependencyError

class neo4j_graphrag.experimental.pipeline.exceptions.PipelineMissingDependencyError

基类: Neo4jGraphRagError

任务已安排但其依赖项尚未完成时引发。

PipelineStatusUpdateError

class neo4j_graphrag.experimental.pipeline.exceptions.PipelineStatusUpdateError

基类: Neo4jGraphRagError

尝试进行无效的状态更改（例如，DONE => DOING）时引发。