`langchain-astradb`¶

langchain_astradb ¶

用于 LangChain 的 Astra DB 集成。

此模块提供了几个使用 Astra DB 作为后端的 LangChain 组件。

有关概述，请参阅集成文档页面。

提供的组件

AstraDBVectorStore，一个由 Astra DB 支持的向量存储，具有 Vectorize 支持、混合搜索等功能。
AstraDBStore、AstraDBByteStore，分别是用于通用值和二进制 blob 的键值存储组件。
AstraDBCache、AstraDBSemanticCache，LLM 响应缓存。
AstraDBChatMessageHistory，用于聊天界面的内存。
AstraDBLoader，从 Astra DB 集合中加载数据的加载器。

AstraDBCache ¶

Bases: BaseCache

方法	描述
`__init__`	使用 Astra DB 作为后端的缓存，使用一个集合作为键值存储。
`lookup`	基于 `prompt` 和 `llm_string` 进行查找。
`alookup`	基于 `prompt` 和 `llm_string` 进行异步查找。
`更新`	基于 `prompt` 和 `llm_string` 更新缓存。
`aupdate`	基于 `prompt` 和 `llm_string` 异步更新缓存。
`delete_through_llm`	一个围绕 `delete` 的包装器，其中传入了 LLM。
`adelete_through_llm`	一个围绕 `adelete` 的包装器，其中传入了 LLM。
`delete`	如果缓存中有条目，则将其驱逐。
`adelete`	如果缓存中有条目，则将其驱逐。
`clear`	清除缓存，可以接受额外的关键字参数。
`aclear`	异步清除缓存，可以接受额外的关键字参数。

init ¶

__init__(
    *,
    collection_name: str = ASTRA_DB_CACHE_DEFAULT_COLLECTION_NAME,
    token: str | TokenProvider | None = None,
    api_endpoint: str | None = None,
    namespace: str | None = None,
    environment: str | None = None,
    pre_delete_collection: bool = False,
    setup_mode: SetupMode = SYNC,
    ext_callers: list[tuple[str | None, str | None] | str | None] | None = None,
    api_options: APIOptions | None = None,
)

使用 Astra DB 作为后端的缓存，使用一个集合作为键值存储。

查找键，组合在文档的 _id 中，是

prompt，一个字符串
llm_string，一个模型参数的确定性字符串表示。（需要防止相同提示但不同模型之间的冲突）

参数	描述
`collection_name`	要创建/使用的 Astra DB 集合的名称。类型： `str` 默认值： `ASTRA_DB_CACHE_DEFAULT_COLLECTION_NAME`
`token`	用于 Astra DB 的 API 令牌，可以是字符串形式，也可以是 `astrapy.authentication.TokenProvider` 的子类。如果未提供，则会检查环境变量 ASTRA_DB_APPLICATION_TOKEN。类型： `str \| TokenProvider \| None` 默认值： `None`
`api_endpoint`	API 端点的完整 URL，例如 `https://-us-east1.apps.astra.datastax.com`。如果未提供，则会检查环境变量 ASTRA_DB_API_ENDPOINT。类型: `str \| None` 默认值: `None`
`namespace`	集合创建所在的命名空间（即 keyspace）。如果未提供，则会检查环境变量 ASTRA_DB_KEYSPACE。默认为数据库的“默认命名空间”。类型: `str \| None` 默认值: `None`
`environment`	一个指定目标数据 API 环境的字符串。如果省略，则默认为“prod”（Astra DB 生产环境）。其他值在 `astrapy.constants.Environment` 枚举类中。类型: `str \| None` 默认值: `None`
`setup_mode`	用于创建 Astra DB 集合的模式（SYNC、ASYNC 或 OFF）。类型： `SetupMode` 默认值： `SYNC`
`pre_delete_collection`	是否在创建集合之前删除它。如果为 False 且集合已存在，则将按原样使用该集合。类型： `bool` 默认值： `False`
`ext_callers`	一个或多个调用者身份，用于在 User-Agent 标头中识别数据 API 调用。这是一个（名称，版本）对的列表，或者如果未提供版本信息，则仅为字符串，如果提供，它将成为与此组件相关的所有 API 请求中 User-Agent 字符串的前导部分。类型： `list[tuple[str \| None, str \| None] \| str \| None] \| None` 默认值： `None`
`api_options`	一个 `astrapy.utils.api_options.APIOptions` 的实例，可用于自定义与数据 API 在序列化/反序列化、超时、自定义标头等方面的交互。提供的选项将应用于已为此库量身定制的设置之上，如果指定，将优先。传递 None（默认值）意味着不请求自定义。有关详细信息，请参阅 astrapy 文档。类型： `APIOptions \| None` 默认值： `None`

lookup ¶

lookup(prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None

基于 `prompt` 和 `llm_string` 进行查找。

期望缓存实现从 `prompt` 和 `llm_string` 的 2 元组生成一个键（例如，通过用分隔符连接它们）。

参数	描述
`prompt`	提示的字符串表示。在聊天模型的情况下，提示是对语言模型提示的非平凡序列化。类型： `str`
`llm_string`	LLM 配置的字符串表示。这用于捕获 LLM 的调用参数（例如，模型名称、温度、停止标记、最大标记等）。这些调用参数被序列化为字符串表示。类型： `str`

返回	描述
`RETURN_VAL_TYPE \| None`	缓存未命中时，返回 `None`。缓存命中时，返回缓存的值。
`RETURN_VAL_TYPE \| None`	缓存的值是 `Generation`（或其子类）的列表。

alookup `async` ¶

alookup(prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None

基于 `prompt` 和 `llm_string` 进行异步查找。

期望缓存实现从 `prompt` 和 `llm_string` 的 2 元组生成一个键（例如，通过用分隔符连接它们）。

参数	描述
`prompt`	提示的字符串表示。在聊天模型的情况下，提示是对语言模型提示的非平凡序列化。类型： `str`
`llm_string`	LLM 配置的字符串表示。这用于捕获 LLM 的调用参数（例如，模型名称、温度、停止标记、最大标记等）。这些调用参数被序列化为字符串表示。类型： `str`

返回	描述
`RETURN_VAL_TYPE \| None`	缓存未命中时，返回 `None`。缓存命中时，返回缓存的值。
`RETURN_VAL_TYPE \| None`	缓存的值是 `Generation`（或其子类）的列表。

update ¶

update(prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None

基于 `prompt` 和 `llm_string` 更新缓存。

prompt 和 llm_string 用于为缓存生成一个键。该键应与 lookup 方法的键匹配。

参数	描述
`prompt`	提示的字符串表示。在聊天模型的情况下，提示是对语言模型提示的非平凡序列化。类型： `str`
`llm_string`	LLM 配置的字符串表示。这用于捕获 LLM 的调用参数（例如，模型名称、温度、停止标记、最大标记等）。这些调用参数被序列化为字符串表示。类型： `str`
`return_val`	要缓存的值。该值是 `Generation`（或其子类）的列表。 TYPE: `RETURN_VAL_TYPE`

aupdate `async` ¶

aupdate(prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None

基于 `prompt` 和 `llm_string` 异步更新缓存。

提示和 llm_string 用于为缓存生成一个键。该键应与查找方法的键匹配。

参数	描述
`prompt`	提示的字符串表示。在聊天模型的情况下，提示是对语言模型提示的非平凡序列化。类型： `str`
`llm_string`	LLM 配置的字符串表示。这用于捕获 LLM 的调用参数（例如，模型名称、温度、停止标记、最大标记等）。这些调用参数被序列化为字符串表示。类型： `str`
`return_val`	要缓存的值。该值是 `Generation`（或其子类）的列表。 TYPE: `RETURN_VAL_TYPE`

delete_through_llm ¶

delete_through_llm(prompt: str, llm: LLM, stop: list[str] | None = None) -> None

一个围绕 `delete` 的包装器，其中传入了 LLM。

如果 llm(prompt) 调用有 `stop` 参数，您应该在这里传递它。

adelete_through_llm `async` ¶

adelete_through_llm(prompt: str, llm: LLM, stop: list[str] | None = None) -> None

一个围绕 `adelete` 的包装器，其中传入了 LLM。

如果 llm(prompt) 调用有 `stop` 参数，您应该在这里传递它。

delete ¶

delete(prompt: str, llm_string: str) -> None

如果缓存中有条目，则将其驱逐。

adelete `async` ¶

adelete(prompt: str, llm_string: str) -> None

如果缓存中有条目，则将其驱逐。

clear ¶

clear(**kwargs: Any) -> None

清除缓存，可以接受额外的关键字参数。

aclear `async` ¶

aclear(**kwargs: Any) -> None

异步清除缓存，可以接受额外的关键字参数。

AstraDBSemanticCache ¶

Bases: BaseCache

方法	描述
`__init__`	Astra DB 语义缓存。
`更新`	基于 `prompt` 和 `llm_string` 更新缓存。
`aupdate`	基于 `prompt` 和 `llm_string` 异步更新缓存。
`lookup`	基于 `prompt` 和 `llm_string` 进行查找。
`alookup`	基于 `prompt` 和 `llm_string` 进行异步查找。
`lookup_with_id`	基于 prompt 和 llm_string 进行查找。
`alookup_with_id`	基于 prompt 和 llm_string 进行查找。
`lookup_with_id_through_llm`	基于 prompt 和 LLM 进行查找。
`alookup_with_id_through_llm`	基于 prompt 和 LLM 进行查找。
`delete_by_document_id`	按文档 ID 删除。
`adelete_by_document_id`	按文档 ID 删除。
`clear`	清除缓存，可以接受额外的关键字参数。
`aclear`	异步清除缓存，可以接受额外的关键字参数。

init ¶

__init__(
    *,
    collection_name: str = ASTRA_DB_SEMANTIC_CACHE_DEFAULT_COLLECTION_NAME,
    token: str | TokenProvider | None = None,
    api_endpoint: str | None = None,
    namespace: str | None = None,
    environment: str | None = None,
    setup_mode: SetupMode = SYNC,
    pre_delete_collection: bool = False,
    embedding: Embeddings,
    metric: str | None = None,
    similarity_threshold: float = ASTRA_DB_SEMANTIC_CACHE_DEFAULT_THRESHOLD,
    ext_callers: list[tuple[str | None, str | None] | str | None] | None = None,
    api_options: APIOptions | None = None,
)

Astra DB 语义缓存。

该缓存使用 Astra DB 作为向量存储后端，用于语义（即基于相似度）查找。

它使用单个（向量）集合，可以存储来自多个 LLM 的缓存值，因此 LLM 的 'llm_string' 存储在文档元数据中。

您可以选择偏好的相似度（或使用 API 默认值）。默认的分数阈值是针对默认度量调整的。如果切换到其他距离度量，请自行仔细调整。

参数	描述
`collection_name`	要创建/使用的 Astra DB 集合的名称。类型： `str` 默认值： `ASTRA_DB_SEMANTIC_CACHE_DEFAULT_COLLECTION_NAME`
`token`	用于 Astra DB 的 API 令牌，可以是字符串形式，也可以是 `astrapy.authentication.TokenProvider` 的子类。如果未提供，则会检查环境变量 ASTRA_DB_APPLICATION_TOKEN。类型： `str \| TokenProvider \| None` 默认值： `None`
`api_endpoint`	API 端点的完整 URL，例如 `https://-us-east1.apps.astra.datastax.com`。如果未提供，则会检查环境变量 ASTRA_DB_API_ENDPOINT。类型: `str \| None` 默认值: `None`
`namespace`	集合创建所在的命名空间（即 keyspace）。如果未提供，则会检查环境变量 ASTRA_DB_KEYSPACE。默认为数据库的“默认命名空间”。类型: `str \| None` 默认值: `None`
`environment`	一个指定目标数据 API 环境的字符串。如果省略，则默认为“prod”（Astra DB 生产环境）。其他值在 `astrapy.constants.Environment` 枚举类中。类型: `str \| None` 默认值: `None`
`setup_mode`	用于创建 Astra DB 集合的模式（SYNC、ASYNC 或 OFF）。类型： `SetupMode` 默认值： `SYNC`
`pre_delete_collection`	是否在创建集合之前删除它。如果为 False 且集合已存在，则将按原样使用该集合。类型： `bool` 默认值： `False`
`embedding`	用于语义编码和搜索的嵌入提供程序。 TYPE: `Embeddings`
`metric`	用于评估文本嵌入相似度的函数。默认为 'cosine'（备选：'euclidean'、'dot_product'）。类型: `str \| None` 默认值: `None`
`similarity_threshold`	接受（语义搜索）匹配的最低相似度。类型： `float` 默认值： `ASTRA_DB_SEMANTIC_CACHE_DEFAULT_THRESHOLD`
`ext_callers`	一个或多个调用者身份，用于在 User-Agent 标头中识别数据 API 调用。这是一个（名称，版本）对的列表，或者如果未提供版本信息，则仅为字符串，如果提供，它将成为与此组件相关的所有 API 请求中 User-Agent 字符串的前导部分。类型： `list[tuple[str \| None, str \| None] \| str \| None] \| None` 默认值： `None`
`api_options`	一个 `astrapy.utils.api_options.APIOptions` 的实例，可用于自定义与数据 API 在序列化/反序列化、超时、自定义标头等方面的交互。提供的选项将应用于已为此库量身定制的设置之上，如果指定，将优先。传递 None（默认值）意味着不请求自定义。有关详细信息，请参阅 astrapy 文档。类型： `APIOptions \| None` 默认值： `None`

update ¶

update(prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None

基于 `prompt` 和 `llm_string` 更新缓存。

prompt 和 llm_string 用于为缓存生成一个键。该键应与 lookup 方法的键匹配。

参数	描述
`prompt`	提示的字符串表示。在聊天模型的情况下，提示是对语言模型提示的非平凡序列化。类型： `str`
`llm_string`	LLM 配置的字符串表示。这用于捕获 LLM 的调用参数（例如，模型名称、温度、停止标记、最大标记等）。这些调用参数被序列化为字符串表示。类型： `str`
`return_val`	要缓存的值。该值是 `Generation`（或其子类）的列表。 TYPE: `RETURN_VAL_TYPE`

aupdate `async` ¶

aupdate(prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None

基于 `prompt` 和 `llm_string` 异步更新缓存。

提示和 llm_string 用于为缓存生成一个键。该键应与查找方法的键匹配。

参数	描述
`prompt`	提示的字符串表示。在聊天模型的情况下，提示是对语言模型提示的非平凡序列化。类型： `str`
`llm_string`	LLM 配置的字符串表示。这用于捕获 LLM 的调用参数（例如，模型名称、温度、停止标记、最大标记等）。这些调用参数被序列化为字符串表示。类型： `str`
`return_val`	要缓存的值。该值是 `Generation`（或其子类）的列表。 TYPE: `RETURN_VAL_TYPE`

lookup ¶

lookup(prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None

基于 `prompt` 和 `llm_string` 进行查找。

期望缓存实现从 `prompt` 和 `llm_string` 的 2 元组生成一个键（例如，通过用分隔符连接它们）。

参数	描述
`prompt`	提示的字符串表示。在聊天模型的情况下，提示是对语言模型提示的非平凡序列化。类型： `str`
`llm_string`	LLM 配置的字符串表示。这用于捕获 LLM 的调用参数（例如，模型名称、温度、停止标记、最大标记等）。这些调用参数被序列化为字符串表示。类型： `str`

返回	描述
`RETURN_VAL_TYPE \| None`	缓存未命中时，返回 `None`。缓存命中时，返回缓存的值。
`RETURN_VAL_TYPE \| None`	缓存的值是 `Generation`（或其子类）的列表。

alookup `async` ¶

alookup(prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None

基于 `prompt` 和 `llm_string` 进行异步查找。

期望缓存实现从 `prompt` 和 `llm_string` 的 2 元组生成一个键（例如，通过用分隔符连接它们）。

参数	描述
`prompt`	提示的字符串表示。在聊天模型的情况下，提示是对语言模型提示的非平凡序列化。类型： `str`
`llm_string`	LLM 配置的字符串表示。这用于捕获 LLM 的调用参数（例如，模型名称、温度、停止标记、最大标记等）。这些调用参数被序列化为字符串表示。类型： `str`

返回	描述
`RETURN_VAL_TYPE \| None`	缓存未命中时，返回 `None`。缓存命中时，返回缓存的值。
`RETURN_VAL_TYPE \| None`	缓存的值是 `Generation`（或其子类）的列表。

lookup_with_id ¶

lookup_with_id(prompt: str, llm_string: str) -> tuple[str, RETURN_VAL_TYPE] | None

基于 prompt 和 llm_string 进行查找。

参数	描述
`prompt`	要查找的提示字符串类型： `str`
`llm_string`	模型参数的字符串表示类型： `str`

返回	描述
`tuple[str, RETURN_VAL_TYPE] \| None`	如果有命中，则为最高命中的（document_id, cached_entry）

alookup_with_id `async` ¶

alookup_with_id(prompt: str, llm_string: str) -> tuple[str, RETURN_VAL_TYPE] | None

基于 prompt 和 llm_string 进行查找。

参数	描述
`prompt`	要查找的提示字符串类型： `str`
`llm_string`	模型参数的字符串表示类型： `str`

返回	描述
`tuple[str, RETURN_VAL_TYPE] \| None`	如果有命中，则为最高命中的（document_id, cached_entry）

lookup_with_id_through_llm ¶

lookup_with_id_through_llm(
    prompt: str, llm: LLM, stop: list[str] | None = None
) -> tuple[str, RETURN_VAL_TYPE] | None

基于 prompt 和 LLM 进行查找。

参数	描述
`prompt`	要查找的提示字符串类型： `str`
`llm`	其参数用于查找的 LLM 实例类型： `LLM`
`停止`	传递给 LLM 调用的可选停止词列表类型: `list[str] \| None` 默认值: `None`

返回	描述
`tuple[str, RETURN_VAL_TYPE] \| None`	如果有命中，则为最高命中的（document_id, cached_entry）。

alookup_with_id_through_llm `async` ¶

alookup_with_id_through_llm(
    prompt: str, llm: LLM, stop: list[str] | None = None
) -> tuple[str, RETURN_VAL_TYPE] | None

基于 prompt 和 LLM 进行查找。

参数	描述
`prompt`	要查找的提示字符串类型： `str`
`llm`	其参数用于查找的 LLM 实例类型： `LLM`
`停止`	传递给 LLM 调用的可选停止词列表类型: `list[str] \| None` 默认值: `None`

返回	描述
`tuple[str, RETURN_VAL_TYPE] \| None`	如果有命中，则为最高命中的（document_id, cached_entry）。

delete_by_document_id ¶

delete_by_document_id(document_id: str) -> None

按文档 ID 删除。

鉴于这是一个“相似性搜索”缓存，一个合理的失效模式是首先查找以获取 ID，然后使用该 ID 删除。这是第二步。

adelete_by_document_id `async` ¶

adelete_by_document_id(document_id: str) -> None

按文档 ID 删除。

鉴于这是一个“相似性搜索”缓存，一个合理的失效模式是首先查找以获取 ID，然后使用该 ID 删除。这是第二步。

clear ¶

clear(**kwargs: Any) -> None

清除缓存，可以接受额外的关键字参数。

aclear `async` ¶

aclear(**kwargs: Any) -> None

异步清除缓存，可以接受额外的关键字参数。

AstraDBChatMessageHistory ¶

Bases: BaseChatMessageHistory

方法	描述
`add_user_message`	将人类消息字符串添加到存储的便捷方法。
`add_ai_message`	将 `AIMessage` 字符串添加到存储的便捷方法。
`add_message`	将一个 Message 对象添加到存储中。
`__str__`	返回聊天历史的字符串表示形式。
`__init__`	将历史记录存储在 Astra DB 中的聊天消息历史记录。
`aget_messages`	获取消息的异步版本。
`add_messages`	添加消息列表。
`aadd_messages`	异步添加消息列表。
`clear`	从存储中删除所有消息。
`aclear`	异步从存储中删除所有消息。

messages `property` `writable` ¶

messages: 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_message ¶

add_message(message: BaseMessage) -> None

将一个 Message 对象添加到存储中。

参数	描述
`message`	一个要存储的 BaseMessage 对象。类型： `BaseMessage`

引发	描述
`NotImplementedError`	如果子类未实现高效的 `add_messages` 方法。

str ¶

__str__() -> str

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

init ¶

__init__(
    *,
    session_id: str,
    collection_name: str = DEFAULT_COLLECTION_NAME,
    token: str | TokenProvider | None = None,
    api_endpoint: str | None = None,
    namespace: str | None = None,
    environment: str | None = None,
    setup_mode: SetupMode = SYNC,
    pre_delete_collection: bool = False,
    ext_callers: list[tuple[str | None, str | None] | str | None] | None = None,
    api_options: APIOptions | None = None,
) -> None

将历史记录存储在 Astra DB 中的聊天消息历史记录。

参数	描述
`session_id`	用于存储单个聊天会话消息的任意键。类型： `str`
`collection_name`	要创建/使用的 Astra DB 集合的名称。类型： `str` 默认值： `DEFAULT_COLLECTION_NAME`
`token`	用于 Astra DB 的 API 令牌，可以是字符串形式，也可以是 `astrapy.authentication.TokenProvider` 的子类。如果未提供，则会检查环境变量 ASTRA_DB_APPLICATION_TOKEN。类型： `str \| TokenProvider \| None` 默认值： `None`
`api_endpoint`	API 端点的完整 URL，例如 `https://-us-east1.apps.astra.datastax.com`。如果未提供，则会检查环境变量 ASTRA_DB_API_ENDPOINT。类型: `str \| None` 默认值: `None`
`namespace`	集合创建所在的命名空间（即 keyspace）。如果未提供，则会检查环境变量 ASTRA_DB_KEYSPACE。默认为数据库的“默认命名空间”。类型: `str \| None` 默认值: `None`
`environment`	一个指定目标数据 API 环境的字符串。如果省略，则默认为“prod”（Astra DB 生产环境）。其他值在 `astrapy.constants.Environment` 枚举类中。类型: `str \| None` 默认值: `None`
`setup_mode`	用于创建 Astra DB 集合的模式（SYNC、ASYNC 或 OFF）。类型： `SetupMode` 默认值： `SYNC`
`pre_delete_collection`	是否在创建集合之前删除它。如果为 False 且集合已存在，则将按原样使用该集合。类型： `bool` 默认值： `False`
`ext_callers`	一个或多个调用者身份，用于在 User-Agent 标头中识别数据 API 调用。这是一个（名称，版本）对的列表，或者如果未提供版本信息，则仅为字符串，如果提供，它将成为与此组件相关的所有 API 请求中 User-Agent 字符串的前导部分。类型： `list[tuple[str \| None, str \| None] \| str \| None] \| None` 默认值： `None`
`api_options`	一个 `astrapy.utils.api_options.APIOptions` 的实例，可用于自定义与数据 API 在序列化/反序列化、超时、自定义标头等方面的交互。提供的选项将应用于已为此库量身定制的设置之上，如果指定，将优先。传递 None（默认值）意味着不请求自定义。有关详细信息，请参阅 astrapy 文档。类型： `APIOptions \| None` 默认值： `None`

aget_messages `async` ¶

aget_messages() -> list[BaseMessage]

获取消息的异步版本。

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

通常，获取消息可能涉及到底层持久层的 IO。

返回	描述
`list[BaseMessage]`	消息。

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

clear ¶

clear() -> None

从存储中删除所有消息。

aclear `async` ¶

aclear() -> None

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

AstraDBLoader ¶

Bases: BaseLoader

方法	描述
`load`	将数据加载到 `Document` 对象中。
`load_and_split`	加载 `Document` 并将其分割成块。块将作为 `Document` 返回。
`__init__`	加载 DataStax Astra DB 文档。
`lazy_load`	`Document` 的惰性加载器。
`aload`	将数据加载到 `Document` 对象中。
`alazy_load`	`Document` 的惰性加载器。

load ¶

load() -> list[Document]

将数据加载到 `Document` 对象中。

返回	描述
`list[Document]`	文档。

load_and_split ¶

load_and_split(text_splitter: TextSplitter | None = None) -> list[Document]

加载 `Document` 并将其分割成块。块将作为 `Document` 返回。

危险

不要重写此方法。应将其视为已弃用！

参数	描述
`text_splitter`	用于分割文档的 `TextSplitter` 实例。默认为 `RecursiveCharacterTextSplitter`。 TYPE: `TextSplitter \| None` DEFAULT: `None`

引发	描述
`ImportError`	如果 `langchain-text-splitters` 未安装且未提供 `text_splitter`。

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

init ¶

__init__(
    collection_name: str,
    *,
    token: str | TokenProvider | None = None,
    api_endpoint: str | None = None,
    environment: str | None = None,
    namespace: str | None = None,
    filter_criteria: dict[str, Any] | None = None,
    projection: dict[str, Any] | None = _NOT_SET,
    limit: int | None = None,
    nb_prefetched: int = _NOT_SET,
    page_content_mapper: Callable[[dict], str] = dumps,
    metadata_mapper: Callable[[dict], dict[str, Any]] | None = None,
    ext_callers: list[tuple[str | None, str | None] | str | None] | None = None,
    api_options: APIOptions | None = None,
) -> None

加载 DataStax Astra DB 文档。

参数	描述
`collection_name`	要使用的 Astra DB 集合的名称。类型： `str`
`token`	用于 Astra DB 的 API 令牌，可以是字符串形式，也可以是 `astrapy.authentication.TokenProvider` 的子类。如果未提供，则会检查环境变量 ASTRA_DB_APPLICATION_TOKEN。类型： `str \| TokenProvider \| None` 默认值： `None`
`api_endpoint`	API 端点的完整 URL，例如 `https://-us-east1.apps.astra.datastax.com`。如果未提供，则会检查环境变量 ASTRA_DB_API_ENDPOINT。类型: `str \| None` 默认值: `None`
`environment`	一个指定目标数据 API 环境的字符串。如果省略，则默认为“prod”（Astra DB 生产环境）。其他值在 `astrapy.constants.Environment` 枚举类中。类型: `str \| None` 默认值: `None`
`namespace`	集合所在的命名空间（即 keyspace）。如果未提供，则检查环境变量 ASTRA_DB_KEYSPACE。默认为数据库的“默认命名空间”。类型: `str \| None` 默认值: `None`
`filter_criteria`	筛选文档的条件。类型: `dict[str, Any] \| None` 默认值: `None`
`projection`	指定要返回的字段。如果未提供，读取操作将回退到数据 API 的默认投影。类型： `dict[str, Any] \| None` 默认值： `_NOT_SET`
`limit`	读取查询中返回的最大文档数。 TYPE: `int \| None` DEFAULT: `None`
`nb_prefetched`	要预取的最大文档数。从 v. 0.3.5 开始被忽略：astrapy v1.0+ 不支持此功能。类型： `int` 默认值： `_NOT_SET`
`page_content_mapper`	应用于集合文档以创建 LangChain 文档的 `page_content` 的函数。默认为 `json.dumps`。类型： `Callable[[dict], str]` 默认值： `dumps`
`metadata_mapper`	应用于集合文档以创建 LangChain 文档的 `metadata` 的函数。默认返回命名空间、API 端点和集合名称。类型： `Callable[[dict], dict[str, Any]] \| None` 默认值： `None`
`ext_callers`	一个或多个调用者身份，用于在 User-Agent 标头中识别数据 API 调用。这是一个（名称，版本）对的列表，或者如果未提供版本信息，则仅为字符串，如果提供，它将成为与此组件相关的所有 API 请求中 User-Agent 字符串的前导部分。类型： `list[tuple[str \| None, str \| None] \| str \| None] \| None` 默认值： `None`
`api_options`	一个 `astrapy.utils.api_options.APIOptions` 的实例，可用于自定义与数据 API 在序列化/反序列化、超时、自定义标头等方面的交互。提供的选项将应用于已为此库量身定制的设置之上，如果指定，将优先。传递 None（默认值）意味着不请求自定义。有关详细信息，请参阅 astrapy 文档。类型： `APIOptions \| None` 默认值： `None`

lazy_load ¶

lazy_load() -> Iterator[Document]

`Document` 的惰性加载器。

YIELDS	描述
`Document`	`Document` 对象。

aload `async` ¶

aload() -> list[Document]

将数据加载到 `Document` 对象中。

返回	描述
`list[Document]`	文档。

alazy_load `async` ¶

alazy_load() -> AsyncIterator[Document]

`Document` 的惰性加载器。

YIELDS	描述
`AsyncIterator[Document]`	`Document` 对象。

AstraDBByteStore ¶

Bases: AstraDBBaseStore[bytes], ByteStore

方法	描述
`mget`	获取与给定键关联的值。
`amget`	异步获取与给定键相关联的值。
`mset`	为给定的键设置值。
`amset`	异步为给定的键设置值。
`mdelete`	删除给定的键及其关联的值。
`amdelete`	异步删除给定的键及其关联的值。
`yield_keys`	获取一个匹配给定前缀的键的迭代器。
`ayield_keys`	异步获取与给定前缀匹配的键的迭代器。
`__init__`	使用 DataStax AstraDB 作为底层存储的 ByteStore 实现。
`decode_value`	从 Astra DB 解码值。
`encode_value`	为 Astra DB 编码值。

mget ¶

mget(keys: Sequence[str]) -> list[V | None]

获取与给定键关联的值。

参数	描述
`keys`	一个键的序列。类型： `Sequence[K]`

返回	描述
`list[V \| None]`	与键相关联的可选值序列。
`list[V \| None]`	如果未找到某个键，则相应的值将为 `None`。

amget `async` ¶

amget(keys: Sequence[str]) -> list[V | None]

异步获取与给定键相关联的值。

参数	描述
`keys`	一个键的序列。类型： `Sequence[K]`

返回	描述
`list[V \| None]`	与键相关联的可选值序列。
`list[V \| None]`	如果未找到某个键，则相应的值将为 `None`。

mset ¶

mset(key_value_pairs: Sequence[tuple[str, V]]) -> None

为给定的键设置值。

参数	描述
`key_value_pairs`	键值对序列。类型： `Sequence[tuple[K, V]]`

amset `async` ¶

amset(key_value_pairs: Sequence[tuple[str, V]]) -> None

异步为给定的键设置值。

参数	描述
`key_value_pairs`	键值对序列。类型： `Sequence[tuple[K, V]]`

mdelete ¶

mdelete(keys: Sequence[str]) -> None

删除给定的键及其关联的值。

参数	描述
`keys`	要删除的键序列。类型： `Sequence[K]`

amdelete `async` ¶

amdelete(keys: Sequence[str]) -> None

异步删除给定的键及其关联的值。

参数	描述
`keys`	要删除的键序列。类型： `Sequence[K]`

yield_keys ¶

yield_keys(*, prefix: str | None = None) -> Iterator[str]

获取一个匹配给定前缀的键的迭代器。

参数	描述
`prefix`	要匹配的前缀。类型: `str \| None` 默认值: `None`

YIELDS	描述
`Iterator[K] \| Iterator[str]`	一个匹配给定前缀的键的迭代器。
`Iterator[K] \| Iterator[str]`	此方法允许返回一个 K 或 str 的迭代器
`Iterator[K] \| Iterator[str]`	取决于哪种方式对给定的存储更有意义。

ayield_keys `async` ¶

ayield_keys(*, prefix: str | None = None) -> AsyncIterator[str]

异步获取与给定前缀匹配的键的迭代器。

参数	描述
`prefix`	要匹配的前缀。类型: `str \| None` 默认值: `None`

YIELDS	描述
`AsyncIterator[K] \| AsyncIterator[str]`	匹配给定前缀的键。
`AsyncIterator[K] \| AsyncIterator[str]`	此方法允许返回一个 K 或 str 的迭代器
`AsyncIterator[K] \| AsyncIterator[str]`	取决于哪种方式对给定的存储更有意义。

init ¶

__init__(
    *,
    collection_name: str,
    token: str | TokenProvider | None = None,
    api_endpoint: str | None = None,
    namespace: str | None = None,
    environment: str | None = None,
    pre_delete_collection: bool = False,
    setup_mode: SetupMode = SYNC,
    ext_callers: list[tuple[str | None, str | None] | str | None] | None = None,
    api_options: APIOptions | None = None,
) -> None

使用 DataStax AstraDB 作为底层存储的 ByteStore 实现。

字节值被转换为 base64 编码的字符串。

AstraDB 集合中的文档将具有以下格式

{
    "_id": "<key>",
    "value": "<byte64 string value>"
}

参数	描述
`collection_name`	要创建/使用的 Astra DB 集合的名称。类型： `str`
`token`	用于 Astra DB 的 API 令牌，可以是字符串形式，也可以是 `astrapy.authentication.TokenProvider` 的子类。如果未提供，则会检查环境变量 ASTRA_DB_APPLICATION_TOKEN。类型： `str \| TokenProvider \| None` 默认值： `None`
`api_endpoint`	API 端点的完整 URL，例如 `https://-us-east1.apps.astra.datastax.com`。如果未提供，则会检查环境变量 ASTRA_DB_API_ENDPOINT。类型: `str \| None` 默认值: `None`
`namespace`	集合创建所在的命名空间（即 keyspace）。如果未提供，则会检查环境变量 ASTRA_DB_KEYSPACE。默认为数据库的“默认命名空间”。类型: `str \| None` 默认值: `None`
`environment`	一个指定目标数据 API 环境的字符串。如果省略，则默认为“prod”（Astra DB 生产环境）。其他值在 `astrapy.constants.Environment` 枚举类中。类型: `str \| None` 默认值: `None`
`setup_mode`	用于创建 Astra DB 集合的模式（SYNC、ASYNC 或 OFF）。类型： `SetupMode` 默认值： `SYNC`
`pre_delete_collection`	是否在创建集合之前删除它。如果为 False 且集合已存在，则将按原样使用该集合。类型： `bool` 默认值： `False`
`ext_callers`	一个或多个调用者身份，用于在 User-Agent 标头中识别数据 API 调用。这是一个（名称，版本）对的列表，或者如果未提供版本信息，则仅为字符串，如果提供，它将成为与此组件相关的所有 API 请求中 User-Agent 字符串的前导部分。类型： `list[tuple[str \| None, str \| None] \| str \| None] \| None` 默认值： `None`
`api_options`	一个 `astrapy.utils.api_options.APIOptions` 的实例，可用于自定义与数据 API 在序列化/反序列化、超时、自定义标头等方面的交互。提供的选项将应用于已为此库量身定制的设置之上，如果指定，将优先。传递 None（默认值）意味着不请求自定义。有关详细信息，请参阅 astrapy 文档。类型： `APIOptions \| None` 默认值： `None`

decode_value ¶

decode_value(value: Any) -> bytes | None

从 Astra DB 解码值。

encode_value ¶

encode_value(value: bytes | None) -> Any

为 Astra DB 编码值。

AstraDBStore ¶

Bases: AstraDBBaseStore[Any]

方法	描述
`mget`	获取与给定键关联的值。
`amget`	异步获取与给定键相关联的值。
`mset`	为给定的键设置值。
`amset`	异步为给定的键设置值。
`mdelete`	删除给定的键及其关联的值。
`amdelete`	异步删除给定的键及其关联的值。
`yield_keys`	获取一个匹配给定前缀的键的迭代器。
`ayield_keys`	异步获取与给定前缀匹配的键的迭代器。
`__init__`	使用 DataStax AstraDB 作为底层存储的 BaseStore 实现。
`decode_value`	从 Astra DB 解码值。
`encode_value`	为 Astra DB 编码值。

mget ¶

mget(keys: Sequence[str]) -> list[V | None]

获取与给定键关联的值。

参数	描述
`keys`	一个键的序列。类型： `Sequence[K]`

返回	描述
`list[V \| None]`	与键相关联的可选值序列。
`list[V \| None]`	如果未找到某个键，则相应的值将为 `None`。

amget `async` ¶

amget(keys: Sequence[str]) -> list[V | None]

异步获取与给定键相关联的值。

参数	描述
`keys`	一个键的序列。类型： `Sequence[K]`

返回	描述
`list[V \| None]`	与键相关联的可选值序列。
`list[V \| None]`	如果未找到某个键，则相应的值将为 `None`。

mset ¶

mset(key_value_pairs: Sequence[tuple[str, V]]) -> None

为给定的键设置值。

参数	描述
`key_value_pairs`	键值对序列。类型： `Sequence[tuple[K, V]]`

amset `async` ¶

amset(key_value_pairs: Sequence[tuple[str, V]]) -> None

异步为给定的键设置值。

参数	描述
`key_value_pairs`	键值对序列。类型： `Sequence[tuple[K, V]]`

mdelete ¶

mdelete(keys: Sequence[str]) -> None

删除给定的键及其关联的值。

参数	描述
`keys`	要删除的键序列。类型： `Sequence[K]`

amdelete `async` ¶

amdelete(keys: Sequence[str]) -> None

异步删除给定的键及其关联的值。

参数	描述
`keys`	要删除的键序列。类型： `Sequence[K]`

yield_keys ¶

yield_keys(*, prefix: str | None = None) -> Iterator[str]

获取一个匹配给定前缀的键的迭代器。

参数	描述
`prefix`	要匹配的前缀。类型: `str \| None` 默认值: `None`

YIELDS	描述
`Iterator[K] \| Iterator[str]`	一个匹配给定前缀的键的迭代器。
`Iterator[K] \| Iterator[str]`	此方法允许返回一个 K 或 str 的迭代器
`Iterator[K] \| Iterator[str]`	取决于哪种方式对给定的存储更有意义。

ayield_keys `async` ¶

ayield_keys(*, prefix: str | None = None) -> AsyncIterator[str]

异步获取与给定前缀匹配的键的迭代器。

参数	描述
`prefix`	要匹配的前缀。类型: `str \| None` 默认值: `None`

YIELDS	描述
`AsyncIterator[K] \| AsyncIterator[str]`	匹配给定前缀的键。
`AsyncIterator[K] \| AsyncIterator[str]`	此方法允许返回一个 K 或 str 的迭代器
`AsyncIterator[K] \| AsyncIterator[str]`	取决于哪种方式对给定的存储更有意义。

init ¶

__init__(
    collection_name: str,
    *,
    token: str | TokenProvider | None = None,
    api_endpoint: str | None = None,
    namespace: str | None = None,
    environment: str | None = None,
    pre_delete_collection: bool = False,
    setup_mode: SetupMode = SYNC,
    ext_callers: list[tuple[str | None, str | None] | str | None] | None = None,
    api_options: APIOptions | None = None,
) -> None

使用 DataStax AstraDB 作为底层存储的 BaseStore 实现。

值类型可以是任何可由 json.dumps 序列化的类型。可用于通过 CacheBackedEmbeddings 存储嵌入。

AstraDB 集合中的文档将具有以下格式

{
    "_id": "<key>",
    "value": <value>
}

参数	描述
`collection_name`	要创建/使用的 Astra DB 集合的名称。类型： `str`
`token`	用于 Astra DB 的 API 令牌，可以是字符串形式，也可以是 `astrapy.authentication.TokenProvider` 的子类。如果未提供，则会检查环境变量 ASTRA_DB_APPLICATION_TOKEN。类型： `str \| TokenProvider \| None` 默认值： `None`
`api_endpoint`	API 端点的完整 URL，例如 `https://-us-east1.apps.astra.datastax.com`。如果未提供，则会检查环境变量 ASTRA_DB_API_ENDPOINT。类型: `str \| None` 默认值: `None`
`namespace`	集合创建所在的命名空间（即 keyspace）。如果未提供，则会检查环境变量 ASTRA_DB_KEYSPACE。默认为数据库的“默认命名空间”。类型: `str \| None` 默认值: `None`
`environment`	一个指定目标数据 API 环境的字符串。如果省略，则默认为“prod”（Astra DB 生产环境）。其他值在 `astrapy.constants.Environment` 枚举类中。类型: `str \| None` 默认值: `None`
`setup_mode`	用于创建 Astra DB 集合的模式（SYNC、ASYNC 或 OFF）。类型： `SetupMode` 默认值： `SYNC`
`pre_delete_collection`	是否在创建集合之前删除它。如果为 False 且集合已存在，则将按原样使用该集合。类型： `bool` 默认值： `False`
`ext_callers`	一个或多个调用者身份，用于在 User-Agent 标头中识别数据 API 调用。这是一个（名称，版本）对的列表，或者如果未提供版本信息，则仅为字符串，如果提供，它将成为与此组件相关的所有 API 请求中 User-Agent 字符串的前导部分。类型： `list[tuple[str \| None, str \| None] \| str \| None] \| None` 默认值： `None`
`api_options`	一个 `astrapy.utils.api_options.APIOptions` 的实例，可用于自定义与数据 API 在序列化/反序列化、超时、自定义标头等方面的交互。提供的选项将应用于已为此库量身定制的设置之上，如果指定，将优先。传递 None（默认值）意味着不请求自定义。有关详细信息，请参阅 astrapy 文档。类型： `APIOptions \| None` 默认值： `None`

decode_value ¶

decode_value(value: Any) -> Any

从 Astra DB 解码值。

encode_value ¶

encode_value(value: Any) -> Any

为 Astra DB 编码值。

AstraDBVectorStore ¶

Bases: VectorStore

一个使用 DataStax Astra DB 作为后端的向量存储。

设置

安装 `langchain-astradb` 包并访问 AstraDB 网站，创建一个账户，创建一个新数据库并创建一个应用程序令牌。

pip install -qU langchain-astradb

实例化

从数据库的仪表板获取您的 API 端点和应用程序令牌。

创建一个向量存储并提供一个 LangChain 嵌入对象以供使用。

import getpass

from langchain_astradb import AstraDBVectorStore
from langchain_openai import OpenAIEmbeddings

ASTRA_DB_API_ENDPOINT = getpass.getpass("ASTRA_DB_API_ENDPOINT = ")
ASTRA_DB_APPLICATION_TOKEN = getpass.getpass("ASTRA_DB_APPLICATION_TOKEN = ")

vector_store = AstraDBVectorStore(
    collection_name="astra_vector_langchain",
    embedding=OpenAIEmbeddings(),
    api_endpoint=ASTRA_DB_API_ENDPOINT,
    token=ASTRA_DB_APPLICATION_TOKEN,
)

（Vectorize）创建一个向量存储，其中嵌入向量计算完全在服务器端进行，使用 vectorize 功能。

import getpass
from astrapy.info import VectorServiceOptions

from langchain_astradb import AstraDBVectorStore

ASTRA_DB_API_ENDPOINT = getpass.getpass("ASTRA_DB_API_ENDPOINT = ")
ASTRA_DB_APPLICATION_TOKEN = getpass.getpass("ASTRA_DB_APPLICATION_TOKEN = ")

vector_store = AstraDBVectorStore(
    collection_name="astra_vectorize_langchain",
    api_endpoint=ASTRA_DB_API_ENDPOINT,
    token=ASTRA_DB_APPLICATION_TOKEN,
    collection_vector_service_options=VectorServiceOptions(
        provider="nvidia",
        model_name="NV-Embed-QA",
        # authentication=...,  # needed by some providers/models
    ),
)

（混合）底层的 Astra DB 通常支持混合搜索（即词法 + 向量 ANN）以提高结果的准确性。当可用时，会自动配置和使用。要手动控制，请使用 `collection_rerank` 和 `collection_lexical` 构造函数参数。

import getpass
from astrapy.info import (
    CollectionLexicalOptions,
    CollectionRerankOptions,
    RerankServiceOptions,
    VectorServiceOptions,
)

from langchain_astradb import AstraDBVectorStore

ASTRA_DB_API_ENDPOINT = getpass.getpass("ASTRA_DB_API_ENDPOINT = ")
ASTRA_DB_APPLICATION_TOKEN = getpass.getpass("ASTRA_DB_APPLICATION_TOKEN = ")

vector_store = AstraDBVectorStore(
    collection_name="astra_vectorize_langchain",
    # embedding=...,  # needed unless using 'vectorize'
    api_endpoint=ASTRA_DB_API_ENDPOINT,
    token=ASTRA_DB_APPLICATION_TOKEN,
    collection_vector_service_options=VectorServiceOptions(...),  # see above
    collection_lexical=CollectionLexicalOptions(analyzer="standard"),
    collection_rerank=CollectionRerankOptions(
        service=RerankServiceOptions(
            provider="nvidia",
            model_name="nvidia/llama-3.2-nv-rerankqa-1b-v2",
        ),
    ),
    collection_reranking_api_key=...,  # if needed by the model/setup
)

与混合相关的服务器升级可能会导致存储默认值与预先存在的集合之间出现不匹配：如果报告了此类不匹配（作为数据 API“EXISTING_COLLECTION_DIFFERENT_SETTINGS”错误），解决方法有：(1) 使用自动检测模式，(2) 切换到 `setup_mode` "OFF"，或 (3) 在向量存储构造函数中明确指定词法和/或重排设置，以匹配现有集合配置。更多详情请参见此处。

（自动检测）让向量存储通过检查现有集合来确定配置（包括 vectorize 和数据库上的文档编码方案）。

import getpass

from langchain_astradb import AstraDBVectorStore

ASTRA_DB_API_ENDPOINT = getpass.getpass("ASTRA_DB_API_ENDPOINT = ")
ASTRA_DB_APPLICATION_TOKEN = getpass.getpass("ASTRA_DB_APPLICATION_TOKEN = ")

vector_store = AstraDBVectorStore(
    collection_name="astra_existing_collection",
    # embedding=...,  # needed unless using 'vectorize'
    api_endpoint=ASTRA_DB_API_ENDPOINT,
    token=ASTRA_DB_APPLICATION_TOKEN,
    autodetect_collection=True,
)

（非 Astra DB）此类也可以通过数据 API 针对非 Astra DB 数据库，例如自部署的 HCD。

import getpass

from astrapy.authentication import UsernamePasswordTokenProvider

from langchain_astradb import AstraDBVectorStore

vector_store = AstraDBVectorStore(
    collection_name="astra_existing_collection",
    # embedding=...,  # needed unless using 'vectorize'
    api_endpoint="https://:8181",
    token=UsernamePasswordTokenProvider(
        username="user",
        password="pwd",
    ),
    collection_vector_service_options=...,  # if 'vectorize'
)

添加文档

向向量存储中添加一个或多个文档。ID 是可选的：如果提供，并且匹配现有文档，则会执行覆盖操作。

from langchain_core.documents import Document

document_1 = Document(page_content="foo", metadata={"baz": "bar"})
document_2 = Document(page_content="thud", metadata={"bar": "baz"})
document_3 = Document(page_content="i will be deleted :(")

documents = [document_1, document_2, document_3]
ids = ["1", "2", "3"]
vector_store.add_documents(documents=documents, ids=ids)

删除文档

通过 ID 从向量存储中删除一个或多个文档。

vector_store.delete(ids=["3"])

搜索

使用提供的查询字符串运行相似性搜索。

results = vector_store.similarity_search(query="thud", k=1)
for doc in results:
    print(f"{doc.page_content}[{doc.metadata}]")

thud[{"bar": "baz"}]

带筛选的搜索

为搜索指定元数据过滤器。过滤器的简单 `key: value` 语法表示相等（并隐含“和”）。还有更复杂的语法可用，遵循数据 API 规范，请参见（文档）[https://docs.datastax.com/en/astra-db-serverless/api-reference/filter-operator-collections.html]。

results = vector_store.similarity_search(
    query="thud", k=1, filter={"bar": "baz"}
)
for doc in results:
    print(f"{doc.page_content}[{doc.metadata}]")

thud[{"bar": "baz"}]

带分数的搜索

搜索结果会连同其相似度分数一起返回。

results = vector_store.similarity_search_with_score(query="qux", k=1)
for doc, score in results:
    print(f"* [SIM={score:3f}] {doc.page_content} [{doc.metadata}]")

[SIM=0.916135] foo [{'baz': 'bar'}]

异步

所有方法都带有其异步对应版本（方法名前缀为 `a`）。

# add documents
await vector_store.aadd_documents(documents=documents, ids=ids)

# delete documents
await vector_store.adelete(ids=["3"])

# search
results = vector_store.asimilarity_search(query="thud", k=1)

# search with score
results = await vector_store.asimilarity_search_with_score(query="qux", k=1)
for doc, score in results:
    print(f"* [SIM={score:3f}] {doc.page_content} [{doc.metadata}]")

[SIM=0.916135] foo [{'baz': 'bar'}]

用作检索器

可以从向量存储中生成一个 Retriever 以供进一步使用。

retriever = vector_store.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={"k": 1, "score_threshold": 0.5},
)
retriever.invoke("thud")

[Document(metadata={"bar": "baz"}, page_content="thud")]

方法	描述
`add_documents`	在 `VectorStore` 中添加或更新文档。
`aadd_documents`	异步运行更多文档通过嵌入并添加到 `VectorStore`。
`search`	使用指定的搜索类型返回与查询最相似的文档。
`asearch`	异步返回与查询最相似的文档，使用指定的搜索类型。
`similarity_search_with_relevance_scores`	返回文档和在 `[0, 1]` 范围内的相关性分数。
`asimilarity_search_with_relevance_scores`	异步返回文档和在 `[0, 1]` 范围内的相关性分数。
`as_retriever`	返回从此 `VectorStore` 初始化的 `VectorStoreRetriever`。
`filter_to_query`	基于元数据过滤器准备一个用于数据库的查询。
`__init__`	一个使用 DataStax Astra DB 作为后端的向量存储。
`copy`	创建一个副本，可能会更改属性。
`clear`	清空集合中的所有存储条目。
`aclear`	清空集合中的所有存储条目。
`delete_by_document_id`	给定文档 ID，从存储中删除单个文档。
`adelete_by_document_id`	给定文档 ID，从存储中删除单个文档。
`delete`	按向量 ID 删除。
`adelete`	按向量 ID 删除。
`delete_by_metadata_filter`	删除所有匹配特定元数据过滤条件的文档。
`adelete_by_metadata_filter`	删除所有匹配特定元数据过滤条件的文档。
`delete_collection`	从数据库中完全删除该集合。
`adelete_collection`	从数据库中完全删除该集合。
`add_texts`	通过嵌入运行文本并将它们添加到向量存储中。
`aadd_texts`	通过嵌入运行文本并将它们添加到向量存储中。
`update_metadata`	添加/覆盖现有文档的元数据。
`aupdate_metadata`	添加/覆盖现有文档的元数据。
`full_decode_astra_db_found_document`	完全解码一个 Astra DB 文档，即解码为 Document+embedding/similarity。
`full_decode_astra_db_reranked_result`	完全解码一个 Astra DB 查找并重排的命中结果（Document+embedding/similarity）。
`run_query_raw`	在存储的文档上执行通用查询，返回 Astra DB 文档。
`run_query`	在存储的文档上执行通用查询，返回 Documents+其他信息。
`arun_query_raw`	在存储的文档上执行通用查询，返回 Astra DB 文档。
`arun_query`	在存储的文档上执行通用查询，返回 Documents+其他信息。
`metadata_search`	通过元数据搜索获取文档。
`ametadata_search`	通过元数据搜索获取文档。
`get_by_document_id`	给定文档 ID，从存储中检索单个文档。
`aget_by_document_id`	给定文档 ID，从存储中检索单个文档。
`get_by_ids`	根据 ID 获取文档。
`get_by_document_ids`	根据 ID 获取文档。
`aget_by_ids`	根据 ID 获取文档。
`aget_by_document_ids`	根据 ID 获取文档。
`similarity_search`	返回与查询最相似的文档。
`similarity_search_with_score`	返回与查询最相似且带有分数的文档。
`similarity_search_with_score_id`	返回与查询最相似且带有分数和 ID 的文档。
`similarity_search_by_vector`	返回与嵌入向量最相似的文档。
`similarity_search_with_score_by_vector`	返回与嵌入向量最相似且带有分数的文档。
`similarity_search_with_score_id_by_vector`	返回与嵌入向量最相似且带有分数和 ID 的文档。
`asimilarity_search`	返回与查询最相似的文档。
`asimilarity_search_with_score`	返回与查询最相似且带有分数的文档。
`asimilarity_search_with_score_id`	返回与查询最相似且带有分数和 ID 的文档。
`asimilarity_search_by_vector`	返回与嵌入向量最相似的文档。
`asimilarity_search_with_score_by_vector`	返回与嵌入向量最相似且带有分数的文档。
`asimilarity_search_with_score_id_by_vector`	返回与嵌入向量最相似且带有分数和 ID 的文档。
`similarity_search_with_embedding_by_vector`	返回与嵌入向量最相似且带有嵌入的文档。
`asimilarity_search_with_embedding_by_vector`	返回与嵌入向量最相似且带有嵌入的文档。
`similarity_search_with_embedding`	返回与查询最相似且带有嵌入的文档。
`asimilarity_search_with_embedding`	返回与查询最相似且带有嵌入的文档。
`max_marginal_relevance_search_by_vector`	返回使用最大边际相关性选择的文档。
`amax_marginal_relevance_search_by_vector`	返回使用最大边际相关性选择的文档。
`max_marginal_relevance_search`	返回使用最大边际相关性选择的文档。
`amax_marginal_relevance_search`	返回使用最大边际相关性选择的文档。
`from_texts`	从原始文本创建 Astra DB 向量存储。
`afrom_texts`	从原始文本创建 Astra DB 向量存储。
`from_documents`	从文档列表创建 Astra DB 向量存储。
`afrom_documents`	从文档列表创建 Astra DB 向量存储。

embeddings `property` ¶

embeddings: Embeddings | None

访问提供的嵌入对象。

如果使用服务器端嵌入，此方法将返回 None。

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'` 之一。

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)`

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"}}
)

filter_to_query ¶

filter_to_query(filter_dict: dict[str, Any] | None) -> dict[str, Any]

基于元数据过滤器准备一个用于数据库的查询。

将元数据上的“抽象”过滤子句编码为能够识别集合模式选择的查询过滤条件。

参数	描述
`filter_dict`	一个元数据条件，形式为 {"field": "value"} 或相关形式。类型: `dict[str, Any] \| None`

返回	描述
`dict[str, Any]`	准备好用于查询的相应映射，
`dict[str, Any]`	能够识别用于在数据库上编码文档的模式的详细信息。

init ¶

__init__(
    *,
    collection_name: str,
    embedding: Embeddings | None = None,
    token: str | TokenProvider | None = None,
    api_endpoint: str | None = None,
    environment: str | None = None,
    namespace: str | None = None,
    metric: str | None = None,
    batch_size: int | None = None,
    bulk_insert_batch_concurrency: int | None = None,
    bulk_insert_overwrite_concurrency: int | None = None,
    bulk_delete_concurrency: int | None = None,
    setup_mode: SetupMode | None = None,
    pre_delete_collection: bool = False,
    metadata_indexing_include: Iterable[str] | None = None,
    metadata_indexing_exclude: Iterable[str] | None = None,
    collection_indexing_policy: dict[str, Any] | None = None,
    collection_vector_service_options: VectorServiceOptions | None = None,
    collection_embedding_api_key: str | EmbeddingHeadersProvider | None = None,
    content_field: str | None = None,
    ignore_invalid_documents: bool = False,
    autodetect_collection: bool = False,
    ext_callers: list[tuple[str | None, str | None] | str | None] | None = None,
    component_name: str = COMPONENT_NAME_VECTORSTORE,
    api_options: APIOptions | None = None,
    collection_rerank: CollectionRerankOptions | RerankServiceOptions | None = None,
    collection_reranking_api_key: str | RerankingHeadersProvider | None = None,
    collection_lexical: str | dict[str, Any] | CollectionLexicalOptions | None = None,
    hybrid_search: HybridSearchMode | None = None,
    hybrid_limit_factor: float
    | dict[str, float]
    | HybridLimitFactorPrescription
    | None = None,
) -> None

一个使用 DataStax Astra DB 作为后端的向量存储。

有关 Astra DB 的更多信息，请访问 https://docs.datastax.com/en/astra-db-serverless/index.html

参数	描述
`embedding`	要使用的嵌入函数或服务。这启用了客户端嵌入函数或对外部嵌入提供商的调用。如果传递了 `embedding`，则不能提供 `collection_vector_service_options`。 TYPE: `Embeddings \| None` DEFAULT: `None`
`collection_name`	要创建/使用的 Astra DB 集合的名称。类型： `str`
`token`	用于 Astra DB 的 API 令牌，可以是字符串形式，也可以是 `astrapy.authentication.TokenProvider` 的子类。如果未提供，则会检查环境变量 ASTRA_DB_APPLICATION_TOKEN。类型： `str \| TokenProvider \| None` 默认值： `None`
`api_endpoint`	API 端点的完整 URL，例如 `https://-us-east1.apps.astra.datastax.com`。如果未提供，则会检查环境变量 ASTRA_DB_API_ENDPOINT。类型: `str \| None` 默认值: `None`
`environment`	一个指定目标数据 API 环境的字符串。如果省略，则默认为“prod”（Astra DB 生产环境）。其他值在 `astrapy.constants.Environment` 枚举类中。类型: `str \| None` 默认值: `None`
`namespace`	集合创建所在的命名空间（即 keyspace）。如果未提供，则会检查环境变量 ASTRA_DB_KEYSPACE。默认为数据库的“默认命名空间”。类型: `str \| None` 默认值: `None`
`metric`	在 Astra DB 中可用的相似性函数。如果省略，将使用 Astra DB API 的默认值（即“cosine”——但出于性能原因，如果嵌入被归一化为 1，建议使用“dot_product”）。类型: `str \| None` 默认值: `None`
`batch_size`	每个单独插入 API 请求的文档块大小。如果未提供，则应用 astrapy 的默认值。 TYPE: `int \| None` DEFAULT: `None`
`bulk_insert_batch_concurrency`	并发插入批次的线程或协程数。 TYPE: `int \| None` DEFAULT: `None`
`bulk_insert_overwrite_concurrency`	批次中插入已存在条目的线程或协程数。 TYPE: `int \| None` DEFAULT: `None`
`bulk_delete_concurrency`	用于多条目删除的线程或协程数。 TYPE: `int \| None` DEFAULT: `None`
`setup_mode`	用于创建集合的模式（SYNC、ASYNC 或 OFF）。类型： `SetupMode \| None` 默认值： `None`
`pre_delete_collection`	是否在创建集合之前删除它。如果为 False 且集合已存在，则将按原样使用该集合。类型： `bool` 默认值： `False`
`metadata_indexing_include`	应为以后在搜索中进行筛选而建立索引的特定元数据子字段的允许列表。类型： `Iterable[str] \| None` 默认值： `None`
`metadata_indexing_exclude`	不应为以后在搜索中进行筛选而建立索引的特定元数据子字段的拒绝列表。类型： `Iterable[str] \| None` 默认值： `None`
`collection_indexing_policy`	一个完整的“索引”规范，用于指定哪些字段应为以后在搜索中进行筛选而建立索引。此字典必须符合 API 规范（请参阅 https://docs.datastax.com/en/astra-db-serverless/api-reference/collection-indexes.html）类型: `dict[str, Any] \| None` 默认值: `None`
`collection_vector_service_options`	指定在 Astra DB 中使用服务器端嵌入。如果传递此参数，则不能提供 `embedding`。类型： `VectorServiceOptions \| None` 默认值： `None`
`collection_embedding_api_key`	用于在 Astra DB 中使用服务器端嵌入。通过此参数，可以提供一个 API 密钥，该密钥将与每个数据请求一起传递给 Astra DB。此参数可以是字符串或 `astrapy.authentication.EmbeddingHeadersProvider` 的子类。这在为集合配置了服务，但 Astra 的密钥管理系统中未存储相应密钥时很有用。类型： `str \| EmbeddingHeadersProvider \| None` 默认值： `None`
`content_field`	在 Astra DB 上保存时，文档中包含文本内容的字段名称。对于 vectorize 集合，不能指定此字段；对于非 vectorize 集合，默认为 "content"。特殊值 "" 只能在 autodetect_collection=True 时传递。在这种情况下，文本内容的键的实际名称是通过检查集合中的几个文档来猜测的，假设较长的字符串是最可能的候选者。在使用 `""` 作为此参数之前，请了解此方法的局限性并对您的数据有所了解。类型: `str \| None` 默认值: `None`
`ignore_invalid_documents`	如果为 False（默认值），当在 Astra DB 集合中发现不符合预期形状的文档时会引发异常。如果设置为 True，则会忽略来自数据库的此类结果并发出警告。请注意，在这种情况下，相似性搜索最终可能会返回少于所需 `k` 个的结果。类型： `bool` 默认值： `False`
`autodetect_collection`	如果为 True，则开启自动检测行为。存储将查找具有所提供名称的现有集合，并从中推断存储设置。默认为 False。在自动检测模式下，`content_field` 可以指定为 `""`，这意味着将尝试通过检查来确定它（除非启用了 vectorize，在这种情况下 `content_field` 被忽略）。在自动检测模式下，存储不仅确定嵌入是客户端还是服务器端，而且——最重要的是——自动在数据库上文档的“嵌套”和“扁平”表示之间切换（即将元数据键值对分组在 `metadata` 字段中或在文档的顶层展开）。前一种方案是 AstraDBVectorStore 的本机模式；在将 AstraDBVectorStore 应用于它们之前，如果向量集合是通过外部方式（例如第三方数据导入工具）填充的，则存储会采用后一种方案。请注意，如果此参数为 True，则不能使用以下参数：`metric`、`setup_mode`、`metadata_indexing_include`、`metadata_indexing_exclude`、`collection_indexing_policy`、`collection_vector_service_options`。类型：* `bool` 默认值： `False`
`ext_callers`	一个或多个调用者身份，用于在 User-Agent 标头中识别数据 API 调用。这是一个（名称，版本）对的列表，或者如果未提供版本信息，则仅为字符串，如果提供，它将成为与此组件相关的所有 API 请求中 User-Agent 字符串的前导部分。类型： `list[tuple[str \| None, str \| None] \| str \| None] \| None` 默认值： `None`
`component_name`	在作为 User-Agent 字符串传递给数据 API 的使用信息堆栈中标识此特定组件的字符串。默认为 "langchain_vectorstore"，但如果此组件实际上用作另一个组件的构建块（例如，当向量存储在 `GraphRetriever` 中使用时），则可以覆盖它。类型： `str` 默认值： `COMPONENT_NAME_VECTORSTORE`
`api_options`	一个 `astrapy.utils.api_options.APIOptions` 的实例，可用于自定义与数据 API 在序列化/反序列化、超时、自定义标头等方面的交互。提供的选项将应用于已为此库量身定制的设置之上，如果指定，将优先。传递 None（默认值）意味着不请求自定义。有关详细信息，请参阅 astrapy 文档。类型： `APIOptions \| None` 默认值： `None`
`collection_rerank`	提供重排设置是运行混合相似性搜索所必需的。此参数可以是 astrapy 类 `CollectionRerankOptions` 或 `RerankServiceOptions` 的实例。类型： `CollectionRerankOptions \| RerankServiceOptions \| None` 默认值： `None`
`collection_reranking_api_key`	用于在 Astra DB 中使用服务器端重排服务。通过此参数，可以提供一个 API 密钥，该密钥将与每个数据请求一起传递给 Astra DB。此参数可以是字符串或 `astrapy.authentication.RerankingHeadersProvider` 的子类。这在为集合配置了服务，但 Astra 的密钥管理系统中未存储相应密钥时很有用。类型： `str \| RerankingHeadersProvider \| None` 默认值： `None`
`collection_lexical`	配置词法分析器是运行词法和混合搜索所必需的。此参数可以是字符串或字典，然后将其原样传递给 createCollection 的 `"$lexical.analyzer"` 值，或者是一个现成的 astrapy `CollectionLexicalOptions` 对象。类型： `str \| dict[str, Any] \| CollectionLexicalOptions \| None` 默认值： `None`
`hybrid_search`	相似性搜索是否应作为混合搜索运行。值为 DEFAULT、ON 或 OFF。在 DEFAULT 的情况下，搜索将根据集合配置的允许情况执行，并优先使用混合搜索。将此设置强制为 ON 的非混合启用集合将在运行搜索时导致服务器错误。类型： `HybridSearchMode \| None` 默认值： `None`
`hybrid_limit_factor`	混合搜索的子搜索“limit”规范。如果省略，混合搜索不指定它，并让数据 API 使用其默认值。如果提供一个正浮点数：参与混合搜索的每个子搜索（即基于向量的 ANN 和基于词法的）将被要求获取最多 `int(khybrid_limit_factor)` 个项目，其中 `k` 是整个搜索的期望结果计数。如果提供一个 `HybridLimitFactorPrescription`（有关详细信息，请参见类文档字符串），则将对向量和词法子搜索应用不同的因子。或者，一个带有键 `"$lexical"` 和 `"$vector"` 的简单字典可以达到相同的效果。类型：* `float \| dict[str, float] \| HybridLimitFactorPrescription \| None` 默认值： `None`

引发	描述
`ValueError`	如果参数不一致或无效。

注意

对于同步 add_texts 中的并发性，根据经验法则，在典型的客户端计算机上，建议将 bulk_insert_batch_concurrency * bulk_insert_overwrite_concurrency 的数量远低于 1000，以避免耗尽客户端多线程/网络资源。硬编码的默认值有些保守，以满足大多数计算机的规格，但可以测试的一个明智选择是

bulk_insert_batch_concurrency = 80
bulk_insert_overwrite_concurrency = 10

需要进行一些实验才能获得最佳结果，这取决于计算机/网络规格和预期的工作负载（特别是，写入是更新现有 ID 的频率）。请记住，您也可以将并发设置传递给对 add_texts 和 add_documents" href="#langchain_astradb.AstraDBVectorStore.add_documents">add_documents 的单个调用。

copy ¶

copy(
    *,
    token: str | TokenProvider | None = None,
    ext_callers: list[tuple[str | None, str | None] | str | None] | None = None,
    component_name: str | None = None,
    collection_embedding_api_key: str | EmbeddingHeadersProvider | None = None,
    collection_reranking_api_key: str | RerankingHeadersProvider | None = None,
) -> AstraDBVectorStore

创建一个副本，可能会更改属性。

此方法创建此环境的浅拷贝。如果传递的参数不同于 None，它将替换拷贝中的相应值。

该方法只允许更改确保拷贝功能正常且不触发副作用的参数：例如，不能创建作用于新集合的拷贝。在这些情况下，应从头开始创建一个新的 `AstraDBVectorStore` 实例。

参数	描述
`token`	用于 Astra DB 的 API 令牌，可以是字符串形式或 `astrapy.authentication.TokenProvider` 的子类。为了在拷贝中取消令牌使用，请显式传递 `astrapy.authentication.StaticTokenProvider(None)`。类型： `str \| TokenProvider \| None` 默认值： `None`
`ext_callers`	在发出数据 API 请求时附加到 User-Agent 标头的附加自定义（caller_name, caller_version）对。类型： `list[tuple[str \| None, str \| None] \| str \| None] \| None` 默认值： `None`
`component_name`	在识别数据 API 请求的发起者时要使用的 LangChain 组件名称的值。类型: `str \| None` 默认值: `None`
`collection_embedding_api_key`	如有必要，在每个数据 API 请求中提供的 API 密钥。如果使用 Vectorize 功能且数据库中未存储密钥，则这是必需的。为了在拷贝中取消 API 密钥，请显式传递 `astrapy.authentication.EmbeddingAPIKeyHeaderProvider(None)`。类型： `str \| EmbeddingHeadersProvider \| None` 默认值： `None`
`collection_reranking_api_key`	用于在 Astra DB 中使用服务器端重排服务。通过此参数，可以提供一个 API 密钥，该密钥将与每个数据请求一起传递给 Astra DB。此参数可以是字符串或 `astrapy.authentication.RerankingHeadersProvider` 的子类。这在为集合配置了服务，但 Astra 的密钥管理系统中未存储相应密钥时很有用。类型： `str \| RerankingHeadersProvider \| None` 默认值： `None`

返回	描述
`AstraDBVectorStore`	此向量存储的浅拷贝，可能具有一些更改的
`AstraDBVectorStore`	属性。

clear ¶

clear() -> None

清空集合中的所有存储条目。

aclear `async` ¶

aclear() -> None

清空集合中的所有存储条目。

delete_by_document_id ¶

delete_by_document_id(document_id: str) -> bool

给定文档 ID，从存储中删除单个文档。

参数	描述
`document_id`	文档 ID 类型： `str`

返回	描述
`bool`	如果文档确实被删除，则为 True；如果未找到 ID，则为 False。

adelete_by_document_id `async` ¶

adelete_by_document_id(document_id: str) -> bool

给定文档 ID，从存储中删除单个文档。

参数	描述
`document_id`	文档 ID 类型： `str`

返回	描述
`bool`	如果文档确实被删除，则为 True；如果未找到 ID，则为 False。

delete ¶

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

按向量 ID 删除。

参数	描述
`ids`	要删除的 ID 列表。类型： `Iterable[str] \| None` 默认值： `None`
`concurrency`	发出单文档删除请求的最大线程数。默认为向量存储的总体设置。 TYPE: `int \| None` DEFAULT: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

返回	描述
`bool \| None`	如果删除（完全）成功，则为 True，否则为 False。

引发	描述
`ValueError`	如果没有提供 ID。

adelete `async` ¶

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

按向量 ID 删除。

参数	描述
`ids`	要删除的 ID 列表。类型： `Iterable[str] \| None` 默认值： `None`
`concurrency`	用于单文档删除请求的并发协程的最大数量。默认为向量存储的全局设置。 TYPE: `int \| None` DEFAULT: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

返回	描述
`bool \| None`	如果删除（完全）成功，则为 True，否则为 False。

引发	描述
`ValueError`	如果没有提供 ID。

delete_by_metadata_filter ¶

delete_by_metadata_filter(filter: dict[str, Any]) -> int

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

此操作不以任何方式使用向量嵌入，它仅移除元数据匹配所提供条件的全部文档。

参数	描述
`filter`	应用于元数据的筛选器。筛选器不能为空。类型： `dict[str, Any]`

返回	描述
`int`	表示已删除文档数量的数字。

引发	描述
`ValueError`	如果提供的筛选器为空。

adelete_by_metadata_filter `async` ¶

adelete_by_metadata_filter(filter: dict[str, Any]) -> int

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

此操作不以任何方式使用向量嵌入，它仅移除元数据匹配所提供条件的全部文档。

参数	描述
`filter`	应用于元数据的筛选器。筛选器不能为空。类型： `dict[str, Any]`

返回	描述
`int`	表示已删除文档数量的数字。

引发	描述
`ValueError`	如果提供的筛选器为空。

delete_collection ¶

delete_collection() -> None

从数据库中完全删除该集合。

从数据库中完全删除集合（与 clear 相反，后者仅清空集合）。存储的数据将丢失且无法恢复，资源将被释放。请谨慎使用。

adelete_collection `async` ¶

adelete_collection() -> None

从数据库中完全删除该集合。

从数据库中完全删除集合（与 aclear 相反，后者仅清空集合）。存储的数据将丢失且无法恢复，资源将被释放。请谨慎使用。

add_texts ¶

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

通过嵌入运行文本并将它们添加到向量存储中。

如果传递了显式 ID，那么那些 ID 已存在于存储中的条目将被替换。

参数	描述
`texts`	要添加到向量存储的文本。类型： `Iterable[str]`
`metadatas`	可选的元数据列表。类型： `Iterable[dict] \| None` 默认值： `None`
`ids`	可选的 ID 列表。类型： `Iterable[str \| None] \| None` 默认值： `None`
`batch_size`	每个单独插入 API 请求的文档块大小。如果未提供，则默认为向量存储的全局默认值（该值又会回退到 astrapy 的默认值）。 TYPE: `int \| None` DEFAULT: `None`
`batch_concurrency`	用于并发处理插入批次的线程数。如果未提供，则默认为向量存储的全局设置。 TYPE: `int \| None` DEFAULT: `None`
`overwrite_concurrency`	用于处理每个批次中已存在文档的线程数。如果未提供，则默认为向量存储的全局设置。 TYPE: `int \| None` DEFAULT: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

注意

元数据文档属性所允许的字段名称必须遵守特定规则（例如：键不能以美元符号开头，也不能为空）。请参阅文档字段命名规则。

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

引发	描述
`AstraDBVectorStoreError`	如果并非所有文档都能被插入。

aadd_texts `async` ¶

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

通过嵌入运行文本并将它们添加到向量存储中。

如果传递了显式 ID，那么那些 ID 已存在于存储中的条目将被替换。

参数	描述
`texts`	要添加到向量存储的文本。类型： `Iterable[str]`
`metadatas`	可选的元数据列表。类型： `Iterable[dict] \| None` 默认值： `None`
`ids`	可选的 ID 列表。类型： `Iterable[str \| None] \| None` 默认值： `None`
`batch_size`	每个单独插入 API 请求的文档块大小。如果未提供，则默认为向量存储的全局默认值（该值又会回退到 astrapy 的默认值）。 TYPE: `int \| None` DEFAULT: `None`
`batch_concurrency`	用于并发处理插入批次的协程数。如果未提供，则默认为向量存储的全局设置。 TYPE: `int \| None` DEFAULT: `None`
`overwrite_concurrency`	用于并发处理每个批次中已存在文档的协程数。如果未提供，则默认为向量存储的全局设置。 TYPE: `int \| None` DEFAULT: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

注意

元数据文档属性所允许的字段名称必须遵守特定规则（例如：键不能以美元符号开头，也不能为空）。请参阅文档字段命名规则。

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

引发	描述
`AstraDBVectorStoreError`	如果并非所有文档都能被插入。

update_metadata ¶

update_metadata(
    id_to_metadata: dict[str, dict], *, overwrite_concurrency: int | None = None
) -> int

添加/覆盖现有文档的元数据。

对于每个要更新的文档，新的元数据字典将附加到现有的元数据上，覆盖已存在的单个键。

参数	描述
`id_to_metadata`	从要修改的文档 ID 到用于更新的新元数据的映射。此字典中不对应于现有文档的键将被静默忽略。此映射的值是用于更新文档的元数据字典。任何预先存在的元数据都将与这些条目合并，这些条目在逐个键的基础上具有优先权。类型： `dict[str, dict]`
`overwrite_concurrency`	用于处理更新的线程数。如果未提供，则默认为向量存储的全局设置。 TYPE: `int \| None` DEFAULT: `None`

返回	描述
`int`	成功更新的文档数量（即找到存在的文档，
`int`	因为即使使用 `{}` 作为新元数据的更新也算作成功。）

aupdate_metadata `async` ¶

aupdate_metadata(
    id_to_metadata: dict[str, dict], *, overwrite_concurrency: int | None = None
) -> int

添加/覆盖现有文档的元数据。

对于每个要更新的文档，新的元数据字典将附加到现有的元数据上，覆盖已存在的单个键。

参数	描述
`id_to_metadata`	从要修改的文档 ID 到用于更新的新元数据的映射。此字典中不对应于现有文档的键将被静默忽略。此映射的值是用于更新文档的元数据字典。任何预先存在的元数据都将与这些条目合并，这些条目在逐个键的基础上具有优先权。类型： `dict[str, dict]`
`overwrite_concurrency`	用于处理更新的异步任务数。如果未提供，则默认为向量存储的全局设置。 TYPE: `int \| None` DEFAULT: `None`

返回	描述
`int`	成功更新的文档数量（即找到存在的文档，
`int`	因为即使使用 `{}` 作为新元数据的更新也算作成功。）

full_decode_astra_db_found_document ¶

full_decode_astra_db_found_document(
    astra_db_document: DocDict,
) -> AstraDBQueryResult | None

完全解码一个 Astra DB 文档，即解码为 Document+embedding/similarity。

此操作返回一个独立于集合中所用编解码器的表示形式（而输入，一个“原始”的 Astra DB 文档，是依赖于编解码器的）。

根据用于检索它的查询的细节，输入的原始文档可以携带关于嵌入和相似度的信息。如果在结果中找不到这些信息，它们可以被设置为 None。

整个方法可以返回一个 None，以表示编解码器拒绝了转换（例如，因为输入文档被认为是有问题的）。

参数	描述
`astra_db_document`	通过对集合进行 `run_query_raw` 操作获得的字典。类型： `DocDict`

返回	描述
`AstraDBQueryResult \| None`	一个包含 Document、id、嵌入（如适用）和相似度（如适用）的 AstraDBQueryResult 命名元组，或者如果编解码器拒绝解码，则为整体的 None。

full_decode_astra_db_reranked_result ¶

full_decode_astra_db_reranked_result(
    astra_db_reranked_result: RerankedResult[DocDict],
) -> AstraDBQueryResult | None

完全解码一个 Astra DB 查找并重排的命中结果（Document+embedding/similarity）。

此操作返回一个独立于集合中所用编解码器的表示形式（而输入的“文档”部分，即来自 find-and-rerank 混合搜索的“原始”Astra DB 响应，是依赖于编解码器的）。

输入的原始文档是 astrapy 的 find_and_rerank 方法返回的内容，即一个 RerankedResult 对象的可迭代对象。缺失的条目（如嵌入）如果在结果中找不到，则被设置为 None。

整个方法可以返回一个 None，以表示编解码器拒绝了转换（例如，因为输入文档被认为是有问题的）。

参数	描述
`astra_db_reranked_result`	通过在集合上调用 `find_and_rerank` 方法获得的 RerankedResult。类型： `RerankedResult[DocDict]`

返回	描述
`AstraDBQueryResult \| None`	一个包含 Document、id、嵌入（如适用）和相似度（如适用）的 AstraDBQueryResult 命名元组，或者如果编解码器拒绝解码，则为整体的 None。

run_query_raw ¶

run_query_raw(
    *,
    n: int,
    ids: list[str] | None = None,
    filter: dict[str, Any] | None = None,
    sort: dict[str, Any] | None = None,
    include_similarity: bool | None = None,
    include_sort_vector: bool = False,
    include_embeddings: bool = False,
) -> tuple[list[float] | None, Iterable[DocDict]] | Iterable[DocDict]

在存储的文档上执行通用查询，返回 Astra DB 文档。

返回值的格式是可变的，取决于是否请求从服务器返回“排序向量”。

只有 `n` 参数是必需的。省略所有其他参数会导致查询匹配集合上找到的每一个文档。

该方法不直接公开投影，而是根据调用选项自动确定。

返回的文档与它们从 Astra DB 返回时完全一样（也考虑了投影）。需要进一步的步骤，即随后调用 `convert_astra_db_document` 方法，来重建独立于编解码器的 Document 对象。将检索和解码步骤分开的原因是，调用者可能希望首先去重/丢弃项目，以便只转换实际需要的项目。

参数	描述
`n`	要返回的项目数量。如果集合没有足够的匹配项，可能会返回少于 `n` 的项目。类型： `int`
`ids`	用于限制查询的文档 ID 列表。如果提供了此参数，则只有 ID 在所提供列表中的文档才会匹配。如果提供了进一步的查询筛选器（即元数据），匹配项必须同时满足这两个要求。类型: `list[str] \| None` 默认值: `None`
`filter`	元数据筛选部分。如果提供，它必须通过其裸名称引用元数据键（例如 `{"key": 123}`）。此筛选器可以使用“$or"/"$and”连接器组合嵌套条件，例如： - `{"tag": "a"}` - `{"$or": [{"tag": "a"}, "label": "b"]}` - `{"$and": [{"tag": {"$in": ["a", "z"]}}, "label": "b"]}` 类型: `dict[str, Any] \| None` 默认值: `None`
`sort`	查询的“排序”子句，例如 `{"$vector": [...]}`、`{"$vectorize": "..."}` 或 `{"mdkey": 1}`。元数据排序条件必须由其“裸”名称表示。类型: `dict[str, Any] \| None` 默认值: `None`
`include_similarity`	是否与每个匹配项一起返回相似度分数。需要向量排序。类型： `bool \| None` 默认值： `None`
`include_sort_vector`	是否在结果的可迭代对象旁边返回用于 ANN 搜索的查询向量。需要向量排序。请注意，返回值的形状取决于此参数。类型： `bool` 默认值： `False`
`include_embeddings`	是否检索匹配项自身的嵌入向量。类型： `bool` 默认值： `False`

返回	描述
`tuple[list[float] \| None, Iterable[DocDict]] \| Iterable[DocDict]`	返回值的形状取决于 `include_sort_vector` 的值。
`tuple[list[float] \| None, Iterable[DocDict]] \| Iterable[DocDict]`	如果 `include_sort_vector = False`，返回值是一个 Astra DB 文档（字典）的可迭代对象；
`tuple[list[float] \| None, Iterable[DocDict]] \| Iterable[DocDict]`	如果 `include_sort_vector = True`，返回值是一个包含 2 个项目的元组 `(sort_v, astra_db_ite)`，其中如果请求了排序向量，`sort_v` 是排序向量，如果不可用则为 None。 `astra_db_ite` 是一个 Astra DB 文档（字典）的可迭代对象。

run_query ¶

run_query(
    *,
    n: int,
    ids: list[str] | None = None,
    filter: dict[str, Any] | None = None,
    sort: dict[str, Any] | None = None,
    include_similarity: bool | None = None,
    include_sort_vector: bool = False,
    include_embeddings: bool = False,
) -> (
    tuple[list[float] | None, Iterable[AstraDBQueryResult]]
    | Iterable[AstraDBQueryResult]
)

在存储的文档上执行通用查询，返回 Documents+其他信息。

返回值的格式是可变的，取决于是否请求从服务器返回“排序向量”。

只有 `n` 参数是必需的。省略所有其他参数会导致查询匹配集合上找到的每一个文档。

该方法不直接公开投影，而是根据调用选项自动确定。

返回的 Document 对象是独立于编解码器的。

参数	描述
`n`	要返回的项目数量。在以下情况下可能会返回少于 `n` 的项目：(a) 解码跳过了来自服务器的一些原始条目；(b) 集合没有足够的匹配项。类型： `int`
`ids`	用于限制查询的文档 ID 列表。如果提供了此参数，则只有 ID 在所提供列表中的文档才会匹配。如果提供了进一步的查询筛选器（即元数据），匹配项必须同时满足这两个要求。类型: `list[str] \| None` 默认值: `None`
`filter`	元数据筛选部分。如果提供，它必须通过其裸名称引用元数据键（例如 `{"key": 123}`）。此筛选器可以使用“$or"/"$and”连接器组合嵌套条件，例如： - `{"tag": "a"}` - `{"$or": [{"tag": "a"}, "label": "b"]}` - `{"$and": [{"tag": {"$in": ["a", "z"]}}, "label": "b"]}` 类型: `dict[str, Any] \| None` 默认值: `None`
`sort`	查询的“排序”子句，例如 `{"$vector": [...]}`、`{"$vectorize": "..."}` 或 `{"mdkey": 1}`。元数据排序条件必须由其“裸”名称表示。类型: `dict[str, Any] \| None` 默认值: `None`
`include_similarity`	是否与每个匹配项一起返回相似度分数。需要向量排序。类型： `bool \| None` 默认值： `None`
`include_sort_vector`	是否在结果的可迭代对象旁边返回用于 ANN 搜索的查询向量。需要向量排序。请注意，返回值的形状取决于此参数。类型： `bool` 默认值： `False`
`include_embeddings`	是否检索匹配项自身的嵌入向量。类型： `bool` 默认值： `False`

返回	描述
`tuple[list[float] \| None, Iterable[AstraDBQueryResult]] \| Iterable[AstraDBQueryResult]`	返回值的形状取决于 `include_sort_vector` 的值。
`tuple[list[float] \| None, Iterable[AstraDBQueryResult]] \| Iterable[AstraDBQueryResult]`	如果 `include_sort_vector = False`，返回值是查询返回的 AstraDBQueryResult 项目的可迭代对象。任何解码失败的条目都将在查询后被丢弃，这可能导致返回的项目数量少于所请求的 `n`。
`tuple[list[float] \| None, Iterable[AstraDBQueryResult]] \| Iterable[AstraDBQueryResult]`	如果 `include_sort_vector = True`，返回值是一个包含 2 个项目的元组 `(sort_v, results_ite)`，其中如果请求了排序向量，`sort_v` 是排序向量，如果不可用则为 None。 `results_ite` 是如上所述的 AstraDBQueryResult 项目的可迭代对象。

arun_query_raw `async` ¶

arun_query_raw(
    *,
    n: int,
    ids: list[str] | None = None,
    filter: dict[str, Any] | None = None,
    sort: dict[str, Any] | None = None,
    include_similarity: bool | None = None,
    include_sort_vector: bool = False,
    include_embeddings: bool = False,
) -> tuple[list[float] | None, AsyncIterable[DocDict]] | AsyncIterable[DocDict]

在存储的文档上执行通用查询，返回 Astra DB 文档。

返回值的格式是可变的，取决于是否请求从服务器返回“排序向量”。

只有 `n` 参数是必需的。省略所有其他参数会导致查询匹配集合上找到的每一个文档。

该方法不直接公开投影，而是根据调用选项自动确定。

返回的文档与它们从 Astra DB 返回时完全一样（也考虑了投影）。需要进一步的步骤，即随后调用 `convert_astra_db_document` 方法，来重建独立于编解码器的 Document 对象。将检索和解码步骤分开的原因是，调用者可能希望首先去重/丢弃项目，以便只转换实际需要的项目。

参数	描述
`n`	要返回的项目数量。在以下情况下可能会返回少于 `n` 的项目：(a) 解码跳过了来自服务器的一些原始条目；(b) 集合没有足够的匹配项。类型： `int`
`ids`	用于限制查询的文档 ID 列表。如果提供了此参数，则只有 ID 在所提供列表中的文档才会匹配。如果提供了进一步的查询筛选器（即元数据），匹配项必须同时满足这两个要求。类型: `list[str] \| None` 默认值: `None`
`filter`	元数据筛选部分。如果提供，它必须通过其裸名称引用元数据键（例如 `{"key": 123}`）。此筛选器可以使用“$or"/"$and”连接器组合嵌套条件，例如： - `{"tag": "a"}` - `{"$or": [{"tag": "a"}, "label": "b"]}` - `{"$and": [{"tag": {"$in": ["a", "z"]}}, "label": "b"]}` 类型: `dict[str, Any] \| None` 默认值: `None`
`sort`	查询的“排序”子句，例如 `{"$vector": [...]}`、`{"$vectorize": "..."}` 或 `{"mdkey": 1}`。元数据排序条件必须由其“裸”名称表示。类型: `dict[str, Any] \| None` 默认值: `None`
`include_similarity`	是否与每个匹配项一起返回相似度分数。需要向量排序。类型： `bool \| None` 默认值： `None`
`include_sort_vector`	是否在结果的可迭代对象旁边返回用于 ANN 搜索的查询向量。需要向量排序。请注意，返回值的形状取决于此参数。类型： `bool` 默认值： `False`
`include_embeddings`	是否检索匹配项自身的嵌入向量。类型： `bool` 默认值： `False`

返回	描述
`tuple[list[float] \| None, AsyncIterable[DocDict]] \| AsyncIterable[DocDict]`	返回值的形状取决于 `include_sort_vector` 的值。
`tuple[list[float] \| None, AsyncIterable[DocDict]] \| AsyncIterable[DocDict]`	如果 `include_sort_vector = False`，返回值是一个 Astra DB 文档（字典）的可迭代对象；
`tuple[list[float] \| None, AsyncIterable[DocDict]] \| AsyncIterable[DocDict]`	如果 `include_sort_vector = True`，返回值是一个包含 2 个项目的元组 `(sort_v, astra_db_ite)`，其中如果请求了排序向量，`sort_v` 是排序向量，如果不可用则为 None。 `astra_db_ite` 是一个 Astra DB 文档（字典）的可迭代对象。

arun_query `async` ¶

arun_query(
    *,
    n: int,
    ids: list[str] | None = None,
    filter: dict[str, Any] | None = None,
    sort: dict[str, Any] | None = None,
    include_similarity: bool | None = None,
    include_sort_vector: bool = False,
    include_embeddings: bool = False,
) -> (
    tuple[list[float] | None, AsyncIterable[AstraDBQueryResult]]
    | AsyncIterable[AstraDBQueryResult]
)

在存储的文档上执行通用查询，返回 Documents+其他信息。

返回值的格式是可变的，取决于是否请求从服务器返回“排序向量”。

只有 `n` 参数是必需的。省略所有其他参数会导致查询匹配集合上找到的每一个文档。

该方法不直接公开投影，而是根据调用选项自动确定。

返回的 Document 对象是独立于编解码器的。

参数	描述
`n`	要返回的项目数量。如果集合没有足够的匹配项，可能会返回少于 `n` 的项目。类型： `int`
`ids`	用于限制查询的文档 ID 列表。如果提供了此参数，则只有 ID 在所提供列表中的文档才会匹配。如果提供了进一步的查询筛选器（即元数据），匹配项必须同时满足这两个要求。类型: `list[str] \| None` 默认值: `None`
`filter`	元数据筛选部分。如果提供，它必须通过其裸名称引用元数据键（例如 `{"key": 123}`）。此筛选器可以使用“$or"/"$and”连接器组合嵌套条件，例如： - `{"tag": "a"}` - `{"$or": [{"tag": "a"}, "label": "b"]}` - `{"$and": [{"tag": {"$in": ["a", "z"]}}, "label": "b"]}` 类型: `dict[str, Any] \| None` 默认值: `None`
`sort`	查询的“排序”子句，例如 `{"$vector": [...]}`、`{"$vectorize": "..."}` 或 `{"mdkey": 1}`。元数据排序条件必须由其“裸”名称表示。类型: `dict[str, Any] \| None` 默认值: `None`
`include_similarity`	是否与每个匹配项一起返回相似度分数。需要向量排序。类型： `bool \| None` 默认值： `None`
`include_sort_vector`	是否在结果的可迭代对象旁边返回用于 ANN 搜索的查询向量。需要向量排序。请注意，返回值的形状取决于此参数。类型： `bool` 默认值： `False`
`include_embeddings`	是否检索匹配项自身的嵌入向量。类型： `bool` 默认值： `False`

返回	描述
`tuple[list[float] \| None, AsyncIterable[AstraDBQueryResult]] \| AsyncIterable[AstraDBQueryResult]`	返回值的形状取决于 `include_sort_vector` 的值。
`tuple[list[float] \| None, AsyncIterable[AstraDBQueryResult]] \| AsyncIterable[AstraDBQueryResult]`	如果 `include_sort_vector = False`，返回值是查询返回的 AstraDBQueryResult 项目的可迭代对象。任何解码失败的条目都将在查询后被丢弃，这可能导致返回的项目数量少于所请求的 `n`。
`tuple[list[float] \| None, AsyncIterable[AstraDBQueryResult]] \| AsyncIterable[AstraDBQueryResult]`	如果 `include_sort_vector = True`，返回值是一个包含 2 个项目的元组 `(sort_v, results_ite)`，其中如果请求了排序向量，`sort_v` 是排序向量，如果不可用则为 None。 `results_ite` 是如上所述的 AstraDBQueryResult 项目的可迭代对象。

metadata_search ¶

metadata_search(filter: dict[str, Any] | None = None, n: int = 5) -> list[Document]

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

参数	描述
`filter`	要查询的元数据。类型: `dict[str, Any] \| None` 默认值: `None`
`n`	要返回的最大文档数。类型： `int` 默认值： `5`

返回	描述
`list[Document]`	找到的文档。

ametadata_search `async` ¶

ametadata_search(
    filter: dict[str, Any] | None = None, n: int = 5
) -> Iterable[Document]

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

参数	描述
`filter`	要查询的元数据。类型: `dict[str, Any] \| None` 默认值: `None`
`n`	要返回的最大文档数。类型： `int` 默认值： `5`

返回	描述
`Iterable[Document]`	找到的文档。

get_by_document_id ¶

get_by_document_id(document_id: str) -> Document | None

给定文档 ID，从存储中检索单个文档。

参数	描述
`document_id`	文档 ID 类型： `str`

返回	描述
`Document \| None`	如果文档存在，则返回该文档。否则返回 None。

aget_by_document_id `async` ¶

aget_by_document_id(document_id: str) -> Document | None

给定文档 ID，从存储中检索单个文档。

参数	描述
`document_id`	文档 ID 类型： `str`

返回	描述
`Document \| None`	如果文档存在，则返回该文档。否则返回 None。

get_by_ids ¶

get_by_ids(
    ids: Sequence[str],
    /,
    batch_size: int | None = None,
    batch_concurrency: int | None = None,
) -> list[Document]

根据 ID 获取文档。

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

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

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

参数	描述
`ids`	要检索的 ID 列表。类型： `Sequence[str]`
`batch_size`	如果请求了许多 ID，这些 ID 将被分成块，并运行和整理多个请求。此参数设置每个此类 ID 块的大小。默认值为 80。数据库设置了 100 的硬性限制。 TYPE: `int \| None` DEFAULT: `None`
`batch_concurrency`	如果需要，用于执行多个请求的线程数。默认值为 20。 TYPE: `int \| None` DEFAULT: `None`

返回	描述
`list[Document]`	文档列表。

get_by_document_ids ¶

get_by_document_ids(
    ids: Sequence[str],
    /,
    batch_size: int | None = None,
    batch_concurrency: int | None = None,
) -> list[Document]

根据 ID 获取文档。

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

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

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

参数	描述
`ids`	要检索的 ID 列表。类型： `Sequence[str]`
`batch_size`	如果请求了许多 ID，这些 ID 将被分成块，并运行和整理多个请求。此参数设置每个此类 ID 块的大小。默认值为 80。数据库设置了 100 的硬性限制。 TYPE: `int \| None` DEFAULT: `None`
`batch_concurrency`	如果需要，用于执行多个请求的线程数。默认值为 20。 TYPE: `int \| None` DEFAULT: `None`

返回	描述
`list[Document]`	文档列表。

aget_by_ids `async` ¶

aget_by_ids(
    ids: Sequence[str],
    /,
    batch_size: int | None = None,
    batch_concurrency: int | None = None,
) -> list[Document]

根据 ID 获取文档。

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

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

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

参数	描述
`ids`	要检索的 ID 列表。类型： `Sequence[str]`
`batch_size`	如果请求了许多 ID，这些 ID 将被分成块，并运行和整理多个请求。此参数设置每个此类 ID 块的大小。默认值为 80。数据库设置了 100 的硬性限制。 TYPE: `int \| None` DEFAULT: `None`
`batch_concurrency`	如果需要，用于执行多个请求的线程数。默认值为 20。 TYPE: `int \| None` DEFAULT: `None`

返回	描述
`list[Document]`	文档列表。

aget_by_document_ids `async` ¶

aget_by_document_ids(
    ids: Sequence[str],
    /,
    batch_size: int | None = None,
    batch_concurrency: int | None = None,
) -> list[Document]

根据 ID 获取文档。

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

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

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

参数	描述
`ids`	要检索的 ID 列表。类型： `Sequence[str]`
`batch_size`	如果请求了许多 ID，这些 ID 将被分成块，并运行和整理多个请求。此参数设置每个此类 ID 块的大小。默认值为 80。数据库设置了 100 的硬性限制。 TYPE: `int \| None` DEFAULT: `None`
`batch_concurrency`	如果需要，用于执行多个请求的线程数。默认值为 20。 TYPE: `int \| None` DEFAULT: `None`

返回	描述
`list[Document]`	文档列表。

similarity_search ¶

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

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

参数	描述
`query`	用于查找相似文档的查询。类型： `str`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`lexical_query`	对于混合搜索，这是检索的词法部分的特定查询。如果省略或为空，则默认为与“query”相同。如果在非混合搜索上传递，则会引发错误。类型: `str \| None` 默认值: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

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

similarity_search_with_score ¶

similarity_search_with_score(
    query: str,
    k: int = 4,
    filter: dict[str, Any] | None = None,
    lexical_query: str | None = None,
) -> list[tuple[Document, float]]

返回与查询最相似且带有分数的文档。

参数	描述
`query`	用于查找相似文档的查询。类型： `str`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`lexical_query`	对于混合搜索，这是检索的词法部分的特定查询。如果省略或为空，则默认为与“query”相同。如果在非混合搜索上传递，则会引发错误。类型: `str \| None` 默认值: `None`

返回	描述
`list[tuple[Document, float]]`	与查询向量最相似的（文档，分数）列表。

similarity_search_with_score_id ¶

similarity_search_with_score_id(
    query: str,
    k: int = 4,
    filter: dict[str, Any] | None = None,
    lexical_query: str | None = None,
) -> list[tuple[Document, float, str]]

返回与查询最相似且带有分数和 ID 的文档。

参数	描述
`query`	用于查找相似文档的查询。类型： `str`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`lexical_query`	对于混合搜索，这是检索的词法部分的特定查询。如果省略或为空，则默认为与“query”相同。如果在非混合搜索上传递，则会引发错误。类型: `str \| None` 默认值: `None`

返回	描述
`list[tuple[Document, float, str]]`	与查询最相似的（文档，分数，ID）列表。

similarity_search_by_vector ¶

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

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

参数	描述
`embedding`	用于查找相似文档的嵌入。类型： `list[float]`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

返回	描述
`list[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
) -> list[tuple[Document, float]]

返回与嵌入向量最相似且带有分数的文档。

参数	描述
`embedding`	用于查找相似文档的嵌入。类型： `list[float]`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`

返回	描述
`list[tuple[Document, float]]`	与查询向量最相似的（文档，分数）列表。

similarity_search_with_score_id_by_vector ¶

similarity_search_with_score_id_by_vector(
    embedding: list[float], k: int = 4, filter: dict[str, Any] | None = None
) -> list[tuple[Document, float, str]]

返回与嵌入向量最相似且带有分数和 ID 的文档。

参数	描述
`embedding`	用于查找相似文档的嵌入。类型： `list[float]`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`

返回	描述
`list[tuple[Document, float, str]]`	与查询向量最相似的（文档，分数，ID）列表。

引发	描述
`ValueError`	如果向量存储使用服务器端嵌入。

asimilarity_search `async` ¶

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

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

参数	描述
`query`	用于查找相似文档的查询。类型： `str`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`lexical_query`	对于混合搜索，这是检索的词法部分的特定查询。如果省略或为空，则默认为与“query”相同。如果在非混合搜索上传递，则会引发错误。类型: `str \| None` 默认值: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

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

asimilarity_search_with_score `async` ¶

asimilarity_search_with_score(
    query: str,
    k: int = 4,
    filter: dict[str, Any] | None = None,
    lexical_query: str | None = None,
) -> list[tuple[Document, float]]

返回与查询最相似且带有分数的文档。

参数	描述
`query`	用于查找相似文档的查询。类型： `str`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`lexical_query`	对于混合搜索，这是检索的词法部分的特定查询。如果省略或为空，则默认为与“query”相同。如果在非混合搜索上传递，则会引发错误。类型: `str \| None` 默认值: `None`

返回	描述
`list[tuple[Document, float]]`	与查询向量最相似的（文档，分数）列表。

asimilarity_search_with_score_id `async` ¶

asimilarity_search_with_score_id(
    query: str,
    k: int = 4,
    filter: dict[str, Any] | None = None,
    lexical_query: str | None = None,
) -> list[tuple[Document, float, str]]

返回与查询最相似且带有分数和 ID 的文档。

参数	描述
`query`	用于查找相似文档的查询。类型： `str`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`lexical_query`	对于混合搜索，这是检索的词法部分的特定查询。如果省略或为空，则默认为与“query”相同。如果在非混合搜索上传递，则会引发错误。类型: `str \| None` 默认值: `None`

返回	描述
`list[tuple[Document, float, str]]`	与查询最相似的（文档，分数，ID）列表。

asimilarity_search_by_vector `async` ¶

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

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

参数	描述
`embedding`	用于查找相似文档的嵌入。类型： `list[float]`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

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

asimilarity_search_with_score_by_vector `async` ¶

asimilarity_search_with_score_by_vector(
    embedding: list[float], k: int = 4, filter: dict[str, Any] | None = None
) -> list[tuple[Document, float]]

返回与嵌入向量最相似且带有分数的文档。

参数	描述
`embedding`	用于查找相似文档的嵌入。类型： `list[float]`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`

返回	描述
`list[tuple[Document, float]]`	与查询向量最相似的（文档，分数）列表。

asimilarity_search_with_score_id_by_vector `async` ¶

asimilarity_search_with_score_id_by_vector(
    embedding: list[float], k: int = 4, filter: dict[str, Any] | None = None
) -> list[tuple[Document, float, str]]

返回与嵌入向量最相似且带有分数和 ID 的文档。

参数	描述
`embedding`	用于查找相似文档的嵌入。类型： `list[float]`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`

返回	描述
`list[tuple[Document, float, str]]`	与查询向量最相似的（文档，分数，ID）列表。

引发	描述
`ValueError`	如果向量存储使用服务器端嵌入。

similarity_search_with_embedding_by_vector ¶

similarity_search_with_embedding_by_vector(
    embedding: list[float], k: int = 4, filter: dict[str, Any] | None = None
) -> list[tuple[Document, list[float]]]

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

参数	描述
`embedding`	用于查找相似文档的嵌入。类型： `list[float]`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`

返回	描述
`list[tuple[Document, list[float]]]`	（查询嵌入向量，（文档，嵌入）列表，
`list[tuple[Document, list[float]]]`	与查询向量最相似的。）。

asimilarity_search_with_embedding_by_vector `async` ¶

asimilarity_search_with_embedding_by_vector(
    embedding: list[float], k: int = 4, filter: dict[str, Any] | None = None
) -> list[tuple[Document, list[float]]]

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

参数	描述
`embedding`	用于查找相似文档的嵌入。类型： `list[float]`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`

返回	描述
`list[tuple[Document, list[float]]]`	（查询嵌入向量，（文档，嵌入）列表，
`list[tuple[Document, list[float]]]`	与查询向量最相似的。）。

similarity_search_with_embedding ¶

similarity_search_with_embedding(
    query: str, k: int = 4, filter: dict[str, Any] | None = None
) -> tuple[list[float], list[tuple[Document, list[float]]]]

返回与查询最相似且带有嵌入的文档。

还包括查询嵌入向量。

参数	描述
`query`	用于查找相似文档的查询。类型： `str`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`

返回	描述
`list[float]`	（查询嵌入向量，（文档，嵌入）列表，
`list[tuple[Document, list[float]]]`	与查询向量最相似的。）。

asimilarity_search_with_embedding `async` ¶

asimilarity_search_with_embedding(
    query: str, k: int = 4, filter: dict[str, Any] | None = None
) -> tuple[list[float], list[tuple[Document, list[float]]]]

返回与查询最相似且带有嵌入的文档。

还包括查询嵌入向量。

参数	描述
`query`	用于查找相似文档的查询。类型： `str`
`k`	要返回的文档数量。默认为 4。 TYPE: `int` DEFAULT: `4`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`

返回	描述
`list[float]`	（查询嵌入向量，（文档，嵌入）列表，
`list[tuple[Document, list[float]]]`	与查询向量最相似的。）。

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,
    filter: dict[str, Any] | None = None,
    **kwargs: Any,
) -> list[Document]

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

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

参数	描述
`embedding`	用于查找相似文档的嵌入。类型： `list[float]`
`k`	要返回的文档数量。 TYPE: `int` DEFAULT: `4`
`fetch_k`	要获取以传递给 MMR 算法的文档数量。类型： `int` 默认值： `20`
`lambda_mult`	一个介于 0 和 1 之间的数字，用于确定结果之间的多样性程度，其中 0 对应最大多样性，1 对应最小多样性。类型： `float` 默认值： `0.5`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

返回	描述
`list[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,
    filter: dict[str, Any] | None = None,
    **kwargs: Any,
) -> list[Document]

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

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

参数	描述
`embedding`	用于查找相似文档的嵌入。类型： `list[float]`
`k`	要返回的文档数量。 TYPE: `int` DEFAULT: `4`
`fetch_k`	要获取以传递给 MMR 算法的文档数量。类型： `int` 默认值： `20`
`lambda_mult`	一个介于 0 和 1 之间的数字，用于确定结果之间的多样性程度，其中 0 对应最大多样性，1 对应最小多样性。类型： `float` 默认值： `0.5`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

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

max_marginal_relevance_search ¶

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

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

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

参数	描述
`query`	用于查找相似文档的查询。类型： `str`
`k`	要返回的文档数量。 TYPE: `int` DEFAULT: `4`
`fetch_k`	要获取以传递给 MMR 算法的文档数量。类型： `int` 默认值： `20`
`lambda_mult`	一个介于 0 和 1 之间的数字，用于确定结果之间的多样性程度，其中 0 对应最大多样性，1 对应最小多样性。类型： `float` 默认值： `0.5`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

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

amax_marginal_relevance_search `async` ¶

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

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

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

参数	描述
`query`	用于查找相似文档的查询。类型： `str`
`k`	要返回的文档数量。 TYPE: `int` DEFAULT: `4`
`fetch_k`	要获取以传递给 MMR 算法的文档数量。类型： `int` 默认值： `20`
`lambda_mult`	一个介于 0 和 1 之间的数字，用于确定结果之间的多样性程度，其中 0 对应最大多样性，1 对应最小多样性。类型： `float` 默认值： `0.5`
`filter`	要应用的元数据筛选器。类型: `dict[str, Any] \| None` 默认值: `None`
`**kwargs`	其他参数将被忽略。类型： `Any` 默认值： `{}`

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

from_texts `classmethod` ¶

from_texts(
    texts: Iterable[str],
    embedding: Embeddings | None = None,
    metadatas: Iterable[dict] | None = None,
    ids: Iterable[str | None] | None = None,
    **kwargs: Any,
) -> AstraDBVectorStore

从原始文本创建 Astra DB 向量存储。

参数	描述
`texts`	要插入的文本。类型： `Iterable[str]`
`embedding`	在存储中使用的嵌入函数。 TYPE: `Embeddings \| None` DEFAULT: `None`
`metadatas`	文本的元数据字典。类型： `Iterable[dict] \| None` 默认值： `None`
`ids`	与文本关联的 ID。类型： `Iterable[str \| None] \| None` 默认值： `None`
`**kwargs`	您可以传递任何您会传递给 `add_texts` 和/或 `AstraDBVectorStore` 构造函数的参数（详见这些方法）。这些参数将按原样路由到各自的方法。类型： `Any` 默认值： `{}`

返回	描述
`AstraDBVectorStore`	一个 `AstraDBVectorStore` 向量存储。

afrom_texts `async` `classmethod` ¶

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

从原始文本创建 Astra DB 向量存储。

参数	描述
`texts`	要插入的文本。类型： `Iterable[str]`
`embedding`	要使用的嵌入函数。 TYPE: `Embeddings \| None` DEFAULT: `None`
`metadatas`	文本的元数据字典。类型： `Iterable[dict] \| None` 默认值： `None`
`ids`	与文本关联的 ID。类型： `Iterable[str \| None] \| None` 默认值： `None`
`**kwargs`	您可以传递任何您会传递给 `aadd_texts` 和/或 `AstraDBVectorStore` 构造函数的参数（详见这些方法）。这些参数将按原样路由到各自的方法。类型： `Any` 默认值： `{}`

返回	描述
`AstraDBVectorStore`	一个 `AstraDBVectorStore` 向量存储。

from_documents `classmethod` ¶

from_documents(
    documents: Iterable[Document], embedding: Embeddings | None = None, **kwargs: Any
) -> AstraDBVectorStore

从文档列表创建 Astra DB 向量存储。

一个实用方法，它会调用 from_texts。

参数	描述
`documents`	要在存储中插入的 `Document` 对象列表。类型： `Iterable[Document]`
`embedding`	在存储中使用的嵌入函数。 TYPE: `Embeddings \| None` DEFAULT: `None`
`**kwargs`	您可以传递任何您会传递给 `add_texts` 和/或 `AstraDBVectorStore` 构造函数的参数（详见这些方法）。这些参数将按原样路由到各自的方法。类型： `Any` 默认值： `{}`

返回	描述
`AstraDBVectorStore`	一个 `AstraDBVectorStore` 向量存储。

afrom_documents `async` `classmethod` ¶

afrom_documents(
    documents: Iterable[Document], embedding: Embeddings | None = None, **kwargs: Any
) -> AstraDBVectorStore

从文档列表创建 Astra DB 向量存储。

一个实用方法，它会调用 afrom_texts。

参数	描述
`documents`	要在存储中插入的 `Document` 对象列表。类型： `Iterable[Document]`
`embedding`	在存储中使用的嵌入函数。 TYPE: `Embeddings \| None` DEFAULT: `None`
`**kwargs`	您可以传递任何您会传递给 `aadd_texts` 和/或 `AstraDBVectorStore` 构造函数的参数（详见这些方法）。这些参数将按原样路由到各自的方法。类型： `Any` 默认值： `{}`

返回	描述
`AstraDBVectorStore`	一个 `AstraDBVectorStore` 向量存储。

AstraDBVectorStoreError ¶

基类： Exception

向量存储活动期间的异常。

此异常表示在 AstraDBVectorStore 中执行操作时发生的任何操作性异常。

langchain-astradb¶