qdrant_client.qdrant_client 模块¶

class QdrantClient(location: Optional[str] = None, url: Optional[str] = None, port: Optional[int] = 6333, grpc_port: int = 6334, prefer_grpc: bool = False, https: Optional[bool] = None, api_key: Optional[str] = None, prefix: Optional[str] = None, timeout: Optional[int] = None, host: Optional[str] = None, path: Optional[str] = None, force_disable_check_same_thread: bool = False, grpc_options: Optional[dict[str, Any]] = None, auth_token_provider: Optional[Union[Callable[[], str], Callable[[], Awaitable[str]]]] = None, cloud_inference: bool = False, local_inference_batch_size: Optional[int] = None, check_compatibility: bool = True, **kwargs: Any)[source]¶

继承自: QdrantFastembedMixin

通过 REST 或 gRPC API 与 Qdrant 服务通信的入口点。

它结合了接口类和端点实现。此外，它还提供了自定义实现，用于处理频繁使用的方法，例如初始集合上传。

QdrantClient 中的所有方法都接受 gRPC 和 REST 结构作为输入。将自动执行转换。

注意

本模块方法是 gRPC 和 REST 方法生成的客户端代码的包装器。如果您需要更低级别的访问生成的客户端，请使用以下属性：

QdrantClient.grpc_points
QdrantClient.grpc_collections
QdrantClient.rest

注意

如果您需要异步操作，请考虑使用 QdrantClient 的异步实现。

qdrant_client.async_qdrant_client

参数:

location – 如果是 ``":memory:"`` - 使用内存中的 Qdrant 实例。如果是 ``str`` - 将其用作 ``url`` 参数。如果是 ``None`` - 使用 ``host`` 和 ``port`` 的默认值。
url – host 或 ``Optional[scheme], host, Optional[port], Optional[prefix]`` 的字符串。默认值：``None``
port – REST API 接口的端口。默认值：6333
grpc_port – gRPC 接口的端口。默认值：6334
prefer_grpc – 如果是 ``true`` - 在自定义方法中尽可能使用 gPRC 接口。
https – 如果是 ``true`` - 使用 HTTPS(SSL) 协议。默认值：``None``
api_key – 用于 Qdrant Cloud 中身份验证的 API 密钥。默认值：``None``
prefix – 如果不是 ``None`` - 将 ``prefix`` 添加到 REST URL 路径。示例：``service/v1`` 将导致 REST API 的 URL 为 ``http://localhost:6333/service/v1/{qdrant-endpoint}``。默认值：``None``
timeout – REST 和 gRPC API 请求的超时时间。默认值：REST 为 5 秒，gRPC 为无限
host – Qdrant 服务的 Host 名称。如果 url 和 host 都为 None，则设置为 'localhost'。默认值：``None``
path – QdrantLocal 的持久化路径。默认值：``None``
force_disable_check_same_thread – 对于 QdrantLocal，强制禁用 check_same_thread 检查。默认值：``False`` 仅当您能保证在 QdrantClient 外部解决线程安全问题时才使用此选项。
auth_token_provider – 用于获取 Bearer 访问令牌的回调函数。如果提供，该函数将在每次请求前被调用以获取令牌。
check_compatibility – 如果是 ``true`` - 检查与服务器版本的兼容性。默认值：``true``。
**kwargs – 直接传递给 REST 客户端初始化的附加参数。

batch_update_points(collection_name: str, update_operations: Sequence[Union[UpsertOperation, DeleteOperation, SetPayloadOperation, OverwritePayloadOperation, DeletePayloadOperation, ClearPayloadOperation, UpdateVectorsOperation, DeleteVectorsOperation]], wait: bool = True, ordering: Optional[WriteOrdering] = None, **kwargs: Any) → list[UpdateResult][source]¶

在集合中批量更新点。

参数:

collection_name – 集合的名称
update_operations – 更新操作列表
wait – 等待处理结果。- 如果为 ``true``，仅当所有更改都应用后才返回结果 - 如果为 ``false``，收到确认后立即返回结果。
ordering (Optional[*WriteOrdering*]) –
定义点的排序策略。可能的值
- ``weak`` (默认) - 写操作可能被重新排序，速度更快
- ``medium`` - 写操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致
- ``strong`` - 写操作通过永久领导者进行，一致，但如果领导者宕机可能会不可用

返回:

操作结果

clear_payload(collection_name: str, points_selector: Union[list[Union[int, str, points_pb2.PointId]], Filter, Filter, PointIdsList, FilterSelector, PointsSelector], wait: bool = True, ordering: Optional[WriteOrdering] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → UpdateResult[source]¶

删除选中点的所有 payload。

参数:

collection_name – 集合的名称
wait – 等待处理结果。- 如果为 ``true``，仅当所有更改都应用后才返回结果 - 如果为 ``false``，收到确认后立即返回结果。
points_selector – 受影响的点列表、filter 或 points selector。示例：- ``points=[1, 2, 3, “cd3b53f0-11a7-449f-bc50-d06310e7ed90”]`` - ``points=Filter(must=[FieldCondition(key=’rand_number’, range=Range(gte=0.7))])``
ordering (Optional[*WriteOrdering*]) –
定义点的排序策略。可能的值
- ``weak`` (默认) - 写操作可能被重新排序，速度更快
- ``medium`` - 写操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致
- ``strong`` - 写操作通过永久领导者进行，一致，但如果领导者宕机可能会不可用
shard_key_selector – 定义应用于写入更新的分片组。如果提供了多个 shard_key，更新将写入到每个分片组。仅适用于采用 ``custom`` 分片方法的集合。

返回:

操作结果

close(grpc_grace: Optional[float] = None, **kwargs: Any) → None[source]¶

关闭与 Qdrant 的连接。

参数:: grpc_grace – gRPC 连接关闭的宽限期。默认值：None

collection_exists(collection_name: str, **kwargs: Any) → bool[source]¶

检查集合是否已存在。

参数:: collection_name – 集合的名称
返回:: 如果集合存在则为 True，否则为 False。

count(collection_name: str, count_filter: Optional[Union[Filter, Filter]] = None, exact: bool = True, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, timeout: Optional[int] = None, **kwargs: Any) → CountResult[source]¶

计算集合中的点数量。

计算集合中匹配给定 filter 的点数量。

参数:

collection_name – 要计算点数量的集合名称
count_filter – 过滤条件
exact – 如果为 ``True`` - 提供匹配 filter 的点的精确数量。如果为 ``False`` - 提供匹配 filter 的点的近似数量。速度更快。
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。
timeout – 覆盖此操作的全局超时设置。单位为秒。

返回:

集合中匹配 filter 的点数量。

create_collection(collection_name: str, vectors_config: Optional[Union[VectorParams, Mapping[str, VectorParams]]] = None, sparse_vectors_config: Optional[Mapping[str, SparseVectorParams]] = None, shard_number: Optional[int] = None, sharding_method: Optional[ShardingMethod] = None, replication_factor: Optional[int] = None, write_consistency_factor: Optional[int] = None, on_disk_payload: Optional[bool] = None, hnsw_config: Optional[Union[HnswConfigDiff, HnswConfigDiff]] = None, optimizers_config: Optional[Union[OptimizersConfigDiff, OptimizersConfigDiff]] = None, wal_config: Optional[Union[WalConfigDiff, WalConfigDiff]] = None, quantization_config: Optional[Union[ScalarQuantization, ProductQuantization, BinaryQuantization, QuantizationConfig]] = None, init_from: Optional[Union[InitFrom, str]] = None, timeout: Optional[int] = None, strict_mode_config: Optional[StrictModeConfig] = None, **kwargs: Any) → bool[source]¶

创建具有给定参数的空集合。

参数:

collection_name – 要重新创建的集合名称
vectors_config – 向量存储的配置。Vector params 包含向量存储的大小和距离。如果传入 dict，服务将为 dict 中的每个键创建一个向量存储。如果传入单个 VectorParams，服务将创建一个单独的匿名向量存储。
sparse_vectors_config – 稀疏向量存储的配置。服务将为 dict 中的每个键创建一个稀疏向量存储。
shard_number – 集合中的分片数量。默认值为 1，最小值为 1。
sharding_method – 定义分片创建策略。选项 ``auto`` (默认) 自动创建指定数量的分片。数据将自动分布到分片之间。创建后，可以额外复制分片，但无法创建新的分片。选项 ``custom`` 允许手动创建分片，每个分片都应分配唯一的 ``shard_key``。数据将根据 ``shard_key`` 值分布。
replication_factor – 集合的复制因子。默认值为 1，最小值为 1。定义每个分片将创建多少个副本。仅在分布式模式下有效。
write_consistency_factor – 集合的写入一致性因子。默认值为 1，最小值为 1。定义需要有多少个副本应用操作才能被视为成功。增加此数字会使集合对不一致更具弹性，但如果可用副本不足也会导致失败。不影响性能。仅在分布式模式下有效。
on_disk_payload – 如果为 true - 点的 payload 将不存储在内存中。每次请求时都会从磁盘读取。此设置通过（略微）增加响应时间来节省 RAM。注意：参与过滤并已索引的 payload 值仍保留在 RAM 中。
hnsw_config – HNSW 索引的参数
optimizers_config – 优化器的参数
wal_config – Write-Ahead-Log 的参数
quantization_config – 量化的参数，如果为 None - 将禁用量化
init_from – 使用存储在另一个集合中的数据初始化此集合
timeout – 操作提交的等待超时时间（秒）。如果达到超时，请求将返回服务错误。
strict_mode_config – 配置集合的限制，例如最大大小、速率限制等。

返回:

操作结果

create_full_snapshot(wait: bool = True, **kwargs: Any) → Optional[SnapshotDescription][source]¶

为整个存储创建快照。

参数:

wait –

等待快照创建。

如果为 ``true``，仅当快照创建完成后才返回结果
如果为 ``false``，收到确认后立即返回结果。

返回:

快照描述

create_payload_index(collection_name: str, field_name: str, field_schema: Optional[Union[PayloadSchemaType, KeywordIndexParams, IntegerIndexParams, FloatIndexParams, GeoIndexParams, TextIndexParams, BoolIndexParams, DatetimeIndexParams, UuidIndexParams, int, PayloadIndexParams]] = None, field_type: Optional[Union[PayloadSchemaType, KeywordIndexParams, IntegerIndexParams, FloatIndexParams, GeoIndexParams, TextIndexParams, BoolIndexParams, DatetimeIndexParams, UuidIndexParams, int, PayloadIndexParams]] = None, wait: bool = True, ordering: Optional[WriteOrdering] = None, **kwargs: Any) → UpdateResult[source]¶

为给定的 payload 字段创建索引。索引字段可以更快地执行过滤搜索操作。

参数:

collection_name – 集合的名称
field_name – payload 字段的名称
field_schema – 要索引的数据类型
field_type – 与 field_schema 相同，但已弃用
wait –
等待处理结果。
- 如果为 ``true``，仅当所有更改都应用后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。
ordering (Optional[*WriteOrdering*]) –
定义点的排序策略。可能的值
- ``weak`` (默认) - 写操作可能被重新排序，速度更快
- ``medium`` - 写操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致
- ``strong`` - 写操作通过永久领导者进行，一致，但如果领导者宕机可能会不可用

返回:

操作结果

create_shard_key(collection_name: str, shard_key: Union[int, str], shards_number: Optional[int] = None, replication_factor: Optional[int] = None, placement: Optional[list[int]] = None, **kwargs: Any) → bool[source]¶

为集合创建分片键。

仅适用于采用 ``custom`` 分片方法的集合。

参数:

collection_name – 集合的名称
shard_key – 要创建的分片键
shards_number – 为此键创建的分片数量
replication_factor – 此键的复制因子
placement – 要放置分片的对等节点列表。如果为 None - 放置在所有对等节点上。

返回:

操作结果

create_shard_snapshot(collection_name: str, shard_id: int, wait: bool = True, **kwargs: Any) → Optional[SnapshotDescription][source]¶

为给定分片创建快照。

参数:

collection_name – 集合的名称
shard_id – 分片的索引
wait –
等待快照创建。
- 如果为 ``true``，仅当快照创建完成后才返回结果。
- 如果为 ``false``，收到确认后立即返回结果。

返回:

快照描述

create_snapshot(collection_name: str, wait: bool = True, **kwargs: Any) → Optional[SnapshotDescription][source]¶

为给定集合创建快照。

参数:

collection_name – 集合的名称
wait –
等待快照创建。
- 如果为 ``true``，仅当快照创建完成后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。

返回:

快照描述

delete(collection_name: str, points_selector: Union[list[Union[int, str, points_pb2.PointId]], Filter, Filter, PointIdsList, FilterSelector, PointsSelector], wait: bool = True, ordering: Optional[WriteOrdering] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → UpdateResult[source]¶

从集合中删除选定的点。

参数:

collection_name – 集合的名称
wait –
等待处理结果。
- 如果为 ``true``，仅当所有更改都应用后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。
points_selector –
根据 ID 列表或 filter 选择点。示例：
- points=[1, 2, 3, “cd3b53f0-11a7-449f-bc50-d06310e7ed90”]
- points=Filter(must=[FieldCondition(key=’rand_number’, range=Range(gte=0.7))])
ordering (Optional[*WriteOrdering*]) –
定义点的排序策略。可能的值
- ``weak`` (默认) - 写操作可能被重新排序，速度更快
- ``medium`` - 写操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致
- ``strong`` - 写操作通过永久领导者进行，一致，但如果领导者宕机可能会不可用
shard_key_selector – 定义应用于写入更新的分片组。如果提供了多个 shard_key，更新将写入到每个分片组。仅适用于采用 ``custom`` 分片方法的集合。

返回:

操作结果

delete_collection(collection_name: str, timeout: Optional[int] = None, **kwargs: Any) → bool[source]¶

删除集合及其所有数据。

参数:

collection_name – 要删除的集合名称
timeout – 操作提交的等待超时时间（秒）。如果达到超时，请求将返回服务错误。

返回:

操作结果

delete_full_snapshot(snapshot_name: str, wait: bool = True, **kwargs: Any) → Optional[bool][source]¶

删除整个存储的快照。

参数:

snapshot_name – 快照名称
wait –
等待快照删除。
- 如果为 ``true``，仅当快照删除完成后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。

返回:

如果快照已删除则为 True。

delete_payload(collection_name: str, keys: Sequence[str], points: Union[list[Union[int, str, points_pb2.PointId]], Filter, Filter, PointIdsList, FilterSelector, PointsSelector], wait: bool = True, ordering: Optional[WriteOrdering] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → UpdateResult[source]¶

从点的载荷中移除值

参数:

collection_name – 集合的名称
wait –
等待处理结果。
- 如果为 ``true``，仅当所有更改都应用后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。
keys – 要移除的载荷键列表
points –
受影响点的列表、过滤器或点选择器。 .. rubric:: 示例
- points=[1, 2, 3, “cd3b53f0-11a7-449f-bc50-d06310e7ed90”]
- points=Filter(must=[FieldCondition(key=’rand_number’, range=Range(gte=0.7))])
ordering (Optional[*WriteOrdering*]) –
定义点的排序策略。可能的值
- ``weak`` (默认) - 写操作可能被重新排序，速度更快
- ``medium`` - 写操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致
- strong - 写操作通过永久领导者进行，一致性高，但如果领导者宕机可能不可用
shard_key_selector – 定义应用于写入更新的分片组。如果提供了多个 shard_key，更新将写入到每个分片组。仅适用于采用 ``custom`` 分片方法的集合。

返回:

操作结果

delete_payload_index(collection_name: str, field_name: str, wait: bool = True, ordering: Optional[WriteOrdering] = None, **kwargs: Any) → UpdateResult[source]¶

移除给定载荷字段的索引。

参数:

collection_name – 集合的名称
field_name – payload 字段的名称
wait –
等待处理结果。
- 如果为 ``true``，仅当所有更改都应用后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。
ordering (Optional[*WriteOrdering*]) –
定义点的排序策略。可能的值
- ``weak`` (默认) - 写操作可能被重新排序，速度更快
- ``medium`` - 写操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致
- ``strong`` - 写操作通过永久领导者进行，一致，但如果领导者宕机可能会不可用

返回:

操作结果

delete_shard_key(collection_name: str, shard_key: Union[int, str], **kwargs: Any) → bool[source]¶

删除集合的分片键。

仅适用于采用 ``custom`` 分片方法的集合。

参数:

collection_name – 集合的名称
shard_key – 要删除的分片键

返回:

操作结果

delete_shard_snapshot(collection_name: str, shard_id: int, snapshot_name: str, wait: bool = True, **kwargs: Any) → Optional[bool][source]¶

删除给定分片的快照。

参数:

collection_name – 集合的名称
shard_id – 分片的索引
snapshot_name – 快照ID
wait –
等待快照删除。
- 如果为 ``true``，仅当快照删除完成后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。

返回:

如果快照已删除则为 True。

delete_snapshot(collection_name: str, snapshot_name: str, wait: bool = True, **kwargs: Any) → Optional[bool][source]¶

删除给定集合的快照。

参数:

collection_name – 集合的名称
snapshot_name – 快照ID
wait –
等待快照删除。
- 如果为 ``true``，仅当快照删除完成后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。

返回:

如果快照已删除则为 True。

delete_vectors(collection_name: str, vectors: Sequence[str], points: Union[list[Union[int, str, points_pb2.PointId]], Filter, Filter, PointIdsList, FilterSelector, PointsSelector], wait: bool = True, ordering: Optional[WriteOrdering] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → UpdateResult[source]¶

从集合中删除指定的向量。不影响载荷。

参数:

collection_name (str) – 要从中删除向量的集合名称
vectors – 要删除的向量名称列表。使用 “” 删除默认向量。必须至少指定一个向量。
points (Point) –
根据ID列表或过滤器选择点示例
- points=[1, 2, 3, “cd3b53f0-11a7-449f-bc50-d06310e7ed90”]
- points=Filter(must=[FieldCondition(key=’rand_number’, range=Range(gte=0.7))])
wait (bool) –
等待处理结果。
- 如果为 ``true``，仅当所有更改都应用后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。
ordering (Optional[*WriteOrdering*]) –
定义点的排序策略。可能的值
- ``weak`` (默认) - 写操作可能被重新排序，速度更快
- ``medium`` - 写操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致
- ``strong`` - 写操作通过永久领导者进行，一致，但如果领导者宕机可能会不可用
shard_key_selector – 定义应用于写入更新的分片组。如果提供了多个 shard_key，更新将写入到每个分片组。仅适用于采用 ``custom`` 分片方法的集合。

返回:

操作结果

discover(collection_name: str, target: Optional[Union[int, str, List[float], SparseVector, TargetVector]] = None, context: Optional[Sequence[Union[ContextExamplePair, ContextExamplePair]]] = None, query_filter: Optional[Union[Filter, Filter]] = None, search_params: Optional[Union[SearchParams, SearchParams]] = None, limit: int = 10, offset: int = 0, with_payload: Union[bool, list[str], PayloadSelectorInclude, PayloadSelectorExclude, WithPayloadSelector] = True, with_vectors: Union[bool, list[str]] = False, using: Optional[str] = None, lookup_from: Optional[Union[LookupLocation, LookupLocation]] = None, consistency: Optional[Union[int, ReadConsistencyType]] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, timeout: Optional[int] = None, **kwargs: Any) → list[ScoredPoint][source]¶

使用上下文和目标查找最相似的点，受上下文约束。

参数:

collection_name – 要在其中进行发现的集合
target –
查找最接近此向量的向量。

使用目标（无论有无上下文）时，分数的整数部分表示相对于上下文的排名，而分数的十进制部分与到目标的距离相关。
context –
用于约束搜索的 { 正例, 负例 } 对。

仅使用上下文（不带目标）时，将执行一种特殊搜索，称为上下文搜索。在该搜索中，使用点对生成一个损失，该损失引导搜索方向，使其靠近大多数正例重叠的区域。这意味着分数会最小化找到的点更接近负例而非正例部分的情况。

由于上下文分数与损失相关，点能获得的最高分数是 0.0，许多点拥有 0.0 分数是正常的。

对于发现搜索（包含目标时），每对的上下文分数计算方式为：如果点更接近对的正例而非负例部分，则为 +1，否则为 -1。
query_filter – 仅查找满足这些条件的点
search_params – 附加搜索参数
limit – 返回的最大结果数量
offset – 要返回的第一个结果的偏移量。可用于结果分页。注意：较大的偏移量值可能会导致性能问题。
with_payload – 选择响应中要返回的载荷。默认值：None
with_vectors – 是否在结果中返回点向量？
using – 定义用于推荐的向量。如果未指定，则尝试使用默认向量。
lookup_from – 用于查找向量的位置。如果未指定，则使用当前集合。注意：其他集合应与当前集合具有相同的向量大小。
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。
timeout – 覆盖此搜索的全局超时设置。单位为秒。

返回:

根据是发现搜索还是上下文搜索，返回带有相应分数的结果点列表。

discover_batch(collection_name: str, requests: Sequence[Union[DiscoverRequest, DiscoverPoints]], consistency: Optional[Union[int, ReadConsistencyType]] = None, timeout: Optional[int] = None, **kwargs: Any) → list[list[ScoredPoint]][source]¶

facet(collection_name: str, key: str, facet_filter: Optional[Union[Filter, Filter]] = None, limit: int = 10, exact: bool = False, consistency: Optional[Union[int, ReadConsistencyType]] = None, timeout: Optional[int] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → FacetResponse[source]¶

集合的切面计数。对于特定的载荷键，返回唯一值及其计数。计数较高的结果排在前面。

参数:

collection_name – 集合的名称
key – 要进行切面的载荷字段
facet_filter – 要应用的过滤器
limit – 要返回的最大匹配数
exact – 如果为 ``True`` - 提供匹配 filter 的点的精确数量。如果为 ``False`` - 提供匹配 filter 的点的近似数量。速度更快。
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
timeout – 覆盖此搜索的全局超时设置。单位为秒。
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。

返回:

切面中的唯一值及其覆盖的点数量。

get_aliases(**kwargs: Any) → CollectionsAliasesResponse[source]¶

获取所有别名

返回:: 所有集合的所有别名

get_collection(collection_name: str, **kwargs: Any) → CollectionInfo[source]¶

获取关于指定现有集合的详细信息

参数:: collection_name – 集合的名称
返回:: 集合的详细信息

get_collection_aliases(collection_name: str, **kwargs: Any) → CollectionsAliasesResponse[source]¶

获取集合别名

参数:: collection_name – 集合的名称
返回:: 集合别名

get_collections(**kwargs: Any) → CollectionsResponse[source]¶

获取所有现有集合的名称列表

返回:: 集合列表

get_locks(**kwargs: Any) → LocksOption[source]¶: 获取当前锁状态。

info() → VersionInfo[source]¶

返回关于正在运行的 Qdrant 实例的信息，例如版本和提交ID

返回:: 标题、版本以及可选的提交信息

list_full_snapshots(**kwargs: Any) → list[SnapshotDescription][source]¶

列出整个存储的所有快照

返回:: 快照列表

list_shard_snapshots(collection_name: str, shard_id: int, **kwargs: Any) → list[SnapshotDescription][source]¶

列出给定分片的所有快照

参数:

collection_name – 集合的名称
shard_id – 分片的索引

返回:

快照列表

list_snapshots(collection_name: str, **kwargs: Any) → list[SnapshotDescription][source]¶

列出给定集合的所有快照。

参数:: collection_name – 集合的名称
返回:: 快照列表

lock_storage(reason: str, **kwargs: Any) → LocksOption[source]¶: 锁定存储以禁止写入。

migrate(dest_client: QdrantBase, collection_names: Optional[list[str]] = None, batch_size: int = 100, recreate_on_collision: bool = False) → None[source]¶

将数据从一个 Qdrant 实例迁移到另一个实例。

参数:

dest_client – 目标 Qdrant 实例，可以是本地或远程模式
collection_names – 要迁移的集合名称列表。如果为 None，则迁移所有集合。
batch_size – 迁移过程中滚动和 upsert 操作的批次大小
recreate_on_collision – 如果为 True，则如果目标集合已存在，则重新创建该集合，否则引发 ValueError 异常。

overwrite_payload(collection_name: str, payload: Dict[str, Any], points: Union[list[Union[int, str, points_pb2.PointId]], Filter, Filter, PointIdsList, FilterSelector, PointsSelector], wait: bool = True, ordering: Optional[WriteOrdering] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → UpdateResult[source]¶

覆盖指定点的载荷。应用此操作后，点中将只包含指定的载荷。即使键未在载荷中指定，现有的载荷也会被删除。

示例

设置载荷:

# Overwrite payload value with key `"key"` to points 1, 2, 3.
# If any other valid payload value exists - it will be deleted
qdrant_client.overwrite_payload(
    collection_name="test_collection",
    wait=True,
    payload={
        "key": "value"
    },
    points=[1,2,3]
)

参数:

collection_name – 集合的名称
wait –
等待处理结果。
- 如果为 ``true``，仅当所有更改都应用后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。
payload – 要分配的载荷的键值对
points –
受影响点的列表、过滤器或点选择器。 .. rubric:: 示例
- points=[1, 2, 3, “cd3b53f0-11a7-449f-bc50-d06310e7ed90”]
- points=Filter(must=[FieldCondition(key=’rand_number’, range=Range(gte=0.7))])
ordering (Optional[*WriteOrdering*]) –
定义点的排序策略。可能的值
- ``weak`` (默认) - 写操作可能被重新排序，速度更快
- ``medium`` - 写操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致
- ``strong`` - 写操作通过永久领导者进行，一致，但如果领导者宕机可能会不可用
shard_key_selector – 定义应用于写入更新的分片组。如果提供了多个 shard_key，更新将写入到每个分片组。仅适用于采用 ``custom`` 分片方法的集合。

返回:

操作结果

query_batch_points(collection_name: str, requests: Sequence[Union[QueryRequest, QueryPoints]], consistency: Optional[Union[int, ReadConsistencyType]] = None, timeout: Optional[int] = None, **kwargs: Any) → list[QueryResponse][source]¶

批量执行搜索、推荐、发现、上下文搜索等操作，并减少网络开销

参数:

collection_name – 集合的名称
requests – 查询请求列表
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
timeout – 覆盖此搜索的全局超时设置。单位为秒。

返回:

查询响应列表

query_points(collection_name: str, query: Optional[Union[int, str, PointId, list[float], list[list[float]], SparseVector, NearestQuery, RecommendQuery, DiscoverQuery, ContextQuery, OrderByQuery, FusionQuery, FormulaQuery, SampleQuery, ndarray[tuple[int, ...], dtype[Union[bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, longdouble]]], Document, Image, InferenceObject]] = None, using: Optional[str] = None, prefetch: Optional[Union[Prefetch, list[Prefetch]]] = None, query_filter: Optional[Union[Filter, Filter]] = None, search_params: Optional[Union[SearchParams, SearchParams]] = None, limit: int = 10, offset: Optional[int] = None, with_payload: Union[bool, Sequence[str], PayloadSelectorInclude, PayloadSelectorExclude, WithPayloadSelector] = True, with_vectors: Union[bool, Sequence[str]] = False, score_threshold: Optional[float] = None, lookup_from: Optional[Union[LookupLocation, LookupLocation]] = None, consistency: Optional[Union[int, ReadConsistencyType]] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, timeout: Optional[int] = None, **kwargs: Any) → QueryResponse[source]¶

用于运行任何可用操作（如搜索、推荐、发现、上下文搜索）的通用端点。

参数:

collection_name – 要在其中搜索的集合
query – 所选搜索类型操作的查询。- 如果是 str，则将字符串用作现有点的 UUID 进行搜索查询。- 如果是 int，则将整数用作现有点的 ID 进行搜索查询。- 如果是 list[float]，则用作密集向量进行最近邻搜索。- 如果是 list[list[float]]，则用作多向量进行最近邻搜索。- 如果是 SparseVector，则用作稀疏向量进行最近邻搜索。- 如果是 Query，则用作特定搜索类型的查询。- 如果是 NumpyArray，则用作密集向量进行最近邻搜索。- 如果是 Document，则从文档文本推断向量并用作最近邻搜索（需要安装 fastembed 包）。- 如果是 None，则返回集合中前 limit 个点。
prefetch – 预取查询以选择要与主查询一起使用的数据
query_filter –
- 排除不符合给定条件的向量。
- 如果为 None，则在所有向量中搜索。
search_params – 附加搜索参数
limit – 返回多少结果
offset – 要返回的第一个结果的偏移量。可用于结果分页。注意：较大的偏移量值可能会导致性能问题。
with_payload –
- 指定应附加到结果的存储载荷。
- 如果为 True，则附加所有载荷
- 如果为 False，则不附加任何载荷
- 如果是字符串列表，则仅包含指定字段
- 如果是 PayloadSelector，则使用显式规则
with_vectors –
- 如果为 True，则将存储的向量附加到搜索结果中。
- 如果为 False，则不附加向量。
- 如果是字符串列表，则仅包含指定字段
- 默认值：False
score_threshold – 定义结果的最小分数阈值。如果定义了该值，则相似度较低的结果将不会返回。返回结果的分数可能高于或低于阈值，具体取决于使用的距离函数。例如，对于余弦相似度，只会返回较高的分数。
using – 用于查询的向量名称。如果为 None，则使用默认向量或命名向量结构中提供的向量。
lookup_from –

定义一个位置（集合和向量字段名称），用于查找推荐、
发现和上下文查询所需的向量。

如果为 None，则使用当前集合。
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。
timeout – 覆盖此搜索的全局超时设置。单位为秒。

示例

使用过滤器搜索最近的点:

qdrant.query(
    collection_name="test_collection",
    query=[1.0, 0.1, 0.2, 0.7],
    query_filter=Filter(
        must=[
            FieldCondition(
                key='color',
                range=Match(
                    value="red"
                )
            )
        ]
    )
)

返回:: QueryResponse 结构，包含找到的相似点列表及其相似度分数。

query_points_groups(collection_name: str, group_by: str, query: Optional[Union[int, str, PointId, list[float], list[list[float]], SparseVector, NearestQuery, RecommendQuery, DiscoverQuery, ContextQuery, OrderByQuery, FusionQuery, FormulaQuery, SampleQuery, ndarray[tuple[int, ...], dtype[Union[bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, longdouble]]], Document, Image, InferenceObject]] = None, using: Optional[str] = None, prefetch: Optional[Union[Prefetch, list[Prefetch]]] = None, query_filter: Optional[Union[Filter, Filter]] = None, search_params: Optional[Union[SearchParams, SearchParams]] = None, limit: int = 10, group_size: int = 3, with_payload: Union[bool, Sequence[str], PayloadSelectorInclude, PayloadSelectorExclude, WithPayloadSelector] = True, with_vectors: Union[bool, Sequence[str]] = False, score_threshold: Optional[float] = None, with_lookup: Optional[Union[str, WithLookup]] = None, lookup_from: Optional[Union[LookupLocation, LookupLocation]] = None, consistency: Optional[Union[int, ReadConsistencyType]] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, timeout: Optional[int] = None, **kwargs: Any) → GroupsResult[source]¶

对任何可用的操作（如搜索、推荐、发现、上下文搜索）进行分组的通用端点。

参数:

collection_name – 要在其中搜索的集合
query – 所选搜索类型操作的查询。- 如果是 str，则将字符串用作现有点的 UUID 进行搜索查询。- 如果是 int，则将整数用作现有点的 ID 进行搜索查询。- 如果是 list[float]，则用作密集向量进行最近邻搜索。- 如果是 list[list[float]]，则用作多向量进行最近邻搜索。- 如果是 SparseVector，则用作稀疏向量进行最近邻搜索。- 如果是 Query，则用作特定搜索类型的查询。- 如果是 NumpyArray，则用作密集向量进行最近邻搜索。- 如果是 Document，则从文档文本推断向量并用作最近邻搜索（需要安装 fastembed 包）。- 如果是 None，则返回集合中前 limit 个点。
prefetch – 预取查询以选择要与主查询一起使用的数据
query_filter –
- 排除不符合给定条件的向量。
- 如果为 None，则在所有向量中搜索。
search_params – 附加搜索参数
limit – 返回多少结果
group_size – 每组返回多少结果
group_by – 用于分组的 payload 字段名称。字段必须是“keyword”或“integer”类型。嵌套字段使用点表示法指定，例如“nested_field.subfield”。
with_payload –
- 指定应附加到结果的存储载荷。
- 如果为 True，则附加所有载荷
- 如果为 False，则不附加任何载荷
- 如果是字符串列表，则仅包含指定字段
- 如果是 PayloadSelector，则使用显式规则
with_vectors –
- 如果为 True，则将存储的向量附加到搜索结果中。
- 如果为 False，则不附加向量。
- 如果是字符串列表，则仅包含指定字段
- 默认值：False
score_threshold – 定义结果的最小分数阈值。如果定义了该值，则相似度较低的结果将不会返回。返回结果的分数可能高于或低于阈值，具体取决于使用的距离函数。例如，对于余弦相似度，只会返回较高的分数。
using – 用于查询的向量名称。如果为 None，则使用默认向量或命名向量结构中提供的向量。
with_lookup – 使用组 ID 在另一个集合中查找点。如果指定，每个组将包含来自指定集合的记录，其 ID 与组 ID 相同。此外，该参数允许指定应返回记录的哪些部分，类似于 with_payload 和 with_vectors 参数。
lookup_from – 定义一个位置（集合和向量字段名称），用于查找查询中作为 ID 引用的向量。如果为 None - 将使用当前集合。
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。
timeout – 覆盖此搜索的全局超时设置。单位为秒。

示例

搜索最近的点并对结果进行分组:

   qdrant.query_points_groups(
       collection_name="test_collection",
       query=[1.0, 0.1, 0.2, 0.7],
       group_by="color",
       group_size=3,
   )

Returns:
   List of groups with not more than `group_size` hits in each group.
   Each group also contains an id of the group, which is the value of the payload field.

recommend(collection_name: str, positive: Optional[Sequence[Union[int, str, List[float], SparseVector]]] = None, negative: Optional[Sequence[Union[int, str, List[float], SparseVector]]] = None, query_filter: Optional[Union[Filter, Filter]] = None, search_params: Optional[Union[SearchParams, SearchParams]] = None, limit: int = 10, offset: int = 0, with_payload: Union[bool, list[str], PayloadSelectorInclude, PayloadSelectorExclude, WithPayloadSelector] = True, with_vectors: Union[bool, list[str]] = False, score_threshold: Optional[float] = None, using: Optional[str] = None, lookup_from: Optional[Union[LookupLocation, LookupLocation]] = None, strategy: Optional[RecommendStrategy] = None, consistency: Optional[Union[int, ReadConsistencyType]] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, timeout: Optional[int] = None, **kwargs: Any) → list[ScoredPoint][source]¶

推荐点：根据 Qdrant 中已存储的示例搜索相似点。

提供已存储点的 ID，Qdrant 将根据已有的向量执行搜索。此功能对于基于现有集合的点进行推荐特别有用。

参数:

collection_name – 要在其中搜索的集合
positive – 已存储点 ID 或向量列表，应将其用作相似性搜索的参考。如果只有一个示例，则此请求等同于对该点的向量进行常规搜索。如果存在多个示例，Qdrant 将尝试搜索与所有示例相似的点。对多个向量进行推荐是实验性功能。其行为可能会根据所选策略而改变。
negative – 已存储点 ID 或向量列表，应与搜索结果不相似。负例是实验性功能。其行为可能会根据所选策略而改变。
query_filter –
- 排除不符合给定条件的向量。
- 如果为 None，则在所有向量中搜索。
search_params – 附加搜索参数
limit – 返回多少结果
offset – 要返回的第一个结果的偏移量。可用于结果分页。注意：较大的偏移量值可能会导致性能问题。
with_payload –
- 指定应附加到结果的存储载荷。
- 如果为 True，则附加所有载荷
- 如果为 False，则不附加任何载荷
- 如果是字符串列表，则仅包含指定字段
- 如果是 PayloadSelector，则使用显式规则
with_vectors –
- 如果为 True，则将存储的向量附加到搜索结果中。
- 如果为 False，则不附加向量。
- 如果是字符串列表，则仅包含指定字段
- 默认值：False
score_threshold – 定义结果的最小分数阈值。如果定义了该值，则相似度较低的结果将不会返回。返回结果的分数可能高于或低于阈值，具体取决于使用的距离函数。例如，对于余弦相似度，只会返回较高的分数。
using – 用于推荐的向量名称。如果为 None - 使用默认向量。
lookup_from – 定义一个位置（集合和向量字段名称），用于查找推荐中使用的向量。如果为 None - 将使用当前集合。
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。
strategy –
用于推荐的策略。策略定义了如何将多个示例组合成一个推荐查询。可能的值：
- ‘average_vector’ - 计算所有示例的平均向量并用于搜索
- ‘best_score’ - 找到更接近正例且更远离负例的结果
timeout – 覆盖此搜索的全局超时设置。单位为秒。

返回:

推荐点的列表，包含相似性分数。

recommend_batch(collection_name: str, requests: Sequence[Union[RecommendRequest, RecommendPoints]], consistency: Optional[Union[int, ReadConsistencyType]] = None, timeout: Optional[int] = None, **kwargs: Any) → list[list[ScoredPoint]][source]¶

以批处理模式执行多个推荐请求

参数:

collection_name – 集合的名称
requests – 推荐请求列表
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
timeout – 覆盖此搜索的全局超时设置。单位为秒。

返回:

推荐响应列表

recommend_groups(collection_name: str, group_by: str, positive: Optional[Sequence[Union[int, str, List[float], SparseVector]]] = None, negative: Optional[Sequence[Union[int, str, List[float], SparseVector]]] = None, query_filter: Optional[Union[Filter, Filter]] = None, search_params: Optional[Union[SearchParams, SearchParams]] = None, limit: int = 10, group_size: int = 1, score_threshold: Optional[float] = None, with_payload: Union[bool, Sequence[str], PayloadSelectorInclude, PayloadSelectorExclude, WithPayloadSelector] = True, with_vectors: Union[bool, Sequence[str]] = False, using: Optional[str] = None, lookup_from: Optional[Union[LookupLocation, LookupLocation]] = None, with_lookup: Optional[Union[str, WithLookup]] = None, strategy: Optional[RecommendStrategy] = None, consistency: Optional[Union[int, ReadConsistencyType]] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, timeout: Optional[int] = None, **kwargs: Any) → GroupsResult[source]¶

推荐点组：根据 Qdrant 中已存储的示例搜索相似点，并按 payload 字段进行分组。

推荐按 payload 字段值分组的给定已存储示例的最佳匹配。这对于获取每个类别中最相关的结果、去除重复结果、为同一实体找到最佳表示向量非常有用。

参数:

collection_name – 要在其中搜索的集合
positive – 已存储点 ID 或向量列表，应将其用作相似性搜索的参考。如果只有一个示例，则此请求等同于对该点的向量进行常规搜索。如果存在多个示例，Qdrant 将尝试搜索与所有示例相似的点。对多个向量进行推荐是实验性功能。其行为可能会根据所选策略而改变。
negative – 已存储点 ID 或向量列表，应与搜索结果不相似。负例是实验性功能。其行为可能会根据所选策略而改变。
group_by – 用于分组的 payload 字段名称。字段必须是“keyword”或“integer”类型。嵌套字段使用点表示法指定，例如“nested_field.subfield”。
query_filter –
- 排除不符合给定条件的向量。
- 如果为 None，则在所有向量中搜索。
search_params – 附加搜索参数
limit – 返回多少组
group_size – 每组返回多少结果
with_payload –
- 指定应附加到结果的存储载荷。
- 如果为 True，则附加所有载荷
- 如果为 False，则不附加任何载荷
- 如果是字符串列表，则仅包含指定字段
- 如果是 PayloadSelector，则使用显式规则
with_vectors –
- 如果为 True，则将存储的向量附加到搜索结果中。
- 如果为 False，则不附加向量。
- 如果是字符串列表，则仅包含指定字段
- 默认值：False
score_threshold – 定义结果的最小分数阈值。如果定义了该值，则相似度较低的结果将不会返回。返回结果的分数可能高于或低于阈值，具体取决于使用的距离函数。例如，对于余弦相似度，只会返回较高的分数。
using – 用于推荐的向量名称。如果为 None - 使用默认向量。
lookup_from – 定义一个位置（集合和向量字段名称），用于查找推荐中使用的向量。如果为 None - 将使用当前集合。
with_lookup – 使用组 ID 在另一个集合中查找点。如果指定，每个组将包含来自指定集合的记录，其 ID 与组 ID 相同。此外，该参数允许指定应返回记录的哪些部分，类似于 with_payload 和 with_vectors 参数。
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。
strategy –
用于推荐的策略。策略定义了如何将多个示例组合成一个推荐查询。可能的值：
- ‘average_vector’ - 计算所有示例的平均向量并用于搜索
- ‘best_score’ - 找到更接近正例且更远离负例的结果
timeout – 覆盖此搜索的全局超时设置。单位为秒。

返回:

组列表，每组包含不超过 group_size 个匹配项。每个组还包含一个组 ID，即 payload 字段的值。

recover_shard_snapshot(collection_name: str, shard_id: int, location: str, api_key: Optional[str] = None, checksum: Optional[str] = None, priority: Optional[SnapshotPriority] = None, wait: bool = True, **kwargs: Any) → Optional[bool][source]¶

从快照恢复分片。

参数:

collection_name – 集合的名称
shard_id – 分片的索引
location – 快照的 URL 示例：- URL http://localhost:8080/collections/my_collection/snapshots/my_snapshot
api_key – 用于访问另一台服务器上快照的 API 密钥。
checksum – 快照的校验和，用于验证快照的完整性。
priority –
定义快照恢复的真相来源
- replica（默认）表示 - 优先使用现有数据而非快照
- no_sync 表示 - 不与其他分片同步
- snapshot 表示 - 优先使用快照数据而非当前状态
wait –
等待恢复完成。
- 如果为 true，结果只会在恢复完成后返回
- 如果为 ``false``，收到确认后立即返回结果。

返回:

如果快照已恢复则为 True

recover_snapshot(collection_name: str, location: str, api_key: Optional[str] = None, checksum: Optional[str] = None, priority: Optional[SnapshotPriority] = None, wait: bool = True, **kwargs: Any) → Optional[bool][source]¶

从快照恢复集合。

参数:

collection_name – 集合的名称
location – 快照的 URL 示例：- URL http://localhost:8080/collections/my_collection/snapshots/my_snapshot - 本地路径 file:///qdrant/snapshots/test_collection/test_collection-6194298859870377-2023-11-09-15-17-51.snapshot
api_key – 用于访问另一台服务器上快照的 API 密钥。
checksum – 快照的校验和，用于验证快照的完整性。
priority –
定义快照恢复的真相来源
- replica（默认）表示 - 优先使用现有数据而非快照
- no_sync 表示 - 不与其他分片同步
- snapshot 表示 - 优先使用快照数据而非当前状态
wait –
等待恢复完成。
- 如果为 true，结果只会在恢复完成后返回
- 如果为 ``false``，收到确认后立即返回结果。

返回:

如果快照已恢复则为 True

recreate_collection(collection_name: str, vectors_config: Union[VectorParams, Mapping[str, VectorParams]], sparse_vectors_config: Optional[Mapping[str, SparseVectorParams]] = None, shard_number: Optional[int] = None, sharding_method: Optional[ShardingMethod] = None, replication_factor: Optional[int] = None, write_consistency_factor: Optional[int] = None, on_disk_payload: Optional[bool] = None, hnsw_config: Optional[Union[HnswConfigDiff, HnswConfigDiff]] = None, optimizers_config: Optional[Union[OptimizersConfigDiff, OptimizersConfigDiff]] = None, wal_config: Optional[Union[WalConfigDiff, WalConfigDiff]] = None, quantization_config: Optional[Union[ScalarQuantization, ProductQuantization, BinaryQuantization, QuantizationConfig]] = None, init_from: Optional[Union[InitFrom, str]] = None, timeout: Optional[int] = None, strict_mode_config: Optional[StrictModeConfig] = None, **kwargs: Any) → bool[source]¶

删除并使用给定参数创建空集合

参数:

collection_name – 要重新创建的集合名称
vectors_config – 向量存储的配置。Vector params 包含向量存储的大小和距离。如果传入 dict，服务将为 dict 中的每个键创建一个向量存储。如果传入单个 VectorParams，服务将创建一个单独的匿名向量存储。
sparse_vectors_config – 稀疏向量存储的配置。服务将为 dict 中的每个键创建一个稀疏向量存储。
shard_number – 集合中的分片数量。默认值为 1，最小值为 1。
sharding_method – 定义分片创建策略。选项 ``auto`` (默认) 自动创建指定数量的分片。数据将自动分布到分片之间。创建后，可以额外复制分片，但无法创建新的分片。选项 ``custom`` 允许手动创建分片，每个分片都应分配唯一的 ``shard_key``。数据将根据 ``shard_key`` 值分布。
replication_factor – 集合的复制因子。默认值为 1，最小值为 1。定义每个分片将创建多少个副本。仅在分布式模式下有效。
write_consistency_factor – 集合的写入一致性因子。默认值为 1，最小值为 1。定义需要有多少个副本应用操作才能被视为成功。增加此数字会使集合对不一致更具弹性，但如果可用副本不足也会导致失败。不影响性能。仅在分布式模式下有效。
on_disk_payload – 如果为 true - 点的 payload 将不存储在内存中。每次请求时都会从磁盘读取。此设置通过（略微）增加响应时间来节省 RAM。注意：参与过滤并已索引的 payload 值仍保留在 RAM 中。
hnsw_config – HNSW 索引的参数
optimizers_config – 优化器的参数
wal_config – Write-Ahead-Log 的参数
quantization_config – 量化的参数，如果为 None - 将禁用量化
init_from – 使用存储在另一个集合中的数据初始化此集合
timeout – 操作提交的等待超时时间（秒）。如果达到超时，请求将返回服务错误。
strict_mode_config – 配置集合的限制，例如最大大小、速率限制等。

返回:

操作结果

retrieve(collection_name: str, ids: Sequence[Union[int, str, PointId]], with_payload: Union[bool, Sequence[str], PayloadSelectorInclude, PayloadSelectorExclude, WithPayloadSelector] = True, with_vectors: Union[bool, Sequence[str]] = False, consistency: Optional[Union[int, ReadConsistencyType]] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, timeout: Optional[int] = None, **kwargs: Any) → list[Record][source]¶

按 ID 检索存储的点

参数:

collection_name – 要查找的集合名称
ids – 要查找的 ID 列表
with_payload –
- 指定应附加到结果的存储载荷。
- 如果为 True，则附加所有载荷
- 如果为 False，则不附加任何载荷
- 如果是字符串列表，则仅包含指定字段
- 如果是 PayloadSelector，则使用显式规则
with_vectors –
- 如果为 True，则将存储的向量附加到搜索结果中。
- 如果为 False，则不附加向量。
- 如果为字符串列表 - 仅附加指定的向量。
- 默认值：False
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。
timeout – 覆盖此操作的全局超时设置。单位为秒。

返回:

点列表

scroll(collection_name: str, scroll_filter: Optional[Union[Filter, Filter]] = None, limit: int = 10, order_by: Optional[Union[str, OrderBy, OrderBy]] = None, offset: Optional[Union[int, str, PointId]] = None, with_payload: Union[bool, Sequence[str], PayloadSelectorInclude, PayloadSelectorExclude, WithPayloadSelector] = True, with_vectors: Union[bool, Sequence[str]] = False, consistency: Optional[Union[int, ReadConsistencyType]] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, timeout: Optional[int] = None, **kwargs: Any) → tuple[list[Record], Union[int, str, points_pb2.PointId, NoneType]][source]¶

滚动查看集合中的所有（匹配的）点。

此方法提供了一种迭代遍历所有存储的点的方法，并带有一些可选的过滤条件。滚动不应用任何相似度估计，它将按 ID 升序返回点。

参数:

collection_name – 集合的名称
scroll_filter – 如果提供 - 仅返回符合过滤条件的点
limit – 要返回的点数
order_by – 按 payload 键对记录排序。如果为 None - 按 ID 排序
offset – 如果提供 - 跳过 ID 小于给定 offset 的点
with_payload –
- 指定应附加到结果的存储载荷。
- 如果为 True，则附加所有载荷
- 如果为 False，则不附加任何载荷
- 如果是字符串列表，则仅包含指定字段
- 如果是 PayloadSelector，则使用显式规则
with_vectors –
- 如果为 True，则将存储的向量附加到搜索结果中。
- 如果为 False（默认）- 不附加向量。
- 如果是字符串列表，则仅包含指定字段
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。
timeout – 覆盖此操作的全局超时设置。单位为秒。

返回:

一个包含（点列表）和（下一个滚动请求的可选偏移量）的对。如果下一页偏移量为 None - 则集合中没有更多点可供滚动。

search(collection_name: str, query_vector: Union[Sequence[float], tuple[str, list[float]], NamedVector, NamedSparseVector, ndarray[tuple[int, ...], dtype[Union[bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, longdouble]]]], query_filter: Optional[Union[Filter, Filter]] = None, search_params: Optional[Union[SearchParams, SearchParams]] = None, limit: int = 10, offset: Optional[int] = None, with_payload: Union[bool, Sequence[str], PayloadSelectorInclude, PayloadSelectorExclude, WithPayloadSelector] = True, with_vectors: Union[bool, Sequence[str]] = False, score_threshold: Optional[float] = None, append_payload: bool = True, consistency: Optional[Union[int, ReadConsistencyType]] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, timeout: Optional[int] = None, **kwargs: Any) → list[ScoredPoint][source]¶

在考虑过滤条件的情况下搜索集合中最接近的向量

参数:

collection_name – 要在其中搜索的集合
query_vector – 搜索最接近此向量的向量。可以是向量本身，也可以是命名向量、命名稀疏向量，或者是向量名称和向量本身的元组
query_filter –
- 排除不符合给定条件的向量。
- 如果为 None，则在所有向量中搜索。
search_params – 附加搜索参数
limit – 返回多少结果
offset – 要返回的第一个结果的偏移量。可用于结果分页。注意：较大的偏移量值可能会导致性能问题。
with_payload –
- 指定应附加到结果的存储载荷。
- 如果为 True，则附加所有载荷
- 如果为 False，则不附加任何载荷
- 如果是字符串列表，则仅包含指定字段
- 如果是 PayloadSelector，则使用显式规则
with_vectors –
- 如果为 True，则将存储的向量附加到搜索结果中。
- 如果为 False，则不附加向量。
- 如果是字符串列表，则仅包含指定字段
- 默认值：False
score_threshold – 定义结果的最小分数阈值。如果定义了该值，则相似度较低的结果将不会返回。返回结果的分数可能高于或低于阈值，具体取决于使用的距离函数。例如，对于余弦相似度，只会返回较高的分数。
append_payload – 与 with_payload 相同。已弃用。
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。
timeout – 覆盖此搜索的全局超时设置。单位为秒。

示例

带过滤器的搜索:

qdrant.search(
    collection_name="test_collection",
    query_vector=[1.0, 0.1, 0.2, 0.7],
    query_filter=Filter(
        must=[
            FieldCondition(
                key='color',
                range=Match(
                    value="red"
                )
            )
        ]
    )
)

返回:: 找到的相似点列表及其相似度分数。

search_batch(collection_name: str, requests: Sequence[Union[SearchRequest, SearchPoints]], timeout: Optional[int] = None, consistency: Optional[Union[int, ReadConsistencyType]] = None, **kwargs: Any) → list[list[ScoredPoint]][source]¶

在集合中执行多次搜索以减轻网络开销

参数:

collection_name – 集合的名称
requests – 搜索请求列表
consistency –
搜索的读取一致性。定义在返回结果之前应查询多少个副本。取值如下：
- int - 要查询的副本数量，值应存在于所有被查询的副本中
- ’majority’ - 查询所有副本，返回大多数副本中存在的值
- ’quorum’ - 查询大多数副本，返回所有这些副本中存在的值
- ’all’ - 查询所有副本，返回所有副本中存在的值
timeout – 覆盖此搜索的全局超时设置。单位为秒。

返回:

搜索响应列表

search_groups(collection_name: str, query_vector: Union[Sequence[float], tuple[str, list[float]], NamedVector, NamedSparseVector, ndarray[tuple[int, ...], dtype[Union[bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, longdouble]]]], group_by: str, query_filter: Optional[Union[Filter, Filter]] = None, search_params: Optional[Union[SearchParams, SearchParams]] = None, limit: int = 10, group_size: int = 1, with_payload: Union[bool, Sequence[str], PayloadSelectorInclude, PayloadSelectorExclude, WithPayloadSelector] = True, with_vectors: Union[bool, Sequence[str]] = False, score_threshold: Optional[float] = None, with_lookup: Optional[Union[str, WithLookup]] = None, consistency: Optional[Union[int, ReadConsistencyType]] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, timeout: Optional[int] = None, **kwargs: Any) → GroupsResult[source]¶

按 payload 字段分组搜索最接近的向量。

按 payload 字段的值分组搜索与查询向量最匹配的结果。这对于获取每个类别中最相关的结果、去重结果、以及为同一实体找到最佳表示向量非常有用。

参数:

collection_name – 要在其中搜索的集合
query_vector – 搜索最接近此向量的向量。可以是向量本身，也可以是命名向量、命名稀疏向量，或者是向量名称和向量本身的元组
group_by – 用于分组的 payload 字段名称。字段必须是“keyword”或“integer”类型。嵌套字段使用点表示法指定，例如“nested_field.subfield”。
query_filter –
- 排除不符合给定条件的向量。
- 如果为 None，则在所有向量中搜索。
search_params – 附加搜索参数
limit – 返回多少组
group_size – 每组返回多少结果
with_payload –
- 指定应附加到结果的存储载荷。
- 如果为 True，则附加所有载荷
- 如果为 False，则不附加任何载荷
- 如果是字符串列表，则仅包含指定字段
- 如果是 PayloadSelector，则使用显式规则
with_vectors –
- 如果为 True，则将存储的向量附加到搜索结果中。
- 如果为 False，则不附加向量。
- 如果是字符串列表，则仅包含指定字段
- 默认值：False
score_threshold – 结果的最小分数阈值。如果定义，相似度较低的结果将不返回。返回结果的分数可能高于或低于阈值，具体取决于使用的距离函数。例如，对于余弦相似度，只返回分数较高的结果。
with_lookup – 使用组 ID 在另一个集合中查找点。如果指定，每个组将包含来自指定集合的记录，其 ID 与组 ID 相同。此外，该参数允许指定应返回记录的哪些部分，类似于 with_payload 和 with_vectors 参数。
consistency – 读取一致性。定义在返回结果之前应查询多少个副本。值：- int - 要查询的副本数，值应存在于所有被查询的副本中 - ‘majority’ - 查询所有副本，但返回存在于大多数副本中的值 - ‘quorum’ - 查询大多数副本，返回存在于所有这些副本中的值 - ‘all’ - 查询所有副本，并返回存在于所有副本中的值
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 ``None`` - 查询所有分片。仅适用于采用 ``custom`` 分片方法的集合。
timeout – 覆盖此搜索的全局超时设置。单位为秒。

返回:

组列表，每组包含不超过 group_size 个匹配项。每个组还包含一个组 ID，即 payload 字段的值。

search_matrix_offsets(collection_name: str, query_filter: Optional[Union[Filter, Filter]] = None, limit: int = 3, sample: int = 10, using: Optional[str] = None, consistency: Optional[Union[int, ReadConsistencyType]] = None, timeout: Optional[int] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → SearchMatrixOffsetsResponse[source]¶

计算采样点的距离矩阵，采用基于偏移量的输出格式。

参数:

collection_name – 集合的名称。
query_filter – 要应用的过滤器。
limit – 每个样本查找多少个邻居。
sample – 要选择和搜索的点数。
using – 用于搜索的向量名称。如果为 None，则使用默认向量。
consistency – 读取一致性。定义在返回结果之前应查询多少个副本。值：- int：要查询的副本数量，值必须存在于所有被查询的副本中。- ‘majority’：查询所有副本，但返回存在于大多数副本中的值。- ‘quorum’：查询大多数副本，返回存在于所有这些副本中的值。- ‘all’：查询所有副本，并返回存在于所有副本中的值。
timeout – 覆盖此搜索的全局超时设置。单位为秒。
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 None，则查询所有分片。仅适用于使用 custom 分片方法的集合。

返回:

使用基于偏移量编码的距离矩阵。

search_matrix_pairs(collection_name: str, query_filter: Optional[Union[Filter, Filter]] = None, limit: int = 3, sample: int = 10, using: Optional[str] = None, consistency: Optional[Union[int, ReadConsistencyType]] = None, timeout: Optional[int] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → SearchMatrixPairsResponse[source]¶

计算采样点的距离矩阵，采用基于对的输出格式。

参数:

collection_name – 集合的名称。
query_filter – 要应用的过滤器。
limit – 每个样本查找多少个邻居。
sample – 要选择和搜索的点数。
using – 用于搜索的向量名称。如果为 None，则使用默认向量。
consistency – 读取一致性。定义在返回结果之前应查询多少个副本。值：- int：要查询的副本数量，值必须存在于所有被查询的副本中。- ‘majority’：查询所有副本，但返回存在于大多数副本中的值。- ‘quorum’：查询大多数副本，返回存在于所有这些副本中的值。- ‘all’：查询所有副本，并返回存在于所有副本中的值。
timeout – 覆盖此搜索的全局超时设置。单位为秒。
shard_key_selector – 此参数允许指定应查询哪些分片。如果为 None，则查询所有分片。仅适用于使用 custom 分片方法的集合。

返回:

使用基于对编码的距离矩阵。

set_payload(collection_name: str, payload: Dict[str, Any], points: Union[list[Union[int, str, points_pb2.PointId]], Filter, Filter, PointIdsList, FilterSelector, PointsSelector], key: Optional[str] = None, wait: bool = True, ordering: Optional[WriteOrdering] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → UpdateResult[source]¶

修改指定点的 payload。

示例

设置载荷:

# Assign payload value with key `"key"` to points 1, 2, 3.
# If payload value with specified key already exists - it will be overwritten
qdrant_client.set_payload(
    collection_name="test_collection",
    wait=True,
    payload={
        "key": "value"
    },
    points=[1, 2, 3]
)

参数:

collection_name – 集合的名称。
wait – 等待结果被处理。- 如果为 true，只有当所有更改都应用后才会返回结果。- 如果为 false，收到确认后立即返回结果。
payload – 要分配的 payload 键值对。
points –
受影响点列表、过滤器或点选择器。示例：
- points=[1, 2, 3, “cd3b53f0-11a7-449f-bc50-d06310e7ed90”]
- points=Filter(must=[FieldCondition(key=’rand_number’, range=Range(gte=0.7))])
ordering (Optional[WriteOrdering]) – 定义点排序策略。可能的值：- weak（默认）：写入操作可能会被重新排序，工作速度更快。- medium：写入操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致。- strong：写入操作通过永久领导者进行，一致，但如果领导者宕机可能不可用。
shard_key_selector – 定义应用于写入更新的分片组。如果提供了多个分片键，更新将写入每个分片键对应的分片。仅适用于使用 custom 分片方法的集合。

key –

要修改的 payload 中嵌套字段的路径。如果未指定，则修改 payload 的根。例如：

PointStruct(
    id=42,
    vector=[...],
    payload={
        "recipe": {
            "fruits": {"apple": "100g"}
        }
    }
)

qdrant_client.set_payload(
    ...,
    payload={"cinnamon": "2g"},
    key="recipe.fruits",
    points=[42]
)

PointStruct(
    id=42,
    vector=[...],
    payload={
        "recipe": {
            "fruits": {
                "apple": "100g",
                "cinnamon": "2g"
            }
        }
    }
)

返回:

操作结果。

unlock_storage(**kwargs: Any) → LocksOption[source]¶: 解锁存储以进行写入。

update_collection(collection_name: str, optimizers_config: Optional[Union[OptimizersConfigDiff, OptimizersConfigDiff]] = None, collection_params: Optional[Union[CollectionParamsDiff, CollectionParamsDiff]] = None, vectors_config: Optional[Union[Dict[str, VectorParamsDiff], VectorsConfigDiff]] = None, hnsw_config: Optional[Union[HnswConfigDiff, HnswConfigDiff]] = None, quantization_config: Optional[Union[ScalarQuantization, ProductQuantization, BinaryQuantization, Disabled, QuantizationConfigDiff]] = None, timeout: Optional[int] = None, sparse_vectors_config: Optional[Mapping[str, SparseVectorParams]] = None, strict_mode_config: Optional[StrictModeConfig] = None, **kwargs: Any) → bool[source]¶

更新集合参数

参数:

collection_name – 集合的名称
optimizers_config – 覆盖优化器配置
collection_params – 覆盖集合参数
vectors_config – 覆盖特定向量配置
hnsw_config – 覆盖 HNSW 索引参数
quantization_config – 覆盖量化参数
timeout – 操作提交的等待超时时间（秒）。如果达到超时，请求将返回服务错误。
sparse_vectors_config – 覆盖稀疏向量特定配置
strict_mode_config – 覆盖严格模式配置

返回:

操作结果

update_collection_aliases(change_aliases_operations: Sequence[Union[CreateAliasOperation, RenameAliasOperation, DeleteAliasOperation, AliasOperations]], timeout: Optional[int] = None, **kwargs: Any) → bool[source]¶

用于执行集合别名更改的操作。

别名更改是原子性的，意味着在别名操作之间不会发生其他集合修改。

参数:

change_aliases_operations – 要执行的操作列表
timeout – 操作提交的等待超时时间（秒）。如果达到超时，请求将返回服务错误。

返回:

操作结果

update_vectors(collection_name: str, points: Sequence[PointVectors], wait: bool = True, ordering: Optional[WriteOrdering] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → UpdateResult[source]¶

更新集合中指定的向量。保留 payload 和未指定的向量不变。

参数:

collection_name (str) – 要更新向量的集合名称
points (Point) –
要更新的 (id, vector) 对列表。Vector 可以是数字列表或命名向量的字典。示例：
- PointVectors(id=1, vector=[1, 2, 3])
- PointVectors(id=2, vector={‘vector_1’: [1, 2, 3], ‘vector_2’: [4, 5, 6]})
wait (bool) –
等待处理结果。
- 如果为 ``true``，仅当所有更改都应用后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。
ordering (Optional[*WriteOrdering*]) –
定义点的排序策略。可能的值
- ``weak`` (默认) - 写操作可能被重新排序，速度更快
- ``medium`` - 写操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致
- ``strong`` - 写操作通过永久领导者进行，一致，但如果领导者宕机可能会不可用
shard_key_selector – 定义应用于写入更新的分片组。如果提供了多个 shard_key，更新将写入到每个分片组。仅适用于采用 ``custom`` 分片方法的集合。

返回:

操作结果(UpdateResult)

upload_collection(collection_name: str, vectors: Union[Iterable[Union[List[float], List[List[float]], Dict[str, Union[List[float], SparseVector, List[List[float]], Document, Image, InferenceObject]], Document, Image, InferenceObject]], dict[str, numpy.ndarray[tuple[int, ...], numpy.dtype[Union[numpy.bool, numpy.int8, numpy.int16, numpy.int32, numpy.int64, numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64, numpy.float16, numpy.float32, numpy.float64, numpy.longdouble]]]], ndarray[tuple[int, ...], dtype[Union[bool, int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32, float64, longdouble]]]], payload: Optional[Iterable[dict[Any, Any]]] = None, ids: Optional[Iterable[Union[int, str, PointId]]] = None, batch_size: int = 64, parallel: int = 1, method: Optional[str] = None, max_retries: int = 3, wait: bool = False, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → None[source]¶

将向量和负载上传到集合中。此方法将自动对数据进行批处理。如果您需要执行单个更新，请使用 upsert 方法。注意：如果您想上传具有单个负载的多个向量，请使用 upload_records 方法。

参数:

collection_name – 要上传到的集合的名称
vectors – numpy.ndarray 或可迭代的要上传的向量。可能是 mmap 映射的
payload – 可迭代的向量负载，可选，默认为 None
ids – 可迭代的自定义向量 ID，可选，默认为 None
batch_size – 每个请求上传多少个向量，默认为 64
parallel – 上传的并行进程数
method – 并行进程的启动方法，默认为 forkserver
max_retries – 在上传批次过程中发生故障时的最大重试次数
wait – 等待结果在服务器端应用。如果为 true，每个更新请求将显式等待完成确认。这可能较慢。如果为 false，每个更新请求在收到确认后立即返回。默认为 false
shard_key_selector – 定义应用于写入更新的分片组。如果提供了多个 shard_key，更新将写入到每个分片组。仅适用于采用 ``custom`` 分片方法的集合。

upload_points(collection_name: str, points: Iterable[PointStruct], batch_size: int = 64, parallel: int = 1, method: Optional[str] = None, max_retries: int = 3, wait: bool = False, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → None[source]¶

将点上传到集合中

类似于 upload_collection 方法，但处理的是点，而不是单独的向量和负载。

参数:

collection_name – 要上传到的集合的名称
points – 要上传的点的迭代器
batch_size – 每个请求上传多少个向量，默认为 64
parallel – 上传的并行进程数
method – 并行进程的启动方法，默认为 forkserver
max_retries – 在上传批次过程中发生故障时的最大重试次数
wait – 等待结果在服务器端应用。如果为 true，每个更新请求将显式等待完成确认。这可能较慢。如果为 false，每个更新请求在收到确认后立即返回。默认为 false
shard_key_selector – 定义用于写入更新的分片组。如果提供了多个分片键，则更新将写入到每个分片中。仅适用于使用 custom 分片方法的集合。此参数将覆盖记录中写入的分片键。

upload_records(collection_name: str, records: Iterable[Record], batch_size: int = 64, parallel: int = 1, method: Optional[str] = None, max_retries: int = 3, wait: bool = False, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → None[source]¶

将记录上传到集合中

类似于 upload_collection 方法，但处理的是记录，而不是单独的向量和负载。

参数:

collection_name – 要上传到的集合的名称
records – 要上传的记录的迭代器
batch_size – 每个请求上传多少个向量，默认为 64
parallel – 上传的并行进程数
method – 并行进程的启动方法，默认为 forkserver
max_retries – 在上传批次过程中发生故障时的最大重试次数
wait – 等待结果在服务器端应用。如果为 true，每个更新请求将显式等待完成确认。这可能较慢。如果为 false，每个更新请求在收到确认后立即返回。默认为 false
shard_key_selector – 定义用于写入更新的分片组。如果提供了多个分片键，则更新将写入到每个分片中。仅适用于使用 custom 分片方法的集合。此参数将覆盖记录中写入的分片键。

upsert(collection_name: str, points: Union[Batch, Sequence[Union[PointStruct, PointStruct]]], wait: bool = True, ordering: Optional[WriteOrdering] = None, shard_key_selector: Optional[Union[int, str, List[Union[int, str]]]] = None, **kwargs: Any) → UpdateResult[source]¶

更新或向集合插入一个新点。

如果给定 ID 的点已存在，它将被覆盖。

参数:

collection_name (str) – 要插入到的集合
points (Point) – 要插入的点批次或列表
wait (bool) –
等待处理结果。
- 如果为 ``true``，仅当所有更改都应用后才返回结果
- 如果为 ``false``，收到确认后立即返回结果。
ordering (Optional[*WriteOrdering*]) –
定义点的排序策略。可能的值
- ``weak`` (默认) - 写操作可能被重新排序，速度更快
- ``medium`` - 写操作通过动态选择的领导者进行，在领导者变更的情况下可能会在短时间内不一致
- ``strong`` - 写操作通过永久领导者进行，一致，但如果领导者宕机可能会不可用
shard_key_selector – 定义应用于写入更新的分片组。如果提供了多个 shard_key，更新将写入到每个分片组。仅适用于采用 ``custom`` 分片方法的集合。

返回:

操作结果(UpdateResult)

property grpc_collections: CollectionsStub¶

用于集合方法的 gRPC 客户端

返回:: 原始 gRPC 客户端的实例，由 Protobuf 生成

property grpc_points: PointsStub¶

用于点方法的 gRPC 客户端

返回:: 原始 gRPC 客户端的实例，由 Protobuf 生成

property http: SyncApis[ApiClient]¶

REST 客户端

返回:: 原始 REST API 客户端的实例，由 OpenAPI schema 生成

property init_options: dict[str, Any]¶

__init__ 选项

返回:: 实例化客户端类时使用的选项字典

property rest: SyncApis[ApiClient]¶

REST 客户端

返回:: 原始 REST API 客户端的实例，由 OpenAPI schema 生成

qdrant_client.qdrant_client 模块¶

Qdrant

相似度学习

社区