模块 haystack_integrations.components.retrievers.opensearch.bm25_retriever

OpenSearchBM25Retriever

使用基于关键字的 BM25 算法从 OpenSearchDocumentStore 获取文档。

BM25 计算查询字符串与文档之间的加权词重叠，以确定其相似度。

OpenSearchBM25Retriever.init

def __init__(*,
             document_store: OpenSearchDocumentStore,
             filters: Optional[Dict[str, Any]] = None,
             fuzziness: Union[int, str] = "AUTO",
             top_k: int = 10,
             scale_score: bool = False,
             all_terms_must_match: bool = False,
             filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
             custom_query: Optional[Dict[str, Any]] = None,
             raise_on_failure: bool = True)

创建 OpenSearchBM25Retriever 组件。

参数:

document_store: 要与 Retriever 一起使用的 OpenSearchDocumentStore 实例。
filters: 用于缩小 Document Store 中文档搜索范围的过滤器。
fuzziness: 确定在全文查询中如何应用近似字符串匹配。此参数设置将一个单词转换为另一个单词所需的字符编辑（插入、删除或替换）次数。例如，“wined”和“wind”之间的“fuzziness”为 1，因为匹配它们只需要一次编辑。

对于大多数场景，请使用“AUTO”（默认值），以便根据术语长度自动调整，这是最理想的。有关详细指南，请参阅 OpenSearch fuzzy query 文档。

top_k: 要返回的最大文档数。
scale_score: 如果True，则将检索到的文档的分数缩放到 0 到 1 之间的范围。当跨不同索引比较文档时，这很有用。
all_terms_must_match: 如果True，则查询字符串中的所有术语都必须存在于检索到的文档中。当搜索文本很短，甚至一个术语都可能产生影响时，这很有用。
filter_policy: 确定过滤器如何应用的策略。可能选项
replace: 运行时过滤器替换初始化过滤器。使用此策略更改特定查询的过滤范围。
merge: 运行时过滤器与初始化过滤器合并。

custom_query: 包含必需的$query 和可选的$filters 占位符的查询。一个示例 custom_query：

{
    "query": {
        "bool": {
            "should": [{"multi_match": {
                "query": "$query",                 // mandatory query placeholder
                "type": "most_fields",
                "fields": ["content", "title"]}}],
            "filter": "$filters"                  // optional filter placeholder
        }
    }
}

一个示例run() 方法，用于此custom_query:

retriever.run(
    query="Why did the revenue increase?",
    filters={
        "operator": "AND",
        "conditions": [
            {"field": "meta.years", "operator": "==", "value": "2019"},
            {"field": "meta.quarters", "operator": "in", "value": ["Q1", "Q2"]},
        ],
    },
)

raise_on_failure: API 调用失败时是否引发异常。否则，记录警告并返回一个空列表。

引发:

ValueError: 如果document_store 不是 OpenSearchDocumentStore 的实例。

OpenSearchBM25Retriever.to_dict

def to_dict() -> Dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

OpenSearchBM25Retriever.from_dict

@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "OpenSearchBM25Retriever"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

OpenSearchBM25Retriever.run

@component.output_types(documents=List[Document])
def run(
    query: str,
    filters: Optional[Dict[str, Any]] = None,
    all_terms_must_match: Optional[bool] = None,
    top_k: Optional[int] = None,
    fuzziness: Optional[Union[int, str]] = None,
    scale_score: Optional[bool] = None,
    custom_query: Optional[Dict[str, Any]] = None,
    document_store: Optional[OpenSearchDocumentStore] = None
) -> Dict[str, List[Document]]

使用 BM25 检索来检索文档。

参数:

query: 查询字符串。
filters: 应用于检索到的文档的过滤器。运行时过滤器的应用方式取决于 Retriever 初始化时指定的filter_policy。
all_terms_must_match: 如果True，则查询字符串中的所有术语都必须存在于检索到的文档中。
top_k: 要返回的最大文档数。
fuzziness: 用于全文查询的模糊度参数，以应用近似字符串匹配。有关更多信息，请参阅 OpenSearch fuzzy query。
scale_score: 如果True，则将检索到的文档的分数缩放到 0 到 1 之间的范围。当跨不同索引比较文档时，这很有用。

custom_query: 自定义的 OpenSearch 查询，其中包含必需的$query 占位符，并且可以选择性地包含$filters 占位符。

**An example custom_query:**

```python
{
    "query": {
        "bool": {
            "should": [{"multi_match": {
                "query": "$query",                 // mandatory query placeholder
                "type": "most_fields",
                "fields": ["content", "title"]}}],
            "filter": "$filters"                  // optional filter placeholder
        }
    }
}
```

对于此 custom_query，一个示例run() 可以是

retriever.run(
    query="Why did the revenue increase?",
    filters={
        "operator": "AND",
        "conditions": [
            {"field": "meta.years", "operator": "==", "value": "2019"},
            {"field": "meta.quarters", "operator": "in", "value": ["Q1", "Q2"]},
        ],
    },
)

document_store: 可选的 OpenSearchDocumentStore 实例，用于与 Retriever 一起使用

返回值:

一个包含检索到的文档的字典，结构如下

documents: 检索到的文档列表。

OpenSearchBM25Retriever.run_async

@component.output_types(documents=List[Document])
async def run_async(
    query: str,
    filters: Optional[Dict[str, Any]] = None,
    all_terms_must_match: Optional[bool] = None,
    top_k: Optional[int] = None,
    fuzziness: Optional[Union[int, str]] = None,
    scale_score: Optional[bool] = None,
    custom_query: Optional[Dict[str, Any]] = None,
    document_store: Optional[OpenSearchDocumentStore] = None
) -> Dict[str, List[Document]]

异步使用 BM25 检索来检索文档。

参数:

query: 查询字符串。
filters: 应用于检索到的文档的过滤器。运行时过滤器的应用方式取决于 Retriever 初始化时指定的filter_policy。
all_terms_must_match: 如果True，则查询字符串中的所有术语都必须存在于检索到的文档中。
top_k: 要返回的最大文档数。
fuzziness: 用于全文查询的模糊度参数，以应用近似字符串匹配。有关更多信息，请参阅 OpenSearch fuzzy query。
scale_score: 如果True，则将检索到的文档的分数缩放到 0 到 1 之间的范围。当跨不同索引比较文档时，这很有用。
custom_query: 自定义的 OpenSearch 查询，其中包含必需的$query 占位符，并且可以选择性地包含$filters 占位符。
document_store: 可选的 OpenSearchDocumentStore 实例，用于与 Retriever 一起使用

返回值:

一个包含检索到的文档的字典，结构如下

documents: 检索到的文档列表。

模块 haystack_integrations.components.retrievers.opensearch.embedding_retriever

OpenSearchEmbeddingRetriever

使用向量相似性度量从 OpenSearchDocumentStore 检索文档。

必须连接到 OpenSearchDocumentStore 才能运行。

OpenSearchEmbeddingRetriever.init

def __init__(*,
             document_store: OpenSearchDocumentStore,
             filters: Optional[Dict[str, Any]] = None,
             top_k: int = 10,
             filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
             custom_query: Optional[Dict[str, Any]] = None,
             raise_on_failure: bool = True,
             efficient_filtering: bool = False)

创建 OpenSearchEmbeddingRetriever 组件。

参数:

document_store: 要与 Retriever 一起使用的 OpenSearchDocumentStore 实例。
filters: 从 Document Store 获取文档时应用的过滤器。过滤器在近似 kNN 搜索期间应用，以确保 Retriever 返回top_k 个匹配的文档。
top_k: 要返回的最大文档数。
filter_policy: 确定过滤器如何应用的策略。可能选项
merge: 运行时过滤器与初始化过滤器合并。
replace: 运行时过滤器替换初始化过滤器。使用此策略更改过滤范围。

custom_query: 自定义的 OpenSearch 查询，其中包含必需的$query_embedding 占位符，并且可选地包含$filters 占位符。

**An example custom_query:**

```python
{
    "query": {
        "bool": {
            "must": [
                {
                    "knn": {
                        "embedding": {
                            "vector": "$query_embedding",   // mandatory query placeholder
                            "k": 10000,
                        }
                    }
                }
            ],
            "filter": "$filters"                            // optional filter placeholder
        }
    }
}
```

对于这个custom_query，一个示例run() 可以是

retriever.run(
    query_embedding=embedding,
    filters={
        "operator": "AND",
        "conditions": [
            {"field": "meta.years", "operator": "==", "value": "2019"},
            {"field": "meta.quarters", "operator": "in", "value": ["Q1", "Q2"]},
        ],
    },
)

raise_on_failure: 如果True，则 API 调用失败时引发异常。如果False，则记录警告并返回一个空列表。
efficient_filtering: 如果True，则过滤器将在近似 kNN 搜索期间应用。这仅支持 knn 引擎“faiss”和“lucene”，并且不适用于默认的“nmslib”。

引发:

ValueError: 如果document_store 不是 OpenSearchDocumentStore 的实例。

OpenSearchEmbeddingRetriever.to_dict

def to_dict() -> Dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

OpenSearchEmbeddingRetriever.from_dict

@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "OpenSearchEmbeddingRetriever"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

OpenSearchEmbeddingRetriever.run

@component.output_types(documents=List[Document])
def run(
    query_embedding: List[float],
    filters: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    custom_query: Optional[Dict[str, Any]] = None,
    efficient_filtering: Optional[bool] = None,
    document_store: Optional[OpenSearchDocumentStore] = None
) -> Dict[str, List[Document]]

使用向量相似性度量来检索文档。

参数:

query_embedding: 查询的嵌入。
filters: 从 Document Store 获取文档时应用的过滤器。过滤器在近似 kNN 搜索期间应用，以确保 Retriever 返回top_k 个匹配文档。运行时过滤器的应用方式取决于初始化 Retriever 时选择的filter_policy。
top_k: 要返回的最大文档数。

custom_query: 自定义的 OpenSearch 查询，其中包含必需的$query_embedding 占位符，并且可选地包含$filters 占位符。

**An example custom_query:**

```python
{
    "query": {
        "bool": {
            "must": [
                {
                    "knn": {
                        "embedding": {
                            "vector": "$query_embedding",   // mandatory query placeholder
                            "k": 10000,
                        }
                    }
                }
            ],
            "filter": "$filters"                            // optional filter placeholder
        }
    }
}
```

对于这个custom_query，一个示例run() 可以是

retriever.run(
    query_embedding=embedding,
    filters={
        "operator": "AND",
        "conditions": [
            {"field": "meta.years", "operator": "==", "value": "2019"},
            {"field": "meta.quarters", "operator": "in", "value": ["Q1", "Q2"]},
        ],
    },
)

efficient_filtering: 如果True，则过滤器将在近似 kNN 搜索期间应用。这仅支持 knn 引擎“faiss”和“lucene”，并且不适用于默认的“nmslib”。
document_store: 可选的 OpenSearchDocumentStore 实例，用于与 Retriever 一起使用。

返回值:

包含检索到的文档的键“documents”的字典。

documents: 类似于query_embedding.

OpenSearchEmbeddingRetriever.run_async

@component.output_types(documents=List[Document])
async def run_async(
    query_embedding: List[float],
    filters: Optional[Dict[str, Any]] = None,
    top_k: Optional[int] = None,
    custom_query: Optional[Dict[str, Any]] = None,
    efficient_filtering: Optional[bool] = None,
    document_store: Optional[OpenSearchDocumentStore] = None
) -> Dict[str, List[Document]]

异步使用向量相似性度量来检索文档。

参数:

query_embedding: 查询的嵌入。
filters: 从 Document Store 获取文档时应用的过滤器。过滤器在近似 kNN 搜索期间应用，以确保 Retriever 返回top_k 个匹配文档。运行时过滤器的应用方式取决于初始化 Retriever 时选择的filter_policy。
top_k: 要返回的最大文档数。

custom_query: 自定义的 OpenSearch 查询，其中包含必需的$query_embedding 占位符，并且可选地包含$filters 占位符。

**An example custom_query:**

```python
{
    "query": {
        "bool": {
            "must": [
                {
                    "knn": {
                        "embedding": {
                            "vector": "$query_embedding",   // mandatory query placeholder
                            "k": 10000,
                        }
                    }
                }
            ],
            "filter": "$filters"                            // optional filter placeholder
        }
    }
}
```

对于这个custom_query，一个示例run() 可以是

retriever.run(
    query_embedding=embedding,
    filters={
        "operator": "AND",
        "conditions": [
            {"field": "meta.years", "operator": "==", "value": "2019"},
            {"field": "meta.quarters", "operator": "in", "value": ["Q1", "Q2"]},
        ],
    },
)

efficient_filtering: 如果True，则过滤器将在近似 kNN 搜索期间应用。这仅支持 knn 引擎“faiss”和“lucene”，并且不适用于默认的“nmslib”。
document_store: 可选的 OpenSearchDocumentStore 实例，用于与 Retriever 一起使用。

返回值:

包含检索到的文档的键“documents”的字典。

documents: 类似于query_embedding.

模块 haystack_integrations.components.retrievers.opensearch.open_search_hybrid_retriever

OpenSearchHybridRetriever

一个混合检索器，它结合了 OpenSearch 中的基于嵌入和基于关键字的检索。

示例用法

确保你已安装 "sentence-transformers>=3.0.0"

pip install haystack-ai datasets "sentence-transformers>=3.0.0"

并运行 OpenSearch。你可以使用 Docker 运行 OpenSearch

docker run -d --name opensearch-nosec -p 9200:9200 -p 9600:9600 -e "discovery.type=single-node"
-e "DISABLE_SECURITY_PLUGIN=true" opensearchproject/opensearch:2.12.0

from haystack import Document
from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder
from haystack_integrations.components.retrievers.opensearch import OpenSearchHybridRetriever
from haystack_integrations.document_stores.opensearch import OpenSearchDocumentStore

# Initialize the document store
doc_store = OpenSearchDocumentStore(
    hosts=["<https://:9200>"],
    index="document_store",
    embedding_dim=384,
)

# Create some sample documents
docs = [
    Document(content="Machine learning is a subset of artificial intelligence."),
    Document(content="Deep learning is a subset of machine learning."),
    Document(content="Natural language processing is a field of AI."),
    Document(content="Reinforcement learning is a type of machine learning."),
    Document(content="Supervised learning is a type of machine learning."),
]

# Embed the documents and add them to the document store
doc_embedder = SentenceTransformersDocumentEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")
doc_embedder.warm_up()
docs = doc_embedder.run(docs)
doc_store.write_documents(docs['documents'])

# Initialize some haystack text embedder, in this case the SentenceTransformersTextEmbedder
embedder = SentenceTransformersTextEmbedder(model="sentence-transformers/all-MiniLM-L6-v2")

# Initialize the hybrid retriever
retriever = OpenSearchHybridRetriever(
    document_store=doc_store,
    embedder=embedder,
    top_k_bm25=3,
    top_k_embedding=3,
    join_mode="reciprocal_rank_fusion"
)

# Run the retriever
results = retriever.run(query="What is reinforcement learning?", filters_bm25=None, filters_embedding=None)

>> results['documents']
{'documents': [Document(id=..., content: 'Reinforcement learning is a type of machine learning.', score: 1.0),
  Document(id=..., content: 'Supervised learning is a type of machine learning.', score: 0.9760624679979518),
  Document(id=..., content: 'Deep learning is a subset of machine learning.', score: 0.4919354838709677),
  Document(id=..., content: 'Machine learning is a subset of artificial intelligence.', score: 0.4841269841269841)]}

OpenSearchHybridRetriever.init

def __init__(document_store: OpenSearchDocumentStore,
             *,
             embedder: TextEmbedder,
             filters_bm25: Optional[Dict[str, Any]] = None,
             fuzziness: Union[int, str] = "AUTO",
             top_k_bm25: int = 10,
             scale_score: bool = False,
             all_terms_must_match: bool = False,
             filter_policy_bm25: Union[str,
                                       FilterPolicy] = FilterPolicy.REPLACE,
             custom_query_bm25: Optional[Dict[str, Any]] = None,
             filters_embedding: Optional[Dict[str, Any]] = None,
             top_k_embedding: int = 10,
             filter_policy_embedding: Union[
                 str, FilterPolicy] = FilterPolicy.REPLACE,
             custom_query_embedding: Optional[Dict[str, Any]] = None,
             join_mode: Union[str, JoinMode] = JoinMode.RECIPROCAL_RANK_FUSION,
             weights: Optional[List[float]] = None,
             top_k: Optional[int] = None,
             sort_by_score: bool = True,
             **kwargs: Any) -> None

初始化 OpenSearchHybridRetriever，这是一个超级组件，用于使用

嵌入式和关键字检索方法从 OpenSearch 检索文档。

我们不明确定义构造函数中所有组件的初始化参数，因为这大约有 20 多个参数。相反，我们定义了最重要的参数，并将其余的作为 kwargs 传递。这样可以使构造函数保持简洁易读。

如果你需要将额外的参数传递给组件，可以通过将它们作为 kwargs 传递来实现。它期望一个以组件名称为键，参数为值的字典。组件名称应该是

- "bm25_retriever" -> OpenSearchBM25Retriever
- "embedding_retriever" -> OpenSearchEmbeddingRetriever

参数:

document_store: 用于检索的 OpenSearchDocumentStore。
embedder: 用于嵌入查询的 TextEmbedder。有关更多信息，请参阅haystack.components.embedders.types.protocol.TextEmbedder。
filters_bm25: BM25 检索器的过滤器。
fuzziness: BM25 检索器的模糊度。
top_k_bm25: 从 BM25 检索器返回的结果数量。
scale_score: 是否为 BM25 检索器缩放分数。
all_terms_must_match: BM25 检索器是否必须匹配所有术语。
filter_policy_bm25: BM25 检索器的过滤器策略。
custom_query_bm25: BM25 检索器的自定义查询。
filters_embedding: 嵌入式检索器的过滤器。
top_k_embedding: 从嵌入式检索器返回的结果数量。
filter_policy_embedding: 嵌入式检索器的过滤器策略。
custom_query_embedding: 嵌入式检索器的自定义查询。
join_mode: 用于连接 BM25 和嵌入式检索器结果的模式。
weights: 连接器的权重。
top_k: 从连接器返回的结果数量。
sort_by_score: 是否按分数对结果进行排序。
**kwargs: 附加的关键字参数。使用以下键将额外参数传递给检索器
"bm25_retriever" -> OpenSearchBM25Retriever
"embedding_retriever" -> OpenSearchEmbeddingRetriever

OpenSearchHybridRetriever.to_dict

def to_dict()

将 OpenSearchHybridRetriever 序列化为字典。

返回值:

包含序列化数据的字典。

模块 haystack_integrations.document_stores.opensearch.document_store

OpenSearchDocumentStore

一个 OpenSearch 数据库实例，可用于存储所有类型的数据。

此文档存储是 OpenSearch 客户端的一个薄封装。它允许你从 OpenSearch 索引存储和检索文档。

使用示例

from haystack_integrations.document_stores.opensearch import OpenSearchDocumentStore
from haystack import Document

document_store = OpenSearchDocumentStore(hosts="localhost:9200")

document_store.write_documents(
    [
        Document(content="My first document", id="1"),
        Document(content="My second document", id="2"),
    ]
)

print(document_store.count_documents())
# 2

print(document_store.filter_documents())
# [Document(id='1', content='My first document', ...), Document(id='2', content='My second document', ...)]

OpenSearchDocumentStore.init

def __init__(
        *,
        hosts: Optional[Hosts] = None,
        index: str = "default",
        max_chunk_bytes: int = DEFAULT_MAX_CHUNK_BYTES,
        embedding_dim: int = 768,
        return_embedding: bool = False,
        method: Optional[Dict[str, Any]] = None,
        mappings: Optional[Dict[str, Any]] = None,
        settings: Optional[Dict[str, Any]] = DEFAULT_SETTINGS,
        create_index: bool = True,
        http_auth: Any = (
            Secret.from_env_var("OPENSEARCH_USERNAME",
                                strict=False),  # noqa: B008
            Secret.from_env_var("OPENSEARCH_PASSWORD",
                                strict=False),  # noqa: B008
        ),
        use_ssl: Optional[bool] = None,
        verify_certs: Optional[bool] = None,
        timeout: Optional[int] = None,
        **kwargs: Any) -> None

创建新的 OpenSearchDocumentStore 实例。

该embeddings_dim, method, mappings 和settings 参数仅在索引不存在且需要创建时使用。如果索引已存在，则将使用其当前配置。

有关连接参数，请参阅官方 OpenSearch 文档

参数:

hosts: 运行 OpenSearch 客户端的主机列表。默认为 None
index: OpenSearch 中的索引名称，如果不存在，将创建。默认为 "default"
max_chunk_bytes: 请求的最大字节大小。默认为 100MB
embedding_dim: 嵌入的维度。默认为 768
return_embedding: 是否返回检索到的文档的嵌入。此参数也适用于filter_documents 和filter_documents_async 方法。
method: 近似 k-NN 算法底层配置的方法定义。有关更多信息，请参阅官方 OpenSearch 文档。默认为 None
mappings: 文档存储和索引方式的映射。有关更多信息，请参阅官方 OpenSearch 文档。如果为 None，则使用 embedding_dim 和 method 参数创建默认映射。默认为 None
settings: 要创建的索引的设置。有关更多信息，请参阅官方 OpenSearch 文档。默认为 {"index.knn": True}
create_index: 如果索引不存在，是否创建索引。默认为 True
http_auth: 传递给底层连接类的 http_auth 参数。对于带有默认连接类的基本身份验证Urllib3HttpConnection，这可以是
一个元组 (用户名, 密码)
一个列表 [用户名, 密码]
一个字符串 "用户名:密码" 如果未提供，将从 OPENSEARCH_USERNAME 和 OPENSEARCH_PASSWORD 环境变量中读取值。对于带有Urllib3HttpConnection 的 AWS 身份验证，传递一个AWSAuth 实例。默认为 None
use_ssl: 是否使用 SSL。默认为 None
verify_certs: 是否验证证书。默认为 None
timeout: 超时（秒）。默认为 None
**kwargs: 可选参数，OpenSearch 采用。有关支持的 kwargs 的完整列表，请参阅官方 OpenSearch 参考

OpenSearchDocumentStore.create_index

def create_index(index: Optional[str] = None,
                 mappings: Optional[Dict[str, Any]] = None,
                 settings: Optional[Dict[str, Any]] = None) -> None

在 OpenSearch 中创建一个索引。

请注意，此方法将忽略构造函数中的create_index 参数。

参数:

index: 要创建的索引的名称。如果为 None，则使用构造函数中的索引名称。
mappings: 文档存储和索引方式的映射。有关更多信息，请参阅官方 OpenSearch 文档。如果为 None，则使用构造函数中的映射。
settings: 要创建的索引的设置。有关更多信息，请参阅官方 OpenSearch 文档。如果为 None，则使用构造函数中的设置。

OpenSearchDocumentStore.to_dict

def to_dict() -> Dict[str, Any]

将组件序列化为字典。

返回值:

包含序列化数据的字典。

OpenSearchDocumentStore.from_dict

@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "OpenSearchDocumentStore"

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

OpenSearchDocumentStore.count_documents

def count_documents() -> int

返回文档存储中存在的文档数量。

OpenSearchDocumentStore.count_documents_async

async def count_documents_async() -> int

异步返回文档存储中的文档总数。

OpenSearchDocumentStore.filter_documents

def filter_documents(
        filters: Optional[Dict[str, Any]] = None) -> List[Document]

返回与提供的过滤器匹配的文档。

有关过滤器的详细规范，请参阅文档

参数:

filters: 要应用于文档列表的过滤器。

返回值:

与给定过滤器匹配的文档列表。

OpenSearchDocumentStore.filter_documents_async

async def filter_documents_async(
        filters: Optional[Dict[str, Any]] = None) -> List[Document]

异步返回与提供的过滤器匹配的文档。

有关过滤器的详细规范，请参阅文档

参数:

filters: 要应用于文档列表的过滤器。

返回值:

与给定过滤器匹配的文档列表。

OpenSearchDocumentStore.write_documents

def write_documents(documents: List[Document],
                    policy: DuplicatePolicy = DuplicatePolicy.NONE) -> int

将文档写入文档存储。

参数:

documents: 要写入文档存储的文档列表。
policy: 写入文档时使用的重复策略。

引发:

DuplicateDocumentError: 如果文档 ID 与文档存储中已有的文档 ID 相同，并且策略设置为DuplicatePolicy.FAIL（或未指定）。

返回值:

写入文档存储的文档数量。

OpenSearchDocumentStore.write_documents_async

async def write_documents_async(
        documents: List[Document],
        policy: DuplicatePolicy = DuplicatePolicy.NONE) -> int

异步将文档写入文档存储。

参数:

documents: 要写入文档存储的文档列表。
policy: 写入文档时使用的重复策略。

返回值:

写入文档存储的文档数量。

OpenSearchDocumentStore.delete_documents

def delete_documents(document_ids: List[str]) -> None

删除与提供的document_ids 匹配的文档。

参数:

document_ids: 要删除的文档 ID

OpenSearchDocumentStore.delete_documents_async

async def delete_documents_async(document_ids: List[str]) -> None

异步删除与提供的document_ids 匹配的文档。

参数:

document_ids: 要删除的文档 ID

OpenSearchDocumentStore.delete_all_documents

def delete_all_documents(recreate_index: bool = False) -> None

删除文档存储中的所有文档。

参数:

recreate_index: 如果为 True，则将删除索引并使用原始映射和设置重新创建。如果为 False，则将使用delete_by_query API 删除所有文档。

OpenSearchDocumentStore.delete_all_documents_async

async def delete_all_documents_async(recreate_index: bool = False) -> None

异步删除文档存储中的所有文档。

参数:

recreate_index: 如果为 True，则将删除索引并使用原始映射和设置重新创建。如果为 False，则将使用delete_by_query API 删除所有文档。

模块 haystack_integrations.document_stores.opensearch.filters

normalize_filters

def normalize_filters(filters: Dict[str, Any]) -> Dict[str, Any]

将 Haystack 过滤器转换为 OpenSearch 兼容的过滤器。

模块 haystack_integrations.components.retrievers.opensearch.bm25_retriever

OpenSearchBM25Retriever

OpenSearchBM25Retriever.__init__

OpenSearchBM25Retriever.to_dict

OpenSearchBM25Retriever.from_dict

OpenSearchBM25Retriever.run

OpenSearchBM25Retriever.run_async

模块 haystack_integrations.components.retrievers.opensearch.embedding_retriever

OpenSearchEmbeddingRetriever

OpenSearchEmbeddingRetriever.__init__

OpenSearchEmbeddingRetriever.to_dict

OpenSearchEmbeddingRetriever.from_dict

OpenSearchEmbeddingRetriever.run

OpenSearchEmbeddingRetriever.run_async

模块 haystack_integrations.components.retrievers.opensearch.open_search_hybrid_retriever

OpenSearchHybridRetriever

OpenSearchHybridRetriever.__init__

OpenSearchHybridRetriever.to_dict

模块 haystack_integrations.document_stores.opensearch.document_store

OpenSearchDocumentStore

OpenSearchDocumentStore.__init__

OpenSearchDocumentStore.create_index

OpenSearchDocumentStore.to_dict

OpenSearchDocumentStore.from_dict

OpenSearchDocumentStore.count_documents

OpenSearchDocumentStore.count_documents_async

OpenSearchDocumentStore.filter_documents

OpenSearchDocumentStore.filter_documents_async

OpenSearchDocumentStore.write_documents

OpenSearchDocumentStore.write_documents_async

OpenSearchDocumentStore.delete_documents

OpenSearchDocumentStore.delete_documents_async

OpenSearchDocumentStore.delete_all_documents

OpenSearchDocumentStore.delete_all_documents_async

模块 haystack_integrations.document_stores.opensearch.filters

normalize_filters

OpenSearchBM25Retriever.init

OpenSearchEmbeddingRetriever.init

OpenSearchHybridRetriever.init

OpenSearchDocumentStore.init