• Docs >
  • qdrant_client.http.models.models module
Shortcuts

qdrant_client.http.models.models module

class AbortTransferOperation(*, abort_transfer: MoveShard)[source]

Bases: BaseModel

abort_transfer: MoveShard
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'abort_transfer': FieldInfo(annotation=MoveShard, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class AliasDescription(*, alias_name: str, collection_name: str)[source]

Bases: BaseModel

alias_name: str
collection_name: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'alias_name': FieldInfo(annotation=str, required=True, description=''), 'collection_name': FieldInfo(annotation=str, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class AppBuildTelemetry(*, name: str, version: str, features: Optional[AppFeaturesTelemetry] = None, system: Optional[RunningEnvironmentTelemetry] = None, startup: datetime)[source]

Bases: BaseModel

features: Optional[AppFeaturesTelemetry]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'features': FieldInfo(annotation=Union[AppFeaturesTelemetry, NoneType], required=False, description=''), 'name': FieldInfo(annotation=str, required=True, description=''), 'startup': FieldInfo(annotation=datetime, required=True, description=''), 'system': FieldInfo(annotation=Union[RunningEnvironmentTelemetry, NoneType], required=False, description=''), 'version': FieldInfo(annotation=str, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str
startup: datetime.datetime
system: Optional[RunningEnvironmentTelemetry]
version: str
class AppFeaturesTelemetry(*, debug: bool, web_feature: bool, service_debug_feature: bool, recovery_mode: bool)[source]

Bases: BaseModel

debug: bool
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'debug': FieldInfo(annotation=bool, required=True, description=''), 'recovery_mode': FieldInfo(annotation=bool, required=True, description=''), 'service_debug_feature': FieldInfo(annotation=bool, required=True, description=''), 'web_feature': FieldInfo(annotation=bool, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

recovery_mode: bool
service_debug_feature: bool
web_feature: bool
class Batch(*, ids: List[Union[int[int], str[str]]], vectors: Union[List[List[float[float]]], Dict[str[str], List[Union[SparseVector, List[float[float]]]]]], payloads: Optional[List[Dict[str, Any]]] = None)[source]

Bases: BaseModel

ids: List[ExtendedPointId]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'ids': FieldInfo(annotation=List[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]], required=True, description=''), 'payloads': FieldInfo(annotation=Union[List[Dict[str, Any]], NoneType], required=False, description=''), 'vectors': FieldInfo(annotation=Union[List[List[Annotated[float, Strict(strict=True)]]], Dict[Annotated[str, Strict(strict=True)], List[Union[qdrant_client.http.models.models.SparseVector, List[Annotated[float, Strict(strict=True)]]]]]], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

payloads: Optional[List[Payload]]
vectors: BatchVectorStruct
class BinaryQuantization(*, binary: BinaryQuantizationConfig)[source]

Bases: BaseModel

binary: BinaryQuantizationConfig
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'binary': FieldInfo(annotation=BinaryQuantizationConfig, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class BinaryQuantizationConfig(*, always_ram: Optional[bool] = None)[source]

Bases: BaseModel

always_ram: Optional[bool]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'always_ram': FieldInfo(annotation=Union[bool, NoneType], required=False, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class ChangeAliasesOperation(*, actions: List[Union[CreateAliasOperation, DeleteAliasOperation, RenameAliasOperation]])[source]

Bases: BaseModel

Operation for performing changes of collection aliases. Alias changes are atomic, meaning that no collection modifications can happen between alias operations.

actions: List[AliasOperations]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'actions': FieldInfo(annotation=List[Union[qdrant_client.http.models.models.CreateAliasOperation, qdrant_client.http.models.models.DeleteAliasOperation, qdrant_client.http.models.models.RenameAliasOperation]], required=True, description='Operation for performing changes of collection aliases. Alias changes are atomic, meaning that no collection modifications can happen between alias operations.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class ClearPayloadOperation(*, clear_payload: Union[PointIdsList, FilterSelector])[source]

Bases: BaseModel

clear_payload: PointsSelector
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'clear_payload': FieldInfo(annotation=Union[PointIdsList, FilterSelector], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class ClusterConfigTelemetry(*, grpc_timeout_ms: int, p2p: P2pConfigTelemetry, consensus: ConsensusConfigTelemetry)[source]

Bases: BaseModel

consensus: ConsensusConfigTelemetry
grpc_timeout_ms: int
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'consensus': FieldInfo(annotation=ConsensusConfigTelemetry, required=True, description=''), 'grpc_timeout_ms': FieldInfo(annotation=int, required=True, description=''), 'p2p': FieldInfo(annotation=P2pConfigTelemetry, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

p2p: P2pConfigTelemetry
class ClusterStatusOneOf(*, status: Literal['disabled'])[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'status': FieldInfo(annotation=Literal['disabled'], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

status: Literal['disabled']
class ClusterStatusOneOf1(*, status: Literal['enabled'], peer_id: int, peers: Dict[str, PeerInfo], raft_info: RaftInfo, consensus_thread_status: Union[ConsensusThreadStatusOneOf, ConsensusThreadStatusOneOf1, ConsensusThreadStatusOneOf2], message_send_failures: Dict[str, MessageSendErrors])[source]

Bases: BaseModel

Description of enabled cluster

consensus_thread_status: ConsensusThreadStatus
message_send_failures: Dict[str, MessageSendErrors]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'consensus_thread_status': FieldInfo(annotation=Union[ConsensusThreadStatusOneOf, ConsensusThreadStatusOneOf1, ConsensusThreadStatusOneOf2], required=True, description='Description of enabled cluster'), 'message_send_failures': FieldInfo(annotation=Dict[str, qdrant_client.http.models.models.MessageSendErrors], required=True, description='Consequent failures of message send operations in consensus by peer address. On the first success to send to that peer - entry is removed from this hashmap.'), 'peer_id': FieldInfo(annotation=int, required=True, description='ID of this peer'), 'peers': FieldInfo(annotation=Dict[str, qdrant_client.http.models.models.PeerInfo], required=True, description='Peers composition of the cluster with main information'), 'raft_info': FieldInfo(annotation=RaftInfo, required=True, description='Description of enabled cluster'), 'status': FieldInfo(annotation=Literal['enabled'], required=True, description='Description of enabled cluster')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

peer_id: int
peers: Dict[str, PeerInfo]
raft_info: RaftInfo
status: Literal['enabled']
class ClusterStatusTelemetry(*, number_of_peers: int, term: int, commit: int, pending_operations: int, role: Optional[StateRole] = None, is_voter: bool, peer_id: Optional[int] = None, consensus_thread_status: Union[ConsensusThreadStatusOneOf, ConsensusThreadStatusOneOf1, ConsensusThreadStatusOneOf2])[source]

Bases: BaseModel

commit: int
consensus_thread_status: ConsensusThreadStatus
is_voter: bool
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'commit': FieldInfo(annotation=int, required=True, description=''), 'consensus_thread_status': FieldInfo(annotation=Union[ConsensusThreadStatusOneOf, ConsensusThreadStatusOneOf1, ConsensusThreadStatusOneOf2], required=True, description=''), 'is_voter': FieldInfo(annotation=bool, required=True, description=''), 'number_of_peers': FieldInfo(annotation=int, required=True, description=''), 'peer_id': FieldInfo(annotation=Union[int, NoneType], required=False, description=''), 'pending_operations': FieldInfo(annotation=int, required=True, description=''), 'role': FieldInfo(annotation=Union[StateRole, NoneType], required=False, description=''), 'term': FieldInfo(annotation=int, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

number_of_peers: int
peer_id: Optional[int]
pending_operations: int
role: Optional[StateRole]
term: int
class ClusterTelemetry(*, enabled: bool, status: Optional[ClusterStatusTelemetry] = None, config: Optional[ClusterConfigTelemetry] = None)[source]

Bases: BaseModel

config: Optional[ClusterConfigTelemetry]
enabled: bool
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'config': FieldInfo(annotation=Union[ClusterConfigTelemetry, NoneType], required=False, description=''), 'enabled': FieldInfo(annotation=bool, required=True, description=''), 'status': FieldInfo(annotation=Union[ClusterStatusTelemetry, NoneType], required=False, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

status: Optional[ClusterStatusTelemetry]
class CollectionClusterInfo(*, peer_id: int, shard_count: int, local_shards: List[LocalShardInfo], remote_shards: List[RemoteShardInfo], shard_transfers: List[ShardTransferInfo])[source]

Bases: BaseModel

Current clustering distribution for the collection

local_shards: List[LocalShardInfo]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'local_shards': FieldInfo(annotation=List[qdrant_client.http.models.models.LocalShardInfo], required=True, description='Local shards'), 'peer_id': FieldInfo(annotation=int, required=True, description='ID of this peer'), 'remote_shards': FieldInfo(annotation=List[qdrant_client.http.models.models.RemoteShardInfo], required=True, description='Remote shards'), 'shard_count': FieldInfo(annotation=int, required=True, description='Total number of shards'), 'shard_transfers': FieldInfo(annotation=List[qdrant_client.http.models.models.ShardTransferInfo], required=True, description='Shard transfers')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

peer_id: int
remote_shards: List[RemoteShardInfo]
shard_count: int
shard_transfers: List[ShardTransferInfo]
class CollectionConfig(*, params: CollectionParams, hnsw_config: HnswConfig, optimizer_config: OptimizersConfig, wal_config: WalConfig, quantization_config: Optional[Union[ScalarQuantization, ProductQuantization, BinaryQuantization]] = None)[source]

Bases: BaseModel

hnsw_config: HnswConfig
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'hnsw_config': FieldInfo(annotation=HnswConfig, required=True, description=''), 'optimizer_config': FieldInfo(annotation=OptimizersConfig, required=True, description=''), 'params': FieldInfo(annotation=CollectionParams, required=True, description=''), 'quantization_config': FieldInfo(annotation=Union[Union[ScalarQuantization, ProductQuantization, BinaryQuantization], NoneType], required=False, description=''), 'wal_config': FieldInfo(annotation=WalConfig, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

optimizer_config: OptimizersConfig
params: CollectionParams
quantization_config: Optional[QuantizationConfig]
wal_config: WalConfig
class CollectionDescription(*, name: str)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'name': FieldInfo(annotation=str, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str
class CollectionInfo(*, status: CollectionStatus, optimizer_status: Union[OptimizersStatusOneOf, OptimizersStatusOneOf1], vectors_count: Optional[int] = None, indexed_vectors_count: Optional[int] = None, points_count: Optional[int] = None, segments_count: int, config: CollectionConfig, payload_schema: Dict[str, PayloadIndexInfo])[source]

Bases: BaseModel

Current statistics and configuration of the collection

config: CollectionConfig
indexed_vectors_count: Optional[int]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'config': FieldInfo(annotation=CollectionConfig, required=True, description='Current statistics and configuration of the collection'), 'indexed_vectors_count': FieldInfo(annotation=Union[int, NoneType], required=False, description='Approximate number of indexed vectors in the collection. Indexed vectors in large segments are faster to query, as it is stored in a specialized vector index.'), 'optimizer_status': FieldInfo(annotation=Union[OptimizersStatusOneOf, OptimizersStatusOneOf1], required=True, description='Current statistics and configuration of the collection'), 'payload_schema': FieldInfo(annotation=Dict[str, qdrant_client.http.models.models.PayloadIndexInfo], required=True, description='Types of stored payload'), 'points_count': FieldInfo(annotation=Union[int, NoneType], required=False, description='Approximate number of points (vectors + payloads) in collection. Each point could be accessed by unique id.'), 'segments_count': FieldInfo(annotation=int, required=True, description='Number of segments in collection. Each segment has independent vector as payload indexes'), 'status': FieldInfo(annotation=CollectionStatus, required=True, description='Current statistics and configuration of the collection'), 'vectors_count': FieldInfo(annotation=Union[int, NoneType], required=False, description='Approximate number of vectors in collection. All vectors in collection are available for querying. Calculated as `points_count x vectors_per_point`. Where `vectors_per_point` is a number of named vectors in schema.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

optimizer_status: OptimizersStatus
payload_schema: Dict[str, PayloadIndexInfo]
points_count: Optional[int]
segments_count: int
status: CollectionStatus
vectors_count: Optional[int]
class CollectionParams(*, vectors: Optional[Union[VectorParams, Dict[str[str], VectorParams]]] = None, shard_number: Optional[int] = 1, sharding_method: Optional[ShardingMethod] = None, replication_factor: Optional[int] = 1, write_consistency_factor: Optional[int] = 1, read_fan_out_factor: Optional[int] = None, on_disk_payload: Optional[bool] = False, sparse_vectors: Optional[Dict[str, SparseVectorParams]] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'on_disk_payload': FieldInfo(annotation=Union[bool, NoneType], required=False, default=False, description='If true - point's payload will not be stored in memory. It will be read from the disk every time it is requested. This setting saves RAM by (slightly) increasing the response time. Note: those payload values that are involved in filtering and are indexed - remain in RAM.'), 'read_fan_out_factor': FieldInfo(annotation=Union[int, NoneType], required=False, description='Defines how many additional replicas should be processing read request at the same time. Default value is Auto, which means that fan-out will be determined automatically based on the busyness of the local replica. Having more than 0 might be useful to smooth latency spikes of individual nodes.'), 'replication_factor': FieldInfo(annotation=Union[int, NoneType], required=False, default=1, description='Number of replicas for each shard'), 'shard_number': FieldInfo(annotation=Union[int, NoneType], required=False, default=1, description='Number of shards the collection has'), 'sharding_method': FieldInfo(annotation=Union[ShardingMethod, NoneType], required=False, description='Sharding method Default is Auto - points are distributed across all available shards Custom - points are distributed across shards according to shard key'), 'sparse_vectors': FieldInfo(annotation=Union[Dict[str, qdrant_client.http.models.models.SparseVectorParams], NoneType], required=False, description='Configuration of the sparse vector storage'), 'vectors': FieldInfo(annotation=Union[Union[VectorParams, Dict[Annotated[str, Strict(strict=True)], qdrant_client.http.models.models.VectorParams]], NoneType], required=False, description=''), 'write_consistency_factor': FieldInfo(annotation=Union[int, NoneType], required=False, default=1, description='Defines how many replicas should apply the operation for us to consider it successful. Increasing this number will make the collection more resilient to inconsistencies, but will also make it fail if not enough replicas are available. Does not have any performance impact.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

on_disk_payload: Optional[bool]
read_fan_out_factor: Optional[int]
replication_factor: Optional[int]
shard_number: Optional[int]
sharding_method: Optional[ShardingMethod]
sparse_vectors: Optional[Dict[str, SparseVectorParams]]
vectors: Optional[VectorsConfig]
write_consistency_factor: Optional[int]
class CollectionParamsDiff(*, replication_factor: Optional[int] = None, write_consistency_factor: Optional[int] = None, read_fan_out_factor: Optional[int] = None, on_disk_payload: Optional[bool] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'on_disk_payload': FieldInfo(annotation=Union[bool, NoneType], required=False, description='If true - point's payload will not be stored in memory. It will be read from the disk every time it is requested. This setting saves RAM by (slightly) increasing the response time. Note: those payload values that are involved in filtering and are indexed - remain in RAM.'), 'read_fan_out_factor': FieldInfo(annotation=Union[int, NoneType], required=False, description='Fan-out every read request to these many additional remote nodes (and return first available response)'), 'replication_factor': FieldInfo(annotation=Union[int, NoneType], required=False, description='Number of replicas for each shard'), 'write_consistency_factor': FieldInfo(annotation=Union[int, NoneType], required=False, description='Minimal number successful responses from replicas to consider operation successful')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

on_disk_payload: Optional[bool]
read_fan_out_factor: Optional[int]
replication_factor: Optional[int]
write_consistency_factor: Optional[int]
class CollectionStatus(value)[source]

Bases: str, Enum

Current state of the collection. Green - all good. Yellow - optimization is running, Red - some operations failed and was not recovered

GREEN = 'green'
RED = 'red'
YELLOW = 'yellow'
class CollectionTelemetry(*, id: str, init_time_ms: int, config: CollectionConfig, shards: List[ReplicaSetTelemetry], transfers: List[ShardTransferInfo])[source]

Bases: BaseModel

config: CollectionConfig
id: str
init_time_ms: int
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'config': FieldInfo(annotation=CollectionConfig, required=True, description=''), 'id': FieldInfo(annotation=str, required=True, description=''), 'init_time_ms': FieldInfo(annotation=int, required=True, description=''), 'shards': FieldInfo(annotation=List[qdrant_client.http.models.models.ReplicaSetTelemetry], required=True, description=''), 'transfers': FieldInfo(annotation=List[qdrant_client.http.models.models.ShardTransferInfo], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

shards: List[ReplicaSetTelemetry]
transfers: List[ShardTransferInfo]
class CollectionsAggregatedTelemetry(*, vectors: int, optimizers_status: Union[OptimizersStatusOneOf, OptimizersStatusOneOf1], params: CollectionParams)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'optimizers_status': FieldInfo(annotation=Union[OptimizersStatusOneOf, OptimizersStatusOneOf1], required=True, description=''), 'params': FieldInfo(annotation=CollectionParams, required=True, description=''), 'vectors': FieldInfo(annotation=int, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

optimizers_status: OptimizersStatus
params: CollectionParams
vectors: int
class CollectionsAliasesResponse(*, aliases: List[AliasDescription])[source]

Bases: BaseModel

aliases: List[AliasDescription]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'aliases': FieldInfo(annotation=List[qdrant_client.http.models.models.AliasDescription], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class CollectionsResponse(*, collections: List[CollectionDescription])[source]

Bases: BaseModel

collections: List[CollectionDescription]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'collections': FieldInfo(annotation=List[qdrant_client.http.models.models.CollectionDescription], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class CollectionsTelemetry(*, number_of_collections: int, collections: Optional[List[Union[CollectionTelemetry, CollectionsAggregatedTelemetry]]] = None)[source]

Bases: BaseModel

collections: Optional[List[CollectionTelemetryEnum]]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'collections': FieldInfo(annotation=Union[List[Union[qdrant_client.http.models.models.CollectionTelemetry, qdrant_client.http.models.models.CollectionsAggregatedTelemetry]], NoneType], required=False, description=''), 'number_of_collections': FieldInfo(annotation=int, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

number_of_collections: int
class CompressionRatio(value)[source]

Bases: str, Enum

An enumeration.

X16 = 'x16'
X32 = 'x32'
X4 = 'x4'
X64 = 'x64'
X8 = 'x8'
class ConsensusConfigTelemetry(*, max_message_queue_size: int, tick_period_ms: int, bootstrap_timeout_sec: int)[source]

Bases: BaseModel

bootstrap_timeout_sec: int
max_message_queue_size: int
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'bootstrap_timeout_sec': FieldInfo(annotation=int, required=True, description=''), 'max_message_queue_size': FieldInfo(annotation=int, required=True, description=''), 'tick_period_ms': FieldInfo(annotation=int, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

tick_period_ms: int
class ConsensusThreadStatusOneOf(*, consensus_thread_status: Literal['working'], last_update: datetime)[source]

Bases: BaseModel

consensus_thread_status: Literal['working']
last_update: datetime.datetime
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'consensus_thread_status': FieldInfo(annotation=Literal['working'], required=True, description=''), 'last_update': FieldInfo(annotation=datetime, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class ConsensusThreadStatusOneOf1(*, consensus_thread_status: Literal['stopped'])[source]

Bases: BaseModel

consensus_thread_status: Literal['stopped']
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'consensus_thread_status': FieldInfo(annotation=Literal['stopped'], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class ConsensusThreadStatusOneOf2(*, consensus_thread_status: Literal['stopped_with_err'], err: str)[source]

Bases: BaseModel

consensus_thread_status: Literal['stopped_with_err']
err: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'consensus_thread_status': FieldInfo(annotation=Literal['stopped_with_err'], required=True, description=''), 'err': FieldInfo(annotation=str, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class ContextExamplePair(*, positive: Union[int[int], str[str], SparseVector, List[float[float]]], negative: Union[int[int], str[str], SparseVector, List[float[float]]])[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'negative': FieldInfo(annotation=Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)], SparseVector, List[Annotated[float, Strict(strict=True)]]], required=True, description=''), 'positive': FieldInfo(annotation=Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)], SparseVector, List[Annotated[float, Strict(strict=True)]]], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

negative: RecommendExample
positive: RecommendExample
class CountRequest(*, shard_key: Optional[Union[int[int], str[str], List[Union[int[int], str[str]]]]] = None, filter: Optional[Filter] = None, exact: Optional[bool] = True)[source]

Bases: BaseModel

Count Request Counts the number of points which satisfy the given filter. If filter is not provided, the count of all points in the collection will be returned.

exact: Optional[bool]
filter: Optional[Filter]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'exact': FieldInfo(annotation=Union[bool, NoneType], required=False, default=True, description='If true, count exact number of points. If false, count approximate number of points faster. Approximate count might be unreliable during the indexing process. Default: true'), 'filter': FieldInfo(annotation=Union[Filter, NoneType], required=False, description='Look only for points which satisfies this conditions'), 'shard_key': FieldInfo(annotation=Union[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)], List[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]]], NoneType], required=False, description='Specify in which shards to look for the points, if not specified - look in all shards')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

shard_key: Optional[ShardKeySelector]
class CountResult(*, count: int)[source]

Bases: BaseModel

count: int
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'count': FieldInfo(annotation=int, required=True, description='Number of points which satisfy the conditions')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class CreateAlias(*, collection_name: str, alias_name: str)[source]

Bases: BaseModel

Create alternative name for a collection. Collection will be available under both names for search, retrieve,

alias_name: str
collection_name: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'alias_name': FieldInfo(annotation=str, required=True, description='Create alternative name for a collection. Collection will be available under both names for search, retrieve,'), 'collection_name': FieldInfo(annotation=str, required=True, description='Create alternative name for a collection. Collection will be available under both names for search, retrieve,')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class CreateAliasOperation(*, create_alias: CreateAlias)[source]

Bases: BaseModel

create_alias: CreateAlias
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'create_alias': FieldInfo(annotation=CreateAlias, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class CreateCollection(*, vectors: Optional[Union[VectorParams, Dict[str[str], VectorParams]]] = 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[HnswConfigDiff] = None, wal_config: Optional[WalConfigDiff] = None, optimizers_config: Optional[OptimizersConfigDiff] = None, init_from: Optional[InitFrom] = None, quantization_config: Optional[Union[ScalarQuantization, ProductQuantization, BinaryQuantization]] = None, sparse_vectors: Optional[Dict[str, SparseVectorParams]] = None)[source]

Bases: BaseModel

Operation for creating new collection and (optionally) specify index params

hnsw_config: Optional[HnswConfigDiff]
init_from: Optional[InitFrom]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'hnsw_config': FieldInfo(annotation=Union[HnswConfigDiff, NoneType], required=False, description='Custom params for HNSW index. If none - values from service configuration file are used.'), 'init_from': FieldInfo(annotation=Union[InitFrom, NoneType], required=False, description='Specify other collection to copy data from.'), 'on_disk_payload': FieldInfo(annotation=Union[bool, NoneType], required=False, description='If true - point's payload will not be stored in memory. It will be read from the disk every time it is requested. This setting saves RAM by (slightly) increasing the response time. Note: those payload values that are involved in filtering and are indexed - remain in RAM.'), 'optimizers_config': FieldInfo(annotation=Union[OptimizersConfigDiff, NoneType], required=False, description='Custom params for Optimizers.  If none - values from service configuration file are used.'), 'quantization_config': FieldInfo(annotation=Union[Union[ScalarQuantization, ProductQuantization, BinaryQuantization], NoneType], required=False, description='Quantization parameters. If none - quantization is disabled.'), 'replication_factor': FieldInfo(annotation=Union[int, NoneType], required=False, description='Number of shards replicas. Default is 1 Minimum is 1'), 'shard_number': FieldInfo(annotation=Union[int, NoneType], required=False, description='For auto sharding: Number of shards in collection. - Default is 1 for standalone, otherwise equal to the number of nodes - Minimum is 1 For custom sharding: Number of shards in collection per shard group. - Default is 1, meaning that each shard key will be mapped to a single shard - Minimum is 1'), 'sharding_method': FieldInfo(annotation=Union[ShardingMethod, NoneType], required=False, description='Sharding method Default is Auto - points are distributed across all available shards Custom - points are distributed across shards according to shard key'), 'sparse_vectors': FieldInfo(annotation=Union[Dict[str, qdrant_client.http.models.models.SparseVectorParams], NoneType], required=False, description='Sparse vector data config.'), 'vectors': FieldInfo(annotation=Union[Union[VectorParams, Dict[Annotated[str, Strict(strict=True)], qdrant_client.http.models.models.VectorParams]], NoneType], required=False, description='Operation for creating new collection and (optionally) specify index params'), 'wal_config': FieldInfo(annotation=Union[WalConfigDiff, NoneType], required=False, description='Custom params for WAL. If none - values from service configuration file are used.'), 'write_consistency_factor': FieldInfo(annotation=Union[int, NoneType], required=False, description='Defines how many replicas should apply the operation for us to consider it successful. Increasing this number will make the collection more resilient to inconsistencies, but will also make it fail if not enough replicas are available. Does not have any performance impact.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

on_disk_payload: Optional[bool]
optimizers_config: Optional[OptimizersConfigDiff]
quantization_config: Optional[QuantizationConfig]
replication_factor: Optional[int]
shard_number: Optional[int]
sharding_method: Optional[ShardingMethod]
sparse_vectors: Optional[Dict[str, SparseVectorParams]]
vectors: Optional[VectorsConfig]
wal_config: Optional[WalConfigDiff]
write_consistency_factor: Optional[int]
class CreateFieldIndex(*, field_name: str, field_schema: Optional[Union[PayloadSchemaType, TextIndexParams]] = None)[source]

Bases: BaseModel

field_name: str
field_schema: Optional[PayloadFieldSchema]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'field_name': FieldInfo(annotation=str, required=True, description=''), 'field_schema': FieldInfo(annotation=Union[Union[PayloadSchemaType, TextIndexParams], NoneType], required=False, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class CreateShardingKey(*, shard_key: Union[int[int], str[str]], shards_number: Optional[int] = None, replication_factor: Optional[int] = None, placement: Optional[List[int]] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'placement': FieldInfo(annotation=Union[List[int], NoneType], required=False, description='Placement of shards for this key List of peer ids, that can be used to place shards for this key If not specified, will be randomly placed among all peers'), 'replication_factor': FieldInfo(annotation=Union[int, NoneType], required=False, description='How many replicas to create for each shard If not specified, will use the default value from config'), 'shard_key': FieldInfo(annotation=Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]], required=True, description=''), 'shards_number': FieldInfo(annotation=Union[int, NoneType], required=False, description='How many shards to create for this key If not specified, will use the default value from config')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

placement: Optional[List[int]]
replication_factor: Optional[int]
shard_key: ShardKey
shards_number: Optional[int]
class CreateShardingKeyOperation(*, create_sharding_key: CreateShardingKey)[source]

Bases: BaseModel

create_sharding_key: CreateShardingKey
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'create_sharding_key': FieldInfo(annotation=CreateShardingKey, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class DeleteAlias(*, alias_name: str)[source]

Bases: BaseModel

Delete alias if exists

alias_name: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'alias_name': FieldInfo(annotation=str, required=True, description='Delete alias if exists')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class DeleteAliasOperation(*, delete_alias: DeleteAlias)[source]

Bases: BaseModel

Delete alias if exists

delete_alias: DeleteAlias
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'delete_alias': FieldInfo(annotation=DeleteAlias, required=True, description='Delete alias if exists')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class DeleteOperation(*, delete: Union[PointIdsList, FilterSelector])[source]

Bases: BaseModel

delete: PointsSelector
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'delete': FieldInfo(annotation=Union[PointIdsList, FilterSelector], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class DeletePayload(*, keys: List[str], points: Optional[List[Union[int[int], str[str]]]] = None, filter: Optional[Filter] = None, shard_key: Optional[Union[int[int], str[str], List[Union[int[int], str[str]]]]] = None)[source]

Bases: BaseModel

This data structure is used in API interface and applied across multiple shards

filter: Optional[Filter]
keys: List[str]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'filter': FieldInfo(annotation=Union[Filter, NoneType], required=False, description='Deletes values from points that satisfy this filter condition'), 'keys': FieldInfo(annotation=List[str], required=True, description='List of payload keys to remove from payload'), 'points': FieldInfo(annotation=Union[List[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]], NoneType], required=False, description='Deletes values from each point in this list'), 'shard_key': FieldInfo(annotation=Union[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)], List[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]]], NoneType], required=False, description='This data structure is used in API interface and applied across multiple shards')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

points: Optional[List[ExtendedPointId]]
shard_key: Optional[ShardKeySelector]
class DeletePayloadOperation(*, delete_payload: DeletePayload)[source]

Bases: BaseModel

delete_payload: DeletePayload
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'delete_payload': FieldInfo(annotation=DeletePayload, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class DeleteVectors(*, points: Optional[List[Union[int[int], str[str]]]] = None, filter: Optional[Filter] = None, vector: List[str], shard_key: Optional[Union[int[int], str[str], List[Union[int[int], str[str]]]]] = None)[source]

Bases: BaseModel

filter: Optional[Filter]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'filter': FieldInfo(annotation=Union[Filter, NoneType], required=False, description='Deletes values from points that satisfy this filter condition'), 'points': FieldInfo(annotation=Union[List[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]], NoneType], required=False, description='Deletes values from each point in this list'), 'shard_key': FieldInfo(annotation=Union[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)], List[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]]], NoneType], required=False, description=''), 'vector': FieldInfo(annotation=List[str], required=True, description='Vector names')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

points: Optional[List[ExtendedPointId]]
shard_key: Optional[ShardKeySelector]
vector: List[str]
class DeleteVectorsOperation(*, delete_vectors: DeleteVectors)[source]

Bases: BaseModel

delete_vectors: DeleteVectors
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'delete_vectors': FieldInfo(annotation=DeleteVectors, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class Disabled(value)[source]

Bases: str, Enum

An enumeration.

DISABLED = 'Disabled'
class DiscoverRequest(*, shard_key: Optional[Union[int[int], str[str], List[Union[int[int], str[str]]]]] = None, target: Optional[Union[int[int], str[str], SparseVector, List[float[float]]]] = None, context: Optional[List[ContextExamplePair]] = None, filter: Optional[Filter] = None, params: Optional[SearchParams] = None, limit: int, offset: Optional[int] = None, with_payload: Optional[Union[PayloadSelectorInclude, PayloadSelectorExclude, List[str[str]], bool[bool]]] = None, with_vector: Optional[Union[List[str[str]], bool[bool]]] = None, using: Optional[str[str]] = None, lookup_from: Optional[LookupLocation] = None)[source]

Bases: BaseModel

Use context and a target to find the most similar points, constrained by the context.

context: Optional[List[ContextExamplePair]]
filter: Optional[Filter]
limit: int
lookup_from: Optional[LookupLocation]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'context': FieldInfo(annotation=Union[List[qdrant_client.http.models.models.ContextExamplePair], NoneType], required=False, description='Pairs of { positive, negative } examples to constrain the search.  When using only the context (without a target), a special search - called context search - is performed where pairs of points are used to generate a loss that guides the search towards the zone where most positive examples overlap. This means that the score minimizes the scenario of finding a point closer to a negative than to a positive part of a pair.  Since the score of a context relates to loss, the maximum score a point can get is 0.0, and it becomes normal that many points can have a score of 0.0.  For discovery search (when including a target), the context part of the score for each pair is calculated +1 if the point is closer to a positive than to a negative part of a pair, and -1 otherwise.'), 'filter': FieldInfo(annotation=Union[Filter, NoneType], required=False, description='Look only for points which satisfies this conditions'), 'limit': FieldInfo(annotation=int, required=True, description='Max number of result to return'), 'lookup_from': FieldInfo(annotation=Union[LookupLocation, NoneType], required=False, description='The location used to lookup vectors. If not specified - use current collection. Note: the other collection should have the same vector size as the current collection'), 'offset': FieldInfo(annotation=Union[int, NoneType], required=False, description='Offset of the first result to return. May be used to paginate results. Note: large offset values may cause performance issues.'), 'params': FieldInfo(annotation=Union[SearchParams, NoneType], required=False, description='Additional search params'), 'shard_key': FieldInfo(annotation=Union[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)], List[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]]], NoneType], required=False, description='Specify in which shards to look for the points, if not specified - look in all shards'), 'target': FieldInfo(annotation=Union[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)], SparseVector, List[Annotated[float, Strict(strict=True)]]], NoneType], required=False, description='Look for vectors closest to this.  When using the target (with or without context), the integer part of the score represents the rank with respect to the context, while the decimal part of the score relates to the distance to the target.'), 'using': FieldInfo(annotation=Union[Annotated[str, Strict(strict=True)], NoneType], required=False, description='Define which vector to use for recommendation, if not specified - try to use default vector'), 'with_payload': FieldInfo(annotation=Union[Union[PayloadSelectorInclude, PayloadSelectorExclude, List[Annotated[str, Strict(strict=True)]], Annotated[bool, Strict(strict=True)]], NoneType], required=False, description='Select which payload to return with the response. Default: None'), 'with_vector': FieldInfo(annotation=Union[Union[List[Annotated[str, Strict(strict=True)]], Annotated[bool, Strict(strict=True)]], NoneType], required=False, description='Whether to return the point vector with the result?')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

offset: Optional[int]
params: Optional[SearchParams]
shard_key: Optional[ShardKeySelector]
target: Optional[RecommendExample]
using: Optional[UsingVector]
with_payload: Optional[WithPayloadInterface]
with_vector: Optional[WithVector]
class DiscoverRequestBatch(*, searches: List[DiscoverRequest])[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'searches': FieldInfo(annotation=List[qdrant_client.http.models.models.DiscoverRequest], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

searches: List[DiscoverRequest]
class Distance(value)[source]

Bases: str, Enum

Type of internal tags, build from payload Distance function types used to compare vectors

COSINE = 'Cosine'
DOT = 'Dot'
EUCLID = 'Euclid'
MANHATTAN = 'Manhattan'
class DropReplicaOperation(*, drop_replica: Replica)[source]

Bases: BaseModel

drop_replica: Replica
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'drop_replica': FieldInfo(annotation=Replica, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class DropShardingKey(*, shard_key: Union[int[int], str[str]])[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'shard_key': FieldInfo(annotation=Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

shard_key: ShardKey
class DropShardingKeyOperation(*, drop_sharding_key: DropShardingKey)[source]

Bases: BaseModel

drop_sharding_key: DropShardingKey
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'drop_sharding_key': FieldInfo(annotation=DropShardingKey, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class ErrorResponse(*, time: Optional[float] = None, status: Optional[ErrorResponseStatus] = None, result: Optional[Any] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[Any, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[ErrorResponseStatus, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[Any]
status: Optional[ErrorResponseStatus]
time: Optional[float]
class ErrorResponseStatus(*, error: Optional[str] = None)[source]

Bases: BaseModel

error: Optional[str]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'error': FieldInfo(annotation=Union[str, NoneType], required=False, description='Description of the occurred error.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class FieldCondition(*, key: str, match: Optional[Union[MatchValue, MatchText, MatchAny, MatchExcept]] = None, range: Optional[Range] = None, geo_bounding_box: Optional[GeoBoundingBox] = None, geo_radius: Optional[GeoRadius] = None, geo_polygon: Optional[GeoPolygon] = None, values_count: Optional[ValuesCount] = None)[source]

Bases: BaseModel

All possible payload filtering conditions

geo_bounding_box: Optional[GeoBoundingBox]
geo_polygon: Optional[GeoPolygon]
geo_radius: Optional[GeoRadius]
key: str
match: Optional[Match]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'geo_bounding_box': FieldInfo(annotation=Union[GeoBoundingBox, NoneType], required=False, description='Check if points geo location lies in a given area'), 'geo_polygon': FieldInfo(annotation=Union[GeoPolygon, NoneType], required=False, description='Check if geo point is within a given polygon'), 'geo_radius': FieldInfo(annotation=Union[GeoRadius, NoneType], required=False, description='Check if geo point is within a given radius'), 'key': FieldInfo(annotation=str, required=True, description='Payload key'), 'match': FieldInfo(annotation=Union[Union[MatchValue, MatchText, MatchAny, MatchExcept], NoneType], required=False, description='Check if point has field with a given value'), 'range': FieldInfo(annotation=Union[Range, NoneType], required=False, description='Check if points value lies in a given range'), 'values_count': FieldInfo(annotation=Union[ValuesCount, NoneType], required=False, description='Check number of values of the field')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

range: Optional[Range]
values_count: Optional[ValuesCount]
class Filter(*, should: Optional[List[Union[FieldCondition, IsEmptyCondition, IsNullCondition, HasIdCondition, NestedCondition, Filter]]] = None, must: Optional[List[Union[FieldCondition, IsEmptyCondition, IsNullCondition, HasIdCondition, NestedCondition, Filter]]] = None, must_not: Optional[List[Union[FieldCondition, IsEmptyCondition, IsNullCondition, HasIdCondition, NestedCondition, Filter]]] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'must': FieldInfo(annotation=Union[List[Union[qdrant_client.http.models.models.FieldCondition, qdrant_client.http.models.models.IsEmptyCondition, qdrant_client.http.models.models.IsNullCondition, qdrant_client.http.models.models.HasIdCondition, qdrant_client.http.models.models.NestedCondition, qdrant_client.http.models.models.Filter]], NoneType], required=False, description='All conditions must match'), 'must_not': FieldInfo(annotation=Union[List[Union[qdrant_client.http.models.models.FieldCondition, qdrant_client.http.models.models.IsEmptyCondition, qdrant_client.http.models.models.IsNullCondition, qdrant_client.http.models.models.HasIdCondition, qdrant_client.http.models.models.NestedCondition, qdrant_client.http.models.models.Filter]], NoneType], required=False, description='All conditions must NOT match'), 'should': FieldInfo(annotation=Union[List[Union[qdrant_client.http.models.models.FieldCondition, qdrant_client.http.models.models.IsEmptyCondition, qdrant_client.http.models.models.IsNullCondition, qdrant_client.http.models.models.HasIdCondition, qdrant_client.http.models.models.NestedCondition, qdrant_client.http.models.models.Filter]], NoneType], required=False, description='At least one of those conditions should match')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

must: Optional[List[Condition]]
must_not: Optional[List[Condition]]
should: Optional[List[Condition]]
class FilterSelector(*, filter: Filter, shard_key: Optional[Union[int[int], str[str], List[Union[int[int], str[str]]]]] = None)[source]

Bases: BaseModel

filter: Filter
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'filter': FieldInfo(annotation=Filter, required=True, description=''), 'shard_key': FieldInfo(annotation=Union[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)], List[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]]], NoneType], required=False, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

shard_key: Optional[ShardKeySelector]
class GeoBoundingBox(*, top_left: GeoPoint, bottom_right: GeoPoint)[source]

Bases: BaseModel

Geo filter request Matches coordinates inside the rectangle, described by coordinates of lop-left and bottom-right edges

bottom_right: GeoPoint
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'bottom_right': FieldInfo(annotation=GeoPoint, required=True, description='Geo filter request  Matches coordinates inside the rectangle, described by coordinates of lop-left and bottom-right edges'), 'top_left': FieldInfo(annotation=GeoPoint, required=True, description='Geo filter request  Matches coordinates inside the rectangle, described by coordinates of lop-left and bottom-right edges')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

top_left: GeoPoint
class GeoLineString(*, points: List[GeoPoint])[source]

Bases: BaseModel

Ordered sequence of GeoPoints representing the line

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'points': FieldInfo(annotation=List[qdrant_client.http.models.models.GeoPoint], required=True, description='Ordered sequence of GeoPoints representing the line')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

points: List[GeoPoint]
class GeoPoint(*, lon: float, lat: float)[source]

Bases: BaseModel

Geo point payload schema

lat: float
lon: float
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'lat': FieldInfo(annotation=float, required=True, description='Geo point payload schema'), 'lon': FieldInfo(annotation=float, required=True, description='Geo point payload schema')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class GeoPolygon(*, exterior: GeoLineString, interiors: Optional[List[GeoLineString]] = None)[source]

Bases: BaseModel

Geo filter request Matches coordinates inside the polygon, defined by exterior and interiors

exterior: GeoLineString
interiors: Optional[List[GeoLineString]]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'exterior': FieldInfo(annotation=GeoLineString, required=True, description='Geo filter request  Matches coordinates inside the polygon, defined by `exterior` and `interiors`'), 'interiors': FieldInfo(annotation=Union[List[qdrant_client.http.models.models.GeoLineString], NoneType], required=False, description='Interior lines (if present) bound holes within the surface each GeoLineString must consist of a minimum of 4 points, and the first and last points must be the same.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class GeoRadius(*, center: GeoPoint, radius: float)[source]

Bases: BaseModel

Geo filter request Matches coordinates inside the circle of radius and center with coordinates center

center: GeoPoint
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'center': FieldInfo(annotation=GeoPoint, required=True, description='Geo filter request  Matches coordinates inside the circle of `radius` and center with coordinates `center`'), 'radius': FieldInfo(annotation=float, required=True, description='Radius of the area in meters')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

radius: float
class GroupsResult(*, groups: List[PointGroup])[source]

Bases: BaseModel

groups: List[PointGroup]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'groups': FieldInfo(annotation=List[qdrant_client.http.models.models.PointGroup], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class GrpcTelemetry(*, responses: Dict[str, OperationDurationStatistics])[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'responses': FieldInfo(annotation=Dict[str, qdrant_client.http.models.models.OperationDurationStatistics], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

responses: Dict[str, OperationDurationStatistics]
class HasIdCondition(*, has_id: List[Union[int[int], str[str]]])[source]

Bases: BaseModel

ID-based filtering condition

has_id: List[ExtendedPointId]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'has_id': FieldInfo(annotation=List[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]], required=True, description='ID-based filtering condition')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class HnswConfig(*, m: int, ef_construct: int, full_scan_threshold: int, max_indexing_threads: Optional[int] = 0, on_disk: Optional[bool] = None, payload_m: Optional[int] = None)[source]

Bases: BaseModel

Config of HNSW index

ef_construct: int
full_scan_threshold: int
m: int
max_indexing_threads: Optional[int]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'ef_construct': FieldInfo(annotation=int, required=True, description='Number of neighbours to consider during the index building. Larger the value - more accurate the search, more time required to build index.'), 'full_scan_threshold': FieldInfo(annotation=int, required=True, description='Minimal size (in KiloBytes) of vectors for additional payload-based indexing. If payload chunk is smaller than `full_scan_threshold_kb` additional indexing won't be used - in this case full-scan search should be preferred by query planner and additional indexing is not required. Note: 1Kb = 1 vector of size 256'), 'm': FieldInfo(annotation=int, required=True, description='Number of edges per node in the index graph. Larger the value - more accurate the search, more space required.'), 'max_indexing_threads': FieldInfo(annotation=Union[int, NoneType], required=False, default=0, description='Number of parallel threads used for background index building. If 0 - auto selection.'), 'on_disk': FieldInfo(annotation=Union[bool, NoneType], required=False, description='Store HNSW index on disk. If set to false, index will be stored in RAM. Default: false'), 'payload_m': FieldInfo(annotation=Union[int, NoneType], required=False, description='Custom M param for hnsw graph built for payload index. If not set, default M will be used.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

on_disk: Optional[bool]
payload_m: Optional[int]
class HnswConfigDiff(*, m: Optional[int] = None, ef_construct: Optional[int] = None, full_scan_threshold: Optional[int] = None, max_indexing_threads: Optional[int] = None, on_disk: Optional[bool] = None, payload_m: Optional[int] = None)[source]

Bases: BaseModel

ef_construct: Optional[int]
full_scan_threshold: Optional[int]
m: Optional[int]
max_indexing_threads: Optional[int]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'ef_construct': FieldInfo(annotation=Union[int, NoneType], required=False, description='Number of neighbours to consider during the index building. Larger the value - more accurate the search, more time required to build the index.'), 'full_scan_threshold': FieldInfo(annotation=Union[int, NoneType], required=False, description='Minimal size (in kilobytes) of vectors for additional payload-based indexing. If payload chunk is smaller than `full_scan_threshold_kb` additional indexing won't be used - in this case full-scan search should be preferred by query planner and additional indexing is not required. Note: 1Kb = 1 vector of size 256'), 'm': FieldInfo(annotation=Union[int, NoneType], required=False, description='Number of edges per node in the index graph. Larger the value - more accurate the search, more space required.'), 'max_indexing_threads': FieldInfo(annotation=Union[int, NoneType], required=False, description='Number of parallel threads used for background index building. If 0 - auto selection.'), 'on_disk': FieldInfo(annotation=Union[bool, NoneType], required=False, description='Store HNSW index on disk. If set to false, the index will be stored in RAM. Default: false'), 'payload_m': FieldInfo(annotation=Union[int, NoneType], required=False, description='Custom M param for additional payload-aware HNSW links. If not set, default M will be used.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

on_disk: Optional[bool]
payload_m: Optional[int]
class IndexesOneOf(*, type: Literal['plain'], options: Any)[source]

Bases: BaseModel

Do not use any index, scan whole vector collection during search. Guarantee 100% precision, but may be time consuming on large collections.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'options': FieldInfo(annotation=Any, required=True, description='Do not use any index, scan whole vector collection during search. Guarantee 100% precision, but may be time consuming on large collections.'), 'type': FieldInfo(annotation=Literal['plain'], required=True, description='Do not use any index, scan whole vector collection during search. Guarantee 100% precision, but may be time consuming on large collections.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

options: Any
type: Literal['plain']
class IndexesOneOf1(*, type: Literal['hnsw'], options: HnswConfig)[source]

Bases: BaseModel

Use filterable HNSW index for approximate search. Is very fast even on a very huge collections, but require additional space to store index and additional time to build it.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'options': FieldInfo(annotation=HnswConfig, required=True, description='Use filterable HNSW index for approximate search. Is very fast even on a very huge collections, but require additional space to store index and additional time to build it.'), 'type': FieldInfo(annotation=Literal['hnsw'], required=True, description='Use filterable HNSW index for approximate search. Is very fast even on a very huge collections, but require additional space to store index and additional time to build it.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

options: HnswConfig
type: Literal['hnsw']
class InitFrom(*, collection: str)[source]

Bases: BaseModel

Operation for creating new collection and (optionally) specify index params

collection: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'collection': FieldInfo(annotation=str, required=True, description='Operation for creating new collection and (optionally) specify index params')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class InlineResponse200(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[bool] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[bool, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[bool]
status: Optional[str]
time: Optional[float]
class InlineResponse2001(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[TelemetryData] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[TelemetryData, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[TelemetryData]
status: Optional[str]
time: Optional[float]
class InlineResponse20010(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[SnapshotDescription] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[SnapshotDescription, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[SnapshotDescription]
status: Optional[str]
time: Optional[float]
class InlineResponse20011(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[Record] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[Record, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[Record]
status: Optional[str]
time: Optional[float]
class InlineResponse20012(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[List[Record]] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[List[qdrant_client.http.models.models.Record], NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[List[Record]]
status: Optional[str]
time: Optional[float]
class InlineResponse20013(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[List[UpdateResult]] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[List[qdrant_client.http.models.models.UpdateResult], NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[List[UpdateResult]]
status: Optional[str]
time: Optional[float]
class InlineResponse20014(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[ScrollResult] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[ScrollResult, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[ScrollResult]
status: Optional[str]
time: Optional[float]
class InlineResponse20015(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[List[ScoredPoint]] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[List[qdrant_client.http.models.models.ScoredPoint], NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[List[ScoredPoint]]
status: Optional[str]
time: Optional[float]
class InlineResponse20016(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[List[List[ScoredPoint]]] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[List[List[qdrant_client.http.models.models.ScoredPoint]], NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[List[List[ScoredPoint]]]
status: Optional[str]
time: Optional[float]
class InlineResponse20017(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[GroupsResult] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[GroupsResult, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[GroupsResult]
status: Optional[str]
time: Optional[float]
class InlineResponse20018(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[CountResult] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[CountResult, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[CountResult]
status: Optional[str]
time: Optional[float]
class InlineResponse2002(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[LocksOption] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[LocksOption, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[LocksOption]
status: Optional[str]
time: Optional[float]
class InlineResponse2003(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[Union[ClusterStatusOneOf, ClusterStatusOneOf1]] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[Union[ClusterStatusOneOf, ClusterStatusOneOf1], NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[ClusterStatus]
status: Optional[str]
time: Optional[float]
class InlineResponse2004(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[CollectionsResponse] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[CollectionsResponse, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[CollectionsResponse]
status: Optional[str]
time: Optional[float]
class InlineResponse2005(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[CollectionInfo] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[CollectionInfo, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[CollectionInfo]
status: Optional[str]
time: Optional[float]
class InlineResponse2006(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[UpdateResult] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[UpdateResult, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[UpdateResult]
status: Optional[str]
time: Optional[float]
class InlineResponse2007(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[CollectionClusterInfo] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[CollectionClusterInfo, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[CollectionClusterInfo]
status: Optional[str]
time: Optional[float]
class InlineResponse2008(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[CollectionsAliasesResponse] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[CollectionsAliasesResponse, NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[CollectionsAliasesResponse]
status: Optional[str]
time: Optional[float]
class InlineResponse2009(*, time: Optional[float] = None, status: Optional[str] = None, result: Optional[List[SnapshotDescription]] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'result': FieldInfo(annotation=Union[List[qdrant_client.http.models.models.SnapshotDescription], NoneType], required=False, description=''), 'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

result: Optional[List[SnapshotDescription]]
status: Optional[str]
time: Optional[float]
class InlineResponse202(*, time: Optional[float] = None, status: Optional[str] = None)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'status': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'time': FieldInfo(annotation=Union[float, NoneType], required=False, description='Time spent to process this request')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

status: Optional[str]
time: Optional[float]
class IsEmptyCondition(*, is_empty: PayloadField)[source]

Bases: BaseModel

Select points with empty payload for a specified field

is_empty: PayloadField
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'is_empty': FieldInfo(annotation=PayloadField, required=True, description='Select points with empty payload for a specified field')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class IsNullCondition(*, is_null: PayloadField)[source]

Bases: BaseModel

Select points with null payload for a specified field

is_null: PayloadField
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'is_null': FieldInfo(annotation=PayloadField, required=True, description='Select points with null payload for a specified field')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class LocalShardInfo(*, shard_id: int, shard_key: Optional[Union[int[int], str[str]]] = None, points_count: int, state: ReplicaState)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'points_count': FieldInfo(annotation=int, required=True, description='Number of points in the shard'), 'shard_id': FieldInfo(annotation=int, required=True, description='Local shard id'), 'shard_key': FieldInfo(annotation=Union[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]], NoneType], required=False, description='User-defined sharding key'), 'state': FieldInfo(annotation=ReplicaState, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

points_count: int
shard_id: int
shard_key: Optional[ShardKey]
state: ReplicaState
class LocalShardTelemetry(*, variant_name: Optional[str] = None, segments: List[SegmentTelemetry], optimizations: OptimizerTelemetry)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'optimizations': FieldInfo(annotation=OptimizerTelemetry, required=True, description=''), 'segments': FieldInfo(annotation=List[qdrant_client.http.models.models.SegmentTelemetry], required=True, description=''), 'variant_name': FieldInfo(annotation=Union[str, NoneType], required=False, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

optimizations: OptimizerTelemetry
segments: List[SegmentTelemetry]
variant_name: Optional[str]
class LocksOption(*, error_message: Optional[str] = None, write: bool)[source]

Bases: BaseModel

error_message: Optional[str]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'error_message': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'write': FieldInfo(annotation=bool, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

write: bool
class LookupLocation(*, collection: str, vector: Optional[str] = None, shard_key: Optional[Union[int[int], str[str], List[Union[int[int], str[str]]]]] = None)[source]

Bases: BaseModel

Defines a location to use for looking up the vector. Specifies collection and vector field name.

collection: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'collection': FieldInfo(annotation=str, required=True, description='Name of the collection used for lookup'), 'shard_key': FieldInfo(annotation=Union[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)], List[Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]]], NoneType], required=False, description='Specify in which shards to look for the points, if not specified - look in all shards'), 'vector': FieldInfo(annotation=Union[str, NoneType], required=False, description='Optional name of the vector field within the collection. If not provided, the default vector field will be used.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

shard_key: Optional[ShardKeySelector]
vector: Optional[str]
class MatchAny(*, any: Union[List[int[int]], List[str[str]]])[source]

Bases: BaseModel

Exact match on any of the given values

any: AnyVariants
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'any': FieldInfo(annotation=Union[List[Annotated[int, Strict(strict=True)]], List[Annotated[str, Strict(strict=True)]]], required=True, description='Exact match on any of the given values')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class MatchExcept(*, except_: Union[List[int[int]], List[str[str]]])[source]

Bases: BaseModel

Should have at least one value not matching the any given values

except_: AnyVariants
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'except_': FieldInfo(annotation=Union[List[Annotated[int, Strict(strict=True)]], List[Annotated[str, Strict(strict=True)]]], required=True, alias='except', alias_priority=2, description='Should have at least one value not matching the any given values')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class MatchText(*, text: str)[source]

Bases: BaseModel

Full-text match of the strings.

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'text': FieldInfo(annotation=str, required=True, description='Full-text match of the strings.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

text: str
class MatchValue(*, value: Union[bool[bool], int[int], str[str]])[source]

Bases: BaseModel

Exact match of the given value

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'value': FieldInfo(annotation=Union[Annotated[bool, Strict(strict=True)], Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]], required=True, description='Exact match of the given value')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

value: ValueVariants
class MessageSendErrors(*, count: int, latest_error: Optional[str] = None)[source]

Bases: BaseModel

Message send failures for a particular peer

count: int
latest_error: Optional[str]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'count': FieldInfo(annotation=int, required=True, description='Message send failures for a particular peer'), 'latest_error': FieldInfo(annotation=Union[str, NoneType], required=False, description='Message send failures for a particular peer')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class MoveShard(*, shard_id: int, to_peer_id: int, from_peer_id: int, method: Optional[Union[ShardTransferMethodOneOf, ShardTransferMethodOneOf1]] = None)[source]

Bases: BaseModel

from_peer_id: int
method: Optional[ShardTransferMethod]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'from_peer_id': FieldInfo(annotation=int, required=True, description=''), 'method': FieldInfo(annotation=Union[Union[ShardTransferMethodOneOf, ShardTransferMethodOneOf1], NoneType], required=False, description='Method for transferring the shard from one node to another'), 'shard_id': FieldInfo(annotation=int, required=True, description=''), 'to_peer_id': FieldInfo(annotation=int, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

shard_id: int
to_peer_id: int
class MoveShardOperation(*, move_shard: MoveShard)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'move_shard': FieldInfo(annotation=MoveShard, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

move_shard: MoveShard
class NamedSparseVector(*, name: str, vector: SparseVector)[source]

Bases: BaseModel

Sparse vector data with name

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'name': FieldInfo(annotation=str, required=True, description='Name of vector data'), 'vector': FieldInfo(annotation=SparseVector, required=True, description='Sparse vector data with name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str
vector: SparseVector
class NamedVector(*, name: str, vector: List[float])[source]

Bases: BaseModel

Vector data with name

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'name': FieldInfo(annotation=str, required=True, description='Name of vector data'), 'vector': FieldInfo(annotation=List[float], required=True, description='Vector data')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

name: str
vector: List[float]
class Nested(*, key: str, filter: Filter)[source]

Bases: BaseModel

Select points with payload for a specified nested field

filter: Filter
key: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'filter': FieldInfo(annotation=Filter, required=True, description='Select points with payload for a specified nested field'), 'key': FieldInfo(annotation=str, required=True, description='Select points with payload for a specified nested field')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class NestedCondition(*, nested: Nested)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'nested': FieldInfo(annotation=Nested, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

nested: Nested
class OperationDurationStatistics(*, count: int, fail_count: Optional[int] = None, avg_duration_micros: Optional[float] = None, min_duration_micros: Optional[float] = None, max_duration_micros: Optional[float] = None, last_responded: Optional[datetime] = None)[source]

Bases: BaseModel

avg_duration_micros: Optional[float]
count: int
fail_count: Optional[int]
last_responded: Optional[datetime.datetime]
max_duration_micros: Optional[float]
min_duration_micros: Optional[float]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'avg_duration_micros': FieldInfo(annotation=Union[float, NoneType], required=False, description=''), 'count': FieldInfo(annotation=int, required=True, description=''), 'fail_count': FieldInfo(annotation=Union[int, NoneType], required=False, description=''), 'last_responded': FieldInfo(annotation=Union[datetime, NoneType], required=False, description=''), 'max_duration_micros': FieldInfo(annotation=Union[float, NoneType], required=False, description=''), 'min_duration_micros': FieldInfo(annotation=Union[float, NoneType], required=False, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class OptimizerTelemetry(*, status: Union[OptimizersStatusOneOf, OptimizersStatusOneOf1], optimizations: OperationDurationStatistics, log: List[TrackerTelemetry])[source]

Bases: BaseModel

log: List[TrackerTelemetry]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'log': FieldInfo(annotation=List[qdrant_client.http.models.models.TrackerTelemetry], required=True, description=''), 'optimizations': FieldInfo(annotation=OperationDurationStatistics, required=True, description=''), 'status': FieldInfo(annotation=Union[OptimizersStatusOneOf, OptimizersStatusOneOf1], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

optimizations: OperationDurationStatistics
status: OptimizersStatus
class OptimizersConfig(*, deleted_threshold: float, vacuum_min_vector_number: int, default_segment_number: int, max_segment_size: Optional[int] = None, memmap_threshold: Optional[int] = None, indexing_threshold: Optional[int] = None, flush_interval_sec: int, max_optimization_threads: int)[source]

Bases: BaseModel

default_segment_number: int
deleted_threshold: float
flush_interval_sec: int
indexing_threshold: Optional[int]
max_optimization_threads: int
max_segment_size: Optional[int]
memmap_threshold: Optional[int]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'default_segment_number': FieldInfo(annotation=int, required=True, description='Target amount of segments optimizer will try to keep. Real amount of segments may vary depending on multiple parameters: - Amount of stored points - Current write RPS  It is recommended to select default number of segments as a factor of the number of search threads, so that each segment would be handled evenly by one of the threads. If `default_segment_number = 0`, will be automatically selected by the number of available CPUs.'), 'deleted_threshold': FieldInfo(annotation=float, required=True, description='The minimal fraction of deleted vectors in a segment, required to perform segment optimization'), 'flush_interval_sec': FieldInfo(annotation=int, required=True, description='Minimum interval between forced flushes.'), 'indexing_threshold': FieldInfo(annotation=Union[int, NoneType], required=False, description='Maximum size (in kilobytes) of vectors allowed for plain index, exceeding this threshold will enable vector indexing  Default value is 20,000, based on <https://github.com/google-research/google-research/blob/master/scann/docs/algorithms.md>.  To disable vector indexing, set to `0`.  Note: 1kB = 1 vector of size 256.'), 'max_optimization_threads': FieldInfo(annotation=int, required=True, description='Maximum available threads for optimization workers'), 'max_segment_size': FieldInfo(annotation=Union[int, NoneType], required=False, description='Do not create segments larger this size (in kilobytes). Large segments might require disproportionately long indexation times, therefore it makes sense to limit the size of segments.  If indexing speed is more important - make this parameter lower. If search speed is more important - make this parameter higher. Note: 1Kb = 1 vector of size 256 If not set, will be automatically selected considering the number of available CPUs.'), 'memmap_threshold': FieldInfo(annotation=Union[int, NoneType], required=False, description='Maximum size (in kilobytes) of vectors to store in-memory per segment. Segments larger than this threshold will be stored as read-only memmaped file.  Memmap storage is disabled by default, to enable it, set this threshold to a reasonable value.  To disable memmap storage, set this to `0`. Internally it will use the largest threshold possible.  Note: 1Kb = 1 vector of size 256'), 'vacuum_min_vector_number': FieldInfo(annotation=int, required=True, description='The minimal number of vectors in a segment, required to perform segment optimization')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

vacuum_min_vector_number: int
class OptimizersConfigDiff(*, deleted_threshold: Optional[float] = None, vacuum_min_vector_number: Optional[int] = None, default_segment_number: Optional[int] = None, max_segment_size: Optional[int] = None, memmap_threshold: Optional[int] = None, indexing_threshold: Optional[int] = None, flush_interval_sec: Optional[int] = None, max_optimization_threads: Optional[int] = None)[source]

Bases: BaseModel

default_segment_number: Optional[int]
deleted_threshold: Optional[float]
flush_interval_sec: Optional[int]
indexing_threshold: Optional[int]
max_optimization_threads: Optional[int]
max_segment_size: Optional[int]
memmap_threshold: Optional[int]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'default_segment_number': FieldInfo(annotation=Union[int, NoneType], required=False, description='Target amount of segments optimizer will try to keep. Real amount of segments may vary depending on multiple parameters: - Amount of stored points - Current write RPS  It is recommended to select default number of segments as a factor of the number of search threads, so that each segment would be handled evenly by one of the threads If `default_segment_number = 0`, will be automatically selected by the number of available CPUs'), 'deleted_threshold': FieldInfo(annotation=Union[float, NoneType], required=False, description='The minimal fraction of deleted vectors in a segment, required to perform segment optimization'), 'flush_interval_sec': FieldInfo(annotation=Union[int, NoneType], required=False, description='Minimum interval between forced flushes.'), 'indexing_threshold': FieldInfo(annotation=Union[int, NoneType], required=False, description='Maximum size (in kilobytes) of vectors allowed for plain index, exceeding this threshold will enable vector indexing  Default value is 20,000, based on <https://github.com/google-research/google-research/blob/master/scann/docs/algorithms.md>.  To disable vector indexing, set to `0`.  Note: 1kB = 1 vector of size 256.'), 'max_optimization_threads': FieldInfo(annotation=Union[int, NoneType], required=False, description='Maximum available threads for optimization workers'), 'max_segment_size': FieldInfo(annotation=Union[int, NoneType], required=False, description='Do not create segments larger this size (in kilobytes). Large segments might require disproportionately long indexation times, therefore it makes sense to limit the size of segments.  If indexation speed have more priority for your - make this parameter lower. If search speed is more important - make this parameter higher. Note: 1Kb = 1 vector of size 256'), 'memmap_threshold': FieldInfo(annotation=Union[int, NoneType], required=False, description='Maximum size (in kilobytes) of vectors to store in-memory per segment. Segments larger than this threshold will be stored as read-only memmaped file.  Memmap storage is disabled by default, to enable it, set this threshold to a reasonable value.  To disable memmap storage, set this to `0`.  Note: 1Kb = 1 vector of size 256'), 'vacuum_min_vector_number': FieldInfo(annotation=Union[int, NoneType], required=False, description='The minimal number of vectors in a segment, required to perform segment optimization')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

vacuum_min_vector_number: Optional[int]
class OptimizersStatusOneOf(value)[source]

Bases: str, Enum

Optimizers are reporting as expected

OK = 'ok'
class OptimizersStatusOneOf1(*, error: str)[source]

Bases: BaseModel

Something wrong happened with optimizers

error: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'error': FieldInfo(annotation=str, required=True, description='Something wrong happened with optimizers')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class OverwritePayloadOperation(*, overwrite_payload: SetPayload)[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'overwrite_payload': FieldInfo(annotation=SetPayload, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

overwrite_payload: SetPayload
class P2pConfigTelemetry(*, connection_pool_size: int)[source]

Bases: BaseModel

connection_pool_size: int
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'connection_pool_size': FieldInfo(annotation=int, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class PayloadField(*, key: str)[source]

Bases: BaseModel

Payload field

key: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'key': FieldInfo(annotation=str, required=True, description='Payload field name')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class PayloadIndexInfo(*, data_type: PayloadSchemaType, params: Optional[TextIndexParams] = None, points: int)[source]

Bases: BaseModel

Display payload field type & index information

data_type: PayloadSchemaType
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'data_type': FieldInfo(annotation=PayloadSchemaType, required=True, description='Display payload field type & index information'), 'params': FieldInfo(annotation=Union[TextIndexParams, NoneType], required=False, description='Display payload field type & index information'), 'points': FieldInfo(annotation=int, required=True, description='Number of points indexed with this index')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

params: Optional[PayloadSchemaParams]
points: int
class PayloadIndexTelemetry(*, field_name: Optional[str] = None, points_values_count: int, points_count: int, histogram_bucket_size: Optional[int] = None)[source]

Bases: BaseModel

field_name: Optional[str]
histogram_bucket_size: Optional[int]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'field_name': FieldInfo(annotation=Union[str, NoneType], required=False, description=''), 'histogram_bucket_size': FieldInfo(annotation=Union[int, NoneType], required=False, description=''), 'points_count': FieldInfo(annotation=int, required=True, description=''), 'points_values_count': FieldInfo(annotation=int, required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

points_count: int
points_values_count: int
PayloadSchemaParams

alias of TextIndexParams

class PayloadSchemaType(value)[source]

Bases: str, Enum

All possible names of payload types

BOOL = 'bool'
FLOAT = 'float'
GEO = 'geo'
INTEGER = 'integer'
KEYWORD = 'keyword'
TEXT = 'text'
class PayloadSelectorExclude(*, exclude: List[str])[source]

Bases: BaseModel

exclude: List[str]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'exclude': FieldInfo(annotation=List[str], required=True, description='Exclude this fields from returning payload')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class PayloadSelectorInclude(*, include: List[str])[source]

Bases: BaseModel

include: List[str]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'include': FieldInfo(annotation=List[str], required=True, description='Only include this payload keys')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class PayloadStorageTypeOneOf(*, type: Literal['in_memory'])[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'type': FieldInfo(annotation=Literal['in_memory'], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

type: Literal['in_memory']
class PayloadStorageTypeOneOf1(*, type: Literal['on_disk'])[source]

Bases: BaseModel

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid'}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'type': FieldInfo(annotation=Literal['on_disk'], required=True, description='')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ fr