`langchain_community.vectorstores.deeplake`.DeepLake¶

class langchain_community.vectorstores.deeplake.DeepLake(dataset_path: str = './deeplake/', token: Optional[str] = None, embedding: Optional[Embeddings] = None, embedding_function: Optional[Embeddings] = None, read_only: bool = False, ingestion_batch_size: int = 1024, num_workers: int = 0, verbose: bool = True, exec_option: Optional[str] = None, runtime: Optional[Dict] = None, index_params: Optional[Dict[str, Union[str, int]]] = None, **kwargs: Any)[source]¶

Activeloop Deep Lake 向量存储。

我们集成了 deeplake 的相似性搜索和过滤功能，以实现快速原型设计。现在，它支持 Tensor Query Language (TQL)，用于在数十亿行数据上的生产用例。

为什么选择 Deep Lake？

不仅存储嵌入，还存储带有版本控制的原始数据。
无服务器，不需要其他服务，可以与主要的
云提供商（S3、GCS 等）一起使用
不仅仅是多模式向量存储。您可以使用数据集
来微调您自己的 LLM 模型。

要使用，您应该安装 deeplake python 包。

示例

from langchain_community.vectorstores import DeepLake
from langchain_community.embeddings.openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
vectorstore = DeepLake("langchain_store", embeddings.embed_query)

创建空的 DeepLakeVectorStore 或加载现有的 DeepLakeVectorStore。

DeepLakeVectorStore 位于指定的 path。

示例

>>> # Create a vector store with default tensors
>>> deeplake_vectorstore = DeepLake(
...        path = <path_for_storing_Data>,
... )
>>>
>>> # Create a vector store in the Deep Lake Managed Tensor Database
>>> data = DeepLake(
...        path = "hub://org_id/dataset_name",
...        runtime = {"tensor_db": True},
... )

参数

dataset_path (str) –
用于存储到 Deep Lake 向量存储的完整路径。它可以是： - 形式为 hub://org_id/dataset_name 的 Deep Lake 云路径。

需要注册 Deep Lake。
- 形式为 s3://bucketname/path/to/dataset 的 s3 路径。
  凭据需要在环境中提供，或者传递给 creds 参数。
- 形式为 ./path/to/dataset 的本地文件系统路径
  或 ~/path/to/dataset 或 path/to/dataset。
- 形式为 mem://path/to/dataset 的内存路径，它不会
  保存数据集，而是将其保存在内存中。仅应用于测试，因为它不会持久化。默认为 _LANGCHAIN_DEFAULT_DEEPLAKE_PATH。
token (str, optional) – Activeloop 令牌，用于获取路径中数据集的凭据（如果它是 Deep Lake 数据集）。令牌通常是自动生成的。可选。
embedding (Embeddings, optional) – 用于转换文档或查询的函数。可选。
embedding_function (Embeddings, optional) – 用于转换文档或查询的函数。可选。已弃用：保留此参数是为了向后兼容。
read_only (bool) – 以只读模式打开数据集。默认为 False。
ingestion_batch_size (int) – 在数据摄取期间，数据被分成批次。批次大小是每个批次的大小。默认为 1024。
num_workers (int) – 数据摄取期间要使用的工作人员数量。默认为 0。
verbose (bool) – 每次操作后打印数据集摘要。默认为 True。
exec_option (str, optional) –
搜索执行的默认方法。它可以是 "auto"、"python"、"compute_engine" 或 "tensor_db"。默认为 "auto"。如果为 None，则设置为 “auto”。 - auto- 根据向量存储的存储位置选择最佳执行方法。这是默认选项。

向量存储的存储位置。这是默认选项。
- python - 纯 Python 实现，在客户端上运行，并且
  可以用于存储在任何位置的数据。警告：不建议将此选项用于大型数据集，因为它可能导致内存问题。
- compute_engine - Deep Lake 的高性能 C++ 实现
  计算引擎，在客户端上运行，可用于存储在 Deep Lake 中或连接到 Deep Lake 的任何数据。它不能与内存中或本地数据集一起使用。
- tensor_db - 高性能且完全托管的托管张量数据库
  负责存储和查询执行。仅适用于存储在 Deep Lake 托管数据库中的数据。通过在数据集创建期间指定 runtime = {“tensor_db”: True}，将数据集存储在此数据库中。
runtime (Dict, optional) – 用于在 Deep Lake 的托管张量数据库中创建向量存储的参数。加载现有向量存储时不可用。要在托管张量数据库中创建向量存储，请设置 runtime = {“tensor_db”: True}。
index_params (Optional[Dict[str, Union[int, str]]], optional) –
包含将要创建的向量索引信息的字典。默认为 None，这将使用来自 deeplake.constants 的 DEFAULT_VECTORSTORE_INDEX_PARAMS。指定的键值对将覆盖默认值。 - threshold: 数据集大小的阈值，超过此阈值将

为嵌入张量创建索引。当阈值设置为 -1 时，将关闭索引创建。默认为 -1，这将关闭索引。
- distance_metric: 此键指定计算方法
  创建向量数据库 (VDB) 索引时向量之间的距离。它可以是对应于 DistanceType 枚举成员的字符串，也可以是字符串值本身。 - 如果未提供值，则默认为 “L2”。 - “L2” 对应于 DistanceType.L2_NORM。 - “COS” 对应于 DistanceType.COSINE_SIMILARITY。
- additional_params: 用于微调索引的其他参数。
**kwargs – 其他可选关键字参数。

Raises

ValueError – 如果未满足某些条件。

属性

embeddings

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

方法

`__init__`([dataset_path, token, embedding, ...])	创建空的 DeepLakeVectorStore 或加载现有的 DeepLakeVectorStore。
`aadd_documents`(documents, **kwargs)	异步运行更多文档通过嵌入并添加到向量存储。
`aadd_texts`(texts[, metadatas])	异步运行更多文本通过嵌入并添加到向量存储。
`add_documents`(documents, **kwargs)	在向量存储中添加或更新文档。
`add_texts`(texts[, metadatas, ids])	运行更多文本通过嵌入并添加到向量存储。
`adelete`([ids])	异步按向量 ID 或其他条件删除。
`afrom_documents`(documents, embedding, **kwargs)	异步返回从文档和嵌入初始化的 VectorStore。
`afrom_texts`(texts, embedding[, metadatas])	异步返回从文本和嵌入初始化的 VectorStore。
`aget_by_ids`(ids, /)	异步按 ID 获取文档。
`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)	异步运行带距离的相似性搜索。
`astreaming_upsert`(items, /, batch_size, **kwargs)
`aupsert`(items, /, **kwargs)
`delete`([ids])	删除数据集中的实体。
`delete_dataset`()	删除集合。
`ds`()
`force_delete_by_path`(path)	按路径强制删除数据集。
`from_documents`(documents, embedding, **kwargs)	返回从文档和嵌入初始化的 VectorStore。
`from_texts`(texts[, embedding, metadatas, ...])	从原始文档创建 Deep Lake 数据集。
`get_by_ids`(ids, /)	按 ID 获取文档。
`max_marginal_relevance_search`(query[, k, ...])	返回使用最大边际相关性选择的文档。
`max_marginal_relevance_search_by_vector`(...)	返回使用最大边际相关性选择的文档。
`search`(query, search_type, **kwargs)	返回与使用指定搜索类型的查询最相似的文档。
`similarity_search`(query[, k])	返回与查询最相似的文档。
`similarity_search_by_vector`(embedding[, k])	返回与嵌入向量最相似的文档。
`similarity_search_with_relevance_scores`(query)	返回范围在 [0, 1] 内的文档和相关性分数。
`similarity_search_with_score`(query[, k])	运行 Deep Lake 相似性搜索，并返回距离。
`streaming_upsert`(items, /, batch_size, **kwargs)
`upsert`(items, /, **kwargs)

__init__(dataset_path: str = './deeplake/', token: Optional[str] = None, embedding: Optional[Embeddings] = None, embedding_function: Optional[Embeddings] = None, read_only: bool = False, ingestion_batch_size: int = 1024, num_workers: int = 0, verbose: bool = True, exec_option: Optional[str] = None, runtime: Optional[Dict] = None, index_params: Optional[Dict[str, Union[str, int]]] = None, **kwargs: Any) → None[source]¶

创建空的 DeepLakeVectorStore 或加载现有的 DeepLakeVectorStore。

DeepLakeVectorStore 位于指定的 path。

示例

>>> # Create a vector store with default tensors
>>> deeplake_vectorstore = DeepLake(
...        path = <path_for_storing_Data>,
... )
>>>
>>> # Create a vector store in the Deep Lake Managed Tensor Database
>>> data = DeepLake(
...        path = "hub://org_id/dataset_name",
...        runtime = {"tensor_db": True},
... )

参数

dataset_path (str) –
用于存储到 Deep Lake 向量存储的完整路径。它可以是： - 形式为 hub://org_id/dataset_name 的 Deep Lake 云路径。

需要注册 Deep Lake。
- 形式为 s3://bucketname/path/to/dataset 的 s3 路径。
  凭据需要在环境中提供，或者传递给 creds 参数。
- 形式为 ./path/to/dataset 的本地文件系统路径
  或 ~/path/to/dataset 或 path/to/dataset。
- 形式为 mem://path/to/dataset 的内存路径，它不会
  保存数据集，而是将其保存在内存中。仅应用于测试，因为它不会持久化。默认为 _LANGCHAIN_DEFAULT_DEEPLAKE_PATH。
token (str, optional) – Activeloop 令牌，用于获取路径中数据集的凭据（如果它是 Deep Lake 数据集）。令牌通常是自动生成的。可选。
embedding (Embeddings, optional) – 用于转换文档或查询的函数。可选。
embedding_function (Embeddings, optional) – 用于转换文档或查询的函数。可选。已弃用：保留此参数是为了向后兼容。
read_only (bool) – 以只读模式打开数据集。默认为 False。
ingestion_batch_size (int) – 在数据摄取期间，数据被分成批次。批次大小是每个批次的大小。默认为 1024。
num_workers (int) – 数据摄取期间要使用的工作人员数量。默认为 0。
verbose (bool) – 每次操作后打印数据集摘要。默认为 True。
exec_option (str, optional) –
搜索执行的默认方法。它可以是 "auto"、"python"、"compute_engine" 或 "tensor_db"。默认为 "auto"。如果为 None，则设置为 “auto”。 - auto- 根据向量存储的存储位置选择最佳执行方法。这是默认选项。

向量存储的存储位置。这是默认选项。
- python - 纯 Python 实现，在客户端上运行，并且
  可以用于存储在任何位置的数据。警告：不建议将此选项用于大型数据集，因为它可能导致内存问题。
- compute_engine - Deep Lake 的高性能 C++ 实现
  计算引擎，在客户端上运行，可用于存储在 Deep Lake 中或连接到 Deep Lake 的任何数据。它不能与内存中或本地数据集一起使用。
- tensor_db - 高性能且完全托管的托管张量数据库
  负责存储和查询执行。仅适用于存储在 Deep Lake 托管数据库中的数据。通过在数据集创建期间指定 runtime = {“tensor_db”: True}，将数据集存储在此数据库中。
runtime (Dict, optional) – 用于在 Deep Lake 的托管张量数据库中创建向量存储的参数。加载现有向量存储时不可用。要在托管张量数据库中创建向量存储，请设置 runtime = {“tensor_db”: True}。
index_params (Optional[Dict[str, Union[int, str]]], optional) –
包含将要创建的向量索引信息的字典。默认为 None，这将使用来自 deeplake.constants 的 DEFAULT_VECTORSTORE_INDEX_PARAMS。指定的键值对将覆盖默认值。 - threshold: 数据集大小的阈值，超过此阈值将

为嵌入张量创建索引。当阈值设置为 -1 时，将关闭索引创建。默认为 -1，这将关闭索引。
- distance_metric: 此键指定计算方法
  创建向量数据库 (VDB) 索引时向量之间的距离。它可以是对应于 DistanceType 枚举成员的字符串，也可以是字符串值本身。 - 如果未提供值，则默认为 “L2”。 - “L2” 对应于 DistanceType.L2_NORM。 - “COS” 对应于 DistanceType.COSINE_SIMILARITY。
- additional_params: 用于微调索引的其他参数。
**kwargs – 其他可选关键字参数。

Raises

ValueError – 如果未满足某些条件。

返回类型

None

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

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

参数

documents (List[Document]) – 要添加到向量存储的文档。
kwargs (Any) – 额外的关键字参数。

Returns

添加文本的 ID 列表。

Raises

ValueError – 如果 ID 的数量与文档的数量不匹配。

返回类型

List[str]

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

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

参数

texts (Iterable[str]) – 要添加到向量存储的字符串的可迭代对象。
metadatas (Optional[List[dict]]) – 与文本关联的可选元数据列表。默认为 None。
**kwargs (Any) – 向量存储特定的参数。

Returns

将文本添加到向量存储的 ID 列表。

Raises

ValueError – 如果元数据的数量与文本的数量不匹配。
ValueError – 如果 ID 的数量与文本的数量不匹配。

返回类型

List[str]

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

在向量存储中添加或更新文档。

参数

documents (List[Document]) – 要添加到向量存储的文档。
kwargs (Any) – 附加关键字参数。如果 kwargs 包含 ids 并且 documents 包含 ids，则 kwargs 中的 ids 将优先使用。

Returns

添加文本的 ID 列表。

Raises

ValueError – 如果 ids 的数量与 documents 的数量不匹配。

返回类型

List[str]

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

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

示例

>>> ids = deeplake_vectorstore.add_texts(
...     texts = <list_of_texts>,
...     metadatas = <list_of_metadata_jsons>,
...     ids = <list_of_ids>,
... )

参数

texts (Iterable[str]) – 要添加到向量存储的文本。
metadatas (Optional[List[dict]], optional) – 元数据的可选列表。
ids (Optional[List[str]], optional) – ID 的可选列表。
embedding_function (Optional[Embeddings], optional) – 用于将文本转换为嵌入的嵌入函数。
**kwargs (Any) – 此方法不支持传递任何额外的关键字参数。

Returns

添加文本的 ID 列表。

返回类型

List[str]

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

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

参数

ids (Optional[List[str]]) – 要删除的 ID 列表。如果为 None，则删除所有。默认为 None。
**kwargs (Any) – 子类可能使用的其他关键字参数。

Returns

如果删除成功，则为 True，否则为 False，如果未实现则为 None。

返回类型

Optional[bool]

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

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

参数

documents (List[Document]) – 要添加到向量存储的文档列表。
embedding (Embeddings) – 要使用的嵌入函数。
kwargs (Any) – 额外的关键字参数。

Returns

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

返回类型

VectorStore

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

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

参数

texts (List[str]) – 要添加到向量存储的文本列表。
embedding (Embeddings) – 要使用的嵌入函数。
metadatas (Optional[List[dict]]) – 与文本关联的可选元数据列表。默认为 None。
kwargs (Any) – 额外的关键字参数。

Returns

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

返回类型

VectorStore

async aget_by_ids(ids: Sequence[str], /) → List[Document]¶

异步按 ID 获取文档。

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

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

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

如果某些 ID 没有找到文档，此方法**不应**引发异常。

参数: ids (Sequence[str]) – 要检索的 ID 列表。
Returns: 文档列表。
返回类型: List[Document]

0.2.11 版本新增。

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 (int) – 要返回的文档数量。默认为 4。
fetch_k (int) – 要获取并传递给 MMR 算法的文档数量。默认为 20。
lambda_mult (float) – 介于 0 和 1 之间的数字，用于确定结果之间多样性的程度，其中 0 对应于最大多样性，1 对应于最小多样性。默认为 0.5。
kwargs (Any) –

Returns

通过最大边际相关性选择的文档列表。

返回类型

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

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

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

参数

embedding (List[float]) – 用于查找相似文档的嵌入向量。
k (int) – 要返回的文档数量。默认为 4。
fetch_k (int) – 要获取并传递给 MMR 算法的文档数量。默认为 20。
lambda_mult (float) – 介于 0 和 1 之间的数字，用于确定结果之间多样性的程度，其中 0 对应于最大多样性，1 对应于最小多样性。默认为 0.5。
**kwargs (Any) – 传递给搜索方法的参数。

Returns

通过最大边际相关性选择的文档列表。

返回类型

List[Document]

as_retriever(**kwargs: Any) → VectorStoreRetriever¶

返回从该 VectorStore 初始化的 VectorStoreRetriever。

参数

**kwargs (Any) –

传递给搜索函数的关键字参数。可以包括： search_type (Optional[str]): 定义检索器应执行的搜索类型。

可以是 “similarity”（默认），“mmr” 或 “similarity_score_threshold”。

search_kwargs (Optional[Dict]): 传递给搜索函数的关键字参数。可以包括例如：

搜索函数。

k: 要返回的文档数量 (默认: 4) score_threshold: similarity_score_threshold 的最小相关性阈值

similarity_score_threshold 的最小相关性阈值

fetch_k: 传递给 MMR 算法的文档数量 (默认: 20): (默认: 20)
lambda_mult: MMR 返回结果的多样性；: 1 代表最小多样性，0 代表最大多样性。(默认: 0.5)

filter: 按文档元数据筛选

Returns

VectorStore 的检索器类。

返回类型

VectorStoreRetriever

示例

# 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'}}
)

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

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

参数

query (str) – 输入文本。
search_type (str) – 要执行的搜索类型。可以是 “similarity”、“mmr” 或 “similarity_score_threshold”。
**kwargs (Any) – 传递给搜索方法的参数。

Returns

与查询最相似的文档列表。

Raises

ValueError – 如果 search_type 不是 “similarity”、“mmr” 或 “similarity_score_threshold” 之一。

返回类型

List[Document]

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

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

参数

query (str) – 输入文本。
k (int) – 要返回的文档数量。默认为 4。
**kwargs (Any) – 传递给搜索方法的参数。

Returns

与查询最相似的文档列表。

返回类型

List[Document]

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

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

参数

embedding (List[float]) – 用于查找相似文档的嵌入向量。
k (int) – 要返回的文档数量。默认为 4。
**kwargs (Any) – 传递给搜索方法的参数。

Returns

与查询向量最相似的文档列表。

返回类型

List[Document]

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

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

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

参数

query (str) – 输入文本。
k (int) – 要返回的文档数量。默认为 4。
**kwargs (Any) –
要传递给相似性搜索的 kwargs。应包括： score_threshold: 可选，介于 0 到 1 之间的浮点值，用于

筛选检索到的文档结果集

Returns

(doc, similarity_score) 元组的列表

返回类型

List[Tuple[Document, float]]

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

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

参数

*args (Any) – 传递给搜索方法的参数。
**kwargs (Any) – 传递给搜索方法的参数。

Returns

(doc, similarity_score) 元组的列表。

返回类型

List[Tuple[Document, float]]

astreaming_upsert(items: AsyncIterable[Document], /, batch_size: int, **kwargs: Any) → AsyncIterator[UpsertResponse]¶

Beta

在 0.2.11 版本中添加。API 可能会发生变化。

以流式方式更新插入文档。streaming_upsert 的异步版本。

参数

items (AsyncIterable[Document]) – 要添加到向量存储的文档的可迭代对象。
batch_size (int) – 每次更新插入批处理的大小。
kwargs (Any) – 附加关键字参数。kwargs 应仅包含所有文档通用的参数。（例如，索引超时，重试策略等）kwargs 不应包含 ids 以避免语义模糊。而是应将 ID 作为 Document 对象的一部分提供。

Yields

UpsertResponse – 响应对象，其中包含向量存储中成功添加或更新的 ID 列表以及未能添加或更新的 ID 列表。

返回类型

AsyncIterator[UpsertResponse]

0.2.11 版本新增。

async aupsert(items: Sequence[Document], /, **kwargs: Any) → UpsertResponse¶

Beta

在 0.2.11 版本中添加。API 可能会发生变化。

在向量存储中添加或更新文档。upsert 的异步版本。

如果提供了 Document 对象的 ID 字段，则更新插入功能应使用该字段。如果未提供 ID，则更新插入方法可以自由地为文档生成 ID。

当指定 ID 且文档已存在于向量存储中时，更新插入方法应使用新数据更新文档。如果文档不存在，则更新插入方法应将文档添加到向量存储。

参数

items (Sequence[Document]) – 要添加到向量存储的文档序列。
kwargs (Any) – 额外的关键字参数。

Returns

一个响应对象，其中包含向量存储中成功添加或更新的 ID 列表以及未能添加或更新的 ID 列表。

返回类型

UpsertResponse

0.2.11 版本新增。

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

删除数据集中的实体。

参数

ids (Optional[List[str]], optional) – 要删除的 document_ids。默认为 None。
**kwargs – 子类可能使用的其他关键字参数。 - filter (Optional[Dict[str, str]], optional): 要按其删除的过滤器。 - delete_all (Optional[bool], optional): 是否删除数据集。

Returns

删除操作是否成功。

返回类型

bool

delete_dataset() → None[source]¶

删除集合。

返回类型: None

ds() → Any[source]¶

返回类型: Any

classmethod force_delete_by_path(path: str) → None[source]¶

按路径强制删除数据集。

参数: path (str) – 要删除的数据集的路径。
Raises: ValueError – 如果未安装 deeplake。
返回类型: None

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

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

参数

documents (List[Document]) – 要添加到向量存储的文档列表。
embedding (Embeddings) – 要使用的嵌入函数。
kwargs (Any) – 额外的关键字参数。

Returns

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

返回类型

VectorStore

classmethod from_texts(texts: List[str], embedding: Optional[Embeddings] = None, metadatas: Optional[List[dict]] = None, ids: Optional[List[str]] = None, dataset_path: str = './deeplake/', **kwargs: Any) → DeepLake[source]¶

从原始文档创建 Deep Lake 数据集。

如果指定了 dataset_path，数据集将持久化存储在该位置，否则默认存储在 ./deeplake。

示例: >>> # Search using an embedding >>> vector_store = DeepLake.from_texts( … texts = <the_texts_that_you_want_to_embed>, … embedding_function = <embedding_function_for_query>, … k = <number_of_items_to_return>, … exec_option = <preferred_exec_option>, … )

参数

dataset_path (str) –
- 数据集的完整路径。可以是
- Deep Lake 云路径，格式为 hub://username/dataset_name。
  要写入 Deep Lake 云数据集，请确保您已登录 Deep Lake（从命令行使用 ‘activeloop login’）
- AWS S3 路径，格式为 s3://bucketname/path/to/dataset。
  凭据在环境中是必需的
- Google Cloud Storage 路径，格式为
  gcs://bucketname/path/to/dataset 凭据在环境中是必需的
- 本地文件系统路径，格式为 ./path/to/dataset 或
  ~/path/to/dataset 或 path/to/dataset。
- 内存路径，格式为 mem://path/to/dataset，它不会
  保存数据集，而是将其保存在内存中。仅应用于测试，因为它不会持久化。
texts (List[Document]) – 要添加的文档列表。
embedding (Optional[Embeddings]) – 嵌入函数。默认为 None。注意，在其他地方，它被称为 embedding_function。
metadatas (Optional[List[dict]]) – 元数据列表。默认为 None。
ids (Optional[List[str]]) – 文档 ID 列表。默认为 None。
kwargs (Any) – 额外的关键字参数。

Returns

Deep Lake 数据集。

返回类型

DeepLake

get_by_ids(ids: Sequence[str], /) → List[Document]¶

按 ID 获取文档。

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

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

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

如果某些 ID 没有找到文档，此方法**不应**引发异常。

参数: ids (Sequence[str]) – 要检索的 ID 列表。
Returns: 文档列表。
返回类型: List[Document]

0.2.11 版本新增。

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

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

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

示例: >>> # Search using an embedding >>> data = vector_store.max_marginal_relevance_search( … query = <query_to_search>, … embedding_function = <embedding_function_for_query>, … k = <number_of_items_to_return>, … exec_option = <preferred_exec_option>, … )

参数

query (str) – 用于查找相似文档的文本。
k (int) – 要返回的文档数量。默认为 4。
fetch_k (int) – MMR 算法的文档数量。
lambda_mult (float) – 介于 0 和 1 之间的值。 0 对应于最大多样性，1 对应于最小多样性。默认为 0.5。
exec_option (str) –
支持 3 种搜索执行方式。 - “python” - 在客户端上运行的纯 Python 实现。
可用于存储在任何位置的数据。警告：由于潜在的内存问题，不建议对大型数据集使用此选项。
- “compute_engine” - Deep 的高性能 C++ 实现
  Lake Compute Engine。在客户端上运行，可用于存储在 Deep Lake 中或连接到 Deep Lake 的任何数据。它不能与内存中或本地数据集一起使用。
- “tensor_db” - 高性能、完全托管的托管张量数据库。
  负责存储和查询执行。仅适用于存储在 Deep Lake 托管数据库中的数据。要将数据集存储在此数据库中，请在数据集创建期间指定 runtime = {“db_engine”: True}。
deep_memory (bool) – 是否使用 Deep Memory 模型来改进搜索结果。如果 Vector Store 初始化中未指定 deep_memory，则默认为 False。如果为 True，则距离度量设置为 “deepmemory_distance”，它表示模型训练时使用的度量。搜索是使用 Deep Memory 模型执行的。如果为 False，则距离度量设置为 “COS” 或用户指定的任何距离度量。
kwargs (Any) – 附加关键字参数

Returns

通过最大边际相关性选择的文档列表。

Raises

ValueError – 当 MRR 搜索开启但未指定嵌入函数时。

返回类型

List[Document]

max_marginal_relevance_search_by_vector(embedding: List[float], k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, exec_option: Optional:[str] = None, **kwargs: Any) → List[Document][source]¶

返回使用最大边际相关性选择的文档。最大边际相关性优化了与查询的相似性以及所选文档之间的多样性。

示例: >>> data = vector_store.max_marginal_relevance_search_by_vector( … embedding=<your_embedding>, … fetch_k=<elements_to_fetch_before_mmr_search>, … k=<number_of_items_to_return>, … exec_option=<preferred_exec_option>, … )

参数

embedding (List[float]) – 用于查找相似文档的嵌入向量。
k (int) – 要返回的文档数量。默认为 4。
fetch_k (int) – 为 MMR 算法获取的文档数量。
lambda_mult (float) – 介于 0 和 1 之间的数字，用于确定多样性程度。 0 对应于最大多样性，1 对应于最小多样性。默认为 0.5。
exec_option (str) –
DeepLakeVectorStore 支持 3 种搜索方式。可以是 “python”、“compute_engine” 或 “tensor_db”。默认为 “python”。 - “python” - 在客户端上运行的纯 Python 实现。

可用于存储在任何位置的数据。警告：由于潜在的内存问题，不建议对大型数据集使用此选项。
- “compute_engine” - Deep 的高性能 C++ 实现
  Lake Compute Engine。在客户端上运行，可用于存储在 Deep Lake 中或连接到 Deep Lake 的任何数据。它不能与内存中或本地数据集一起使用。
- “tensor_db” - 高性能、完全托管的托管张量数据库。
  负责存储和查询执行。仅适用于存储在 Deep Lake 托管数据库中的数据。要将数据集存储在此数据库中，请在数据集创建期间指定 runtime = {“db_engine”: True}。
deep_memory (bool) – 是否使用 Deep Memory 模型来改进搜索结果。如果 Vector Store 初始化中未指定 deep_memory，则默认为 False。如果为 True，则距离度量设置为 “deepmemory_distance”，它表示模型训练时使用的度量。搜索是使用 Deep Memory 模型执行的。如果为 False，则距离度量设置为 “COS” 或用户指定的任何距离度量。
kwargs (Any) – 额外的关键字参数。

Returns

List[Documents] - 文档列表。

返回类型

List[Document]

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

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

参数

query (str) – 输入文本
search_type (str) – 要执行的搜索类型。可以是 “similarity”、“mmr” 或 “similarity_score_threshold”。
**kwargs (Any) – 传递给搜索方法的参数。

Returns

与查询最相似的文档列表。

Raises

ValueError – 如果 search_type 不是 “similarity”、“mmr” 或 “similarity_score_threshold” 之一。

返回类型

List[Document]

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

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

示例

>>> # Search using an embedding
>>> data = vector_store.similarity_search(
...     query=<your_query>,
...     k=<num_items>,
...     exec_option=<preferred_exec_option>,
... )
>>> # Run tql search:
>>> data = vector_store.similarity_search(
...     query=None,
...     tql="SELECT * WHERE id == <id>",
...     exec_option="compute_engine",
... )

参数

k (int) – 要返回的文档数量。默认为 4。
query (str) – 用于查找相似文档的文本。
kwargs (Any) –
其他关键字参数包括：embedding (Callable): 要使用的嵌入函数。默认为 None。 distance_metric (str): ‘L2’ 代表欧几里得距离, ‘L1’ 代表核距离, ‘max’

代表 L-infinity 距离, ‘cos’ 代表余弦相似度, ‘dot’ 代表点积。默认为 ‘L2’。
filter (Union[Dict, Callable], optional): 附加过滤器
在嵌入搜索之前。 - Dict: 对 htype json 的张量进行键值搜索，

(样本必须满足所有键值过滤器) Dict = {“tensor_1”: {“key”: value}, “tensor_2”: {“key”: value}}
- Function: 与 deeplake.filter 兼容。
默认为 None。
exec_option (str): 支持 3 种搜索执行方式。
‘python’、‘compute_engine’ 或 ‘tensor_db’。默认为 ‘python’。 - ‘python’: 客户端的纯 Python 实现。

警告：不建议用于大型数据集。
- ‘compute_engine’: 客户端 Compute Engine 的 C++ 实现。
  不适用于内存中或本地数据集。
- ‘tensor_db’: 用于存储和查询的托管张量数据库。
  仅适用于 Deep Lake 托管数据库中的数据。在数据集创建期间使用 runtime = {“db_engine”: True}。
deep_memory (bool): 是否使用 Deep Memory 模型来改进
搜索结果。如果 Vector Store 初始化中未指定 deep_memory，则默认为 False。如果为 True，则距离度量设置为 “deepmemory_distance”，它表示模型训练时使用的度量。搜索是使用 Deep Memory 模型执行的。如果为 False，则距离度量设置为 “COS” 或用户指定的任何距离度量。

Returns

与查询向量最相似的文档列表。

返回类型

List[Document]

similarity_search_by_vector(embedding: Union[List[float], ndarray], k: int = 4, **kwargs: Any) → List[Document][source]¶

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

示例

>>> # Search using an embedding
>>> data = vector_store.similarity_search_by_vector(
...    embedding=<your_embedding>,
...    k=<num_items_to_return>,
...    exec_option=<preferred_exec_option>,
... )

参数

embedding (Union[List[float], np.ndarray]) – 用于查找相似文档的嵌入。
k (int) – 要返回的文档数量。默认为 4。
kwargs (Any) –
其他关键字参数包括： filter (Union[Dict, Callable], optional)
嵌入搜索之前的附加过滤器。 - Dict - 对 htype json 的张量进行键值搜索。如果为 True

如果满足所有键值过滤器。 Dict = {“tensor_name_1”: {“key”: value},

”tensor_name_2”: {“key”: value}}
- Function - 与以下项兼容的任何函数
  deeplake.filter.
默认为 None。
exec_option (str): 搜索执行选项包括
“python”、“compute_engine” 或 “tensor_db”。默认为 “python”。 - “python” - 在客户端上运行的纯 Python 实现。

可用于存储在任何位置的数据。警告：由于潜在的内存问题，不建议对大型数据集使用此选项。
- “compute_engine” - Deep 的高性能 C++ 实现
  Lake Compute Engine。在客户端上运行，可用于存储在 Deep Lake 中或连接到 Deep Lake 的任何数据。它不能与内存中或本地数据集一起使用。
- “tensor_db” - 高性能、完全托管的托管张量数据库。
  负责存储和查询执行。仅适用于存储在 Deep Lake 托管数据库中的数据。要将数据集存储在此数据库中，请在数据集创建期间指定 runtime = {“db_engine”: True}。
distance_metric (str): L2 代表欧几里得距离, L1 代表核距离,
max 代表 L-infinity 距离, cos 代表余弦相似度, ‘dot’ 代表点积。默认为 L2。

deep_memory (bool): 是否使用 Deep Memory 模型来改进
搜索结果。如果 Vector Store 初始化中未指定 deep_memory，则默认为 False。如果为 True，则距离度量设置为 “deepmemory_distance”，它表示模型训练时使用的度量。搜索是使用 Deep Memory 模型执行的。如果为 False，则距离度量设置为 “COS” 或用户指定的任何距离度量。

Returns

与查询向量最相似的文档列表。

返回类型

List[Document]

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

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

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

参数

query (str) – 输入文本。
k (int) – 要返回的文档数量。默认为 4。
**kwargs (Any) –
要传递给相似性搜索的 kwargs。应包括： score_threshold: 可选，介于 0 到 1 之间的浮点值，用于

过滤检索到的文档结果集。

Returns

(doc, similarity_score) 元组的列表。

返回类型

List[Tuple[Document, float]]

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

运行 Deep Lake 相似性搜索，并返回距离。

示例: >>> data = vector_store.similarity_search_with_score( … query=<your_query>, … embedding=<your_embedding_function> … k=<number_of_items_to_return>, … exec_option=<preferred_exec_option>, … )

参数

query (str) – 要搜索的查询文本。
k (int) – 要返回的结果数。默认为 4。
kwargs (Any) –
其他关键字参数。其中一些参数是： distance_metric: L2 代表欧几里得距离, L1 代表核距离, max L-infinity

距离, cos 代表余弦相似度, ‘dot’ 代表点积。默认为 L2。
filter (Optional[Dict[str, str]]): 按元数据过滤。默认为 None。
embedding_function (Callable): 要使用的嵌入函数。默认为 None。

exec_option (str): DeepLakeVectorStore 支持 3 种执行方式
搜索。它可以是 “python”、“compute_engine” 或 “tensor_db”。默认为 “python”。 - “python” - 在客户端上运行的纯 Python 实现。

可用于存储在任何位置的数据。警告：由于潜在的内存问题，不建议对大型数据集使用此选项。
- “compute_engine” - Deep 的高性能 C++ 实现
  Lake Compute Engine。在客户端上运行，可用于存储在 Deep Lake 中或连接到 Deep Lake 的任何数据。它不能与内存中或本地数据集一起使用。
- “tensor_db” - 高性能、完全托管的托管张量数据库。
  负责存储和查询执行。仅适用于存储在 Deep Lake 托管数据库中的数据。要将数据集存储在此数据库中，请在数据集创建期间指定 runtime = {“db_engine”: True}。
deep_memory (bool): 是否使用 Deep Memory 模型来改进
搜索结果。如果 Vector Store 初始化中未指定 deep_memory，则默认为 False。如果为 True，则距离度量设置为 “deepmemory_distance”，它表示模型训练时使用的度量。搜索是使用 Deep Memory 模型执行的。如果为 False，则距离度量设置为 “COS” 或用户指定的任何距离度量。

Returns

与查询最相似的文档列表: 文本，带有浮点距离。

返回类型

List[Tuple[Document, float]]

streaming_upsert(items: Iterable[Document], /, batch_size: int, **kwargs: Any) → Iterator[UpsertResponse]¶

Beta

在 0.2.11 版本中添加。API 可能会发生变化。

以流式方式更新文档。

参数

items (Iterable[Document]) – 要添加到向量存储的文档的可迭代对象。
batch_size (int) – 每次更新插入批处理的大小。
kwargs (Any) – 附加关键字参数。 kwargs 应仅包含所有文档通用的参数。（例如，索引超时、重试策略等）kwargs 不应包含 id 以避免语义不明确。相反，ID 应作为 Document 对象的一部分提供。

Yields

UpsertResponse – 响应对象，其中包含向量存储中成功添加或更新的 ID 列表以及未能添加或更新的 ID 列表。

返回类型

Iterator[UpsertResponse]

0.2.11 版本新增。

upsert(items: Sequence[Document], /, **kwargs: Any) → UpsertResponse¶

Beta

在 0.2.11 版本中添加。API 可能会发生变化。

在向量存储中添加或更新文档。

如果提供了 Document 对象的 ID 字段，则更新插入功能应使用该字段。如果未提供 ID，则更新插入方法可以自由地为文档生成 ID。

当指定 ID 且文档已存在于向量存储中时，更新插入方法应使用新数据更新文档。如果文档不存在，则更新插入方法应将文档添加到向量存储。

参数

items (Sequence[Document]) – 要添加到向量存储的文档序列。
kwargs (Any) – 额外的关键字参数。

Returns

一个响应对象，其中包含向量存储中成功添加或更新的 ID 列表以及未能添加或更新的 ID 列表。

返回类型

UpsertResponse

0.2.11 版本新增。

langchain_community.vectorstores.deeplake.DeepLake¶

使用 DeepLake 的示例¶

`langchain_community.vectorstores.deeplake`.DeepLake¶