langchain-neo4j

langchain_neo4j

GraphCypherQAChain

基类：Chain

通过生成 Cypher 语句来对图进行问答的链。

安全说明

请确保数据库连接使用的凭证范围狭窄，仅包含必要的权限。否则可能导致数据损坏或丢失，因为调用代码可能会在被适当提示时尝试执行删除、修改数据的命令，或者如果数据库中存在敏感数据，则会读取这些数据。

防范此类负面结果的最佳方法是（在适当情况下）限制授予此工具所用凭证的权限。

更多信息请参阅 https://docs.langchain.org.cn/oss/python/security-policy。

方法	描述
__init__	初始化链。
from_llm	从 LLM 初始化。

top_k class-attribute instance-attribute

top_k: int = 10

从查询返回的结果数量

return_intermediate_steps class-attribute instance-attribute

return_intermediate_steps: bool = False

是否返回中间步骤以及最终答案。

return_direct class-attribute instance-attribute

return_direct: bool = False

是否直接返回查询图的结果。

cypher_query_corrector class-attribute instance-attribute

cypher_query_corrector: CypherQueryCorrector | None = None

可选的 Cypher 验证工具

use_function_response class-attribute instance-attribute

use_function_response: bool = False

是否将数据库上下文包装为工具/函数响应

allow_dangerous_requests class-attribute instance-attribute

allow_dangerous_requests: bool = False

强制用户选择加入，以确认该链可以发出危险请求。

安全说明

请确保数据库连接使用的凭证范围狭窄，仅包含必要的权限。否则可能导致数据损坏或丢失，因为调用代码可能会在被适当提示时尝试执行删除、修改数据的命令，或者如果数据库中存在敏感数据，则会读取这些数据。

防范此类负面结果的最佳方法是（在适当情况下）限制授予此工具所用凭证的权限。

更多信息请参阅 https://docs.langchain.org.cn/oss/python/security-policy。

input_keys property

input_keys: list[str]

返回输入键。

output_keys property

output_keys: list[str]

返回输出键。

__init__

__init__(**kwargs: Any) -> None

初始化链。

from_llm classmethod

from_llm(
    llm: BaseLanguageModel | None = None,
    *,
    qa_prompt: BasePromptTemplate | None = None,
    cypher_prompt: BasePromptTemplate | None = None,
    cypher_llm: BaseLanguageModel | None = None,
    qa_llm: BaseLanguageModel | None = None,
    exclude_types: list[str] = [],
    include_types: list[str] = [],
    validate_cypher: bool = False,
    qa_llm_kwargs: dict[str, Any] | None = None,
    cypher_llm_kwargs: dict[str, Any] | None = None,
    use_function_response: bool = False,
    function_response_system: str = FUNCTION_RESPONSE_SYSTEM,
    **kwargs: Any,
) -> GraphCypherQAChain

从 LLM 初始化。

Neo4jChatMessageHistory

基类：BaseChatMessageHistory

存储在 Neo4j 数据库中的聊天消息历史记录。

方法	描述
aget_messages	获取消息的异步版本。
add_user_message	用于向存储中添加人类消息字符串的便捷方法。
add_ai_message	用于向存储中添加 AIMessage 字符串的便捷方法。
add_messages	添加消息列表。
aadd_messages	异步添加消息列表。
aclear	从存储中异步移除所有消息。
__str__	返回聊天历史记录的字符串表示形式。
add_message	将消息追加到 Neo4j 中的记录
clear	从 Neo4j 清除会话内存

messages property writable

messages: list[BaseMessage]

从 Neo4j 检索消息

aget_messages async

aget_messages() -> list[BaseMessage]

获取消息的异步版本。

可以重写此方法以提供高效的异步实现。

通常，获取消息可能涉及对底层持久化层的 IO 操作。

返回	描述
list[BaseMessage]	消息。

add_user_message

add_user_message(message: HumanMessage | str) -> None

用于向存储中添加人类消息字符串的便捷方法。

注意

这是一个便捷方法。代码应优先使用批量 add_messages 接口，以节省到持久化层的往返次数。

此方法可能会在将来的版本中被弃用。

参数	描述
message	要添加到存储的 HumanMessage。 类型： HumanMessage | str

add_ai_message

add_ai_message(message: AIMessage | str) -> None

用于向存储中添加 AIMessage 字符串的便捷方法。

注意

这是一个便捷方法。代码应优先使用批量 add_messages 接口，以节省到持久化层的往返次数。

此方法可能会在将来的版本中被弃用。

参数	描述
message	要添加的 AIMessage。 类型： AIMessage | str

add_messages

add_messages(messages: Sequence[BaseMessage]) -> None

添加消息列表。

实现应重写此方法，以高效方式处理批量添加消息，避免不必要的到底层存储的往返。

参数	描述
messages	要存储的 BaseMessage 对象序列。 类型： Sequence[BaseMessage]

aadd_messages async

aadd_messages(messages: Sequence[BaseMessage]) -> None

异步添加消息列表。

参数	描述
messages	要存储的 BaseMessage 对象序列。 类型： Sequence[BaseMessage]

aclear async

aclear() -> None

从存储中异步移除所有消息。

__str__

__str__() -> str

返回聊天历史记录的字符串表示形式。

add_message

add_message(message: BaseMessage) -> None

将消息追加到 Neo4j 中的记录

clear

clear(delete_session_node: bool = False) -> None

从 Neo4j 清除会话内存

参数	描述
delete_session_node	是否删除会话节点。 类型： bool 默认值： False

Neo4jGraph

基类：GraphStore

用于各种图操作的 Neo4j 数据库包装器。

安全说明

请确保数据库连接使用的凭证范围狭窄，仅包含必要的权限。否则可能导致数据损坏或丢失，因为调用代码可能会在被适当提示时尝试执行删除、修改数据的命令，或者如果数据库中存在敏感数据，则会读取这些数据。

防范此类负面结果的最佳方法是（在适当情况下）限制授予此工具所用凭证的权限。

更多信息请参阅 https://docs.langchain.org.cn/oss/python/security-policy。

方法	描述
__init__	创建一个新的 Neo4j 图包装器实例。
query	查询 Neo4j 数据库。
refresh_schema	刷新 Neo4j 图模式信息。
add_graph_documents	此方法根据
close	显式关闭 Neo4j 驱动程序连接。
__enter__	进入 Neo4j 图连接的运行时上下文。
__exit__	退出 Neo4j 图连接的运行时上下文。
__del__	Neo4j 图连接的析构函数。

get_schema property

get_schema: str

返回图的模式

get_structured_schema property

get_structured_schema: dict[str, Any]

返回图的结构化模式

__init__

__init__(
    url: str | None = None,
    username: str | None = None,
    password: str | None = None,
    database: str | None = None,
    timeout: float | None = None,
    sanitize: bool = False,
    refresh_schema: bool = True,
    *,
    driver_config: dict | None = None,
    enhanced_schema: bool = False,
) -> None

创建一个新的 Neo4j 图包装器实例。

参数	描述
url	Neo4j 数据库服务器的 URL。 类型: str | None 默认值: None
username	用于数据库认证的用户名。 类型: str | None 默认值: None
password	用于数据库认证的密码。 类型: str | None 默认值: None
database	要连接的数据库名称。默认为 'neo4j'。 类型: str | None 默认值: None
timeout	事务超时时间（秒）。用于终止长时间运行的查询。 注意 默认情况下，不设置超时。 类型： float | None 默认： None
sanitize	一个标志，指示是否从结果中移除超过 128 个元素的列表。用于从数据库响应中移除类似嵌入的属性。 类型： bool 默认值： False
refresh_schema	一个标志，指示是否在初始化时刷新模式信息。 类型: bool 默认值: True
driver_config	传递给 Neo4j 驱动程序的配置。 类型： dict | None 默认值： None
enhanced_schema	一个标志，指示是否扫描数据库以获取示例值并在图模式中使用它们。 类型： bool 默认值： False

query

query(query: str, params: dict = {}, session_params: dict = {}) -> list[dict[str, Any]]

查询 Neo4j 数据库。

参数	描述
query	要执行的 Cypher 查询。 类型： str
params	要传递给查询的参数。 类型： dict 默认： {}
session_params	传递给用于执行查询的会话的参数。 类型： dict 默认： {}

返回	描述
list[dict[str, Any]]	包含查询结果的字典列表。

引发	描述
RuntimeError	如果连接已关闭。

refresh_schema

refresh_schema() -> None

刷新 Neo4j 图模式信息。

引发	描述
RuntimeError	如果连接已关闭。

add_graph_documents

add_graph_documents(
    graph_documents: list[GraphDocument],
    include_source: bool = False,
    baseEntityLabel: bool = False,
) -> None

此方法根据提供的 GraphDocument 对象在图中构建节点和关系。

参数	描述
graph_documents	一个 GraphDocument 对象列表，包含要添加到图中的节点和关系。每个 GraphDocument 应封装图的一部分结构，包括节点、关系以及可选的源文档信息。 类型： list[GraphDocument]
include_source	如果为 True，则存储源文档并使用 MENTIONS 关系将其链接到图中的节点。这对于追溯数据来源很有用。如果源文档元数据中有 id 属性，则根据该属性合并源文档；否则，它会计算 page_content 的 MD5 哈希值进行合并过程。 类型： bool 默认值： False
baseEntityLabel	如果为 True，则每个新创建的节点都会获得一个辅助的 __Entity__ 标签，该标签被索引，可提高导入速度和性能。 类型： bool 默认值： False

引发	描述
RuntimeError	如果连接已关闭。

close

close() -> None

显式关闭 Neo4j 驱动程序连接。

将连接管理委托给 Neo4j 驱动程序。

__enter__

__enter__() -> Neo4jGraph

进入 Neo4j 图连接的运行时上下文。

允许使用 'with' 语句来使用图连接。此方法允许自动资源管理，并确保连接得到正确处理。

返回	描述
Neo4jGraph	当前图连接实例 类型： Neo4jGraph

示例

with Neo4jGraph(...) as graph:
    graph.query(...)  # Connection automatically managed

__exit__

__exit__(
    exc_type: Type[BaseException] | None,
    exc_val: BaseException | None,
    exc_tb: Any | None,
) -> None

退出 Neo4j 图连接的运行时上下文。

退出 'with' 语句时会自动调用此方法。它确保无论上下文执行期间是否发生异常，数据库连接都会被关闭。

参数	描述
exc_type	导致上下文退出的异常类型 类型： Type[BaseException] | None
exc_val	导致上下文退出的异常实例 类型： BaseException | None
exc_tb	异常的回溯信息 类型： Any | None

信息

连接关闭后，任何异常都会被重新引发。

__del__

__del__() -> None

Neo4j 图连接的析构函数。

此方法在垃圾回收期间调用，以确保如果未显式关闭，数据库资源会被释放。

危险

• 不要依赖此方法进行确定性的资源清理
• 始终优先使用显式 .close() 或上下文管理器

最佳实践

1. 使用上下文管理器

   with Neo4jGraph(...) as graph:
       ...
   

2. 显式关闭

   graph = Neo4jGraph(...)
   try:
       ...
   finally:
       graph.close()
   

Neo4jVector

Bases: VectorStore

Neo4j 向量索引。

要使用，您应已安装 neo4j Python 包。

参数	描述
url	Neo4j 连接 URL 类型: str | None 默认值: None
username	Neo4j 用户名。 类型: str | None 默认值: None
password	Neo4j 密码 类型: str | None 默认值: None
database	可选提供 Neo4j 数据库，默认为 'neo4j' 类型: str | None 默认值: None
embedding	任何实现 langchain.embeddings.base.Embeddings 接口的嵌入函数。 TYPE: Embeddings
distance_strategy	要使用的距离策略。（默认：COSINE） 类型： DistanceStrategy 默认： DEFAULT_DISTANCE_STRATEGY
search_type	要执行的搜索类型，可以是 'vector' 或 'hybrid' 类型： SearchType 默认： VECTOR
node_label	在 Neo4j 数据库中用于节点的标签。 类型： str 默认： 'Chunk'
embedding_node_property	在 Neo4j 中用于存储嵌入的属性名称。 类型： str 默认： 'embedding'
text_node_property	在 Neo4j 中用于存储文本的属性名称。 类型： str 默认： 'text'
retrieval_query	用于自定义检索的 Cypher 查询。如果为空，将使用默认查询。 类型: str 默认值: ''
index_type	要使用的索引类型，可以是 'NODE' 或 'RELATIONSHIP' 类型： EntityType 默认： DEFAULT_INDEX_TYPE
pre_delete_collection	如果为 True，将删除已存在的数据。用于测试。 类型： bool 默认值： False
embedding_dimension	嵌入的维度。如果未提供，将查询嵌入模型以计算维度。 TYPE: int | None DEFAULT: None

示例

from langchain_neo4j import Neo4jVector
from langchain_openai import OpenAIEmbeddings

url="bolt://:7687"
username="neo4j"
password="password"
embeddings = OpenAIEmbeddings()
vectorestore = Neo4jVector.from_documents(
    embedding=embeddings,
    documents=docs,
    url=url
    username=username,
    password=password,
)

方法	描述
delete	按向量 ID 或其他条件删除。
get_by_ids	根据 ID 获取文档。
aget_by_ids	通过 ID 异步获取文档。
adelete	按向量 ID 或其他条件异步删除。
aadd_texts	通过嵌入异步运行更多文本并添加到 `VectorStore`。
add_documents	在 `VectorStore` 中添加或更新文档。
aadd_documents	异步运行更多文档通过嵌入并添加到 `VectorStore`。
search	使用指定的搜索类型返回与查询最相似的文档。
asearch	异步返回与查询最相似的文档，使用指定的搜索类型。
asimilarity_search_with_score	异步运行带距离的相似性搜索。
similarity_search_with_relevance_scores	返回文档和在 `[0, 1]` 范围内的相关性分数。
asimilarity_search_with_relevance_scores	异步返回文档和在 `[0, 1]` 范围内的相关性分数。
asimilarity_search	异步返回与查询最相似的文档。
asimilarity_search_by_vector	异步返回与嵌入向量最相似的文档。
amax_marginal_relevance_search	异步返回使用最大边际相关性选择的文档。
max_marginal_relevance_search_by_vector	返回使用最大边际相关性选择的文档。
amax_marginal_relevance_search_by_vector	异步返回使用最大边际相关性选择的文档。
afrom_documents	异步返回从文档和嵌入初始化的 `VectorStore`。
afrom_texts	异步返回从文本和嵌入初始化的 `VectorStore`。
as_retriever	返回从此 `VectorStore` 初始化的 `VectorStoreRetriever`。
query	使用重试和指数退避查询 Neo4j 数据库。
verify_version	检查连接的 Neo4j 数据库版本是否支持向量索引。
retrieve_existing_index	检查向量索引是否存在于 Neo4j 数据库中
retrieve_existing_fts_index	检查全文索引是否存在于 Neo4j 数据库中
create_new_index	此方法构造一个 Cypher 查询并执行它
create_new_keyword_index	此方法构造一个 Cypher 查询并执行它
add_embeddings	向 VectorStore 添加嵌入。
add_texts	通过嵌入运行更多文本并添加到 `VectorStore`。
similarity_search	使用 Neo4jVector 运行相似性搜索。
similarity_search_with_score	返回与查询最相似的文档。
similarity_search_with_score_by_vector	在 Neo4j 数据库中使用
similarity_search_by_vector	返回与嵌入向量最相似的文档。
from_texts	返回从文本和嵌入初始化的 Neo4jVector。
from_embeddings	从原始文档和预生成的
from_existing_index	获取现有 Neo4j 向量索引的实例。此方法将
from_existing_relationship_index	获取现有 Neo4j 关系向量索引的实例。
from_documents	返回从文档和嵌入初始化的 Neo4jVector。
from_existing_graph	从现有图初始化并返回一个 Neo4jVector 实例。
max_marginal_relevance_search	返回使用最大边际相关性选择的文档。

embeddings property

embeddings: Embeddings

如果可用，则访问查询嵌入对象。

delete

delete(ids: list[str] | None = None, **kwargs: Any) -> bool | None

按向量 ID 或其他条件删除。

参数	描述
ids	要删除的 ID 列表。如果为 `None`，则删除所有。 类型: list[str] | None 默认值: None
**kwargs	子类可能使用的其他关键字参数。 类型： Any 默认值： {}

返回	描述
bool | None	如果删除成功，则为 `True`，否则为 `False`，如果未实现，则为 `None`。

get_by_ids

get_by_ids(ids: Sequence[str]) -> list[Document]

根据 ID 获取文档。

返回的文档应将其 ID 字段设置为文档在向量存储中的 ID。

如果某些 ID 未找到或存在重复的 ID，返回的文档数量可能少于请求的数量。

用户不应假设返回文档的顺序与输入 ID 的顺序相匹配。相反，用户应依赖于返回文档的 ID 字段。

如果某些 ID 未找到文档，此方法不应**抛出异常**。

参数	描述
ids	要检索的 ID 列表。 类型： Sequence[str]

返回	描述
list[Document]	`Document` 对象列表。

aget_by_ids async

aget_by_ids(ids: Sequence[str]) -> list[Document]

通过 ID 异步获取文档。

返回的文档应将其 ID 字段设置为文档在向量存储中的 ID。

如果某些 ID 未找到或存在重复的 ID，返回的文档数量可能少于请求的数量。

用户不应假设返回文档的顺序与输入 ID 的顺序相匹配。相反，用户应依赖于返回文档的 ID 字段。

如果某些 ID 未找到文档，此方法不应**抛出异常**。

参数	描述
ids	要检索的 ID 列表。 类型： Sequence[str]

返回	描述
list[Document]	`Document` 对象列表。

adelete async

adelete(ids: list[str] | None = None, **kwargs: Any) -> bool | None

按向量 ID 或其他条件异步删除。

参数	描述
ids	要删除的 ID 列表。如果为 `None`，则删除所有。 类型: list[str] | None 默认值: None
**kwargs	子类可能使用的其他关键字参数。 类型： Any 默认值： {}

返回	描述
bool | None	如果删除成功，则为 `True`，否则为 `False`，如果未实现，则为 `None`。

aadd_texts async

aadd_texts(
    texts: Iterable[str],
    metadatas: list[dict] | None = None,
    *,
    ids: list[str] | None = None,
    **kwargs: Any,
) -> list[str]

通过嵌入异步运行更多文本并添加到 `VectorStore`。

参数	描述
texts	要添加到 `VectorStore` 的字符串的可迭代对象。 类型： Iterable[str]
metadatas	与文本关联的元数据可选列表。 类型： list[dict] | None 默认值： None
ids	可选列表 类型: list[str] | None 默认值: None
**kwargs	`VectorStore` 特定参数。 类型： Any 默认值： {}

返回	描述
list[str]	将文本添加到 `VectorStore` 后返回的 ID 列表。

引发	描述
ValueError	如果元数据的数量与文本的数量不匹配。
ValueError	如果 ID 的数量与文本的数量不匹配。

add_documents

add_documents(documents: list[Document], **kwargs: Any) -> list[str]

在 `VectorStore` 中添加或更新文档。

参数	描述
documents	要添加到 `VectorStore` 的文档。 TYPE: list[Document]
**kwargs	附加的关键字参数。 如果 kwargs 包含 ID 并且文档也包含 ID，则 kwargs 中的 ID 将优先。 类型： Any 默认值： {}

返回	描述
list[str]	已添加文本的 ID 列表。

aadd_documents async

aadd_documents(documents: list[Document], **kwargs: Any) -> list[str]

异步运行更多文档通过嵌入并添加到 `VectorStore`。

参数	描述
documents	要添加到 `VectorStore` 的文档。 TYPE: list[Document]
**kwargs	附加的关键字参数。 类型： Any 默认值： {}

返回	描述
list[str]	已添加文本的 ID 列表。

search

search(query: str, search_type: str, **kwargs: Any) -> list[Document]

使用指定的搜索类型返回与查询最相似的文档。

参数	描述
query	输入文本。 类型： str
search_type	要执行的搜索类型。可以是 `'similarity'`、`'mmr'` 或 `'similarity_score_threshold'`。 类型： str
**kwargs	传递给搜索方法的参数。 类型： Any 默认值： {}

返回	描述
list[Document]	与查询最相似的 `Document` 对象列表。

引发	描述
ValueError	如果 `search_type` 不是 `'similarity'`、`'mmr'` 或 `'similarity_score_threshold'` 之一。

asearch async

asearch(query: str, search_type: str, **kwargs: Any) -> list[Document]

异步返回与查询最相似的文档，使用指定的搜索类型。

参数	描述
query	输入文本。 类型： str
search_type	要执行的搜索类型。可以是 `'similarity'`、`'mmr'` 或 `'similarity_score_threshold'`。 类型： str
**kwargs	传递给搜索方法的参数。 类型： Any 默认值： {}

返回	描述
list[Document]	与查询最相似的 `Document` 对象列表。

引发	描述
ValueError	如果 `search_type` 不是 `'similarity'`、`'mmr'` 或 `'similarity_score_threshold'` 之一。

asimilarity_search_with_score async

asimilarity_search_with_score(
    *args: Any, **kwargs: Any
) -> list[tuple[Document, float]]

异步运行带距离的相似性搜索。

参数	描述
*args	传递给搜索方法的参数。 类型: Any 默认值: ()
**kwargs	传递给搜索方法的参数。 类型： Any 默认值： {}

返回	描述
list[tuple[Document, float]]	由 `(doc, similarity_score)` 组成的元组列表。

similarity_search_with_relevance_scores

similarity_search_with_relevance_scores(
    query: str, k: int = 4, **kwargs: Any
) -> list[tuple[Document, float]]

返回文档和在 `[0, 1]` 范围内的相关性分数。

`0` 表示不相似，`1` 表示最相似。

参数	描述
query	输入文本。 类型： str
k	要返回的 `Document` 对象数量。 TYPE: int DEFAULT: 4
**kwargs	将传递给相似性搜索的kwargs。应包括`score_threshold`，一个可选的浮点值，介于`0`到`1`之间，用于筛选检索到的文档结果集。 类型： Any 默认值： {}

返回	描述
list[tuple[Document, float]]	由 `(doc, similarity_score)` 组成的元组列表。

asimilarity_search_with_relevance_scores async

asimilarity_search_with_relevance_scores(
    query: str, k: int = 4, **kwargs: Any
) -> list[tuple[Document, float]]

异步返回文档和在 `[0, 1]` 范围内的相关性分数。

`0` 表示不相似，`1` 表示最相似。

参数	描述
query	输入文本。 类型： str
k	要返回的 `Document` 对象数量。 TYPE: int DEFAULT: 4
**kwargs	将传递给相似性搜索的kwargs。应包括`score_threshold`，一个可选的浮点值，介于`0`到`1`之间，用于筛选检索到的文档结果集。 类型： Any 默认值： {}

返回	描述
list[tuple[Document, float]]	元组列表 `(doc, similarity_score)`

asimilarity_search async

asimilarity_search(query: str, k: int = 4, **kwargs: Any) -> list[Document]

异步返回与查询最相似的文档。

参数	描述
query	输入文本。 类型： str
k	要返回的 `Document` 对象数量。 TYPE: int DEFAULT: 4
**kwargs	传递给搜索方法的参数。 类型： Any 默认值： {}

返回	描述
list[Document]	与查询最相似的 `Document` 对象列表。

asimilarity_search_by_vector async

asimilarity_search_by_vector(
    embedding: list[float], k: int = 4, **kwargs: Any
) -> list[Document]

异步返回与嵌入向量最相似的文档。

参数	描述
embedding	用于查找相似文档的嵌入。 类型： list[float]
k	要返回的 `Document` 对象数量。 TYPE: int DEFAULT: 4
**kwargs	传递给搜索方法的参数。 类型： Any 默认值： {}

返回	描述
list[Document]	与查询向量最相似的 `Document` 对象列表。

amax_marginal_relevance_search async

amax_marginal_relevance_search(
    query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, **kwargs: Any
) -> list[Document]

异步返回使用最大边际相关性选择的文档。

最大边际相关性优化查询相似度与所选文档之间的多样性。

参数	描述
query	用于查找相似文档的文本。 类型： str
k	要返回的 `Document` 对象数量。 TYPE: int DEFAULT: 4
fetch_k	要获取并传递给 MMR 算法的 `Document` 对象数量。 类型： int 默认值： 20
lambda_mult	一个介于 `0` 和 `1` 之间的数字，决定了结果之间的多样性程度，其中 `0` 对应最大多样性，`1` 对应最小多样性。 类型： float 默认值： 0.5
**kwargs	传递给搜索方法的参数。 类型： Any 默认值： {}

返回	描述
list[Document]	通过最大边际相关性选择的 `Document` 对象列表。

max_marginal_relevance_search_by_vector

max_marginal_relevance_search_by_vector(
    embedding: list[float],
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    **kwargs: Any,
) -> list[Document]

返回使用最大边际相关性选择的文档。

最大边际相关性优化查询相似度与所选文档之间的多样性。

参数	描述
embedding	用于查找相似文档的嵌入。 类型： list[float]
k	要返回的 `Document` 对象数量。 TYPE: int DEFAULT: 4
fetch_k	要获取并传递给 MMR 算法的 `Document` 对象数量。 类型： int 默认值： 20
lambda_mult	一个介于 `0` 和 `1` 之间的数字，决定了结果之间的多样性程度，其中 `0` 对应最大多样性，`1` 对应最小多样性。 类型： float 默认值： 0.5
**kwargs	传递给搜索方法的参数。 类型： Any 默认值： {}

返回	描述
list[Document]	通过最大边际相关性选择的 `Document` 对象列表。

amax_marginal_relevance_search_by_vector async

amax_marginal_relevance_search_by_vector(
    embedding: list[float],
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    **kwargs: Any,
) -> list[Document]

异步返回使用最大边际相关性选择的文档。

最大边际相关性优化查询相似度与所选文档之间的多样性。

参数	描述
embedding	用于查找相似文档的嵌入。 类型： list[float]
k	要返回的 `Document` 对象数量。 TYPE: int DEFAULT: 4
fetch_k	要获取并传递给 MMR 算法的 `Document` 对象数量。 类型： int 默认值： 20
lambda_mult	一个介于 `0` 和 `1` 之间的数字，决定了结果之间的多样性程度，其中 `0` 对应最大多样性，`1` 对应最小多样性。 类型： float 默认值： 0.5
**kwargs	传递给搜索方法的参数。 类型： Any 默认值： {}

返回	描述
list[Document]	通过最大边际相关性选择的 `Document` 对象列表。

afrom_documents async classmethod

afrom_documents(
    documents: list[Document], embedding: Embeddings, **kwargs: Any
) -> Self

异步返回从文档和嵌入初始化的 `VectorStore`。

参数	描述
documents	要添加到 `VectorStore` 的 `Document` 对象列表。 TYPE: list[Document]
embedding	要使用的嵌入函数。 TYPE: Embeddings
**kwargs	附加的关键字参数。 类型： Any 默认值： {}

返回	描述
Self	从文档和嵌入初始化的 `VectorStore`。

afrom_texts async classmethod

afrom_texts(
    texts: list[str],
    embedding: Embeddings,
    metadatas: list[dict] | None = None,
    *,
    ids: list[str] | None = None,
    **kwargs: Any,
) -> Self

异步返回从文本和嵌入初始化的 `VectorStore`。

参数	描述
texts	要添加到 `VectorStore` 的文本。 类型: list[str]
embedding	要使用的嵌入函数。 TYPE: Embeddings
metadatas	与文本关联的元数据可选列表。 类型： list[dict] | None 默认值： None
ids	与文本关联的 ID 可选列表。 类型: list[str] | None 默认值: None
**kwargs	附加的关键字参数。 类型： Any 默认值： {}

返回	描述
Self	从文本和嵌入初始化的 `VectorStore`。

as_retriever

as_retriever(**kwargs: Any) -> VectorStoreRetriever

返回从此 `VectorStore` 初始化的 `VectorStoreRetriever`。

参数	描述
**kwargs	传递给搜索函数的关键字参数。可以包括 `search_type`：定义检索器应执行的搜索类型。可以是 `'similarity'` (默认)、`'mmr'` 或 `'similarity_score_threshold'`。 `search_kwargs`：传递给搜索函数的关键字参数。可以包括诸如 `k`：要返回的文档数量（默认：`4`） `score_threshold`：`similarity_score_threshold` 的最小相关性阈值 `fetch_k`：传递给 MMR 算法的文档数量（默认值：`20`） `lambda_mult`：MMR 返回结果的多样性；`1` 表示最小多样性，0 表示最大多样性。（默认值：`0.5`） `filter`：按文档元数据过滤 类型： Any 默认值： {}

返回	描述
VectorStoreRetriever	`VectorStore` 的检索器类。

示例

# Retrieve more documents with higher diversity
# Useful if your dataset has many similar documents
docsearch.as_retriever(
    search_type="mmr", search_kwargs={"k": 6, "lambda_mult": 0.25}
)

# Fetch more documents for the MMR algorithm to consider
# But only return the top 5
docsearch.as_retriever(search_type="mmr", search_kwargs={"k": 5, "fetch_k": 50})

# Only retrieve documents that have a relevance score
# Above a certain threshold
docsearch.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={"score_threshold": 0.8},
)

# Only get the single most similar document from the dataset
docsearch.as_retriever(search_kwargs={"k": 1})

# Use a filter to only retrieve documents from a specific paper
docsearch.as_retriever(
    search_kwargs={"filter": {"paper_title": "GPT-4 Technical Report"}}
)

query

query(query: str, *, params: dict | None = None) -> list[dict[str, Any]]

使用重试和指数退避查询 Neo4j 数据库。

参数	描述
query	要执行的 Cypher 查询。 类型： str
params	查询参数字典。 类型： dict | None 默认值： None

返回	描述
list[dict[str, Any]]	包含查询结果的字典列表。

verify_version

verify_version() -> None

检查连接的 Neo4j 数据库版本是否支持向量索引。

查询 Neo4j 数据库以检索其版本，并将其与已知支持向量索引的目标版本（5.11.0）进行比较。如果连接的 Neo4j 版本不受支持，则引发 ValueError。

retrieve_existing_index

retrieve_existing_index() -> tuple[int | None, str] | None

检查向量索引是否存在于 Neo4j 数据库中，并返回其嵌入维度。

此方法查询 Neo4j 数据库中的现有索引，并尝试检索具有指定名称的向量索引的维度。如果索引存在，则返回其维度。如果索引不存在，则返回 None。

返回	描述
tuple[int | None, str] | None	int 或 None：如果找到，则为现有索引的嵌入维度。

retrieve_existing_fts_index

retrieve_existing_fts_index(text_node_properties: list[str] = []) -> str | None

检查全文索引是否存在于 Neo4j 数据库中

此方法查询 Neo4j 数据库中是否存在具有指定名称的 fts 索引。

返回	描述
str | None	关键词索引信息

create_new_index

create_new_index() -> None

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

create_new_keyword_index

create_new_keyword_index(text_node_properties: list[str] = []) -> None

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

add_embeddings

add_embeddings(
    texts: Iterable[str],
    embeddings: list[list[float]],
    metadatas: list[dict] | None = None,
    ids: list[str] | None = None,
    **kwargs: Any,
) -> list[str]

向 VectorStore 添加嵌入。

参数	描述
texts	要添加到 `VectorStore` 的字符串的可迭代对象。 类型： Iterable[str]
embeddings	嵌入向量的列表的列表。 类型： list[list[float]]
metadatas	与文本关联的元数据列表。 类型： list[dict] | None 默认值： None
kwargs	VectorStore 特定参数 类型： Any 默认值： {}

add_texts

add_texts(
    texts: Iterable[str],
    metadatas: list[dict] | None = None,
    ids: list[str] | None = None,
    **kwargs: Any,
) -> list[str]

通过嵌入运行更多文本并添加到 `VectorStore`。

参数	描述
texts	要添加到 `VectorStore` 的字符串的可迭代对象。 类型： Iterable[str]
metadatas	与文本关联的元数据可选列表。 类型： list[dict] | None 默认值： None
kwargs	VectorStore 特定参数 类型： Any 默认值： {}

返回	描述
list[str]	将文本添加到 `VectorStore` 后返回的 ID 列表。

similarity_search

similarity_search(
    query: str,
    k: int = 4,
    params: dict[str, Any] = {},
    filter: dict[str, Any] | None = None,
    effective_search_ratio: int = 1,
    **kwargs: Any,
) -> list[Document]

使用 Neo4jVector 运行相似性搜索。

参数	描述
query	要搜索的查询文本。 类型： str
k	要返回的结果数量。 TYPE: int DEFAULT: 4
params	索引类型的搜索参数。 类型： dict[str, Any] 默认： {}
filter	用于筛选元数据的参数字典。 类型: dict[str, Any] | None 默认值: None
effective_search_ratio	通过乘以 $k 来控制候选池大小，以平衡查询准确性和性能。 类型： int 默认值： 1

返回：与查询最相似的 Document 对象列表。

similarity_search_with_score

similarity_search_with_score(
    query: str,
    k: int = 4,
    params: dict[str, Any] = {},
    filter: dict[str, Any] | None = None,
    effective_search_ratio: int = 1,
    **kwargs: Any,
) -> list[tuple[Document, float]]

返回与查询最相似的文档。

参数	描述
query	用于查找相似文档的文本。 类型： str
k	要返回的 `Document` 对象数量。 TYPE: int DEFAULT: 4
params	索引类型的搜索参数。 类型： dict[str, Any] 默认： {}
filter	用于筛选元数据的参数字典。 类型: dict[str, Any] | None 默认值: None
effective_search_ratio	通过乘以 $k 来控制候选池大小，以平衡查询准确性和性能。 类型： int 默认值： 1

返回	描述
list[tuple[Document, float]]	与查询最相似的 Document 对象列表以及每个对象的分数

similarity_search_with_score_by_vector

similarity_search_with_score_by_vector(
    embedding: list[float],
    k: int = 4,
    filter: dict[str, Any] | None = None,
    params: dict[str, Any] = {},
    effective_search_ratio: int = 1,
    **kwargs: Any,
) -> list[tuple[Document, float]]

在 Neo4j 数据库中使用给定向量执行相似性搜索，并返回前 k 个相似文档及其分数。

此方法使用 Cypher 查询查找与给定嵌入最相似的前 k 个文档。相似度是使用 Neo4j 数据库中的向量索引来测量的。结果以元组列表的形式返回，每个元组包含一个 Document 对象及其相似度分数。

参数	描述
embedding	用于比较的嵌入向量。 类型： list[float]
k	要检索的顶部相似文档的数量。 TYPE: int DEFAULT: 4
filter	用于筛选元数据的参数字典。 类型: dict[str, Any] | None 默认值: None
params	索引类型的搜索参数。 类型： dict[str, Any] 默认： {}
effective_search_ratio	通过乘以 $k 来控制候选池大小，以平衡查询准确性和性能。 类型： int 默认值： 1

返回	描述
list[tuple[Document, float]]	一个元组列表，每个元组包含一个 Document 对象及其相似度分数。

similarity_search_by_vector

similarity_search_by_vector(
    embedding: list[float],
    k: int = 4,
    filter: dict[str, Any] | None = None,
    params: dict[str, Any] = {},
    effective_search_ratio: int = 1,
    **kwargs: Any,
) -> list[Document]

返回与嵌入向量最相似的文档。

参数	描述
embedding	用于查找相似文档的嵌入。 类型： list[float]
k	要返回的 `Document` 对象数量。 TYPE: int DEFAULT: 4
filter	用于筛选元数据的参数字典。 类型: dict[str, Any] | None 默认值: None
params	索引类型的搜索参数。 类型： dict[str, Any] 默认： {}

返回	描述
list[Document]	与查询向量最相似的 `Document` 对象列表。

from_texts classmethod

from_texts(
    texts: list[str],
    embedding: Embeddings,
    metadatas: list[dict] | None = None,
    distance_strategy: DistanceStrategy = DEFAULT_DISTANCE_STRATEGY,
    ids: list[str] | None = None,
    **kwargs: Any,
) -> Neo4jVector

返回从文本和嵌入初始化的 Neo4jVector。需要 Neo4j 凭证，形式为 url、username 和 password，以及可选的 database 参数。

from_embeddings classmethod

from_embeddings(
    text_embeddings: list[tuple[str, list[float]]],
    embedding: Embeddings,
    metadatas: list[dict] | None = None,
    distance_strategy: DistanceStrategy = DEFAULT_DISTANCE_STRATEGY,
    ids: list[str] | None = None,
    pre_delete_collection: bool = False,
    **kwargs: Any,
) -> Neo4jVector

从原始文档和预生成的嵌入构建 Neo4jVector 包装器。

返回从文档和嵌入初始化的 Neo4jVector。需要 Neo4j 凭证，形式为 url、username 和 password，以及可选的 database 参数。

示例

from langchain_neo4j import Neo4jVector
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
text_embeddings = embeddings.embed_documents(texts)
text_embedding_pairs = list(zip(texts, text_embeddings))
vectorstore = Neo4jVector.from_embeddings(
    text_embedding_pairs, embeddings)

from_existing_index classmethod

from_existing_index(
    embedding: Embeddings,
    index_name: str,
    search_type: SearchType = DEFAULT_SEARCH_TYPE,
    keyword_index_name: str | None = None,
    embedding_dimension: int | None = None,
    **kwargs: Any,
) -> Neo4jVector

获取现有 Neo4j 向量索引的实例。此方法将返回存储的实例，而不会插入任何新的嵌入。需要 Neo4j 凭证，形式为 url、username 和 password，以及可选的 database 参数，以及 index_name 定义。

from_existing_relationship_index classmethod

from_existing_relationship_index(
    embedding: Embeddings,
    index_name: str,
    search_type: SearchType = DEFAULT_SEARCH_TYPE,
    embedding_dimension: int | None = None,
    **kwargs: Any,
) -> Neo4jVector

获取现有 Neo4j 关系向量索引的实例。此方法将返回存储的实例，而不会插入任何新的嵌入。需要 Neo4j 凭证，形式为 url、username 和 password，以及可选的 database 参数，以及 index_name 定义。

from_documents classmethod

from_documents(
    documents: list[Document],
    embedding: Embeddings,
    distance_strategy: DistanceStrategy = DEFAULT_DISTANCE_STRATEGY,
    ids: list[str] | None = None,
    **kwargs: Any,
) -> Neo4jVector

返回从文档和嵌入初始化的 Neo4jVector。需要 Neo4j 凭证，形式为 url、username 和 password，以及可选的 database 参数。

from_existing_graph classmethod

from_existing_graph(
    embedding: Embeddings,
    node_label: str,
    embedding_node_property: str,
    text_node_properties: list[str],
    *,
    keyword_index_name: str | None = "keyword",
    index_name: str = "vector",
    search_type: SearchType = DEFAULT_SEARCH_TYPE,
    retrieval_query: str = "",
    **kwargs: Any,
) -> Neo4jVector

从现有图初始化并返回一个 Neo4jVector 实例。

此方法使用提供的参数和现有图初始化 Neo4jVector 实例。它验证索引是否存在，如果不存在则创建新索引。

Neo4jVector：一个使用提供的参数和现有图初始化的 Neo4jVector 实例。

示例

neo4j_vector = Neo4jVector.from_existing_graph(
    embedding=my_embedding,
    node_label="Document",
    embedding_node_property="embedding",
    text_node_properties=["title", "content"]
)

注意

需要 Neo4j 凭证，形式为 url、username 和 password，以及作为附加关键字参数传递的可选 database 参数。

max_marginal_relevance_search

max_marginal_relevance_search(
    query: str,
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    filter: dict | None = None,
    **kwargs: Any,
) -> list[Document]

返回使用最大边际相关性选择的文档。

最大边际相关性优化查询相似度与所选文档之间的多样性。

参数	描述
query	搜索查询文本。 类型： str
k	要返回的 `Document` 对象数量。 TYPE: int DEFAULT: 4
fetch_k	要获取并传递给 MMR 算法的 `Document` 对象数量。 类型： int 默认值： 20
lambda_mult	一个介于 `0` 和 `1` 之间的数字，决定了结果之间的多样性程度，其中 `0` 对应最大多样性，`1` 对应最小多样性。 类型： float 默认值： 0.5
filter	根据元数据属性进行筛选，例如 { "str_property": "foo", "int_property": 123 } 类型： dict | None 默认值： None

返回：通过最大边际相关性选择的 Document 对象列表。