`langchain_community.vectorstores.neo4j_vector`.Neo4jVector¶

class langchain_community.vectorstores.neo4j_vector.Neo4jVector(embedding: Embeddings, *, search_type: SearchType = SearchType.VECTOR, username: Optional[str] = None, password: Optional[str] = None, url: Optional[str] = None, keyword_index_name: Optional[str] = 'keyword', database: Optional[str] = None, index_name: str = 'vector', node_label: str = 'Chunk', embedding_node_property: str = 'embedding', text_node_property: str = 'text', distance_strategy: DistanceStrategy = DistanceStrategy.COSINE, logger: Optional[Logger] = None, pre_delete_collection: bool = False, retrieval_query: str = '', relevance_score_fn: Optional[Callable[[float], float]] = None, index_type: IndexType = IndexType.NODE, graph: Optional[Neo4jGraph] = None)[source]¶

Neo4j 向量索引。

要使用，应安装 neo4j python 包。

参数:

url: Neo4j 连接 url username: Neo4j 用户名。 password: Neo4j 密码 database: 可选提供 Neo4j 数据库

默认为 “neo4j”

embedding: 任何实现 langchain.embeddings.base.Embeddings 接口的嵌入函数。 distance_strategy: 要使用的距离策略。 (默认: COSINE) pre_delete_collection: 如果为 True，将删除现有数据（如果存在）。

(默认: False)。用于测试。

示例:

from langchain_community.vectorstores.neo4j_vector import Neo4jVector
from langchain_community.embeddings.openai import OpenAIEmbeddings

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

Attributes

embeddings

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

Methods

`__init__`(embedding, *[, search_type, ...])
`aadd_documents`(documents, **kwargs)	运行更多的文档通过嵌入并添加到向量存储中。
`aadd_texts`(texts[, metadatas])	运行更多的文本通过嵌入，并添加到向量存储中。
`add_documents`(documents, **kwargs)	运行更多的文档通过嵌入并添加到向量存储中。
`add_embeddings`(texts, embeddings[, ...])	将嵌入添加到向量存储中。
`add_texts`(texts[, metadatas, ids])	运行更多文本通过嵌入并添加到向量存储。
`adelete`([ids])	根据向量ID或其他条件进行删除。
`afrom_documents`(documents, embedding, **kwargs)	返回从文档和嵌入初始化的VectorStore。
`afrom_texts`(texts, embedding[, metadatas])	返回从文本和嵌入初始化的VectorStore。
`amax_marginal_relevance_search`(query[, k, ...])	返回使用最大边际相关性选择的文档。
`amax_marginal_relevance_search_by_vector`(...)	返回使用最大边际相关性选择的文档。
`as_retriever`(**kwargs)	返回从此VectorStore初始化的VectorStoreRetriever。
`asearch`(query, search_type, **kwargs)	返回使用指定搜索类型的查询最相似的文档。
`asimilarity_search`(query[, k])	返回与查询最相似的文档。
`asimilarity_search_by_vector`(embedding[, k])	返回与嵌入向量最相似的文档。
`asimilarity_search_with_relevance_scores`(query)	返回文档和相关性分数在范围[0, 1]内，异步执行。
`asimilarity_search_with_score`(args, *kwargs)	使用异步方式运行相似性搜索与距离。
`create_new_index`()	这个方法构建一个Cypher查询并执行它来在Neo4j中创建一个新的向量索引。
`create_new_keyword_index`([text_node_properties])	这个方法构造一个Cypher查询并执行它来在Neo4j中创建一个新的全文索引。
`delete`([ids])	根据向量ID或其他条件进行删除。
`from_documents`(documents, embedding[, ...])	返回从文档和嵌入初始化的Neo4jVector。需要以`url`、`username`和`password`的形式提供Neo4j凭据，还可以选择性地提供`database`参数。
`from_embeddings`(text_embeddings, embedding)	从原始文档和预生成的嵌入中构建Neo4jVector包装器。
`from_existing_graph`(embedding, node_label, ...)	从现有图形初始化并返回一个Neo4jVector实例。
`from_existing_index`(embedding, index_name[, ...])	获取现有的Neo4j向量索引实例。此方法将返回存储的实例，而不会插入任何新的嵌入。需要Neo4j凭据，包括`url`、username`和`password，以及可选的`database`参数，还需要定义`index_name`。
`from_existing_relationship_index`(embedding, ...)	获取现有的Neo4j关系向量索引的实例。该方法将返回存储的实例，而不会插入任何新的嵌入。需要Neo4j凭据，包括`url`、`username`和`password`参数，以及可选的`database`参数，还有`index_name`定义。
`from_texts`(texts, embedding[, metadatas, ...])	返回从文本和嵌入初始化的Neo4jVector。需要以`url`、`username`和`password`的形式提供Neo4j凭据，还可以选择性地提供`database`参数。
`max_marginal_relevance_search`(query[, k, ...])	返回使用最大边际相关性选择的文档。
`max_marginal_relevance_search_by_vector`(...)	返回使用最大边际相关性选择的文档。
`query`(query, *[, params])	这个方法将一个Cypher查询发送到已连接的Neo4j数据库，并将结果作为一个字典列表返回。
`retrieve_existing_fts_index`([...])	检查Neo4j数据库中是否存在全文索引
`retrieve_existing_index`()	检查向量索引是否存在于Neo4j数据库中，并返回其嵌入维度。
`search`(query, search_type, **kwargs)	返回使用指定搜索类型的查询最相似的文档。
`similarity_search`(query[, k, params, filter])	使用Neo4jVector运行相似性搜索。
`similarity_search_by_vector`(embedding[, k, ...])	返回与嵌入向量最相似的文档。
`similarity_search_with_relevance_scores`(query)	返回文档和相关性得分在[0, 1]范围内。
`similarity_search_with_score`(query[, k, ...])	返回与查询最相似的文档。
`similarity_search_with_score_by_vector`(embedding)	在Neo4j数据库中使用给定向量执行相似性搜索，并返回前k个相似文档及其分数。
`verify_version`()	检查连接的Neo4j数据库版本是否支持向量索引。

Parameters

embedding (Embeddings) –
search_type (SearchType) –
username (Optional[str]) –
password (Optional[str]) –
url (Optional[str]) –
keyword_index_name (Optional[str]) –
database (Optional[str]) –
index_name (str) –
node_label (str) –
embedding_node_property (str) –
text_node_property (str) –
distance_strategy (DistanceStrategy) –
logger (Optional[logging.Logger]) –
pre_delete_collection (bool) –
retrieval_query (str) –
relevance_score_fn (Optional[Callable[[float], float]]) –
index_type (IndexType) –
graph (Optional[Neo4jGraph]) –

Return type

None

__init__(embedding: Embeddings, *, search_type: SearchType = SearchType.VECTOR, username: Optional[str] = None, password: Optional[str] = None, url: Optional[str] = None, keyword_index_name: Optional[str] = 'keyword', database: Optional[str] = None, index_name: str = 'vector', node_label: str = 'Chunk', embedding_node_property: str = 'embedding', text_node_property: str = 'text', distance_strategy: DistanceStrategy = DistanceStrategy.COSINE, logger: Optional[Logger] = None, pre_delete_collection: bool = False, retrieval_query: str = '', relevance_score_fn: Optional[Callable[[float], float]] = None, index_type: IndexType = IndexType.NODE, graph: Optional[Neo4jGraph] = None) → None[source]¶

Parameters

embedding (Embeddings) –
search_type (SearchType) –
username (Optional[str]) –
password (Optional[str]) –
url (Optional[str]) –
keyword_index_name (Optional[str]) –
database (Optional[str]) –
index_name (str) –
node_label (str) –
embedding_node_property (str) –
text_node_property (str) –
distance_strategy (DistanceStrategy) –
logger (Optional[Logger]) –
pre_delete_collection (bool) –
retrieval_query (str) –
relevance_score_fn (Optional[Callable[[float], float]]) –
index_type (IndexType) –
graph (Optional[Neo4jGraph]) –

Return type

None

async aadd_documents(documents: List[Document], **kwargs: Any) → List[str]¶

运行更多的文档通过嵌入并添加到向量存储中。

参数:: documents (List[Document]): 要添加到向量存储中的文档。
返回:: List[str]: 添加的文本的ID列表。

Parameters

documents (List[Document]) –
kwargs (Any) –

Return type

List[str]

async aadd_texts(texts: Iterable[str], metadatas: Optional[List[dict]] = None, **kwargs: Any) → List[str]¶

运行更多的文本通过嵌入，并添加到向量存储中。

Parameters

texts (Iterable[str]) –
metadatas (Optional[List[dict]]) –
kwargs (Any) –

Return type

List[str]

add_documents(documents: List[Document], **kwargs: Any) → List[str]¶

运行更多的文档通过嵌入并添加到向量存储中。

参数:: documents (List[Document]): 要添加到向量存储中的文档。
返回:: List[str]: 添加的文本的ID列表。

Parameters

documents (List[Document]) –
kwargs (Any) –

Return type

List[str]

add_embeddings(texts: Iterable[str], embeddings: List[List[float]], metadatas: Optional[List[dict]] = None, ids: Optional[List[str]] = None, **kwargs: Any) → List[str][source]¶

将嵌入添加到向量存储中。

参数：: texts：要添加到向量存储中的字符串的可迭代对象。 embeddings：嵌入向量的列表的列表。 metadatas：与文本相关联的元数据列表。 kwargs：向量存储特定参数。

Parameters

texts (Iterable[str]) –
embeddings (List[List[float]]) –
metadatas (Optional[List[dict]]) –
ids (Optional[List[str]]) –
kwargs (Any) –

Return type

List[str]

add_texts(texts: Iterable[str], metadatas: Optional[List[dict]] = None, ids: Optional[List[str]] = None, **kwargs: Any) → List[str][source]¶

运行更多文本通过嵌入并添加到向量存储。

参数：: texts：要添加到向量存储的字符串的可迭代对象。 metadatas：与文本相关联的元数据的可选列表。 kwargs：向量存储特定参数
返回：: 将文本添加到向量存储中的ID列表。

Parameters

texts (Iterable[str]) –
metadatas (Optional[List[dict]]) –
ids (Optional[List[str]]) –
kwargs (Any) –

Return type

List[str]

async adelete(ids: Optional[List[str]] = None, **kwargs: Any) → Optional[bool]¶

根据向量ID或其他条件进行删除。

参数：: ids：要删除的ID列表。 **kwargs：子类可能使用的其他关键字参数。
返回：: Optional[bool]：如果删除成功则为True，否则为False，如果未实现则为None。

Parameters

ids (Optional[List[str]]) –
kwargs (Any) –

Return type

Optional[bool]

async classmethod afrom_documents(documents: List[Document], embedding: Embeddings, **kwargs: Any) → VST¶

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

Parameters

documents (List[Document]) –
embedding (Embeddings) –
kwargs (Any) –

Return type

VST

async classmethod afrom_texts(texts: List[str], embedding: Embeddings, metadatas: Optional[List[dict]] = None, **kwargs: Any) → VST¶

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

Parameters

texts (List[str]) –
embedding (Embeddings) –
metadatas (Optional[List[dict]]) –
kwargs (Any) –

Return type

VST

async amax_marginal_relevance_search(query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, **kwargs: Any) → List[Document]¶

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

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

参数：: query：要查找类似文档的文本。 k：要返回的文档数量。默认为4。 fetch_k：要获取以传递给MMR算法的文档数量。 lambda_mult：0到1之间的数字，确定结果之间多样性的程度，0对应最大多样性，1对应最小多样性。默认为0.5。
返回：: 由最大边际相关性选择的文档列表。

Parameters

query (str) –
k (int) –
fetch_k (int) –
lambda_mult (float) –
kwargs (Any) –

Return type

List[Document]

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]¶

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

Parameters

embedding (List[float]) –
k (int) –
fetch_k (int) –
lambda_mult (float) –
kwargs (Any) –

Return type

List[Document]

as_retriever(**kwargs: Any) → VectorStoreRetriever¶

返回从此VectorStore初始化的VectorStoreRetriever。

参数：

search_type（可选[str]）：定义Retriever应执行的搜索类型。: 可以是”similarity”（默认值）、”mmr”或”similarity_score_threshold”。
search_kwargs（可选[Dict]）：传递给搜索函数的关键字参数。可以包括：: k：要返回的文档数量（默认值：4） score_threshold：用于similarity_score_threshold的最小相关性阈值 fetch_k：传递给MMR算法的文档数量（默认值：20） lambda_mult：MMR返回结果的多样性；1表示最小多样性，0表示最大多样性（默认值：0.5） filter：按文档元数据筛选

返回：

VectorStoreRetriever：VectorStore的Retriever类。

示例：

# 检索更多具有更高多样性的文档
# 如果数据集中有许多相似的文档，则很有用
docsearch.as_retriever(
    search_type="mmr",
    search_kwargs={'k': 6, 'lambda_mult': 0.25}
)

# 为MMR算法考虑更多文档
# 但只返回前5个
docsearch.as_retriever(
    search_type="mmr",
    search_kwargs={'k': 5, 'fetch_k': 50}
)

# 仅检索具有特定阈值以上相关性分数的文档
docsearch.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={'score_threshold': 0.8}
)

# 仅从数据集中获取最相似的单个文档
docsearch.as_retriever(search_kwargs={'k': 1})

# 使用筛选器仅从特定论文中检索文档
docsearch.as_retriever(
    search_kwargs={'filter': {'paper_title':'GPT-4 Technical Report'}}
)

Parameters: kwargs (Any) –
Return type: VectorStoreRetriever

async asearch(query: str, search_type: str, **kwargs: Any) → List[Document]¶

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

Parameters

query (str) –
search_type (str) –
kwargs (Any) –

Return type

List[Document]

async asimilarity_search(query: str, k: int = 4, **kwargs: Any) → List[Document]¶

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

Parameters

query (str) –
k (int) –
kwargs (Any) –

Return type

List[Document]

async asimilarity_search_by_vector(embedding: List[float], k: int = 4, **kwargs: Any) → List[Document]¶

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

Parameters

embedding (List[float]) –
k (int) –
kwargs (Any) –

Return type

List[Document]

async asimilarity_search_with_relevance_scores(query: str, k: int = 4, **kwargs: Any) → List[Tuple[Document, float]]¶

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

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

参数：: query：输入文本 k：要返回的文档数量。默认为4。 **kwargs：要传递给相似性搜索的kwargs。应包括：

score_threshold：可选，介于0到1之间的浮点值，用于过滤检索到的文档集
返回：: 元组列表（doc，相似度分数）的列表

Parameters

query (str) –
k (int) –
kwargs (Any) –

Return type

List[Tuple[Document, float]]

async asimilarity_search_with_score(*args: Any, **kwargs: Any) → List[Tuple[Document, float]]¶

使用异步方式运行相似性搜索与距离。

Parameters

args (Any) –
kwargs (Any) –

Return type

List[Tuple[Document, float]]

create_new_index() → None[source]¶

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

Return type: None

create_new_keyword_index(text_node_properties: List[str] = []) → None[source]¶

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

Parameters: text_node_properties (List[str]) –
Return type: None

delete(ids: Optional[List[str]] = None, **kwargs: Any) → Optional[bool]¶

根据向量ID或其他条件进行删除。

参数：: ids：要删除的ID列表。 **kwargs：子类可能使用的其他关键字参数。
返回：: Optional[bool]：如果删除成功则为True，否则为False，如果未实现则为None。

Parameters

ids (Optional[List[str]]) –
kwargs (Any) –

Return type

Optional[bool]

classmethod from_documents(documents: List[Document], embedding: Embeddings, distance_strategy: DistanceStrategy = DistanceStrategy.COSINE, ids: Optional[List[str]] = None, **kwargs: Any) → Neo4jVector[source]¶

返回从文档和嵌入初始化的Neo4jVector。需要以`url`、`username`和`password`的形式提供Neo4j凭据，还可以选择性地提供`database`参数。

Parameters

documents (List[Document]) –
embedding (Embeddings) –
distance_strategy (DistanceStrategy) –
ids (Optional[List[str]]) –
kwargs (Any) –

Return type

Neo4jVector

classmethod from_embeddings(text_embeddings: List[Tuple[str, List[float]]], embedding: Embeddings, metadatas: Optional[List[dict]] = None, distance_strategy: DistanceStrategy = DistanceStrategy.COSINE, ids: Optional[List[str]] = None, pre_delete_collection: bool = False, **kwargs: Any) → Neo4jVector[source]¶

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

返回从文档和嵌入初始化的Neo4jVector。需要Neo4j凭据，包括`url`、`username`和`password`参数，以及可选的`database`参数。

示例：

from langchain_community.vectorstores.neo4j_vector import Neo4jVector
from langchain_community.embeddings 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)

Parameters

text_embeddings (List[Tuple[str, List[float]]]) –
embedding (Embeddings) –
metadatas (Optional[List[dict]]) –
distance_strategy (DistanceStrategy) –
ids (Optional[List[str]]) –
pre_delete_collection (bool) –
kwargs (Any) –

Return type

Neo4jVector

classmethod from_existing_graph(embedding: Embeddings, node_label: str, embedding_node_property: str, text_node_properties: List[str], *, keyword_index_name: Optional[str] = 'keyword', index_name: str = 'vector', search_type: SearchType = SearchType.VECTOR, retrieval_query: str = '', **kwargs: Any) → Neo4jVector[source]¶

从现有图形初始化并返回一个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`参数。

Parameters

embedding (Embeddings) –
node_label (str) –
embedding_node_property (str) –
text_node_properties (List[str]) –
keyword_index_name (Optional[str]) –
index_name (str) –
search_type (SearchType) –
retrieval_query (str) –
kwargs (Any) –

Return type

Neo4jVector

classmethod from_existing_index(embedding: Embeddings, index_name: str, search_type: SearchType = SearchType.VECTOR, keyword_index_name: Optional[str] = None, **kwargs: Any) → Neo4jVector[source]¶

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

Parameters

embedding (Embeddings) –
index_name (str) –
search_type (SearchType) –
keyword_index_name (Optional[str]) –
kwargs (Any) –

Return type

Neo4jVector

classmethod from_existing_relationship_index(embedding: Embeddings, index_name: str, search_type: SearchType = SearchType.VECTOR, **kwargs: Any) → Neo4jVector[source]¶

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

Parameters

embedding (Embeddings) –
index_name (str) –
search_type (SearchType) –
kwargs (Any) –

Return type

Neo4jVector

classmethod from_texts(texts: List[str], embedding: Embeddings, metadatas: Optional[List[dict]] = None, distance_strategy: DistanceStrategy = DistanceStrategy.COSINE, ids: Optional[List[str]] = None, **kwargs: Any) → Neo4jVector[source]¶

返回从文本和嵌入初始化的Neo4jVector。需要以`url`、`username`和`password`的形式提供Neo4j凭据，还可以选择性地提供`database`参数。

Parameters

texts (List[str]) –
embedding (Embeddings) –
metadatas (Optional[List[dict]]) –
distance_strategy (DistanceStrategy) –
ids (Optional[List[str]]) –
kwargs (Any) –

Return type

Neo4jVector

max_marginal_relevance_search(query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, **kwargs: Any) → List[Document]¶

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

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

参数：: query：要查找类似文档的文本。 k：要返回的文档数量。默认为4。 fetch_k：要获取以传递给MMR算法的文档数量。 lambda_mult：0到1之间的数字，确定结果之间多样性的程度，0对应最大多样性，1对应最小多样性。默认为0.5。
返回：: 由最大边际相关性选择的文档列表。

Parameters

query (str) –
k (int) –
fetch_k (int) –
lambda_mult (float) –
kwargs (Any) –

Return type

List[Document]

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：要查找相似文档的嵌入。 k：要返回的文档数量。默认为4。 fetch_k：要获取以传递给MMR算法的文档数量。 lambda_mult：介于0和1之间的数字，确定结果之间多样性的程度，其中0对应最大多样性，1对应最小多样性。默认为0.5。
返回：: 由最大边际相关性选择的文档列表。

Parameters

embedding (List[float]) –
k (int) –
fetch_k (int) –
lambda_mult (float) –
kwargs (Any) –

Return type

List[Document]

query(query: str, *, params: Optional[dict] = None) → List[Dict[str, Any]][source]¶

这个方法将一个Cypher查询发送到已连接的Neo4j数据库，并将结果作为一个字典列表返回。

参数:: query (str): 要执行的Cypher查询。 params (dict, optional): 查询参数的字典。默认为{}。
返回:: List[Dict[str, Any]]: 包含查询结果的字典列表。

Parameters

query (str) –
params (Optional[dict]) –

Return type

List[Dict[str, Any]]

retrieve_existing_fts_index(text_node_properties: List[str] = []) → Optional[str][source]¶

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

该方法查询具有指定名称的现有fts索引的Neo4j数据库。

返回：: （元组）：关键字索引信息

Parameters: text_node_properties (List[str]) –
Return type: Optional[str]

retrieve_existing_index() → Tuple[Optional[int], Optional[str]][source]¶

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

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

返回：: int或None：如果找到现有索引，则返回其嵌入维度。

Return type: Tuple[Optional[int], Optional[str]]

search(query: str, search_type: str, **kwargs: Any) → List[Document]¶

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

Parameters

query (str) –
search_type (str) –
kwargs (Any) –

Return type

List[Document]

similarity_search(query: str, k: int = 4, params: Dict[str, Any] = {}, filter: Optional[Dict[str, Any]] = None, **kwargs: Any) → List[Document][source]¶

使用Neo4jVector运行相似性搜索。

参数：: query (str): 要搜索的查询文本。 k (int): 要返回的结果数量。默认为4。
返回：: 与查询最相似的文档列表。

Parameters

query (str) –
k (int) –
params (Dict[str, Any]) –
filter (Optional[Dict[str, Any]]) –
kwargs (Any) –

Return type

List[Document]

similarity_search_by_vector(embedding: List[float], k: int = 4, filter: Optional[Dict[str, Any]] = None, **kwargs: Any) → List[Document][source]¶

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

参数:: embedding: 要查找与之相似文档的嵌入。 k: 要返回的文档数量。默认为4。
返回:: 与查询向量最相似的文档列表。

Parameters

embedding (List[float]) –
k (int) –
filter (Optional[Dict[str, Any]]) –
kwargs (Any) –

Return type

List[Document]

similarity_search_with_relevance_scores(query: str, k: int = 4, **kwargs: Any) → List[Tuple[Document, float]]¶

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

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

参数：: query：输入文本 k：要返回的文档数量。默认为4。 **kwargs：要传递给相似性搜索的kwargs。应包括：

score_threshold：可选，介于0到1之间的浮点值，用于过滤检索到的文档集
返回：: 元组列表（doc，相似性得分）

Parameters

query (str) –
k (int) –
kwargs (Any) –

Return type

List[Tuple[Document, float]]

similarity_search_with_score(query: str, k: int = 4, params: Dict[str, Any] = {}, filter: Optional[Dict[str, Any]] = None, **kwargs: Any) → List[Tuple[Document, float]][source]¶

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

参数：: query：要查找类似文档的文本。 k：要返回的文档数量。默认为4。
返回：: 与查询最相似的文档列表，以及每个文档的分数。

Parameters

query (str) –
k (int) –
params (Dict[str, Any]) –
filter (Optional[Dict[str, Any]]) –
kwargs (Any) –

Return type

List[Tuple[Document, float]]

similarity_search_with_score_by_vector(embedding: List[float], k: int = 4, filter: Optional[Dict[str, Any]] = None, params: Dict[str, Any] = {}, **kwargs: Any) → List[Tuple[Document, float]][source]¶

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

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

参数:: embedding (List[float]): 要进行比较的嵌入向量。 k (int, optional): 要检索的前k个相似文档的数量。
返回:: List[Tuple[Document, float]]: 一个元组列表，每个元组包含一个Document对象和其相似性分数。

Parameters

embedding (List[float]) –
k (int) –
filter (Optional[Dict[str, Any]]) –
params (Dict[str, Any]) –
kwargs (Any) –

Return type

List[Tuple[Document, float]]

verify_version() → None[source]¶

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

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

Return type: None

Examples using Neo4jVector¶

langchain_community.vectorstores.neo4j_vector.Neo4jVector¶

Examples using Neo4jVector¶

`langchain_community.vectorstores.neo4j_vector`.Neo4jVector¶