langchain-db2

langchain_db2

DB2VS

Bases: VectorStore

DB2VS 向量存储。

参数	描述
embedding_function	用于为存储的文本和查询生成向量的嵌入后端 类型： Callable[[str], list[float]] | Embeddings
table_name	DB2 表名 类型： str
client	现有的 DB2 连接。如果未提供 connection_args，则为必需项 类型： Connection | None 默认值： None
distance_strategy	Db2 VECTOR_DISTANCE 在对结果进行排名时使用的相似性度量 类型： DistanceStrategy 默认值： EUCLIDEAN_DISTANCE
query	用于推断嵌入维度的探测文本，仅使用一次 类型： str | None 默认值： 'What is a Db2 database'
params	额外选项 类型: dict[str, Any] | None 默认值: None
connection_args	当未提供 client 时使用的连接参数。预期的键：{"database": str, "host": str, "port": str, "username": str, "password": str, "security": bool} 类型: dict[str, Any] | None 默认值: None
text_field	原始文本 (CLOB) 的列名 类型： str 默认： 'text'

设置

要使用它，您应该具备

• 已安装 langchain_db2 Python 包
• 与支持向量存储功能的 Db2 数据库 (v12.1.2+) 的连接

pip install -U langchain-db2

# or using uv
uv add langchain-db2

实例化

使用 ibm_db_dbi.Connection 对象创建向量存储实例

from langchain_db2 import DB2VS

db2vs = DB2VS(
    embedding_function=embeddings, table_name=table_name, client=db_client
)

使用 connection_args 创建向量存储实例

from langchain_db2 import DB2VS

db2vs = DB2VS(
    embedding_function=embeddings,
    table_name=table_name,
    connection_args={
        "database": "<DATABASE>",
        "host": "<HOST>",
        "port": "<PORT>",
        "username": "<USERNAME>",
        "password": "<PASSWORD>",
        "security": False,
    },
)

方法	描述
get_by_ids	根据 ID 获取文档。
aget_by_ids	通过 ID 异步获取文档。
adelete	按向量 ID 或其他条件异步删除。
aadd_texts	通过嵌入异步运行更多文本并添加到 `VectorStore`。
add_documents	在 `VectorStore` 中添加或更新文档。
aadd_documents	异步运行更多文档通过嵌入并添加到 `VectorStore`。
search	使用指定的搜索类型返回与查询最相似的文档。
asearch	异步返回与查询最相似的文档，使用指定的搜索类型。
asimilarity_search_with_score	异步运行带距离的相似性搜索。
similarity_search_with_relevance_scores	返回文档和在 `[0, 1]` 范围内的相关性分数。
asimilarity_search_with_relevance_scores	异步返回文档和在 `[0, 1]` 范围内的相关性分数。
asimilarity_search	异步返回与查询最相似的文档。
asimilarity_search_by_vector	异步返回与嵌入向量最相似的文档。
amax_marginal_relevance_search	异步返回使用最大边际相关性选择的文档。
amax_marginal_relevance_search_by_vector	异步返回使用最大边际相关性选择的文档。
from_documents	返回从文档和嵌入初始化的 `VectorStore`。
afrom_documents	异步返回从文档和嵌入初始化的 `VectorStore`。
afrom_texts	异步返回从文本和嵌入初始化的 `VectorStore`。
as_retriever	返回从此 `VectorStore` 初始化的 `VectorStoreRetriever`。
__init__	DB2VS 向量存储。
get_embedding_dimension	通过将单个文档包装在列表中来嵌入该文档。
add_texts	向向量存储中添加更多文本。
similarity_search	返回与查询最相似的文档。
similarity_search_by_vector	返回与查询嵌入最相似的文档。
similarity_search_with_score	返回与文本查询最相似的前 k 个文档，并附带分数。
similarity_search_by_vector_with_relevance_scores	返回查询嵌入的前 k 个文档，并附带相关性分数。
similarity_search_by_vector_returning_embeddings	返回前 k 个文档、它们的距离以及存储的嵌入。
max_marginal_relevance_search_with_score_by_vector	返回选定的文档及其相似性分数。
max_marginal_relevance_search_by_vector	返回使用最大边际相关性选择的文档。
max_marginal_relevance_search	返回使用最大边际相关性选择的文档。
delete	按向量 ID 删除。
from_texts	返回从文本和嵌入初始化的向量存储。
get_pks	获取主键，可选地通过表达式进行筛选。

embeddings 属性

embeddings: Embeddings | None

返回 Embeddings 实例的属性。

返回	描述
Embeddings | None	如果 embedding_function 是 Embeddings 的实例，则返回 Embeddings 实例，否则返回 None

get_by_ids

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

根据 ID 获取文档。

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

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

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

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

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

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

aget_by_ids 异步

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

通过 ID 异步获取文档。

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

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

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

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

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

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

adelete 异步

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

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

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

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

aadd_texts 异步

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

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

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

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

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

add_documents

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

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

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

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

aadd_documents 异步

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 异步

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

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

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

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

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

asimilarity_search_with_score 异步

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

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

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

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

similarity_search_with_relevance_scores

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

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

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

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

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

asimilarity_search_with_relevance_scores 异步

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

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

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

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

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

asimilarity_search 异步

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

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

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

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

asimilarity_search_by_vector 异步

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

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

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

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

amax_marginal_relevance_search 异步

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

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

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

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

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

amax_marginal_relevance_search_by_vector 异步

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

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

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

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

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

from_documents 类方法

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

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

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

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

afrom_documents 异步 类方法

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

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

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

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

afrom_texts 异步 类方法

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

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

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

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

as_retriever

as_retriever(**kwargs: Any) -> VectorStoreRetriever

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

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

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

示例

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

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

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

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

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

__init__

__init__(
    embedding_function: Callable[[str], list[float]] | Embeddings,
    table_name: str,
    client: Connection | None = None,
    distance_strategy: DistanceStrategy = EUCLIDEAN_DISTANCE,
    query: str | None = "What is a Db2 database",
    params: dict[str, Any] | None = None,
    connection_args: dict[str, Any] | None = None,
    text_field: str = "text",
)

DB2VS 向量存储。

get_embedding_dimension

get_embedding_dimension() -> int

通过将单个文档包装在列表中来嵌入该文档。

add_texts

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

向向量存储中添加更多文本。

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

返回	描述
list[str]	将文本添加到向量存储后生成的 ID 列表

similarity_search

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

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

参数	描述
query	要搜索的自然语言文本 类型： str
k	要返回的文档数量 TYPE: int DEFAULT: 4
filter	按元数据筛选 类型: dict[str, Any] | None 默认值: None
kwargs	其他关键字参数 类型： Any 默认值： {}

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

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	要返回的文档数量 TYPE: int DEFAULT: 4
filter	按元数据筛选 类型: dict[str, Any] | 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, **kwargs: Any
) -> list[tuple[Document, float]]

返回与文本查询最相似的前 k 个文档，并附带分数。

参数	描述
query	用于嵌入和搜索的自然语言查询 类型： str
k	要返回的结果数量 TYPE: int DEFAULT: 4
filter	按元数据筛选 类型: dict[str, Any] | None 默认值: None
kwargs	其他关键字参数 类型： Any 默认值： {}

返回	描述
list[tuple[Document, float]]	按相似性排序的 (文档, 分数) 对列表。分数是向量**距离**；值越低表示匹配越接近。

similarity_search_by_vector_with_relevance_scores

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

返回查询嵌入的前 k 个文档，并附带相关性分数。

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

返回	描述
list[tuple[Document, float]]	一个 (Document, distance) 对的列表，按从最相似到最不相似的顺序排列（距离最小的在前）。

similarity_search_by_vector_returning_embeddings

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

返回前 k 个文档、它们的距离以及存储的嵌入。

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

返回	描述
list[tuple[Document, float, ndarray]]	(文档, 距离, 嵌入数组) 的元组，按从最相似到最不相似的顺序排列（距离升序）

max_marginal_relevance_search_with_score_by_vector

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

返回选定的文档及其相似性分数。

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

参数	描述
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

返回	描述
list[tuple[Document, 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]	由最大边际相关性选择的文档列表

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]	由最大边际相关性选择的文档列表

max_marginal_relevance_search 要求 query 返回匹配的嵌入以及匹配的文档。

delete

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

按向量 ID 删除。

参数	描述
ids	要删除的 ID 列表 类型: list[str] | None 默认值: None
kwargs	其他关键字参数 类型： Any 默认值： {}

from_texts 类方法

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

返回从文本和嵌入初始化的向量存储。

参数	描述
texts	要添加到向量存储的字符串的可迭代对象 类型： Iterable[str]
embedding	用于查找相似文档的嵌入 TYPE: Embeddings
metadatas	与文本关联的元数据可选列表 类型： list[dict] | None 默认值： None
kwargs	其他关键字参数 类型： Any 默认值： {}

返回	描述
DB2VS	一个已加载所提供文本的、即用型向量存储

get_pks

get_pks(expr: str | None = None) -> list[str]

获取主键，可选地通过表达式进行筛选。

参数	描述
expr	用于筛选行的 SQL 布尔表达式，例如：id IN ('ABC123','DEF456') 或 title LIKE 'Abc%'。如果为 None，则返回所有行。 类型: str | None 默认值: None

返回	描述
list[str]	匹配的主键值列表。