Cassandra#

class langchain_community.vectorstores.cassandra.Cassandra(embedding: Embeddings, session: Session | None = None, keyspace: str | None = None, table_name: str = '', ttl_seconds: int | None = None, *, body_index_options: List[Tuple[str, Any]] | None = None, setup_mode: SetupMode = SetupMode.SYNC, metadata_indexing: Tuple[str, Iterable[str]] | str = 'all')[来源]#

用于向量存储工作负载的Apache Cassandra(R)。

要使用它，您需要最近安装的cassio库和一个支持向量功能的Cassandra集群/Astra DB实例。

访问cassio.org网站获取广泛的快速入门和代码示例。

示例

from langchain_community.vectorstores import Cassandra
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
session = ...             # create your Cassandra session object
keyspace = 'my_keyspace'  # the keyspace should exist already
table_name = 'my_vector_store'
vectorstore = Cassandra(embeddings, session, keyspace, table_name)

Parameters:

embedding (Embeddings) – 使用的嵌入函数。
session (可选[Session]) – Cassandra 驱动会话。如果未提供，将从 cassio 解析。
keyspace (可选[str]) – Cassandra 键空间。如果未提供，将从 cassio 解析。
table_name (str) – Cassandra 表（必填）。
ttl_seconds (可选[int]) – 添加文本的可选生存时间。
body_index_options (可选[列表[元组[str, Any]]]) – 用于创建body index的可选选项。例如：body_index_options = [cassio.table.cql.STANDARD_ANALYZER]
setup_mode (SetupMode) – 用于创建Cassandra表的模式（SYNC, ASYNC 或 OFF）。
metadata_indexing (Union[Tuple[str, Iterable[str]], str]) –
可选的元数据索引策略规范，即微调哪些元数据字段被索引。它可以是一个字符串（“all”或“none”），或者一个2元组。以下表示除了‘f1’，‘f2’…之外的所有字段都不被索引：

metadata_indexing=(“allowlist”, [“f1”, “f2”, …])

以下表示除了‘g1’，‘g2’，…之外的所有字段都被索引：
metadata_indexing(“denylist”, [“g1”, “g2”, …])

默认情况下，每个元数据字段都会被索引。注意：如果你计划有大量唯一的文本元数据条目，考虑不索引它们以提高性能（并克服最大长度限制）。

属性

embeddings

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

方法

`__init__`(embedding[, session, keyspace, ...])	用于向量存储工作负载的Apache Cassandra(R)。
`aadd_documents`(documents, **kwargs)	异步运行更多文档通过嵌入并添加到向量存储中。
`aadd_texts`(texts[, metadatas, ids, ...])	通过嵌入运行更多文本并将其添加到向量存储中。
`aclear`()	清空表格。
`add_documents`(documents, **kwargs)	在向量存储中添加或更新文档。
`add_texts`(texts[, metadatas, ids, ...])	通过嵌入运行更多文本并将其添加到向量存储中。
`adelete`([ids])	通过向量ID删除。
`adelete_by_document_id`(document_id)	根据文档ID删除。
`adelete_by_metadata_filter`(filter, *[, ...])	删除所有符合特定元数据过滤条件的文档。
`adelete_collection`()	只是 aclear 的别名（以便更好地与其他 VectorStore 实现对齐）。
`afrom_documents`(documents, embedding, *[, ...])	从文档列表创建一个Cassandra向量存储。
`afrom_texts`(texts, embedding[, metadatas, ...])	从原始文本创建Cassandra向量存储。
`aget_by_document_id`(document_id)	根据文档ID从存储中检索单个文档。
`aget_by_ids`(ids, /)	通过ID异步获取文档。
`amax_marginal_relevance_search`(query[, k, ...])	返回使用最大边际相关性选择的文档。最大边际相关性优化了与查询的相似性和所选文档之间的多样性。:param query: 要查找的文档的文本。:param k: 要返回的文档数量。:param fetch_k: 要传递给MMR算法的文档数量。:param lambda_mult: 0到1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认为0.5。:param filter: 要应用的元数据过滤器。:param body_search: 要应用的文档文本搜索条件。目前仅支持Astra DB。
`amax_marginal_relevance_search_by_vector`(...)	返回使用最大边际相关性选择的文档。最大边际相关性优化了查询的相似性和所选文档之间的多样性。 :param embedding: 要查找相似文档的嵌入。 :param k: 要返回的文档数量。默认为4。 :param fetch_k: 要传递给MMR算法的文档数量。默认为20。 :param lambda_mult: 介于0和1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认为0.5。 :param filter: 要应用的元数据过滤器。 :param body_search: 要应用的文档文本搜索词。目前仅由Astra DB支持。
`ametadata_search`([filter, n])	通过元数据搜索获取文档。
`areplace_metadata`(id_to_metadata, *[, ...])	替换文档的元数据。
`as_retriever`([search_type, search_kwargs, ...])	返回从此 VectorStore 初始化的 VectorStoreRetriever。
`asearch`(query, search_type, **kwargs)	异步返回与查询最相似的文档，使用指定的搜索类型。
`asimilarity_search`(query[, k, filter, ...])	返回与查询最相似的文档。
`asimilarity_search_by_vector`(embedding[, k, ...])	返回与嵌入向量最相似的文档。
`asimilarity_search_with_embedding_id_by_vector`(...)	返回与嵌入向量最相似的文档。
`asimilarity_search_with_relevance_scores`(query)	异步返回文档和相关分数，范围在[0, 1]之间。
`asimilarity_search_with_score`(query[, k, ...])	返回与查询最相似的文档。
`asimilarity_search_with_score_by_vector`(...)	返回与嵌入向量最相似的文档。
`asimilarity_search_with_score_id`(query[, k, ...])	返回与查询最相似的文档。
`asimilarity_search_with_score_id_by_vector`(...)	返回与嵌入向量最相似的文档。
`clear`()	清空表格。
`delete`([ids])	通过向量ID删除。
`delete_by_document_id`(document_id)	根据文档ID删除。
`delete_by_metadata_filter`(filter, *[, ...])	删除所有符合特定元数据过滤条件的文档。
`delete_collection`()	只是clear的别名（以便更好地与其他VectorStore实现对齐）。
`from_documents`(documents, embedding, *[, ...])	从文档列表创建一个Cassandra向量存储。
`from_texts`(texts, embedding[, metadatas, ...])	从原始文本创建Cassandra向量存储。
`get_by_document_id`(document_id)	根据文档ID从存储中检索单个文档。
`get_by_ids`(ids, /)	通过ID获取文档。
`max_marginal_relevance_search`(query[, k, ...])	返回使用最大边际相关性选择的文档。最大边际相关性优化了与查询的相似性和所选文档之间的多样性。:param query: 要查找相似文档的文本。:param k: 要返回的文档数量。默认为4。:param fetch_k: 要获取以传递给MMR算法的文档数量。默认为20。:param lambda_mult: 介于0和1之间的数字，确定结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认为0.5。:param filter: 要应用的元数据过滤器。:param body_search: 要应用的文档文本搜索条件。目前仅由Astra DB支持。
`max_marginal_relevance_search_by_vector`(...)	返回使用最大边际相关性选择的文档。最大边际相关性优化了查询的相似性和所选文档之间的多样性。:param embedding: 要查找相似文档的嵌入。:param k: 要返回的文档数量。默认为4。:param fetch_k: 要传递给MMR算法的文档数量。默认为20。:param lambda_mult: 0到1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认为0.5。:param filter: 要应用的元数据过滤器。:param body_search: 要应用的文档文本搜索词。目前仅由Astra DB支持。
`metadata_search`([filter, n])	通过元数据搜索获取文档。
`replace_metadata`(id_to_metadata, *[, batch_size])	替换文档的元数据。
`search`(query, search_type, **kwargs)	使用指定的搜索类型返回与查询最相似的文档。
`similarity_search`(query[, k, filter, ...])	返回与查询最相似的文档。
`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)	返回与嵌入向量最相似的文档。
`similarity_search_with_score_id`(query[, k, ...])	返回与查询最相似的文档。
`similarity_search_with_score_id_by_vector`(...)	返回与嵌入向量最相似的文档。

__init__(embedding: Embeddings, session: Session | None = None, keyspace: str | None = None, table_name: str = '', ttl_seconds: int | None = None, *, body_index_options: List[Tuple[str, Any]] | None = None, setup_mode: SetupMode = SetupMode.SYNC, metadata_indexing: Tuple[str, Iterable[str]] | str = 'all') → None[source]#

用于向量存储工作负载的Apache Cassandra(R)。

要使用它，您需要最近安装的cassio库和一个支持向量功能的Cassandra集群/Astra DB实例。

访问cassio.org网站获取广泛的快速入门和代码示例。

示例

from langchain_community.vectorstores import Cassandra
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
session = ...             # create your Cassandra session object
keyspace = 'my_keyspace'  # the keyspace should exist already
table_name = 'my_vector_store'
vectorstore = Cassandra(embeddings, session, keyspace, table_name)

Parameters:

embedding (Embeddings) – 使用的嵌入函数。
session (可选[Session]) – Cassandra 驱动会话。如果未提供，将从 cassio 解析。
keyspace (可选[str]) – Cassandra 键空间。如果未提供，将从 cassio 解析。
table_name (str) – Cassandra 表（必填）。
ttl_seconds (可选[int]) – 添加文本的可选生存时间。
body_index_options (可选[列表[元组[str, Any]]]) – 用于创建body index的可选选项。例如：body_index_options = [cassio.table.cql.STANDARD_ANALYZER]
setup_mode (SetupMode) – 用于创建Cassandra表的模式（SYNC, ASYNC 或 OFF）。
metadata_indexing (Union[Tuple[str, Iterable[str]], str]) –
可选的元数据索引策略规范，即微调哪些元数据字段被索引。它可以是一个字符串（“all”或“none”），或者一个2元组。以下表示除了‘f1’，‘f2’…之外的所有字段都不被索引：

metadata_indexing=(“allowlist”, [“f1”, “f2”, …])

以下表示除了‘g1’，‘g2’，…之外的所有字段都被索引：
metadata_indexing(“denylist”, [“g1”, “g2”, …])

默认情况下，每个元数据字段都会被索引。注意：如果你计划有大量唯一的文本元数据条目，考虑不索引它们以提高性能（并克服最大长度限制）。

Return type:

无

async aadd_documents(documents: list[Document], **kwargs: Any) → list[str]#

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

Parameters:

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

Returns:

已添加文本的ID列表。

Raises:

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

Return type:

列表[字符串]

async aadd_texts(texts: Iterable[str], metadatas: List[dict] | None = None, ids: List[str] | None = None, concurrency: int = 16, ttl_seconds: int | None = None, **kwargs: Any) → List[str][source]#

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

Parameters:

texts (Iterable[str]) – 要添加到向量存储中的文本。
metadatas (List[dict] | None) – 可选的元数据列表。
ids (List[str] | None) – 可选的ID列表。
concurrency (int) – 并发查询数据库的数量。默认值为16。
ttl_seconds (int | None) – 可选的时间到活期，用于添加的文本。
kwargs (Any)

Returns:

已添加文本的ID列表。

Return type:

列表[str]

async aclear() → None[source]#

清空表格。

Return type:: 无

add_documents(documents: list[Document], **kwargs: Any) → list[str]#

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

Parameters:

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

Returns:

已添加文本的ID列表。

Raises:

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

Return type:

列表[字符串]

add_texts(texts: Iterable[str], metadatas: List[dict] | None = None, ids: List[str] | None = None, batch_size: int = 16, ttl_seconds: int | None = None, **kwargs: Any) → List[str][source]#

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

Parameters:

texts (Iterable[str]) – 要添加到向量存储中的文本。
metadatas (List[dict] | None) – 可选的元数据列表。
ids (List[str] | None) – 可选的ID列表。
batch_size (int) – 发送到服务器的并发请求数量。
ttl_seconds (int | None) – 可选的时间到活期，用于添加的文本。
kwargs (Any)

Returns:

已添加文本的ID列表。

Return type:

列表[str]

async adelete(ids: List[str] | None = None, **kwargs: Any) → bool | None[source]#

通过向量ID删除。

Parameters:

ids (List[str] | None) – 要删除的ID列表。
kwargs (Any)

Returns:

如果删除成功则为真，否则为假，如果未实现则为无。

Return type:

可选[布尔]

async adelete_by_document_id(document_id: str) → None[source]#

按文档ID删除。

Parameters:: document_id (str) – 要删除的文档ID。
Return type:: 无

async adelete_by_metadata_filter(filter: dict[str, Any], *, batch_size: int = 50) → int[source]#

删除所有符合特定元数据过滤条件的文档。

此操作不以任何方式使用向量嵌入，它只是删除所有元数据与提供条件匹配的文档。

Parameters:

filter (dict[str, Any]) – 应用于元数据的过滤器。过滤器不能为空。
batch_size (int) – 每批删除的数量（直到匹配的文档耗尽）。

Returns:

表示已删除文档数量的数字。

Return type:

整数

async adelete_collection() → None[source]#

只是aclear的一个别名（以便更好地与其他VectorStore实现对齐）。

Return type:: 无

async classmethod afrom_documents(documents: List[Document], embedding: Embeddings, *, session: Session | None = None, keyspace: str | None = None, table_name: str = '', ids: List[str] | None = None, ttl_seconds: int | None = None, body_index_options: List[Tuple[str, Any]] | None = None, metadata_indexing: Tuple[str, Iterable[str]] | str = 'all', **kwargs: Any) → CVST[source]#

从文档列表创建一个Cassandra向量存储。

Parameters:

documents (List[Document]) – 要添加到向量存储中的文档。
embedding (Embeddings) – 使用的嵌入函数。
session (可选[Session]) – Cassandra 驱动会话。如果未提供，则从 cassio 解析。
keyspace (Optional[str]) – Cassandra 键空间。如果未提供，则从 cassio 解析。
table_name (str) – Cassandra 表（必填）。
ids (可选[列表[字符串]]) – 与文档关联的可选ID列表。
ttl_seconds (可选[int]) – 添加文档的可选生存时间。
body_index_options (可选[列表[元组[str, Any]]]) – 用于创建body index的可选选项。例如：body_index_options = [cassio.table.cql.STANDARD_ANALYZER]
metadata_indexing (Union[Tuple[str, Iterable[str]], str]) –
可选的元数据索引策略规范，即微调哪些元数据字段被索引。它可以是一个字符串（“all”或“none”），或者一个2元组。以下表示除了‘f1’，‘f2’…之外的所有字段都不被索引：

metadata_indexing=(“allowlist”, [“f1”, “f2”, …])

以下表示除了‘g1’，‘g2’，…之外的所有字段都被索引：
metadata_indexing(“denylist”, [“g1”, “g2”, …])

默认情况下，每个元数据字段都会被索引。注意：如果你计划有大量唯一的文本元数据条目，考虑不索引它们以提高性能（并克服最大长度限制）。
kwargs (Any)

Returns:

一个Cassandra向量存储。

Return type:

CVST

async classmethod afrom_texts(texts: List[str], embedding: Embeddings, metadatas: List[dict] | None = None, *, session: Session | None = None, keyspace: str | None = None, table_name: str = '', ids: List[str] | None = None, ttl_seconds: int | None = None, body_index_options: List[Tuple[str, Any]] | None = None, metadata_indexing: Tuple[str, Iterable[str]] | str = 'all', **kwargs: Any) → CVST[source]#

从原始文本创建一个Cassandra向量存储。

Parameters:

texts (List[str]) – 要添加到向量存储中的文本。
embedding (Embeddings) – 使用的嵌入函数。
metadatas (可选[列表[字典]]) – 可选的与文本关联的元数据列表。
session (可选[Session]) – Cassandra 驱动会话。如果未提供，则从 cassio 解析。
keyspace (可选[str]) – Cassandra 键空间。如果未提供，将从 cassio 解析。
table_name (str) – Cassandra 表（必填）。
ids (可选[列表[字符串]]) – 与文本关联的可选ID列表。
ttl_seconds (可选[int]) – 添加文本的可选生存时间。
body_index_options (可选[列表[元组[str, Any]]]) – 用于创建body index的可选选项。例如：body_index_options = [cassio.table.cql.STANDARD_ANALYZER]
metadata_indexing (Union[Tuple[str, Iterable[str]], str]) –
可选的元数据索引策略规范，即微调哪些元数据字段被索引。它可以是一个字符串（“all”或“none”），或者一个2元组。以下表示除了‘f1’，‘f2’…之外的所有字段都不被索引：

metadata_indexing=(“allowlist”, [“f1”, “f2”, …])

以下表示除了‘g1’，‘g2’，…之外的所有字段都被索引：
metadata_indexing(“denylist”, [“g1”, “g2”, …])

默认情况下，每个元数据字段都会被索引。注意：如果你计划有大量唯一的文本元数据条目，考虑不索引它们以提高性能（并克服最大长度限制）。
kwargs (Any)

Returns:

一个Cassandra向量存储。

Return type:

CVST

async aget_by_document_id(document_id: str) → Document | None[source]#

根据文档ID从存储中检索单个文档。

Parameters:: document_id (str) – 文档ID
Returns:: 如果文档存在，则返回该文档。否则返回 None。
Return type:: Document | 无

async aget_by_ids(ids: Sequence[str], /) → list[Document]#

通过ID异步获取文档。

返回的文档预计将具有ID字段，该字段设置为向量存储中文档的ID。

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

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

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

Parameters:: ids (Sequence[str]) – 要检索的ID列表。
Returns:: 文档列表。
Return type:: 列表[Document]

在版本0.2.11中添加。

async amax_marginal_relevance_search(query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None, **kwargs: Any) → List[Document][source]#

返回使用最大边际相关性选择的文档。最大边际相关性优化了与查询的相似性和所选文档之间的多样性。 :param query: 要查找相似文档的文本。 :param k: 要返回的文档数量。 :param fetch_k: 要获取并传递给MMR算法的文档数量。 :param lambda_mult: 介于0和1之间的数字，确定程度

结果中的多样性，0对应最大多样性，1对应最小多样性。默认值为0.5。

Parameters:

filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。
query (str)
k (整数)
fetch_k (int)
lambda_mult (float)
kwargs (Any)

Returns:

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

Return type:

列表[文档]

async amax_marginal_relevance_search_by_vector(embedding: List[float], k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None, **kwargs: Any) → List[Document][source]#

返回使用最大边际相关性选择的文档。最大边际相关性优化了与查询的相似性和所选文档之间的多样性。 :param embedding: 用于查找相似文档的嵌入。 :param k: 要返回的文档数量。默认为4。 :param fetch_k: 要获取以传递给MMR算法的文档数量。

默认为20。

Parameters:

lambda_mult (float) – 介于0和1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认值为0.5。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。
embedding (列表[浮点数])
k (整数)
fetch_k (int)
kwargs (Any)

Returns:

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

Return type:

列表[文档]

async ametadata_search(filter: dict[str, Any] = {}, n: int = 5) → Iterable[Document][source]#

通过元数据搜索获取文档。

Parameters:

filter (dict[str, Any]) – 用于查询的元数据。
n (int) – 返回的最大文档数量。

Return type:

可迭代[文档]

async areplace_metadata(id_to_metadata: dict[str, dict], *, concurrency: int = 50) → None[source]#

替换文档的元数据。

对于每个要更新的文档，由其ID标识，新的元数据字典完全替换存储中的内容。这包括传递空的元数据{}以擦除当前存储的信息。

Parameters:

id_to_metadata (dict[str, dict]) – 从文档ID映射到要修改的新元数据以进行更新。此字典中与现有文档不对应的键不会导致错误，而是会在Cassandra表中写入新行，但没有关联的向量：因此无法通过向量搜索访问。
concurrency (int) – 并发查询数据库的数量。默认值为50。

Returns:

如果写入成功则为None（否则会引发错误）。

Return type:

无

as_retriever(search_type: str = 'similarity', search_kwargs: Dict[str, Any] | None = None, tags: List[str] | None = None, metadata: Dict[str, Any] | None = None, **kwargs: Any) → VectorStoreRetriever[source]#

返回从此VectorStore初始化的VectorStoreRetriever。

Parameters:

search_type (str) – 定义检索器应执行的搜索类型。可以是“similarity”（默认）、“mmr”或“similarity_score_threshold”。
search_kwargs (Dict[str, Any] | None) –
传递给搜索函数的关键字参数。可以包括以下内容：

k: 返回的文档数量（默认：4） score_threshold: 最小相关性阈值

用于similarity_score_threshold

fetch_k: 传递给MMR算法的文档数量（默认：20） lambda_mult: MMR返回结果的多样性；

1表示最小多样性，0表示最大多样性。（默认：0.5）

filter: 按文档元数据过滤
tags (List[str] | None) – 与检索器关联的标签列表。
metadata (Dict[str, Any] | None) – 与检索器关联的元数据。
kwargs (Any) – 传递给 VectorStoreRetriever 初始化的其他参数。

Returns:

向量存储的检索器。

Return type:

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

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

Parameters:

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

Returns:

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

Raises:

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

Return type:

列表[Document]

async asimilarity_search(query: str, k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None, **kwargs: Any) → List[Document][来源]#

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

Parameters:

query (str) – 用于查找相似文档的文本。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。
kwargs (Any)

Returns:

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

Return type:

列表[文档]

async asimilarity_search_by_vector(embedding: List[float], k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None, **kwargs: Any) → List[Document][source]#

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

Parameters:

embedding (List[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。
kwargs (Any)

Returns:

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

Return type:

列表[文档]

async asimilarity_search_with_embedding_id_by_vector(embedding: List[float], k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None) → List[Tuple[Document, List[float], str]][source]#

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

Parameters:

embedding (List[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。

Returns:

与查询向量最相似的（文档，嵌入，ID）列表。

Return type:

列表[元组[文档, 列表[浮点数], 字符串]]

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

异步返回文档和相关度分数，范围在[0, 1]之间。

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

Parameters:

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

过滤检索到的文档集

Returns:

（文档，相似度分数）的元组列表

Return type:

列表[元组[Document, 浮点数]]

async asimilarity_search_with_score(query: str, k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None) → List[Tuple[Document, float]][来源]#

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

Parameters:

query (str) – 用于查找相似文档的文本。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。

Returns:

与查询向量最相似的（文档，分数）列表。

Return type:

列表[元组[文档, 浮点数]]

async asimilarity_search_with_score_by_vector(embedding: List[float], k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None) → List[Tuple[Document, float]][source]#

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

Parameters:

embedding (List[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。

Returns:

与查询向量最相似的（文档，分数）列表。

Return type:

列表[元组[文档, 浮点数]]

async asimilarity_search_with_score_id(query: str, k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None) → List[Tuple[Document, float, str]][source]#

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

Parameters:

query (str) – 用于查找相似文档的文本。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。

Returns:

与查询向量最相似的（文档、分数、ID）列表。

Return type:

列表[元组[文档, 浮点数, 字符串]]

async asimilarity_search_with_score_id_by_vector(embedding: List[float], k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None) → List[Tuple[Document, float, str]][来源]#

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

Parameters:

embedding (List[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。

Returns:

与查询向量最相似的（文档，分数，ID）列表。

Return type:

列表[元组[文档, 浮点数, 字符串]]

clear() → None[source]#

清空表格。

Return type:: 无

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

通过向量ID删除。

Parameters:

ids (List[str] | None) – 要删除的ID列表。
kwargs (Any)

Returns:

如果删除成功则为真，否则为假，如果未实现则为无。

Return type:

可选[布尔]

delete_by_document_id(document_id: str) → None[source]#

按文档ID删除。

Parameters:: document_id (str) – 要删除的文档ID。
Return type:: 无

delete_by_metadata_filter(filter: dict[str, Any], *, batch_size: int = 50) → int[source]#

删除所有符合特定元数据过滤条件的文档。

此操作不以任何方式使用向量嵌入，它只是删除所有元数据与提供条件匹配的文档。

Parameters:

filter (dict[str, Any]) – 应用于元数据的过滤器。过滤器不能为空。
batch_size (int) – 每批删除的数量（直到匹配的文档耗尽）。

Returns:

表示已删除文档数量的数字。

Return type:

整数

delete_collection() → None[source]#

只是clear的一个别名（以便更好地与其他VectorStore实现对齐）。

Return type:: 无

classmethod from_documents(documents: List[Document], embedding: Embeddings, *, session: Session | None = None, keyspace: str | None = None, table_name: str = '', ids: List[str] | None = None, ttl_seconds: int | None = None, body_index_options: List[Tuple[str, Any]] | None = None, metadata_indexing: Tuple[str, Iterable[str]] | str = 'all', **kwargs: Any) → CVST[source]#

从文档列表创建一个Cassandra向量存储。

Parameters:

documents (List[Document]) – 要添加到向量存储中的文档。
embedding (Embeddings) – 使用的嵌入函数。
session (可选[Session]) – Cassandra 驱动会话。如果未提供，则从 cassio 解析。
keyspace (可选[str]) – Cassandra 键空间。如果未提供，将从 cassio 解析。
table_name (str) – Cassandra 表（必填）。
ids (可选[列表[字符串]]) – 与文档关联的可选ID列表。
ttl_seconds (可选[int]) – 添加文档的可选生存时间。
body_index_options (可选[列表[元组[str, Any]]]) – 用于创建body index的可选选项。例如：body_index_options = [cassio.table.cql.STANDARD_ANALYZER]
metadata_indexing (Union[Tuple[str, Iterable[str]], str]) –
可选的元数据索引策略规范，即微调哪些元数据字段被索引。它可以是一个字符串（“all”或“none”），或者一个2元组。以下表示除了‘f1’，‘f2’…之外的所有字段都不被索引：

metadata_indexing=(“allowlist”, [“f1”, “f2”, …])

以下表示除了‘g1’，‘g2’，…之外的所有字段都被索引：
metadata_indexing(“denylist”, [“g1”, “g2”, …])

默认情况下，每个元数据字段都会被索引。注意：如果你计划有大量唯一的文本元数据条目，考虑不索引它们以提高性能（并克服最大长度限制）。
kwargs (Any)

Returns:

一个Cassandra向量存储。

Return type:

CVST

classmethod from_texts(texts: List[str], embedding: Embeddings, metadatas: List[dict] | None = None, *, session: Session | None = None, keyspace: str | None = None, table_name: str = '', ids: List[str] | None = None, ttl_seconds: int | None = None, body_index_options: List[Tuple[str, Any]] | None = None, metadata_indexing: Tuple[str, Iterable[str]] | str = 'all', **kwargs: Any) → CVST[来源]#

从原始文本创建一个Cassandra向量存储。

Parameters:

texts (List[str]) – 要添加到向量存储中的文本。
embedding (Embeddings) – 使用的嵌入函数。
metadatas (可选[列表[字典]]) – 可选的与文本关联的元数据列表。
session (可选[Session]) – Cassandra 驱动会话。如果未提供，则从 cassio 解析。
keyspace (可选[str]) – Cassandra 键空间。如果未提供，将从 cassio 解析。
table_name (str) – Cassandra 表（必填）。
ids (可选[列表[字符串]]) – 与文本关联的可选ID列表。
ttl_seconds (可选[int]) – 添加文本的可选生存时间。
body_index_options (可选[列表[元组[str, Any]]]) – 用于创建body index的可选选项。例如：body_index_options = [cassio.table.cql.STANDARD_ANALYZER]
metadata_indexing (Union[Tuple[str, Iterable[str]], str]) –
可选的元数据索引策略规范，即微调哪些元数据字段被索引。它可以是一个字符串（“all”或“none”），或者一个2元组。以下表示除了‘f1’，‘f2’…之外的所有字段都不被索引：

metadata_indexing=(“allowlist”, [“f1”, “f2”, …])

以下表示除了‘g1’，‘g2’，…之外的所有字段都被索引：
metadata_indexing(“denylist”, [“g1”, “g2”, …])

默认情况下，每个元数据字段都会被索引。注意：如果你计划有大量唯一的文本元数据条目，考虑不索引它们以提高性能（并克服最大长度限制）。
kwargs (Any)

Returns:

一个Cassandra向量存储。

Return type:

CVST

get_by_document_id(document_id: str) → Document | None[source]#

根据文档ID从存储中检索单个文档。

Parameters:: document_id (str) – 文档ID
Returns:: 如果文档存在，则返回该文档。否则返回 None。
Return type:: Document | 无

get_by_ids(ids: Sequence[str], /) → list[Document]#

通过ID获取文档。

返回的文档预计将具有ID字段，该字段设置为向量存储中文档的ID。

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

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

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

Parameters:: ids (Sequence[str]) – 要检索的ID列表。
Returns:: 文档列表。
Return type:: 列表[Document]

在版本0.2.11中添加。

max_marginal_relevance_search(query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None, **kwargs: Any) → List[Document][source]#

返回使用最大边际相关性选择的文档。最大边际相关性优化了与查询的相似性和所选文档之间的多样性。 :param query: 要查找相似文档的文本。 :param k: 要返回的文档数量。默认为4。 :param fetch_k: 要传递给MMR算法的文档数量。

默认为20。

Parameters:

lambda_mult (float) – 介于0和1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认值为0.5。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。
query (str)
k (整数)
fetch_k (int)
kwargs (Any)

Returns:

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

Return type:

列表[文档]

max_marginal_relevance_search_by_vector(embedding: List[float], k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None, **kwargs: Any) → List[Document][来源]#

返回使用最大边际相关性选择的文档。最大边际相关性优化了与查询的相似性和所选文档之间的多样性。 :param embedding: 用于查找相似文档的嵌入。 :param k: 要返回的文档数量。默认为4。 :param fetch_k: 要获取以传递给MMR算法的文档数量。

默认为20。

Parameters:

lambda_mult (float) – 介于0和1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认值为0.5。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。
embedding (列表[浮点数])
k (整数)
fetch_k (int)
kwargs (Any)

Returns:

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

Return type:

列表[文档]

metadata_search(filter: dict[str, Any] = {}, n: int = 5) → Iterable[Document][来源]#

通过元数据搜索获取文档。

Parameters:

filter (dict[str, Any]) – 用于查询的元数据。
n (int) – 返回的最大文档数量。

Return type:

可迭代[文档]

replace_metadata(id_to_metadata: dict[str, dict], *, batch_size: int = 50) → None[source]#

替换文档的元数据。

对于每个要更新的文档，由其ID标识，新的元数据字典完全替换存储中的内容。这包括传递空的元数据{}以擦除当前存储的信息。

Parameters:

id_to_metadata (dict[str, dict]) – 从文档ID映射到要修改的新元数据以进行更新。此字典中与现有文档不对应的键不会导致错误，而是会在Cassandra表中写入新行，但没有关联的向量：因此无法通过向量搜索访问。
batch_size (int) – 发送到服务器的并发请求数量。

Returns:

如果写入成功则为None（否则会引发错误）。

Return type:

无

search(query: str, search_type: str, **kwargs: Any) → list[Document]#

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

Parameters:

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

Returns:

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

Raises:

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

Return type:

列表[Document]

similarity_search(query: str, k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None, **kwargs: Any) → List[Document][source]#

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

Parameters:

query (str) – 用于查找相似文档的文本。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。
kwargs (Any)

Returns:

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

Return type:

列表[文档]

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

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

Parameters:

embedding (List[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。
kwargs (Any)

Returns:

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

Return type:

列表[文档]

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

返回文档和相关度分数，范围在[0, 1]之间。

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

Parameters:

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

用于过滤检索到的文档集。

Returns:

(文档, 相似度分数) 的元组列表。

Return type:

列表[元组[Document, 浮点数]]

similarity_search_with_score(query: str, k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None) → List[Tuple[Document, float]][source]#

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

Parameters:

query (str) – 用于查找相似文档的文本。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。

Returns:

与查询向量最相似的（文档，分数）列表。

Return type:

列表[元组[文档, 浮点数]]

similarity_search_with_score_by_vector(embedding: List[float], k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None) → List[Tuple[Document, float]][source]#

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

Parameters:

embedding (List[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。

Returns:

与查询向量最相似的（文档，分数）列表。

Return type:

列表[元组[文档, 浮点数]]

similarity_search_with_score_id(query: str, k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None) → List[Tuple[Document, float, str]][source]#

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

Parameters:

query (str) – 用于查找相似文档的文本。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。

Returns:

与查询向量最相似的（文档，分数，ID）列表。

Return type:

列表[元组[文档, 浮点数, 字符串]]

similarity_search_with_score_id_by_vector(embedding: List[float], k: int = 4, filter: Dict[str, str] | None = None, body_search: str | List[str] | None = None) → List[Tuple[Document, float, str]][来源]#

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

Parameters:

embedding (List[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
filter (Dict[str, str] | None) – 应用于元数据的过滤器。
body_search (str | List[str] | None) – 要应用的文档文本搜索词。目前仅由Astra DB支持。

Returns:

与查询向量最相似的（文档，分数，ID）列表。

Return type:

列表[元组[文档, 浮点数, 字符串]]

使用Cassandra的示例