模块 haystack_integrations.components.retrievers.qdrant.retriever

QdrantEmbeddingRetriever

一个使用密集向量从 QdrantDocumentStore 检索文档的组件。

使用示例

from haystack.dataclasses import Document
from haystack_integrations.components.retrievers.qdrant import QdrantEmbeddingRetriever
from haystack_integrations.document_stores.qdrant import QdrantDocumentStore

document_store = QdrantDocumentStore(
    ":memory:",
    recreate_index=True,
    return_embedding=True,
)

document_store.write_documents([Document(content="test", embedding=[0.5]*768)])

retriever = QdrantEmbeddingRetriever(document_store=document_store)

# using a fake vector to keep the example simple
retriever.run(query_embedding=[0.1]*768)

QdrantEmbeddingRetriever.init

def __init__(document_store: QdrantDocumentStore,
             filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
             top_k: int = 10,
             scale_score: bool = False,
             return_embedding: bool = False,
             filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
             score_threshold: Optional[float] = None,
             group_by: Optional[str] = None,
             group_size: Optional[int] = None) -> None

创建一个 QdrantEmbeddingRetriever 组件。

参数:

document_store: QdrantDocumentStore 的一个实例。
filters：一个包含过滤器的字典，用于缩小搜索范围。
top_k: 要检索的文档的最大数量。如果使用group_by 参数，则返回的最大组数。
scale_score: 是否缩放检索到的文档的分数。
return_embedding: 是否返回检索到的文档的嵌入。
filter_policy: 确定如何应用过滤器的策略。
score_threshold: 结果的最小分数阈值。根据 Document Store 中指定的similarity 函数，返回结果的分数可能高于或低于阈值。例如，对于余弦相似度，只会返回更高的分数。
group_by: 用于分组的 Payload 字段，必须是字符串或数字字段。如果该字段包含多个值，则所有值都将用于分组。一个点可能属于多个组。
group_size: 每个组返回的最大点数。默认为 3。

引发:

ValueError: 如果document_store 不是一个实例QdrantDocumentStore.

QdrantEmbeddingRetriever.to_dict

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

将组件序列化为字典。

返回值:

包含序列化数据的字典。

QdrantEmbeddingRetriever.from_dict

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

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

QdrantEmbeddingRetriever.run

@component.output_types(documents=List[Document])
def run(query_embedding: List[float],
        filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
        top_k: Optional[int] = None,
        scale_score: Optional[bool] = None,
        return_embedding: Optional[bool] = None,
        score_threshold: Optional[float] = None,
        group_by: Optional[str] = None,
        group_size: Optional[int] = None) -> Dict[str, List[Document]]

在给定的输入数据上运行 Embedding Retriever。

参数:

query_embedding: 查询的嵌入。
filters：一个包含过滤器的字典，用于缩小搜索范围。
top_k: 要返回的文档的最大数量。如果使用group_by 参数，则返回的最大组数。
scale_score: 是否缩放检索到的文档的分数。
return_embedding: 是否返回检索到的文档的嵌入。
score_threshold: 结果的最小分数阈值。
group_by: 用于分组的 Payload 字段，必须是字符串或数字字段。如果该字段包含多个值，则所有值都将用于分组。一个点可能属于多个组。
group_size: 每个组返回的最大点数。默认为 3。

引发:

ValueError: 如果将 'filter_policy' 设置为 'MERGE' 并且 'filters' 是原生的 Qdrant 过滤器。

返回值:

检索到的文档。

QdrantEmbeddingRetriever.run_async

@component.output_types(documents=List[Document])
async def run_async(
        query_embedding: List[float],
        filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
        top_k: Optional[int] = None,
        scale_score: Optional[bool] = None,
        return_embedding: Optional[bool] = None,
        score_threshold: Optional[float] = None,
        group_by: Optional[str] = None,
        group_size: Optional[int] = None) -> Dict[str, List[Document]]

异步地在给定的输入数据上运行 Embedding Retriever。

参数:

query_embedding: 查询的嵌入。
filters：一个包含过滤器的字典，用于缩小搜索范围。
top_k: 要返回的文档的最大数量。如果使用group_by 参数，则返回的最大组数。
scale_score: 是否缩放检索到的文档的分数。
return_embedding: 是否返回检索到的文档的嵌入。
score_threshold: 结果的最小分数阈值。
group_by: 用于分组的 Payload 字段，必须是字符串或数字字段。如果该字段包含多个值，则所有值都将用于分组。一个点可能属于多个组。
group_size: 每个组返回的最大点数。默认为 3。

引发:

ValueError: 如果将 'filter_policy' 设置为 'MERGE' 并且 'filters' 是原生的 Qdrant 过滤器。

返回值:

检索到的文档。

QdrantSparseEmbeddingRetriever

一个使用稀疏向量从 QdrantDocumentStore 检索文档的组件。

使用示例

from haystack_integrations.components.retrievers.qdrant import QdrantSparseEmbeddingRetriever
from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
from haystack.dataclasses import Document, SparseEmbedding

document_store = QdrantDocumentStore(
    ":memory:",
    use_sparse_embeddings=True,
    recreate_index=True,
    return_embedding=True,
)

doc = Document(content="test", sparse_embedding=SparseEmbedding(indices=[0, 3, 5], values=[0.1, 0.5, 0.12]))
document_store.write_documents([doc])

retriever = QdrantSparseEmbeddingRetriever(document_store=document_store)
sparse_embedding = SparseEmbedding(indices=[0, 1, 2, 3], values=[0.1, 0.8, 0.05, 0.33])
retriever.run(query_sparse_embedding=sparse_embedding)

QdrantSparseEmbeddingRetriever.init

def __init__(document_store: QdrantDocumentStore,
             filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
             top_k: int = 10,
             scale_score: bool = False,
             return_embedding: bool = False,
             filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
             score_threshold: Optional[float] = None,
             group_by: Optional[str] = None,
             group_size: Optional[int] = None) -> None

创建一个 QdrantSparseEmbeddingRetriever 组件。

参数:

document_store: QdrantDocumentStore 的一个实例。
filters：一个包含过滤器的字典，用于缩小搜索范围。
top_k: 要检索的文档的最大数量。如果使用group_by 参数，则返回的最大组数。
scale_score: 是否缩放检索到的文档的分数。
return_embedding: 是否返回检索到的文档的稀疏嵌入。
filter_policy: 确定过滤器如何应用的策略。默认为 "replace"。
score_threshold: 结果的最小分数阈值。根据使用的 Distance 函数，返回结果的分数可能高于或低于阈值。例如，对于余弦相似度，只会返回更高的分数。
group_by: 用于分组的 Payload 字段，必须是字符串或数字字段。如果该字段包含多个值，则所有值都将用于分组。一个点可能属于多个组。
group_size: 每个组返回的最大点数。默认为 3。

引发:

ValueError: 如果document_store 不是一个实例QdrantDocumentStore.

QdrantSparseEmbeddingRetriever.to_dict

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

将组件序列化为字典。

返回值:

包含序列化数据的字典。

QdrantSparseEmbeddingRetriever.from_dict

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

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

QdrantSparseEmbeddingRetriever.run

@component.output_types(documents=List[Document])
def run(query_sparse_embedding: SparseEmbedding,
        filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
        top_k: Optional[int] = None,
        scale_score: Optional[bool] = None,
        return_embedding: Optional[bool] = None,
        score_threshold: Optional[float] = None,
        group_by: Optional[str] = None,
        group_size: Optional[int] = None) -> Dict[str, List[Document]]

在给定的输入数据上运行 Sparse Embedding Retriever。

参数:

query_sparse_embedding: 查询的稀疏嵌入。
filters: 应用于检索到的文档的过滤器。运行时过滤器的应用方式取决于初始化检索器时选择的filter_policy。有关更多详细信息，请参阅 init 方法文档字符串。
top_k: 要返回的文档的最大数量。如果使用group_by 参数，则返回的最大组数。
scale_score: 是否缩放检索到的文档的分数。
return_embedding: 是否返回检索到的文档的嵌入。
score_threshold: 结果的最小分数阈值。根据使用的 Distance 函数，返回结果的分数可能高于或低于阈值。例如，对于余弦相似度，只会返回更高的分数。
group_by: 用于分组的 Payload 字段，必须是字符串或数字字段。如果该字段包含多个值，则所有值都将用于分组。一个点可能属于多个组。
group_size: 每个组返回的最大点数。默认为 3。

引发:

ValueError: 如果将 'filter_policy' 设置为 'MERGE' 并且 'filters' 是原生的 Qdrant 过滤器。

返回值:

检索到的文档。

QdrantSparseEmbeddingRetriever.run_async

@component.output_types(documents=List[Document])
async def run_async(
        query_sparse_embedding: SparseEmbedding,
        filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
        top_k: Optional[int] = None,
        scale_score: Optional[bool] = None,
        return_embedding: Optional[bool] = None,
        score_threshold: Optional[float] = None,
        group_by: Optional[str] = None,
        group_size: Optional[int] = None) -> Dict[str, List[Document]]

异步地在给定的输入数据上运行 Sparse Embedding Retriever。

参数:

query_sparse_embedding: 查询的稀疏嵌入。
filters: 应用于检索到的文档的过滤器。运行时过滤器的应用方式取决于初始化检索器时选择的filter_policy。有关更多详细信息，请参阅 init 方法文档字符串。
top_k: 要返回的文档的最大数量。如果使用group_by 参数，则返回的最大组数。
scale_score: 是否缩放检索到的文档的分数。
return_embedding: 是否返回检索到的文档的嵌入。
score_threshold: 结果的最小分数阈值。根据使用的 Distance 函数，返回结果的分数可能高于或低于阈值。例如，对于余弦相似度，只会返回更高的分数。
group_by: 用于分组的 Payload 字段，必须是字符串或数字字段。如果该字段包含多个值，则所有值都将用于分组。一个点可能属于多个组。
group_size: 每个组返回的最大点数。默认为 3。

引发:

ValueError: 如果将 'filter_policy' 设置为 'MERGE' 并且 'filters' 是原生的 Qdrant 过滤器。

返回值:

检索到的文档。

QdrantHybridRetriever

一个使用密集和稀疏向量从 QdrantDocumentStore 检索文档，并使用 Reciprocal Rank Fusion 融合结果的组件。

使用示例

from haystack_integrations.components.retrievers.qdrant import QdrantHybridRetriever
from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
from haystack.dataclasses import Document, SparseEmbedding

document_store = QdrantDocumentStore(
    ":memory:",
    use_sparse_embeddings=True,
    recreate_index=True,
    return_embedding=True,
    wait_result_from_api=True,
)

doc = Document(content="test",
               embedding=[0.5]*768,
               sparse_embedding=SparseEmbedding(indices=[0, 3, 5], values=[0.1, 0.5, 0.12]))

document_store.write_documents([doc])

retriever = QdrantHybridRetriever(document_store=document_store)
embedding = [0.1]*768
sparse_embedding = SparseEmbedding(indices=[0, 1, 2, 3], values=[0.1, 0.8, 0.05, 0.33])
retriever.run(query_embedding=embedding, query_sparse_embedding=sparse_embedding)

QdrantHybridRetriever.init

def __init__(document_store: QdrantDocumentStore,
             filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
             top_k: int = 10,
             return_embedding: bool = False,
             filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
             score_threshold: Optional[float] = None,
             group_by: Optional[str] = None,
             group_size: Optional[int] = None) -> None

创建一个 QdrantHybridRetriever 组件。

参数:

document_store: QdrantDocumentStore 的一个实例。
filters：一个包含过滤器的字典，用于缩小搜索范围。
top_k: 要检索的文档的最大数量。如果使用group_by 参数，则返回的最大组数。
return_embedding: 是否返回检索到的文档的嵌入。
filter_policy: 确定如何应用过滤器的策略。
score_threshold: 结果的最小分数阈值。根据使用的 Distance 函数，返回结果的分数可能高于或低于阈值。例如，对于余弦相似度，只会返回更高的分数。
group_by: 用于分组的 Payload 字段，必须是字符串或数字字段。如果该字段包含多个值，则所有值都将用于分组。一个点可能属于多个组。
group_size: 每个组返回的最大点数。默认为 3。

引发:

ValueError: 如果 'document_store' 不是 QdrantDocumentStore 的实例。

QdrantHybridRetriever.to_dict

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

将组件序列化为字典。

返回值:

包含序列化数据的字典。

QdrantHybridRetriever.from_dict

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

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

QdrantHybridRetriever.run

@component.output_types(documents=List[Document])
def run(query_embedding: List[float],
        query_sparse_embedding: SparseEmbedding,
        filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
        top_k: Optional[int] = None,
        return_embedding: Optional[bool] = None,
        score_threshold: Optional[float] = None,
        group_by: Optional[str] = None,
        group_size: Optional[int] = None) -> Dict[str, List[Document]]

在给定的输入数据上运行 Sparse Embedding Retriever。

参数:

query_embedding: 查询的密集嵌入。
query_sparse_embedding: 查询的稀疏嵌入。
filters: 应用于检索到的文档的过滤器。运行时过滤器的应用方式取决于初始化检索器时选择的filter_policy。有关更多详细信息，请参阅 init 方法文档字符串。
top_k: 要返回的文档的最大数量。如果使用group_by 参数，则返回的最大组数。
return_embedding: 是否返回检索到的文档的嵌入。
score_threshold: 结果的最小分数阈值。根据使用的 Distance 函数，返回结果的分数可能高于或低于阈值。例如，对于余弦相似度，只会返回更高的分数。
group_by: 用于分组的 Payload 字段，必须是字符串或数字字段。如果该字段包含多个值，则所有值都将用于分组。一个点可能属于多个组。
group_size: 每个组返回的最大点数。默认为 3。

引发:

ValueError: 如果将 'filter_policy' 设置为 'MERGE' 并且 'filters' 是原生的 Qdrant 过滤器。

返回值:

检索到的文档。

QdrantHybridRetriever.run_async

@component.output_types(documents=List[Document])
async def run_async(
        query_embedding: List[float],
        query_sparse_embedding: SparseEmbedding,
        filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
        top_k: Optional[int] = None,
        return_embedding: Optional[bool] = None,
        score_threshold: Optional[float] = None,
        group_by: Optional[str] = None,
        group_size: Optional[int] = None) -> Dict[str, List[Document]]

异步地在给定的输入数据上运行 Sparse Embedding Retriever。

参数:

query_embedding: 查询的密集嵌入。
query_sparse_embedding: 查询的稀疏嵌入。
filters: 应用于检索到的文档的过滤器。运行时过滤器的应用方式取决于初始化检索器时选择的filter_policy。有关更多详细信息，请参阅 init 方法文档字符串。
top_k: 要返回的文档的最大数量。如果使用group_by 参数，则返回的最大组数。
return_embedding: 是否返回检索到的文档的嵌入。
score_threshold: 结果的最小分数阈值。根据使用的 Distance 函数，返回结果的分数可能高于或低于阈值。例如，对于余弦相似度，只会返回更高的分数。
group_by: 用于分组的 Payload 字段，必须是字符串或数字字段。如果该字段包含多个值，则所有值都将用于分组。一个点可能属于多个组。
group_size: 每个组返回的最大点数。默认为 3。

引发:

ValueError: 如果将 'filter_policy' 设置为 'MERGE' 并且 'filters' 是原生的 Qdrant 过滤器。

返回值:

检索到的文档。

模块 haystack_integrations.document_stores.qdrant.document_store

get_batches_from_generator

def get_batches_from_generator(iterable: List, n: int) -> Generator

将可迭代对象的元素分批成固定长度的块。

QdrantDocumentStore

一个 QdrantDocumentStore 实现，您可以将其用于任何 Qdrant 实例：内存中、磁盘持久化、Docker 部署和 Qdrant Cloud Cluster 部署。

通过创建内存实例的使用示例

from haystack.dataclasses.document import Document
from haystack_integrations.document_stores.qdrant import QdrantDocumentStore

document_store = QdrantDocumentStore(
    ":memory:",
    recreate_index=True
)
document_store.write_documents([
    Document(content="This is first", embedding=[0.0]*5),
    Document(content="This is second", embedding=[0.1, 0.2, 0.3, 0.4, 0.5])
])

使用 Qdrant Cloud 的使用示例

from haystack.dataclasses.document import Document
from haystack_integrations.document_stores.qdrant import QdrantDocumentStore

document_store = QdrantDocumentStore(
        url="https://xxxxxx-xxxxx-xxxxx-xxxx-xxxxxxxxx.us-east.aws.cloud.qdrant.io:6333",
    api_key="<your-api-key>",
)
document_store.write_documents([
    Document(content="This is first", embedding=[0.0]*5),
    Document(content="This is second", embedding=[0.1, 0.2, 0.3, 0.4, 0.5])
])

QdrantDocumentStore.init

def __init__(location: Optional[str] = None,
             url: Optional[str] = None,
             port: int = 6333,
             grpc_port: int = 6334,
             prefer_grpc: bool = False,
             https: Optional[bool] = None,
             api_key: Optional[Secret] = None,
             prefix: Optional[str] = None,
             timeout: Optional[int] = None,
             host: Optional[str] = None,
             path: Optional[str] = None,
             force_disable_check_same_thread: bool = False,
             index: str = "Document",
             embedding_dim: int = 768,
             on_disk: bool = False,
             use_sparse_embeddings: bool = False,
             sparse_idf: bool = False,
             similarity: str = "cosine",
             return_embedding: bool = False,
             progress_bar: bool = True,
             recreate_index: bool = False,
             shard_number: Optional[int] = None,
             replication_factor: Optional[int] = None,
             write_consistency_factor: Optional[int] = None,
             on_disk_payload: Optional[bool] = None,
             hnsw_config: Optional[dict] = None,
             optimizers_config: Optional[dict] = None,
             wal_config: Optional[dict] = None,
             quantization_config: Optional[dict] = None,
             init_from: Optional[dict] = None,
             wait_result_from_api: bool = True,
             metadata: Optional[dict] = None,
             write_batch_size: int = 100,
             scroll_size: int = 10_000,
             payload_fields_to_index: Optional[List[dict]] = None) -> None

参数:

location: 如果是":memory:" - 使用内存中的 Qdrant 实例。如果str - 用作 URL 参数。如果None - 使用 host 和 port 的默认值。
url: host 或 str 的Optional[scheme], host, Optional[port], Optional[prefix].
port: REST API 接口的端口。
grpc_port: gRPC 接口的端口。
prefer_grpc: 如果True - 在自定义方法中尽可能使用 gRPC 接口。
https: 如果True - 使用 HTTPS (SSL) 协议。
api_key: Qdrant Cloud 的认证 API 密钥。
prefix: 如果不是None - 在 REST URL 路径中添加前缀。例如：service/v1 会导致 REST API 的 URL 为 https://:6333/service/v1/{qdrant-endpoint}。
timeout: REST 和 gRPC API 请求的超时时间。
host: Qdrant 服务的 host 名称。如果 url和host是None, 则设置为 localhost`。
path: QdrantLocal 的持久化路径。
force_disable_check_same_thread: 对于 QdrantLocal，强制禁用 check_same_thread。仅在您可以保证在 QdrantClient 外部解决线程安全问题时使用此选项。
index: 索引的名称。
embedding_dim: 嵌入的维度。
on_disk: 是否将集合存储在磁盘上。
use_sparse_embeddings: 如果设置为True, 则启用对稀疏嵌入的支持。
sparse_idf: 如果设置为True, 则在使用稀疏嵌入时计算逆文档频率 (IDF)。它对于使用 BM42 等技术是必需的。如果use_sparse_embeddings 为False.
similarity: 要使用的相似度度量。
return_embedding: 是否在搜索结果中返回嵌入。
progress_bar: Whether to show a progress bar or not.
recreate_index: 是否重新创建索引。
shard_number: 集合的分片数量。
replication_factor: 集合的副本因子。定义每个分片将创建多少副本。仅在分布式模式下生效。
write_consistency_factor: 集合的写入一致性因子。最小值为 1。定义操作需要多少副本才能被视为成功。增加此数字会使集合更能抵抗不一致，但如果副本不足，则会导致失败。仅在分布式模式下生效。
on_disk_payload: 如果True, 则点的 Payload 将不会存储在内存中，每次请求时都会从磁盘读取。此设置通过稍微增加响应时间来节省内存。注意：索引的 Payload 值仍保留在内存中。
hnsw_config: HNSW 索引的参数。
optimizers_config: 优化器的参数。
wal_config: Write-Ahead-Log 的参数。
quantization_config: 量化的参数。如果None, 则禁用量化。
init_from: 使用存储在另一个集合中的数据来初始化此集合。
wait_result_from_api: 在每次请求后是否等待 API 的结果。
metadata: 要包含在文档中的附加元数据。
write_batch_size: 写入文档的批次大小。
scroll_size: 读取文档的滚动大小。
payload_fields_to_index: 要索引的 Payload 字段列表。

QdrantDocumentStore.count_documents

def count_documents() -> int

返回 Document Store 中存在的文档数量。

QdrantDocumentStore.count_documents_async

async def count_documents_async() -> int

异步返回 document store 中存在的文档数量。

QdrantDocumentStore.filter_documents

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

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

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

参数:

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

返回值:

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

QdrantDocumentStore.filter_documents_async

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

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

QdrantDocumentStore.write_documents

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

使用指定的策略将文档写入 Qdrant。

QdrantDocumentStore 可以根据给定的策略处理重复文档。可用的策略是

FAIL: 如果任何文档已存在，操作将引发错误。
OVERWRITE: 现有文档将被新文档覆盖。
SKIP: 现有文档将被跳过，只添加新文档。

参数:

documents: 要写入 Qdrant 的 Document 对象列表。
policy: 处理重复文档的策略。

返回值:

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

QdrantDocumentStore.write_documents_async

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

使用指定的策略异步将文档写入 Qdrant。

QdrantDocumentStore 可以根据给定的策略处理重复文档。可用的策略是

FAIL: 如果任何文档已存在，操作将引发错误。
OVERWRITE: 现有文档将被新文档覆盖。
SKIP: 现有文档将被跳过，只添加新文档。

参数:

documents: 要写入 Qdrant 的 Document 对象列表。
policy: 处理重复文档的策略。

返回值:

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

QdrantDocumentStore.delete_documents

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

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

参数:

document_ids: 要删除的文档 ID

QdrantDocumentStore.delete_documents_async

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

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

参数:

document_ids: 要删除的文档 ID

QdrantDocumentStore.from_dict

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

从字典反序列化组件。

参数:

data: 要反序列化的字典。

返回值:

反序列化后的组件。

QdrantDocumentStore.to_dict

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

将组件序列化为字典。

返回值:

包含序列化数据的字典。

QdrantDocumentStore.get_documents_by_id

def get_documents_by_id(ids: List[str]) -> List[Document]

通过 ID 从 Qdrant 检索文档。

参数:

ids: 要检索的文档 ID 列表。

返回值:

文档列表。

QdrantDocumentStore.get_documents_by_id_async

async def get_documents_by_id_async(ids: List[str]) -> List[Document]

通过 ID 从 Qdrant 检索文档。

参数:

ids: 要检索的文档 ID 列表。

返回值:

文档列表。

QdrantDocumentStore.get_distance

def get_distance(similarity: str) -> rest.Distance

检索指定相似度度量的距离。

参数:

similarity: 要检索距离的相似度度量。

引发:

QdrantStoreError: 如果提供的相似度度量不受支持。

返回值:

相应的 rest.Distance 对象。

QdrantDocumentStore.recreate_collection

def recreate_collection(collection_name: str,
                        distance: rest.Distance,
                        embedding_dim: int,
                        on_disk: Optional[bool] = None,
                        use_sparse_embeddings: Optional[bool] = None,
                        sparse_idf: bool = False) -> None

使用指定的参数重新创建 Qdrant 集合。

参数:

collection_name: 要重新创建的集合的名称。
distance: 用于集合的距离度量。
embedding_dim: 嵌入的维度。
on_disk: 是否将集合存储在磁盘上。
use_sparse_embeddings: 是否使用稀疏嵌入。
sparse_idf: 是否在稀疏嵌入时计算逆文档频率 (IDF)。BM42 需要。

QdrantDocumentStore.recreate_collection_async

async def recreate_collection_async(
        collection_name: str,
        distance: rest.Distance,
        embedding_dim: int,
        on_disk: Optional[bool] = None,
        use_sparse_embeddings: Optional[bool] = None,
        sparse_idf: bool = False) -> None

异步地使用指定的参数重新创建 Qdrant 集合。

参数:

collection_name: 要重新创建的集合的名称。
distance: 用于集合的距离度量。
embedding_dim: 嵌入的维度。
on_disk: 是否将集合存储在磁盘上。
use_sparse_embeddings: 是否使用稀疏嵌入。
sparse_idf: 是否在稀疏嵌入时计算逆文档频率 (IDF)。BM42 需要。

模块 haystack_integrations.document_stores.qdrant.migrate_to_sparse

migrate_to_sparse_embeddings_support

def migrate_to_sparse_embeddings_support(
        old_document_store: QdrantDocumentStore, new_index: str) -> None

用于迁移现有QdrantDocumentStore 到一个支持稀疏嵌入的新对象的实用函数。

使用 qdrant-hasytack v3.3.0，稀疏嵌入的支持已添加到QdrantDocumentStore。此功能默认禁用，可以通过在 init 参数中设置use_sparse_embeddings=True 来启用。要存储稀疏嵌入，必须将此功能禁用的 Document stores/collections 迁移到启用此功能的新集合。

此实用函数适用于 Qdrant 的本地部署和云部署。它不适用于本地内存/磁盘持久化实例。

该实用函数仅迁移现有文档，使其可以存储稀疏嵌入。它不计算稀疏嵌入。为此，您需要使用 Sparse Embedder 组件。

示例用法

from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
from haystack_integrations.document_stores.qdrant import migrate_to_sparse_embeddings_support

old_document_store = QdrantDocumentStore(url="https://:6333",
                                         index="Document",
                                         use_sparse_embeddings=False)
new_index = "Document_sparse"

migrate_to_sparse_embeddings_support(old_document_store, new_index)

# now you can use the new document store with sparse embeddings support
new_document_store = QdrantDocumentStore(url="https://:6333",
                                         index=new_index,
                                         use_sparse_embeddings=True)

参数:

old_document_store: 要从中迁移的现有 QdrantDocumentStore 实例。
new_index: 要创建的具有稀疏嵌入支持的新索引/集合的名称。

模块 haystack_integrations.components.retrievers.qdrant.retriever

QdrantEmbeddingRetriever

QdrantEmbeddingRetriever.__init__

QdrantEmbeddingRetriever.to_dict

QdrantEmbeddingRetriever.from_dict

QdrantEmbeddingRetriever.run

QdrantEmbeddingRetriever.run_async

QdrantSparseEmbeddingRetriever

QdrantSparseEmbeddingRetriever.__init__

QdrantSparseEmbeddingRetriever.to_dict

QdrantSparseEmbeddingRetriever.from_dict

QdrantSparseEmbeddingRetriever.run

QdrantSparseEmbeddingRetriever.run_async

QdrantHybridRetriever

QdrantHybridRetriever.__init__

QdrantHybridRetriever.to_dict

QdrantHybridRetriever.from_dict

QdrantHybridRetriever.run

QdrantHybridRetriever.run_async

模块 haystack_integrations.document_stores.qdrant.document_store

get_batches_from_generator

QdrantDocumentStore

QdrantDocumentStore.__init__

QdrantDocumentStore.count_documents

QdrantDocumentStore.count_documents_async

QdrantDocumentStore.filter_documents

QdrantDocumentStore.filter_documents_async

QdrantDocumentStore.write_documents

QdrantDocumentStore.write_documents_async

QdrantDocumentStore.delete_documents

QdrantDocumentStore.delete_documents_async

QdrantDocumentStore.from_dict

QdrantDocumentStore.to_dict

QdrantDocumentStore.get_documents_by_id

QdrantDocumentStore.get_documents_by_id_async

QdrantDocumentStore.get_distance

QdrantDocumentStore.recreate_collection

QdrantDocumentStore.recreate_collection_async

模块 haystack_integrations.document_stores.qdrant.migrate_to_sparse

migrate_to_sparse_embeddings_support

QdrantEmbeddingRetriever.init

QdrantSparseEmbeddingRetriever.init

QdrantHybridRetriever.init

QdrantDocumentStore.init