`langchain_community.vectorstores.marqo`.Marqo¶

class langchain_community.vectorstores.marqo.Marqo(client: marqo.Client, index_name: str, add_documents_settings: Optional[Dict[str, Any]] = None, searchable_attributes: Optional[List[str]] = None, page_content_builder: Optional[Callable[[Dict[str, Any]], str]] = None)[source]¶

`Marqo`向量存储。

Marqo索引具有与之关联的自己的模型，用于生成您的嵌入。这意味着您可以从一系列不同的模型中进行选择，还可以使用CLIP模型创建多模态索引，将图像和文本结合在一起。

Marqo还支持使用多个加权项进行更高级的查询，请参见https://docs.marqo.ai/latest/#searching-using-weights-in-queries。此类可以在其相似性搜索方法中灵活地接受字符串或字典作为加权查询。

要使用，您应该安装`marqo` python包，可以使用`pip install marqo`来实现。

示例:

import marqo
from langchain_community.vectorstores import Marqo
client = marqo.Client(url=os.environ["MARQO_URL"], ...)
vectorstore = Marqo(client, index_name)

使用Marqo客户端进行初始化。

Attributes

embeddings

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

Methods

`__init__`(client, index_name[, ...])	使用Marqo客户端进行初始化。
`aadd_documents`(documents, **kwargs)	运行更多的文档通过嵌入并添加到向量存储中。
`aadd_texts`(texts[, metadatas])	运行更多的文本通过嵌入，并添加到向量存储中。
`add_documents`(documents, **kwargs)	运行更多的文档通过嵌入并添加到向量存储中。
`add_texts`(texts[, metadatas])	将带有元数据（属性）的文本上传到Marqo。
`adelete`([ids])	根据向量ID或其他条件进行删除。
`afrom_documents`(documents, embedding, **kwargs)	返回从文档和嵌入初始化的VectorStore。
`afrom_texts`(texts, embedding[, metadatas])	返回从文本和嵌入初始化的VectorStore。
`amax_marginal_relevance_search`(query[, k, ...])	返回使用最大边际相关性选择的文档。
`amax_marginal_relevance_search_by_vector`(...)	返回使用最大边际相关性选择的文档。
`as_retriever`(**kwargs)	返回从此VectorStore初始化的VectorStoreRetriever。
`asearch`(query, search_type, **kwargs)	返回使用指定搜索类型的查询最相似的文档。
`asimilarity_search`(query[, k])	返回与查询最相似的文档。
`asimilarity_search_by_vector`(embedding[, k])	返回与嵌入向量最相似的文档。
`asimilarity_search_with_relevance_scores`(query)	返回文档和相关性分数在范围[0, 1]内，异步执行。
`asimilarity_search_with_score`(args, *kwargs)	使用异步方式运行相似性搜索与距离。
`bulk_similarity_search`(queries[, k])	在marqo索引中使用多个查询批量搜索最相似的文档。
`bulk_similarity_search_with_score`(queries[, k])	返回与Marqo中的查询相似的文档以及它们的分数，使用一批查询。
`delete`([ids])	根据向量ID或其他条件进行删除。
`from_documents`(documents[, embedding])	从文档初始化的VectorStore。请注意，Marqo不需要嵌入，我们保留参数以遵循Liskov替换原则。
`from_texts`(texts[, embedding, metadatas, ...])	从文本返回初始化的 Marqo。请注意，Marqo 不需要嵌入，我们保留该参数以遵循 Liskov 替换原则。
`get_indexes`()	帮助查看marqo中可用的索引，如果使用from_texts方法而没有指定索引名称，则很有用
`get_number_of_documents`()	返回索引中文档的数量
`marqo_bulk_similarity_search`(queries[, k])	使用批量搜索从Marqo返回文档，直接暴露Marqo的输出
`marqo_similarity_search`(query[, k])	从Marqo返回暴露Marqo输出的文档
`max_marginal_relevance_search`(query[, k, ...])	返回使用最大边际相关性选择的文档。
`max_marginal_relevance_search_by_vector`(...)	返回使用最大边际相关性选择的文档。
`search`(query, search_type, **kwargs)	返回使用指定搜索类型的查询最相似的文档。
`similarity_search`(query[, k])	在marqo索引中搜索最相似的文档。
`similarity_search_by_vector`(embedding[, k])	返回与嵌入向量最相似的文档。
`similarity_search_with_relevance_scores`(query)	返回文档和相关性得分在[0, 1]范围内。
`similarity_search_with_score`(query[, k])	返回与查询相似的Marqo文档以及它们的分数。

Parameters

client (marqo.Client) –
index_name (str) –
add_documents_settings (Optional[Dict[str, Any]]) –
searchable_attributes (Optional[List[str]]) –
page_content_builder (Optional[Callable[[Dict[str, Any]], str]]) –

__init__(client: marqo.Client, index_name: str, add_documents_settings: Optional[Dict[str, Any]] = None, searchable_attributes: Optional[List[str]] = None, page_content_builder: Optional[Callable[[Dict[str, Any]], str]] = None)[source]¶

使用Marqo客户端进行初始化。

Parameters

client (marqo.Client) –
index_name (str) –
add_documents_settings (Optional[Dict[str, Any]]) –
searchable_attributes (Optional[List[str]]) –
page_content_builder (Optional[Callable[[Dict[str, Any]], str]]) –

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

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

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

Parameters

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

Return type

List[str]

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

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

Parameters

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

Return type

List[str]

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

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

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

Parameters

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

Return type

List[str]

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

将带有元数据（属性）的文本上传到Marqo。

您可以让Marqo为每个文档生成ID，也可以通过在元数据对象中包含一个”_id”字段来提供自己的ID。

参数：: texts（Iterable[str]）：文本的迭代器 - 假定保留与元数据匹配的顺序。 metadatas（Optional[List[dict]]，可选）：元数据列表。
引发：: ValueError：如果提供了元数据，并且元数据的数量与文本的数量不同。
返回：: List[str]：已添加的ID列表。

Parameters

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

Return type

List[str]

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

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

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

Parameters

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

Return type

Optional[bool]

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

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

Parameters

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

Return type

VST

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

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

Parameters

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

Return type

VST

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

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

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

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

Parameters

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

Return type

List[Document]

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

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

Parameters

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

Return type

List[Document]

as_retriever(**kwargs: Any) → VectorStoreRetriever¶

返回从此VectorStore初始化的VectorStoreRetriever。

参数：

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

返回：

VectorStoreRetriever：VectorStore的Retriever类。

示例：

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

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

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

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

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

Parameters: kwargs (Any) –
Return type: VectorStoreRetriever

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

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

Parameters

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

Return type

List[Document]

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

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

Parameters

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

Return type

List[Document]

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

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

Parameters

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

Return type

List[Document]

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

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

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

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

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

Parameters

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

Return type

List[Tuple[Document, float]]

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

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

Parameters

args (Any) –
kwargs (Any) –

Return type

List[Tuple[Document, float]]

bulk_similarity_search(queries: Iterable[Union[str, Dict[str, float]]], k: int = 4, **kwargs: Any) → List[List[Document]][source]¶

在marqo索引中使用多个查询批量搜索最相似的文档。

参数：: queries (Iterable[Union[str, Dict[str, float]]]): 一个要批量执行的查询可迭代对象，列表中的查询可以是字符串或带有加权查询的字典。 k (int, optional): 每个查询返回的文档数量。默认为4。
返回：: List[List[Document]]: 每个查询的结果列表。

Parameters

queries (Iterable[Union[str, Dict[str, float]]]) –
k (int) –
kwargs (Any) –

Return type

List[List[Document]]

bulk_similarity_search_with_score(queries: Iterable[Union[str, Dict[str, float]]], k: int = 4, **kwargs: Any) → List[List[Tuple[Document, float]]][source]¶

返回与Marqo中的查询相似的文档以及它们的分数，使用一批查询。

参数：: query（Iterable[Union[str, Dict[str, float]]]）：要批量执行的查询的可迭代对象，列表中的查询可以是字符串或加权查询的字典。 k（int，可选）：要返回的文档数量。默认为4。
返回：: List[Tuple[Document, float]]：每个查询的匹配文档及其分数的列表列表。

Parameters

queries (Iterable[Union[str, Dict[str, float]]]) –
k (int) –
kwargs (Any) –

Return type

List[List[Tuple[Document, float]]]

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

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

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

Parameters

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

Return type

Optional[bool]

classmethod from_documents(documents: List[Document], embedding: Optional[Embeddings] = None, **kwargs: Any) → Marqo[source]¶

从文档初始化的VectorStore。请注意，Marqo不需要嵌入，我们保留参数以遵循Liskov替换原则。

参数:: documents (List[Document]): 输入文档 embedding (Any, optional): 嵌入（不是必需的）。默认为None。
返回:: VectorStore: 一个Marqo向量存储器

Parameters

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

Return type

Marqo

classmethod from_texts(texts: List[str], embedding: Any = None, metadatas: Optional[List[dict]] = None, index_name: str = '', url: str = 'http://localhost:8882', api_key: str = '', add_documents_settings: Optional[Dict[str, Any]] = None, searchable_attributes: Optional[List[str]] = None, page_content_builder: Optional[Callable[[Dict[str, str]], str]] = None, index_settings: Optional[Dict[str, Any]] = None, verbose: bool = True, **kwargs: Any) → Marqo[source]¶

从文本返回初始化的 Marqo。请注意，Marqo 不需要嵌入，我们保留该参数以遵循 Liskov 替换原则。

这是使用 marqo 快速入门的方法 - 只需提供您的文本和元数据，就可以创建数据存储的实例并对提供的数据进行索引。

要使用此方法知道文档的 id，您需要在每个文本的元数据中将它们包含在键 “_id” 下。

示例： .. code-block:: python

from langchain_community.vectorstores import Marqo

datastore = Marqo(texts=[‘text’], index_name=’my-first-index’, url=’http://localhost:8882’)

参数:: texts (List[str]): 要在创建时索引到 marqo 中的文本列表。 embedding (Any, optional): 嵌入（非必需）。默认为 None。 index_name (str, optional): 要使用的索引的名称，如果未提供，则将使用 UUID 创建一个。默认为 None。 url (str, optional): Marqo 的 URL。默认为 “http://localhost:8882”。 api_key (str, optional): Marqo 的 API 密钥。默认为 “”。 metadatas (Optional[List[dict]], optional): 一个元数据列表，用于陪同文本。默认为 None。仅在创建新索引时使用。默认为 “cpu”。可以是 “cpu” 或 “cuda”。 add_documents_settings (Optional[Dict[str, Any]], optional): 添加文档的设置，请参阅 https://docs.marqo.ai/0.0.16/API-Reference/documents/#query-parameters。默认为 {}。 index_settings (Optional[Dict[str, Any]], optional): 如果索引不存在，则使用的索引设置，请参阅 https://docs.marqo.ai/0.0.16/API-Reference/indexes/#index-defaults-object。默认为 {}。
返回:: Marqo: Marqo 向量存储的实例

Parameters

texts (List[str]) –
embedding (Any) –
metadatas (Optional[List[dict]]) –
index_name (str) –
url (str) –
api_key (str) –
add_documents_settings (Optional[Dict[str, Any]]) –
searchable_attributes (Optional[List[str]]) –
page_content_builder (Optional[Callable[[Dict[str, str]], str]]) –
index_settings (Optional[Dict[str, Any]]) –
verbose (bool) –
kwargs (Any) –

Return type

Marqo

get_indexes() → List[Dict[str, str]][source]¶

帮助查看marqo中可用的索引，如果使用from_texts方法而没有指定索引名称，则很有用

返回：: List[Dict[str, str]]: 索引列表

Return type: List[Dict[str, str]]

get_number_of_documents() → int[source]¶

返回索引中文档的数量

返回：: int：文档的数量

Return type: int

marqo_bulk_similarity_search(queries: Iterable[Union[str, Dict[str, float]]], k: int = 4) → Dict[str, List[Dict[str, List[Dict[str, str]]]]][source]¶

使用批量搜索从Marqo返回文档，直接暴露Marqo的输出

参数:: queries (Iterable[Union[str, Dict[str, float]]]): 查询列表。 k (int, optional): 每个查询返回的文档数量。默认为4。
返回:: Dict[str, Dict[List[Dict[str, Dict[str, Any]]]]]: 一个批量搜索结果对象

Parameters

queries (Iterable[Union[str, Dict[str, float]]]) –
k (int) –

Return type

Dict[str, List[Dict[str, List[Dict[str, str]]]]]

marqo_similarity_search(query: Union[str, Dict[str, float]], k: int = 4) → Dict[str, List[Dict[str, str]]][source]¶

从Marqo返回暴露Marqo输出的文档

参数:: query (str): 要搜索的查询。 k (int, 可选): 要返回的文档数量。默认为4。
返回:: List[Dict[str, Any]]: 来自marqo的结果。

Parameters

query (Union[str, Dict[str, float]]) –
k (int) –

Return type

Dict[str, List[Dict[str, str]]]

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

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

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

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

Parameters

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

Return type

List[Document]

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

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

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

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

Parameters

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

Return type

List[Document]

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

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

Parameters

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

Return type

List[Document]

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

在marqo索引中搜索最相似的文档。

参数：: query（Union[str, Dict[str, float]）：搜索的查询，可以是字符串或加权查询。 k（int，可选）：要返回的文档数量。默认为4。
返回：: List[Document]：按照匹配程度从高到低排序的k个文档。

Parameters

query (Union[str, Dict[str, float]]) –
k (int) –
kwargs (Any) –

Return type

List[Document]

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

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

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

Parameters

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

Return type

List[Document]

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

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

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

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

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

Parameters

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

Return type

List[Tuple[Document, float]]

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

返回与查询相似的Marqo文档以及它们的分数。

参数：: query（str）：要搜索的查询，可以是字符串或加权查询。 k（int，可选）：要返回的文档数量。默认为4。
返回：: List[Tuple[Document, float]]：匹配的文档及其分数，按分数降序排列。

Parameters

query (Union[str, Dict[str, float]]) –
k (int) –

Return type

List[Tuple[Document, float]]

langchain_community.vectorstores.marqo.Marqo¶

Examples using Marqo¶

`langchain_community.vectorstores.marqo`.Marqo¶