{"note":"OpenAPI conversion -- returning structured metadata","name":"qdrant","description":"Qdrant API","version":"master","base_url":"http://localhost:6333","endpoints":69,"raw":"@lap v0.3\n# Machine-readable API spec. Each @endpoint block is one API call.\n@api Qdrant API\n@base http://localhost:6333\n@version master\n@auth ApiKey api-key in header | Bearer bearer\n@endpoints 69\n@hint download_for_search\n@toc collections(50), root(1), telemetry(1), metrics(1), healthz(1), livez(1), readyz(1), issues(2), cluster(4), quotas(2), aliases(1), snapshots(4)\n\n@group collections\n@endpoint PUT /collections/{collection_name}/shards\n@desc Create shard key\n@required {collection_name: str # Name of the collection to create shards for, shard_key: any}\n@optional {timeout: int # Wait for operation commit timeout in seconds. If timeout is reached - request will return with service error., shards_number: int(uint32) # How many shards to create for this key If not specified, will use the default value from config, replication_factor: int(uint32) # How many replicas to create for each shard If not specified, will use the default value from config, placement: [int(uint64)] # 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, initial_state: any # Initial state of the shards for this key If not specified, will be `Initializing` first and then `Active` Warning: do not change this unless you know what you are doing}\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}/shards\n@desc List shard keys\n@required {collection_name: str # Name of the collection to list shard keys for}\n@returns(200) {usage: any, time: num(float), status: str, result: map{shard_keys: [map]?}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/shards/delete\n@desc Delete shard key\n@required {collection_name: str # Name of the collection to create shards for, shard_key: any}\n@optional {timeout: int # Wait for operation commit timeout in seconds. If timeout is reached - request will return with service error.}\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endgroup\n\n@group root\n@endpoint GET /\n@desc Returns information about the running Qdrant instance\n@returns(200) {title: str, version: str, commit: str?} # Qdrant server version information\n@errors {4XX: error}\n\n@endgroup\n\n@group telemetry\n@endpoint GET /telemetry\n@desc Collect telemetry data\n@optional {anonymize: bool # If true, anonymize result, details_level: int # Level of details in telemetry data. Minimal level is 0, maximal is infinity, per_collection: bool # If true, include per-collection request statistics in the response, timeout: int=60 # Timeout for this request}\n@returns(200) {usage: any, time: num(float), status: str, result: map{id: str, app: any, collections: map{number_of_collections: int(uint), max_collections: int(uint)?, collections: [any]?, snapshots: [map]?}, cluster: any, requests: any, memory: any, hardware: any, search_pool: any, quota: any}} # successful operation\n@errors {4XX: error}\n\n@endgroup\n\n@group metrics\n@endpoint GET /metrics\n@desc Collect Prometheus metrics data\n@optional {anonymize: bool # If true, anonymize result, per_collection: bool # If true, include per-collection request metrics with a collection label instead of global request metrics, timeout: int=60 # Timeout for this request}\n@returns(200) Metrics data in Prometheus format\n@errors {4XX: error}\n\n@endgroup\n\n@group healthz\n@endpoint GET /healthz\n@desc Kubernetes healthz endpoint\n@returns(200) Healthz response\n@errors {4XX: error}\n\n@endgroup\n\n@group livez\n@endpoint GET /livez\n@desc Kubernetes livez endpoint\n@returns(200) Healthz response\n@errors {4XX: error}\n\n@endgroup\n\n@group readyz\n@endpoint GET /readyz\n@desc Kubernetes readyz endpoint\n@returns(200) The instance is ready to accept traffic\n@errors {503: The instance is not ready to accept traffic yet, 4XX: error}\n\n@endgroup\n\n@group issues\n@endpoint GET /issues\n@desc Get issues\n@returns(200) Successful response\n@errors {4XX: error}\n\n@endpoint DELETE /issues\n@desc Clear issues\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endgroup\n\n@group cluster\n@endpoint GET /cluster\n@desc Get cluster status info\n@returns(200) {usage: any, time: num(float), status: str, result: any} # successful operation\n@errors {4XX: error}\n\n@endpoint GET /cluster/telemetry\n@desc Collect cluster telemetry data\n@optional {details_level: int # The level of detail to include in the response, timeout: int=60 # Timeout for this request}\n@returns(200) {usage: any, time: num(float), status: str, result: map{collections: map, cluster: any}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /cluster/recover\n@desc Tries to recover current peer Raft state.\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endpoint DELETE /cluster/peer/{peer_id}\n@desc Remove peer from the cluster\n@required {peer_id: int # Id of the peer}\n@optional {timeout: int # Wait for operation commit timeout in seconds. If timeout is reached - request will return with service error., force: bool=false # If true - removes peer even if it has shards/replicas on it.}\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endgroup\n\n@group quotas\n@endpoint GET /quotas\n@desc Get global quotas\n@returns(200) {usage: any, time: num(float), status: str, result: map{config: map{enabled: bool, max_resident_memory_percent: int(uint8)?, max_disk_usage_percent: int(uint8)?, release_margin_percent: int(uint8)?}, usage: map{resident_memory_percent: int(uint8)?, disk_usage_percent: int(uint8)?}, peers: map?}} # successful operation\n@errors {4XX: error}\n\n@endpoint PUT /quotas\n@desc Set global quotas\n@optional {wait: bool=false # If true, wait until the new configuration is confirmed by consensus on this peer. If false - the request returns as soon as the change is proposed., enabled: bool=false # Whether the limits below are enforced., max_resident_memory_percent: int(uint8) # Reject memory-consuming updates once process resident memory reaches this percentage of total system memory (or of the cgroup limit, if one applies)., max_disk_usage_percent: int(uint8) # Reject disk-consuming updates once the filesystem hosting the storage directory is filled to this percentage of its capacity., release_margin_percent: int(uint8) # How many percentage points below its limit a resource has to fall before this node starts accepting work again.  Without a margin, a resource resting on its limit crosses it in both directions on the noise between two readings, putting the node in and out of service each time — and restarting a shard recovery with it. Raise it where usage is volatile; `0` disables the margin and releases as soon as usage is back under the limit.  Unset leaves the built-in default in force, so a config written today does not pin a number that a later release may want to revise.}\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endgroup\n\n@group collections\n@endpoint GET /collections\n@desc List collections\n@returns(200) {usage: any, time: num(float), status: str, result: map{collections: [map]}} # successful operation\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}\n@desc Collection info\n@required {collection_name: str # Name of the collection to retrieve}\n@returns(200) {usage: any, time: num(float), status: str, result: map{status: str, optimizer_status: any, warnings: [map], indexed_vectors_count: int(uint)?, points_count: int(uint)?, segments_count: int(uint), config: map{params: map{vectors: any, shard_number: int(uint32), sharding_method: any, replication_factor: int(uint32), write_consistency_factor: int(uint32), read_fan_out_factor: int(uint32)?, read_fan_out_delay_ms: int(uint64)?, on_disk_payload: bool?, payload: any, sparse_vectors: map?}, hnsw_config: map{m: int(uint), ef_construct: int(uint), full_scan_threshold: int(uint), max_indexing_threads: int(uint), on_disk: bool?, memory: any, payload_m: int(uint)?, inline_storage: bool?}, optimizer_config: map{deleted_threshold: num(double), vacuum_min_vector_number: int(uint), default_segment_number: int(uint), max_segment_size: int(uint)?, memmap_threshold: int(uint)?, indexing_threshold: int(uint)?, flush_interval_sec: int(uint64), max_optimization_threads: int(uint)?, prevent_unoptimized: bool?}, wal_config: any, quantization_config: any, strict_mode_config: any, metadata: any}, payload_schema: map, update_queue: any}} # successful operation\n@errors {4XX: error}\n\n@endpoint PUT /collections/{collection_name}\n@desc Create collection\n@required {collection_name: str # Name of the new collection}\n@optional {timeout: int # Wait for operation commit timeout in seconds. If timeout is reached - request will return with service error., vectors: any # Vector params separator for single and multiple vector modes Single mode:  { \"size\": 128, \"distance\": \"Cosine\" }  or multiple mode:  { \"default\": { \"size\": 128, \"distance\": \"Cosine\" } }, shard_number: int(uint32)=null # 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: any=null # Sharding method Default is Auto - points are distributed across all available shards Custom - points are distributed across shards according to shard key, replication_factor: int(uint32)=null # Number of shards replicas. Default is 1 Minimum is 1, write_consistency_factor: int(uint32)=null # 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., on_disk_payload: bool=null # Deprecated: use `payload.memory` instead. 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.  Default: true, payload: any=null # Configuration of the payload storage, hnsw_config: any # Custom params for HNSW index. If none - values from service configuration file are used., wal_config: any # Custom params for WAL. If none - values from service configuration file are used., optimizers_config: any # Custom params for Optimizers.  If none - values from service configuration file are used., quantization_config: any=null # Quantization parameters. If none - quantization is disabled., sparse_vectors: map # Sparse vector data config., strict_mode_config: any # Strict-mode config., metadata: any # Arbitrary JSON metadata for the collection This can be used to store application-specific information such as creation time, migration data, inference model info, etc.}\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endpoint PATCH /collections/{collection_name}\n@desc Update collection parameters\n@required {collection_name: str # Name of the collection to update}\n@optional {timeout: int # Wait for operation commit timeout in seconds. If timeout is reached - request will return with service error., vectors: any # Map of vector data parameters to update for each named vector. To update parameters in a collection having a single unnamed vector, use an empty string as name., optimizers_config: any # Custom params for Optimizers.  If none - it is left unchanged. This operation is blocking, it will only proceed once all current optimizations are complete, params: any # Collection base params. If none - it is left unchanged., hnsw_config: any # HNSW parameters to update for the collection index. If none - it is left unchanged., quantization_config: any=null # Quantization parameters to update. If none - it is left unchanged., sparse_vectors: any # Map of sparse vector data parameters to update for each sparse vector., strict_mode_config: any, metadata: any # Metadata to update for the collection. If provided, this will merge with existing metadata. Individual keys can be removed by setting their value to `null`.}\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endpoint DELETE /collections/{collection_name}\n@desc Delete collection\n@required {collection_name: str # Name of the collection to delete}\n@optional {timeout: int # Wait for operation commit timeout in seconds. If timeout is reached - request will return with service error.}\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/aliases\n@desc Update aliases of the collections\n@required {actions: [any]}\n@optional {timeout: int # Wait for operation commit timeout in seconds. If timeout is reached - request will return with service error.}\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endpoint PUT /collections/{collection_name}/index\n@desc Create index for field in collection\n@required {collection_name: str # Name of the collection, field_name: str}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation, field_schema: any}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}/exists\n@desc Check the existence of a collection\n@required {collection_name: str # Name of the collection}\n@returns(200) {usage: any, time: num(float), status: str, result: map{exists: bool}} # successful operation\n@errors {4XX: error}\n\n@endpoint DELETE /collections/{collection_name}/index/{field_name}\n@desc Delete index for field in collection\n@required {collection_name: str # Name of the collection, field_name: str # Name of the field where to delete the index}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint PUT /collections/{collection_name}/vectors/{vector_name}\n@desc Create named vector\n@required {collection_name: str # Name of the collection, vector_name: str # Name of the vector to create}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint DELETE /collections/{collection_name}/vectors/{vector_name}\n@desc Delete named vector\n@required {collection_name: str # Name of the collection, vector_name: str # Name of the vector to delete}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}/cluster\n@desc Collection cluster info\n@required {collection_name: str # Name of the collection to retrieve the cluster info for}\n@returns(200) {usage: any, time: num(float), status: str, result: map{peer_id: int(uint64), shard_count: int(uint), local_shards: [map], remote_shards: [map], shard_transfers: [map], resharding_operations: [map]?}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/cluster\n@desc Update collection cluster setup\n@required {collection_name: str # Name of the collection on which to to apply the cluster update operation}\n@optional {timeout: int # Wait for operation commit timeout in seconds. If timeout is reached - request will return with service error.}\n@returns(200) {usage: any, time: num(float), status: str, result: bool} # successful operation\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}/optimizations\n@desc Get optimization progress\n@required {collection_name: str # Name of the collection}\n@optional {with: str # Comma-separated list of optional fields to include in the response. Possible values: queued, completed, idle_segments., completed_limit: int=16 # Maximum number of completed optimizations to return. Ignored if `completed` is not in the `with` parameter.}\n@returns(200) {usage: any, time: num(float), status: str, result: map{summary: map{queued_optimizations: int(uint), queued_segments: int(uint), queued_points: int(uint), idle_segments: int(uint)}, running: [map], queued: [map]?, completed: [map]?, idle_segments: [map]?}} # successful operation\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}/aliases\n@desc List aliases for collection\n@required {collection_name: str # Name of the collection}\n@returns(200) {usage: any, time: num(float), status: str, result: map{aliases: [map]}} # successful operation\n@errors {4XX: error}\n\n@endgroup\n\n@group aliases\n@endpoint GET /aliases\n@desc List collections aliases\n@returns(200) {usage: any, time: num(float), status: str, result: map{aliases: [map]}} # successful operation\n@errors {4XX: error}\n\n@endgroup\n\n@group collections\n@endpoint POST /collections/{collection_name}/snapshots/upload\n@desc Recover from an uploaded snapshot\n@required {collection_name: str # Name of the collection}\n@optional {wait: bool # If true, wait for changes to actually happen. If false - let changes happen in background. Default is true., priority: str # Defines source of truth for snapshot recovery, checksum: str # Optional SHA256 checksum to verify snapshot integrity before recovery.}\n@returns(200) {time: num(float), status: str, result: bool} # successful operation\n@returns(202) {time: num(float), status: str} # operation is accepted\n@errors {4XX: error}\n\n@endpoint PUT /collections/{collection_name}/snapshots/recover\n@desc Recover from a snapshot\n@required {collection_name: str # Name of the collection, location: str(uri) # Examples: - URL `http://localhost:8080/collections/my_collection/snapshots/my_snapshot` - Local path `file:///qdrant/snapshots/test_collection-2022-08-04-10-49-10.snapshot`}\n@optional {wait: bool # If true, wait for changes to actually happen. If false - let changes happen in background. Default is true., priority: any=null # Defines which data should be used as a source of truth if there are other replicas in the cluster. If set to `Snapshot`, the snapshot will be used as a source of truth, and the current state will be overwritten. If set to `Replica`, the current state will be used as a source of truth, and after recovery it will be synchronized from other replicas., checksum: str=null # Optional SHA256 checksum to verify snapshot integrity before recovery., api_key: str=null # Optional API key used when fetching the snapshot from a remote URL.}\n@returns(200) {time: num(float), status: str, result: bool} # successful operation\n@returns(202) {time: num(float), status: str} # operation is accepted\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}/snapshots\n@desc List collection snapshots\n@required {collection_name: str # Name of the collection}\n@returns(200) {usage: any, time: num(float), status: str, result: [map]} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/snapshots\n@desc Create collection snapshot\n@required {collection_name: str # Name of the collection for which to create a snapshot}\n@optional {wait: bool # If true, wait for changes to actually happen. If false - let changes happen in background. Default is true.}\n@returns(200) {time: num(float), status: str, result: map{name: str, creation_time: str(partial-date-time)?, size: int(uint64), checksum: str?}} # successful operation\n@returns(202) {time: num(float), status: str} # operation is accepted\n@errors {4XX: error}\n\n@endpoint DELETE /collections/{collection_name}/snapshots/{snapshot_name}\n@desc Delete collection snapshot\n@required {collection_name: str # Name of the collection for which to delete a snapshot, snapshot_name: str # Name of the snapshot to delete}\n@optional {wait: bool # If true, wait for changes to actually happen. If false - let changes happen in background. Default is true.}\n@returns(200) {time: num(float), status: str, result: bool} # successful operation\n@returns(202) {time: num(float), status: str} # operation is accepted\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}/snapshots/{snapshot_name}\n@desc Download collection snapshot\n@required {collection_name: str # Name of the collection, snapshot_name: str # Name of the snapshot to download}\n@returns(200) Snapshot file\n@errors {4XX: error}\n\n@endgroup\n\n@group snapshots\n@endpoint GET /snapshots\n@desc List of storage snapshots\n@returns(200) {usage: any, time: num(float), status: str, result: [map]} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /snapshots\n@desc Create storage snapshot\n@optional {wait: bool # If true, wait for changes to actually happen. If false - let changes happen in background. Default is true.}\n@returns(200) {time: num(float), status: str, result: map{name: str, creation_time: str(partial-date-time)?, size: int(uint64), checksum: str?}} # successful operation\n@returns(202) {time: num(float), status: str} # operation is accepted\n@errors {4XX: error}\n\n@endpoint DELETE /snapshots/{snapshot_name}\n@desc Delete storage snapshot\n@required {snapshot_name: str # Name of the full snapshot to delete}\n@optional {wait: bool # If true, wait for changes to actually happen. If false - let changes happen in background. Default is true.}\n@returns(200) {time: num(float), status: str, result: bool} # successful operation\n@returns(202) {time: num(float), status: str} # operation is accepted\n@errors {4XX: error}\n\n@endpoint GET /snapshots/{snapshot_name}\n@desc Download storage snapshot\n@required {snapshot_name: str # Name of the snapshot to download}\n@returns(200) Snapshot file\n@errors {4XX: error}\n\n@endgroup\n\n@group collections\n@endpoint GET /collections/{collection_name}/shards/{shard_id}/snapshot\n@desc Download shard snapshot\n@required {collection_name: str # Name of the collection, shard_id: int # Id of the shard}\n@returns(200) Snapshot file\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/shards/{shard_id}/snapshots/upload\n@desc Recover shard from an uploaded snapshot\n@required {collection_name: str # Name of the collection, shard_id: int # Id of the shard to recover}\n@optional {wait: bool # If true, wait for changes to actually happen. If false - let changes happen in background. Default is true., priority: str # Defines source of truth for snapshot recovery, checksum: str # Optional SHA256 checksum to verify snapshot integrity before recovery.}\n@returns(200) {time: num(float), status: str, result: bool} # successful operation\n@returns(202) {time: num(float), status: str} # operation is accepted\n@errors {4XX: error}\n\n@endpoint PUT /collections/{collection_name}/shards/{shard_id}/snapshots/recover\n@desc Recover from a snapshot\n@required {collection_name: str # Name of the collection, shard_id: int # Id of the shard to recover, location: any}\n@optional {wait: bool # If true, wait for changes to actually happen. If false - let changes happen in background. Default is true., priority: any=null, checksum: str=null # Optional SHA256 checksum to verify snapshot integrity before recovery., api_key: str=null # Optional API key used when fetching the snapshot from a remote URL.}\n@returns(200) {time: num(float), status: str, result: bool} # successful operation\n@returns(202) {time: num(float), status: str} # operation is accepted\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}/shards/{shard_id}/snapshots\n@desc List shards snapshots for a collection\n@required {collection_name: str # Name of the collection, shard_id: int # Id of the shard}\n@returns(200) {usage: any, time: num(float), status: str, result: [map]} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/shards/{shard_id}/snapshots\n@desc Create shard snapshot\n@required {collection_name: str # Name of the collection for which to create a snapshot, shard_id: int # Id of the shard}\n@optional {wait: bool # If true, wait for changes to actually happen. If false - let changes happen in background. Default is true.}\n@returns(200) {time: num(float), status: str, result: map{name: str, creation_time: str(partial-date-time)?, size: int(uint64), checksum: str?}} # successful operation\n@returns(202) {time: num(float), status: str} # operation is accepted\n@errors {4XX: error}\n\n@endpoint DELETE /collections/{collection_name}/shards/{shard_id}/snapshots/{snapshot_name}\n@desc Delete shard snapshot\n@required {collection_name: str # Name of the collection for which to delete a snapshot, shard_id: int # Id of the shard, snapshot_name: str # Name of the snapshot to delete}\n@optional {wait: bool # If true, wait for changes to actually happen. If false - let changes happen in background. Default is true.}\n@returns(200) {time: num(float), status: str, result: bool} # successful operation\n@returns(202) {time: num(float), status: str} # operation is accepted\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}/shards/{shard_id}/snapshots/{snapshot_name}\n@desc Download collection snapshot\n@required {collection_name: str # Name of the collection, shard_id: int # Id of the shard, snapshot_name: str # Name of the snapshot to download}\n@returns(200) Snapshot file\n@errors {4XX: error}\n\n@endpoint GET /collections/{collection_name}/points/{id}\n@desc Get point\n@required {collection_name: str # Name of the collection to retrieve from, id: any # Id of the point}\n@optional {consistency: any # Define read consistency guarantees for the operation, timeout: int # If set, overrides global timeout for this request. Unit is seconds.}\n@returns(200) {usage: any, time: num(float), status: str, result: map{id: any, payload: any, vector: any, shard_key: any, order_value: any}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points\n@desc Get points\n@required {collection_name: str # Name of the collection to retrieve from, ids: [any] # Look for points with ids}\n@optional {consistency: any # Define read consistency guarantees for the operation, timeout: int # If set, overrides global timeout for this request. Unit is seconds., shard_key: any # Specify in which shards to look for the points, if not specified - look in all shards, with_payload: any # Select which payload to return with the response. Default is true., with_vector: any # Options for specifying which vector to include}\n@returns(200) {usage: any, time: num(float), status: str, result: [map]} # successful operation\n@errors {4XX: error}\n\n@endpoint PUT /collections/{collection_name}/points\n@desc Upsert points\n@required {collection_name: str # Name of the collection to update from}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/delete\n@desc Delete points\n@required {collection_name: str # Name of the collection to delete from}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint PUT /collections/{collection_name}/points/vectors\n@desc Update vectors\n@required {collection_name: str # Name of the collection to update from, points: [map{id!: any, vector!: any}] # Points with named vectors}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation, shard_key: any, update_filter: any}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/vectors/delete\n@desc Delete vectors\n@required {collection_name: str # Name of the collection to delete from, vector: [str] # Vector names}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation, points: [any] # Deletes values from each point in this list, filter: any # Deletes values from points that satisfy this filter condition, shard_key: any}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/payload\n@desc Set payload\n@required {collection_name: str # Name of the collection to set from, payload: map}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation, points: [any] # Assigns payload to each point in this list, filter: any # Assigns payload to each point that satisfy this filter condition, shard_key: any, key: str # Assigns payload to each point that satisfy this path of property}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint PUT /collections/{collection_name}/points/payload\n@desc Overwrite payload\n@required {collection_name: str # Name of the collection to set from, payload: map}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation, points: [any] # Assigns payload to each point in this list, filter: any # Assigns payload to each point that satisfy this filter condition, shard_key: any, key: str # Assigns payload to each point that satisfy this path of property}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/payload/delete\n@desc Delete payload\n@required {collection_name: str # Name of the collection to delete from, keys: [str] # List of payload keys to remove from payload}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation, points: [any] # Deletes values from each point in this list, filter: any # Deletes values from points that satisfy this filter condition, shard_key: any}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/payload/clear\n@desc Clear payload\n@required {collection_name: str # Name of the collection to clear payload from}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation}\n@returns(200) {usage: any, time: num(float), status: str, result: map{operation_id: int(uint64)?, status: str}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/batch\n@desc Batch update points\n@required {collection_name: str # Name of the collection to apply operations on, operations: [any]}\n@optional {wait: bool # If true, wait for changes to actually happen, ordering: str # define ordering guarantees for the operation, timeout: int # Timeout for the operation}\n@returns(200) {usage: any, time: num(float), status: str, result: [map]} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/scroll\n@desc Scroll points\n@required {collection_name: str # Name of the collection to retrieve from}\n@optional {consistency: any # Define read consistency guarantees for the operation, timeout: int # If set, overrides global timeout for this request. Unit is seconds., shard_key: any # Specify in which shards to look for the points, if not specified - look in all shards, offset: any # Start ID to read points from., limit: int(uint) # Page size. Default: 10, filter: any # Look only for points which satisfies this conditions. If not provided - all points., with_payload: any # Select which payload to return with the response. Default is true., with_vector: any # Options for specifying which vector to include, order_by: any # Order the records by a payload field.}\n@returns(200) {usage: any, time: num(float), status: str, result: map{points: [map], next_page_offset: any}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/count\n@desc Count points\n@required {collection_name: str # Name of the collection to count in}\n@optional {consistency: any # Define read consistency guarantees for the operation, timeout: int # If set, overrides global timeout for this request. Unit is seconds., shard_key: any # Specify in which shards to look for the points, if not specified - look in all shards, filter: any # Look only for points which satisfies this conditions, exact: bool=true # 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}\n@returns(200) {usage: any, time: num(float), status: str, result: map{count: int(uint)}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/facet\n@desc Facet a payload key with a given filter.\n@required {collection_name: str # Name of the collection to facet in, key: str # Payload key to use for faceting.}\n@optional {consistency: any # Define read consistency guarantees for the operation, timeout: int # If set, overrides global timeout for this request. Unit is seconds., shard_key: any, limit: int(uint) # Max number of hits to return. Default is 10., filter: any # Filter conditions - only consider points that satisfy these conditions., exact: bool # Whether to do a more expensive exact count for each of the values in the facet. Default is false.}\n@returns(200) {usage: any, time: num(float), status: str, result: map{hits: [map]}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/query\n@desc Query points\n@required {collection_name: str # Name of the collection to query}\n@optional {consistency: any # Define read consistency guarantees for the operation, timeout: int # If set, overrides global timeout for this request. Unit is seconds., shard_key: any, prefetch: any=null # Sub-requests to perform first. If present, the query will be performed on the results of the prefetch(es)., query: any # Query to perform. If missing without prefetches, returns points ordered by their IDs., using: str # Define which vector name to use for querying. If missing, the default vector is used., filter: any # Filter conditions - return only those points that satisfy the specified conditions., params: any # Search params for when there is no prefetch, score_threshold: num(float) # Return points with scores better than this threshold., limit: int(uint) # Max number of points to return. Default is 10., offset: int(uint) # Offset of the result. Skip this many points. Default is 0, with_vector: any # Options for specifying which vectors to include into the response. Default is false., with_payload: any # Options for specifying which payload to include or not. Default is false., lookup_from: any=null # The location to use for IDs lookup, if not specified - use the current collection and the 'using' vector Note: the other collection vectors should have the same vector size as the 'using' vector in the current collection}\n@returns(200) {usage: any, time: num(float), status: str, result: map{points: [map]}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/query/batch\n@desc Query points in batch\n@required {collection_name: str # Name of the collection to query, searches: [map{shard_key: any, prefetch: any, query: any, using: str, filter: any, params: any, score_threshold: num(float), limit: int(uint), offset: int(uint), with_vector: any, with_payload: any, lookup_from: any}]}\n@optional {consistency: any # Define read consistency guarantees for the operation, timeout: int # If set, overrides global timeout for this request. Unit is seconds.}\n@returns(200) {usage: any, time: num(float), status: str, result: [map]} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/query/groups\n@desc Query points, grouped by a given payload field\n@required {collection_name: str # Name of the collection to query, group_by: str # Payload field to group by, must be a string or number field. If the field contains more than 1 value, all values will be used for grouping. One point can be in multiple groups.}\n@optional {consistency: any # Define read consistency guarantees for the operation, timeout: int # If set, overrides global timeout for this request. Unit is seconds., shard_key: any, prefetch: any=null # Sub-requests to perform first. If present, the query will be performed on the results of the prefetch(es)., query: any # Query to perform. If missing without prefetches, returns points ordered by their IDs., using: str # Define which vector name to use for querying. If missing, the default vector is used., filter: any # Filter conditions - return only those points that satisfy the specified conditions., params: any # Search params for when there is no prefetch, score_threshold: num(float) # Return points with scores better than this threshold., with_vector: any # Options for specifying which vectors to include into the response. Default is false., with_payload: any # Options for specifying which payload to include or not. Default is false., lookup_from: any=null # The location to use for IDs lookup, if not specified - use the current collection and the 'using' vector Note: the other collection vectors should have the same vector size as the 'using' vector in the current collection, group_size: int(uint) # Maximum amount of points to return per group. Default is 3., limit: int(uint) # Maximum amount of groups to return. Default is 10., with_lookup: any # Look for points in another collection using the group ids}\n@returns(200) {usage: any, time: num(float), status: str, result: map{groups: [map]}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/search/matrix/pairs\n@desc Search points matrix distance pairs\n@required {collection_name: str # Name of the collection to search in}\n@optional {consistency: any # Define read consistency guarantees for the operation, timeout: int # If set, overrides global timeout for this request. Unit is seconds., shard_key: any # Specify in which shards to look for the points, if not specified - look in all shards, filter: any # Look only for points which satisfies this conditions, sample: int(uint) # How many points to select and search within. Default is 10., limit: int(uint) # How many neighbours per sample to find. Default is 3., using: str # Define which vector name to use for querying. If missing, the default vector is used.}\n@returns(200) {usage: any, time: num(float), status: str, result: map{pairs: [map]}} # successful operation\n@errors {4XX: error}\n\n@endpoint POST /collections/{collection_name}/points/search/matrix/offsets\n@desc Search points matrix distance offsets\n@required {collection_name: str # Name of the collection to search in}\n@optional {consistency: any # Define read consistency guarantees for the operation, timeout: int # If set, overrides global timeout for this request. Unit is seconds., shard_key: any # Specify in which shards to look for the points, if not specified - look in all shards, filter: any # Look only for points which satisfies this conditions, sample: int(uint) # How many points to select and search within. Default is 10., limit: int(uint) # How many neighbours per sample to find. Default is 3., using: str # Define which vector name to use for querying. If missing, the default vector is used.}\n@returns(200) {usage: any, time: num(float), status: str, result: map{offsets_row: [int(uint64)], offsets_col: [int(uint64)], scores: [num(float)], ids: [any]}} # successful operation\n@errors {4XX: error}\n\n@endgroup\n\n@end\n"}