> For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://api.qdrant.tech/v-1-17-x/api-reference/service/telemetry/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://api.qdrant.tech/_mcp/server. # Collect telemetry data GET http://localhost:6333/telemetry Collects telemetry data, such as: application info, system info, collection info, cluster info, configs and statistics. Reference: https://api.qdrant.tech/api-reference/service/telemetry ## Authentication - `api-key` header (required) — API Key authentication via header ## Servers - `http://localhost:6333` (http, default) - `https://localhost:6333` (https) ## Request ### Query parameters - `anonymize` (boolean, optional) — If true, anonymize result - `details_level` (integer, optional) — Level of details in telemetry data. Minimal level is 0, maximal is infinity - `timeout` (integer, optional, default: 60) — Timeout for this request ## Response ### 200 successful operation - `usage` (TelemetryGetResponsesContentApplicationJsonSchemaUsage, optional) - `time` (double, optional) — Time spent to process this request - `status` (string, optional) - `result` (TelemetryData, optional) ## Types ### TelemetryGetResponsesContentApplicationJsonSchemaUsage ### TelemetryData - `id` (string, required) - `collections` (CollectionsTelemetry, required) - `app` (TelemetryDataApp, optional) - `cluster` (TelemetryDataCluster, optional) - `requests` (TelemetryDataRequests, optional) - `memory` (TelemetryDataMemory, optional) - `hardware` (TelemetryDataHardware, optional) ### Usage Usage of the hardware resources, spent to process the request - `hardware` (UsageHardware, optional) - `inference` (UsageInference, optional) ### CollectionsTelemetry - `number_of_collections` (integer, required) - `max_collections` (integer, optional, nullable) - `collections` (list of CollectionTelemetryEnum, optional, nullable) - `snapshots` (list of CollectionSnapshotTelemetry, optional, nullable) ### TelemetryDataApp ### TelemetryDataCluster ### TelemetryDataRequests ### TelemetryDataMemory ### TelemetryDataHardware ### UsageHardware ### UsageInference ### CollectionTelemetryEnum ### CollectionSnapshotTelemetry - `id` (string, required) - `running_snapshots` (integer, optional, nullable) - `running_snapshot_recovery` (integer, optional, nullable) - `total_snapshot_creations` (integer, optional, nullable) ### AppBuildTelemetry - `name` (string, required) - `version` (string, required) - `startup` (string, required) - `features` (AppBuildTelemetryFeatures, optional) - `runtime_features` (AppBuildTelemetryRuntimeFeatures, optional) - `hnsw_global_config` (AppBuildTelemetryHnswGlobalConfig, optional) - `system` (AppBuildTelemetrySystem, optional) - `jwt_rbac` (boolean, optional, nullable) - `hide_jwt_dashboard` (boolean, optional, nullable) ### ClusterTelemetry - `enabled` (boolean, required) - `status` (ClusterTelemetryStatus, optional) - `config` (ClusterTelemetryConfig, optional) - `peers` (map from string to PeerInfo, optional, nullable) - `peer_metadata` (map from string to PeerMetadata, optional, nullable) - `metadata` (map from string to any, optional, nullable) - `resharding_enabled` (boolean, optional, nullable) ### RequestsTelemetry - `rest` (WebApiTelemetry, required) - `grpc` (GrpcTelemetry, required) ### MemoryTelemetry - `active_bytes` (integer, required) — Total number of bytes in active pages allocated by the application - `allocated_bytes` (integer, required) — Total number of bytes allocated by the application - `metadata_bytes` (integer, required) — Total number of bytes dedicated to metadata - `resident_bytes` (integer, required) — Maximum number of bytes in physically resident data pages mapped - `retained_bytes` (integer, required) — Total number of bytes in virtual memory mappings ### HardwareTelemetry - `collection_data` (map from string to HardwareUsage, required) ### HardwareUsage Usage of the hardware resources, spent to process the request - `cpu` (integer, required) - `payload_io_read` (integer, required) - `payload_io_write` (integer, required) - `payload_index_io_read` (integer, required) - `payload_index_io_write` (integer, required) - `vector_io_read` (integer, required) - `vector_io_write` (integer, required) ### InferenceUsage - `models` (map from string to ModelUsage, required) ### CollectionTelemetry - `id` (string, required) - `init_time_ms` (uint64, optional, nullable) - `config` (CollectionTelemetryConfig, optional) - `shards` (list of ReplicaSetTelemetry, optional, nullable) - `transfers` (list of ShardTransferInfo, optional, nullable) - `resharding` (list of ReshardingInfo, optional, nullable) - `shard_clean_tasks` (map from string to ShardCleanStatusTelemetry, optional, nullable) ### CollectionsAggregatedTelemetry - `vectors` (integer, required) - `optimizers_status` (OptimizersStatus, required) — Current state of the collection - `params` (CollectionParams, required) ### AppBuildTelemetryFeatures ### AppBuildTelemetryRuntimeFeatures ### AppBuildTelemetryHnswGlobalConfig ### AppBuildTelemetrySystem ### ClusterTelemetryStatus ### ClusterTelemetryConfig ### PeerInfo Information of a peer in the cluster - `uri` (string, required) ### PeerMetadata Metadata describing extra properties for each peer - `version` (string, required) — Peer Qdrant version ### WebApiTelemetry - `responses` (map from string to map from string to OperationDurationStatistics, required) ### GrpcTelemetry - `responses` (map from string to map from string to OperationDurationStatistics, required) ### ModelUsage - `tokens` (uint64, required) ### CollectionTelemetryConfig ### ReplicaSetTelemetry - `id` (uint, required) - `remote` (list of RemoteShardTelemetry, required) - `replicate_states` (map from string to enum, required) - Allowed values: `Active`, `Dead`, `Partial`, `Initializing`, `Listener`, `PartialSnapshot`, `Recovery`, `Resharding`, `ReshardingScaleDown`, `ActiveRead`, `ManualRecovery` - `key` (ReplicaSetTelemetryKey, optional) - `local` (ReplicaSetTelemetryLocal, optional) - `partial_snapshot` (ReplicaSetTelemetryPartialSnapshot, optional) ### ShardTransferInfo - `shard_id` (uint, required) - `from` (uint64, required) — Source peer id - `to` (uint64, required) — Destination peer id - `sync` (boolean, required) — If `true` transfer is a synchronization of a replicas If `false` transfer is a moving of a shard from one peer to another - `to_shard_id` (uint, optional, nullable) — Target shard ID if different than source shard ID Used exclusively with `ReshardingStreamRecords` transfer method. - `method` (ShardTransferInfoMethod, optional) - `comment` (string, optional, nullable) — A human-readable report of the transfer progress. Available only on the source peer. ### ReshardingInfo - `direction` (enum, required) — Resharding direction, scale up or down in number of shards - `up` - Scale up, add a new shard - `down` - Scale down, remove a shard - Allowed values: `up`, `down` - `shard_id` (uint, required) - `peer_id` (uint64, required) - `shard_key` (ReshardingInfoShardKey, optional) ### ShardCleanStatusTelemetry ### OptimizersStatus Current state of the collection ### CollectionParams - `vectors` (VectorsConfig, optional) — 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` (uint, optional) — Number of shards the collection has - `sharding_method` (CollectionParamsShardingMethod, optional) — Sharding method Default is Auto - points are distributed across all available shards Custom - points are distributed across shards according to shard key - `replication_factor` (uint, optional) — Number of replicas for each shard - `write_consistency_factor` (uint, optional) — 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. - `read_fan_out_factor` (uint, optional, nullable) — 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. - `read_fan_out_delay_ms` (uint64, optional, nullable) — Define number of milliseconds to wait before attempting to read from another replica. This setting can help to reduce latency spikes in case of occasional slow replicas. Default is 0, which means delayed fan out request is disabled. - `on_disk_payload` (boolean, optional, default: true) — 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 - `sparse_vectors` (map from string to SparseVectorParams, optional, nullable) — Configuration of the sparse vector storage ### AppFeaturesTelemetry - `debug` (boolean, required) - `service_debug_feature` (boolean, required) - `recovery_mode` (boolean, required) - `gpu` (boolean, required) - `rocksdb` (boolean, required) - `staging` (boolean, required) ### FeatureFlags - `all` (boolean, optional, default: false) — Magic feature flag that enables all features. Note that this will only be applied to all flags when passed into [`init_feature_flags`]. - `payload_index_skip_rocksdb` (boolean, optional, default: true) — Skip usage of RocksDB in new immutable payload indices. First implemented in Qdrant 1.13.5. Enabled by default in Qdrant 1.14.1. - `payload_index_skip_mutable_rocksdb` (boolean, optional, default: true) — Skip usage of RocksDB in new mutable payload indices. First implemented in Qdrant 1.15.0. Enabled by default in Qdrant 1.16.0. - `payload_storage_skip_rocksdb` (boolean, optional, default: true) — Skip usage of RocksDB in new payload storages. On-disk payload storages never use Gridstore. First implemented in Qdrant 1.15.0. Enabled by default in Qdrant 1.16.0. - `incremental_hnsw_building` (boolean, optional, default: true) — Use incremental HNSW building. Enabled by default in Qdrant 1.14.1. - `migrate_rocksdb_id_tracker` (boolean, optional, default: true) — Migrate RocksDB based ID trackers into file based ID tracker on start. Enabled by default in Qdrant 1.15.0. - `migrate_rocksdb_vector_storage` (boolean, optional, default: true) — Migrate RocksDB based vector storages into new format on start. Enabled by default in Qdrant 1.16.1. - `migrate_rocksdb_payload_storage` (boolean, optional, default: true) — Migrate RocksDB based payload storages into new format on start. Enabled by default in Qdrant 1.16.1. - `migrate_rocksdb_payload_indices` (boolean, optional, default: true) — Migrate RocksDB based payload indices into new format on start. Rebuilds a new payload index from scratch. Enabled by default in Qdrant 1.16.1. - `appendable_quantization` (boolean, optional, default: true) — Use appendable quantization in appendable plain segments. Enabled by default in Qdrant 1.16.0. - `single_file_mmap_vector_storage` (boolean, optional, default: false) — Use single-file mmap in-ram vector storage (InRamMmap) Enabled by default in Qdrant 1.17.1+ ### HnswGlobalConfig - `healing_threshold` (double, optional, default: 0.3) — Enable HNSW healing if the ratio of missing points is no more than this value. To disable healing completely, set this value to `0.0`. ### RunningEnvironmentTelemetry - `is_docker` (boolean, required) - `cpu_flags` (string, required) - `distribution` (string, optional, nullable) - `distribution_version` (string, optional, nullable) - `cores` (integer, optional, nullable) - `ram_size` (integer, optional, nullable) - `disk_size` (integer, optional, nullable) - `cpu_endian` (RunningEnvironmentTelemetryCpuEndian, optional) - `gpu_devices` (list of GpuDeviceTelemetry, optional, nullable) ### ClusterStatusTelemetry - `number_of_peers` (integer, required) - `term` (uint64, required) - `commit` (uint64, required) - `pending_operations` (integer, required) - `is_voter` (boolean, required) - `consensus_thread_status` (ConsensusThreadStatus, required) — Information about current consensus thread status - `role` (ClusterStatusTelemetryRole, optional) - `peer_id` (uint64, optional, nullable) ### ClusterConfigTelemetry - `grpc_timeout_ms` (uint64, required) - `p2p` (P2pConfigTelemetry, required) - `consensus` (ConsensusConfigTelemetry, required) ### OperationDurationStatistics - `count` (integer, required) - `fail_count` (integer, optional, nullable) - `avg_duration_micros` (double, optional, nullable) — The average time taken by 128 latest operations, calculated as a weighted mean. - `min_duration_micros` (double, optional, nullable) — The minimum duration of the operations across all the measurements. - `max_duration_micros` (double, optional, nullable) — The maximum duration of the operations across all the measurements. - `total_duration_micros` (uint64, optional, nullable) — The total duration of all operations in microseconds. - `last_responded` (string, optional, nullable) ### CollectionConfigTelemetry - `params` (CollectionParams, required) - `hnsw_config` (HnswConfig, required) — Config of HNSW index - `optimizer_config` (OptimizersConfig, required) - `wal_config` (WalConfig, required) - `quantization_config` (CollectionConfigTelemetryQuantizationConfig, optional) - `strict_mode_config` (CollectionConfigTelemetryStrictModeConfig, optional) - `uuid` (string, optional, nullable) - `metadata` (CollectionConfigTelemetryMetadata, optional) — Arbitrary JSON metadata for the collection ### RemoteShardTelemetry - `shard_id` (uint, required) - `peer_id` (uint64, required) - `searches` (RemoteShardTelemetrySearches, optional) - `updates` (RemoteShardTelemetryUpdates, optional) ### ReplicaSetTelemetryKey ### ReplicaSetTelemetryLocal ### ReplicaSetTelemetryPartialSnapshot ### ShardTransferInfoMethod ### ReshardingInfoShardKey ### ShardCleanStatusTelemetry1 - `progress` (ShardCleanStatusProgressTelemetry, required) ### ShardCleanStatusTelemetry2 - `failed` (ShardCleanStatusFailedTelemetry, required) ### OptimizersStatus1 Something wrong happened with optimizers - `error` (string, required) ### VectorsConfig Vector params separator for single and multiple vector modes Single mode: \{ "size": 128, "distance": "Cosine" } or multiple mode: \{ "default": \{ "size": 128, "distance": "Cosine" } } ### CollectionParamsShardingMethod Sharding method Default is Auto - points are distributed across all available shards Custom - points are distributed across shards according to shard key ### SparseVectorParams Params of single sparse vector data storage - `index` (SparseVectorParamsIndex, optional) — Custom params for index. If none - values from collection configuration are used. - `modifier` (SparseVectorParamsModifier, optional) — Configures addition value modifications for sparse vectors. Default: none ### RunningEnvironmentTelemetryCpuEndian ### GpuDeviceTelemetry - `name` (string, required) ### ConsensusThreadStatus Information about current consensus thread status ### ClusterStatusTelemetryRole ### P2pConfigTelemetry - `connection_pool_size` (integer, required) ### ConsensusConfigTelemetry - `max_message_queue_size` (integer, required) - `tick_period_ms` (uint64, required) - `bootstrap_timeout_sec` (uint64, required) ### HnswConfig Config of HNSW index - `m` (integer, required) — Number of edges per node in the index graph. Larger the value - more accurate the search, more space required. - `ef_construct` (integer, required) — 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` (integer, required) — Minimal size threshold (in KiloBytes) below which full-scan is preferred over HNSW search. This measures the total size of vectors being queried against. When the maximum estimated amount of points that a condition satisfies is smaller than `full_scan_threshold_kb`, the query planner will use full-scan search instead of HNSW index traversal for better performance. Note: 1Kb = 1 vector of size 256 - `max_indexing_threads` (integer, optional, default: 0) — Number of parallel threads used for background index building. If 0 - automatically select from 8 to 16. Best to keep between 8 and 16 to prevent likelihood of slow building or broken/inefficient HNSW graphs. On small CPUs, less threads are used. - `on_disk` (boolean, optional, nullable) — Store HNSW index on disk. If set to false, index will be stored in RAM. Default: false - `payload_m` (integer, optional, nullable) — Custom M param for hnsw graph built for payload index. If not set, default M will be used. - `inline_storage` (boolean, optional, nullable) — Store copies of original and quantized vectors within the HNSW index file. Default: false. Enabling this option will trade the search speed for disk usage by reducing amount of random seeks during the search. Requires quantized vectors to be enabled. Multi-vectors are not supported. ### OptimizersConfig - `deleted_threshold` (double, required) — The minimal fraction of deleted vectors in a segment, required to perform segment optimization - `vacuum_min_vector_number` (integer, required) — The minimal number of vectors in a segment, required to perform segment optimization - `default_segment_number` (integer, required) — 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. - `flush_interval_sec` (uint64, required) — Minimum interval between forced flushes. - `max_segment_size` (integer, optional, nullable) — 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. - `indexing_threshold` (integer, optional, nullable) — Maximum size (in kilobytes) of vectors allowed for plain index, exceeding this threshold will enable vector indexing Default value is 10,000, based on experiments and observations. To disable vector indexing, set to `0`. Note: 1kB = 1 vector of size 256. - `max_optimization_threads` (integer, optional, nullable) — Max number of threads (jobs) for running optimizations per shard. Note: each optimization job will also use `max_indexing_threads` threads by itself for index building. If null - have no limit and choose dynamically to saturate CPU. If 0 - no optimization threads, optimizations will be disabled. - `prevent_unoptimized` (boolean, optional, nullable) — If this option is set, service will try to prevent creation of large unoptimized segments. When enabled, updates may be blocked at request level if there are unoptimized segments larger than indexing threshold. Updates will be resumed when optimization is completed and segments are optimized below the threshold. Using this option may lead to increased delay between submitting an update and its application. Default is disabled. - `memmap_threshold` (integer, optional, nullable, deprecated) — Maximum size (in kilobytes) of vectors to store in-memory per segment. Segments larger than this threshold will be stored as read-only memmapped 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 ### WalConfig - `wal_capacity_mb` (integer, required) — Size of a single WAL segment in MB - `wal_segments_ahead` (integer, required) — Number of WAL segments to create ahead of actually used ones - `wal_retain_closed` (integer, optional, default: 1) — Number of closed WAL segments to keep ### CollectionConfigTelemetryQuantizationConfig ### CollectionConfigTelemetryStrictModeConfig ### CollectionConfigTelemetryMetadata Arbitrary JSON metadata for the collection ### RemoteShardTelemetrySearches ### RemoteShardTelemetryUpdates ### LocalShardTelemetry - `total_optimized_points` (integer, required) — Total number of optimized points since the last start. - `variant_name` (string, optional, nullable) - `status` (LocalShardTelemetryStatus, optional) - `vectors_size_bytes` (integer, optional, nullable) — An ESTIMATION of effective amount of bytes used for vectors Do NOT rely on this number unless you know what you are doing - `payloads_size_bytes` (integer, optional, nullable) — An estimation of the effective amount of bytes used for payloads Do NOT rely on this number unless you know what you are doing - `num_points` (integer, optional, nullable) — Sum of segment points This is an approximate number Do NOT rely on this number unless you know what you are doing - `num_vectors` (integer, optional, nullable) — Sum of number of vectors in all segments This is an approximate number Do NOT rely on this number unless you know what you are doing - `num_vectors_by_name` (map from string to integer, optional, nullable) — Sum of number of vectors across all segments, grouped by their name. This is an approximate number. Do NOT rely on this number unless you know what you are doing - `segments` (list of SegmentTelemetry, optional, nullable) - `optimizations` (LocalShardTelemetryOptimizations, optional) - `async_scorer` (boolean, optional, nullable) - `indexed_only_excluded_vectors` (map from string to integer, optional, nullable) - `update_queue` (LocalShardTelemetryUpdateQueue, optional) — Update queue status ### PartialSnapshotTelemetry - `ongoing_create_snapshot_requests` (integer, required) - `is_recovering` (boolean, required) - `recovery_timestamp` (uint64, required) ### ShardCleanStatusProgressTelemetry - `deleted_points` (integer, required) ### ShardCleanStatusFailedTelemetry - `reason` (string, required) ### VectorParams Params of single vector data storage - `size` (uint64, required) — Size of a vectors used - `distance` (enum, required) — Type of internal tags, build from payload Distance function types used to compare vectors - Allowed values: `Cosine`, `Euclid`, `Dot`, `Manhattan` - `hnsw_config` (VectorParamsHnswConfig, optional) — Custom params for HNSW index. If none - values from collection configuration are used. - `quantization_config` (VectorParamsQuantizationConfig, optional) — Custom params for quantization. If none - values from collection configuration are used. - `on_disk` (boolean, optional, nullable) — If true, vectors are served from disk, improving RAM usage at the cost of latency Default: false - `datatype` (VectorParamsDatatype, optional) — Defines which datatype should be used to represent vectors in the storage. Choosing different datatypes allows to optimize memory usage and performance vs accuracy. - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are stored as unsigned 8-bit integers, 1 byte. It expects vector elements to be in range `[0, 255]`. - `multivector_config` (VectorParamsMultivectorConfig, optional) ### SparseVectorParamsIndex Custom params for index. If none - values from collection configuration are used. ### SparseVectorParamsModifier Configures addition value modifications for sparse vectors. Default: none ### ConsensusThreadStatus0 - `consensus_thread_status` (enum, required) - Allowed values: `working` - `last_update` (string, required) ### ConsensusThreadStatus1 - `consensus_thread_status` (enum, required) - Allowed values: `stopped` ### ConsensusThreadStatus2 - `consensus_thread_status` (enum, required) - Allowed values: `stopped_with_err` - `err` (string, required) ### StrictModeConfigOutput - `enabled` (boolean, optional, nullable) — Whether strict mode is enabled for a collection or not. - `max_query_limit` (integer, optional, nullable) — Max allowed `limit` parameter for all APIs that don't have their own max limit. - `max_timeout` (integer, optional, nullable) — Max allowed `timeout` parameter. - `unindexed_filtering_retrieve` (boolean, optional, nullable) — Allow usage of unindexed fields in retrieval based (e.g. search) filters. - `unindexed_filtering_update` (boolean, optional, nullable) — Allow usage of unindexed fields in filtered updates (e.g. delete by payload). - `search_max_hnsw_ef` (integer, optional, nullable) — Max HNSW value allowed in search parameters. - `search_allow_exact` (boolean, optional, nullable) — Whether exact search is allowed or not. - `search_max_oversampling` (double, optional, nullable) — Max oversampling value allowed in search. - `upsert_max_batchsize` (integer, optional, nullable) — Max batchsize when upserting - `max_collection_vector_size_bytes` (integer, optional, nullable) — Max size of a collections vector storage in bytes, ignoring replicas. - `read_rate_limit` (integer, optional, nullable) — Max number of read operations per minute per replica - `write_rate_limit` (integer, optional, nullable) — Max number of write operations per minute per replica - `max_collection_payload_size_bytes` (integer, optional, nullable) — Max size of a collections payload storage in bytes - `max_points_count` (integer, optional, nullable) — Max number of points estimated in a collection - `filter_max_conditions` (integer, optional, nullable) — Max conditions a filter can have. - `condition_max_size` (integer, optional, nullable) — Max size of a condition, eg. items in `MatchAny`. - `multivector_config` (StrictModeConfigOutputMultivectorConfig, optional) — Multivector configuration - `sparse_config` (StrictModeConfigOutputSparseConfig, optional) — Sparse vector configuration - `max_payload_index_count` (integer, optional, nullable) — Max number of payload indexes in a collection ### LocalShardTelemetryStatus ### SegmentTelemetry - `info` (SegmentInfo, required) — Aggregated information about segment - `config` (SegmentConfig, required) - `vector_index_searches` (list of VectorIndexSearchesTelemetry, required) - `payload_field_indices` (list of PayloadIndexTelemetry, required) ### LocalShardTelemetryOptimizations ### LocalShardTelemetryUpdateQueue Update queue status ### VectorParamsHnswConfig Custom params for HNSW index. If none - values from collection configuration are used. ### VectorParamsQuantizationConfig Custom params for quantization. If none - values from collection configuration are used. ### VectorParamsDatatype Defines which datatype should be used to represent vectors in the storage. Choosing different datatypes allows to optimize memory usage and performance vs accuracy. - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are stored as unsigned 8-bit integers, 1 byte. It expects vector elements to be in range `[0, 255]`. ### VectorParamsMultivectorConfig ### SparseIndexParams Configuration for sparse inverted index. - `full_scan_threshold` (integer, optional, nullable) — We prefer a full scan search upto (excluding) this number of vectors. Note: this is number of vectors, not KiloBytes. - `on_disk` (boolean, optional, nullable) — Store index on disk. If set to false, the index will be stored in RAM. Default: false - `datatype` (SparseIndexParamsDatatype, optional) — Defines which datatype should be used for the index. Choosing different datatypes allows to optimize memory usage and performance vs accuracy. - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are quantized to unsigned 8-bit integers, 1 byte. Quantization to fit byte range `[0, 255]` happens during indexing automatically, so the actual vector data does not need to conform to this range. ### StrictModeConfigOutputMultivectorConfig Multivector configuration ### StrictModeConfigOutputSparseConfig Sparse vector configuration ### SegmentInfo Aggregated information about segment - `uuid` (string, required) - `segment_type` (enum, required) — Type of segment - Allowed values: `plain`, `indexed`, `special` - `num_vectors` (integer, required) - `num_points` (integer, required) - `num_indexed_vectors` (integer, required) - `num_deleted_vectors` (integer, required) - `vectors_size_bytes` (integer, required) — An ESTIMATION of effective amount of bytes used for vectors Do NOT rely on this number unless you know what you are doing - `payloads_size_bytes` (integer, required) — An estimation of the effective amount of bytes used for payloads - `ram_usage_bytes` (integer, required) - `disk_usage_bytes` (integer, required) - `is_appendable` (boolean, required) - `index_schema` (map from string to PayloadIndexInfo, required) - `vector_data` (map from string to VectorDataInfo, required) ### SegmentConfig - `payload_storage_type` (PayloadStorageType, required) — Type of payload storage - `vector_data` (map from string to VectorDataConfig, optional) - `sparse_vector_data` (map from string to SparseVectorDataConfig, optional) ### VectorIndexSearchesTelemetry - `unfiltered_plain` (OperationDurationStatistics, required) - `unfiltered_hnsw` (OperationDurationStatistics, required) - `unfiltered_sparse` (OperationDurationStatistics, required) - `filtered_plain` (OperationDurationStatistics, required) - `filtered_small_cardinality` (OperationDurationStatistics, required) - `filtered_large_cardinality` (OperationDurationStatistics, required) - `filtered_exact` (OperationDurationStatistics, required) - `filtered_sparse` (OperationDurationStatistics, required) - `unfiltered_exact` (OperationDurationStatistics, required) - `index_name` (string, optional, nullable) ### PayloadIndexTelemetry - `index_type` (string, required) - `points_values_count` (integer, required) — The amount of values indexed for all points. - `points_count` (integer, required) — The amount of points that have at least one value indexed. - `field_name` (string, optional, nullable) - `histogram_bucket_size` (integer, optional, nullable) ### OptimizerTelemetry - `status` (OptimizersStatus, required) — Current state of the collection - `optimizations` (OperationDurationStatistics, required) - `log` (list of TrackerTelemetry, optional, nullable) ### ShardUpdateQueueInfo - `length` (integer, required) — Number of elements in the queue - `op_num` (integer, optional, nullable) — last operation number processed ### HnswConfigDiff - `m` (integer, optional, nullable) — Number of edges per node in the index graph. Larger the value - more accurate the search, more space required. - `ef_construct` (integer, optional, nullable) — 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` (integer, optional, nullable) — Minimal size threshold (in KiloBytes) below which full-scan is preferred over HNSW search. This measures the total size of vectors being queried against. When the maximum estimated amount of points that a condition satisfies is smaller than `full_scan_threshold_kb`, the query planner will use full-scan search instead of HNSW index traversal for better performance. Note: 1Kb = 1 vector of size 256 - `max_indexing_threads` (integer, optional, nullable) — Number of parallel threads used for background index building. If 0 - automatically select from 8 to 16. Best to keep between 8 and 16 to prevent likelihood of building broken/inefficient HNSW graphs. On small CPUs, less threads are used. - `on_disk` (boolean, optional, nullable) — Store HNSW index on disk. If set to false, the index will be stored in RAM. Default: false - `payload_m` (integer, optional, nullable) — Custom M param for additional payload-aware HNSW links. If not set, default M will be used. - `inline_storage` (boolean, optional, nullable) — Store copies of original and quantized vectors within the HNSW index file. Default: false. Enabling this option will trade the search speed for disk usage by reducing amount of random seeks during the search. Requires quantized vectors to be enabled. Multi-vectors are not supported. ### MultiVectorConfig - `comparator` (enum, required) - Allowed values: `max_sim` ### SparseIndexParamsDatatype Defines which datatype should be used for the index. Choosing different datatypes allows to optimize memory usage and performance vs accuracy. - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are quantized to unsigned 8-bit integers, 1 byte. Quantization to fit byte range `[0, 255]` happens during indexing automatically, so the actual vector data does not need to conform to this range. ### PayloadIndexInfo Display payload field type & index information - `data_type` (enum, required) — All possible names of payload types - Allowed values: `keyword`, `integer`, `float`, `geo`, `text`, `bool`, `datetime`, `uuid` - `points` (integer, required) — Number of points indexed with this index - `params` (PayloadIndexInfoParams, optional) ### VectorDataInfo - `num_vectors` (integer, required) - `num_indexed_vectors` (integer, required) - `num_deleted_vectors` (integer, required) ### PayloadStorageType Type of payload storage ### VectorDataConfig Config of single vector data storage - `size` (integer, required) — Size/dimensionality of the vectors used - `distance` (enum, required) — Type of internal tags, build from payload Distance function types used to compare vectors - Allowed values: `Cosine`, `Euclid`, `Dot`, `Manhattan` - `storage_type` (VectorStorageType, required) — Storage types for vectors - `index` (Indexes, required) — Vector index configuration - `quantization_config` (VectorDataConfigQuantizationConfig, optional) — Vector specific quantization config that overrides collection config - `multivector_config` (VectorDataConfigMultivectorConfig, optional) — Vector specific configuration to enable multiple vectors per point - `datatype` (VectorDataConfigDatatype, optional) — Vector specific configuration to set specific storage element type ### SparseVectorDataConfig Config of single sparse vector data storage - `index` (SparseIndexConfig, required) — Configuration for sparse inverted index. - `storage_type` (SparseVectorStorageType, optional) - `modifier` (SparseVectorDataConfigModifier, optional) — Configures addition value modifications for sparse vectors. Default: none ### TrackerTelemetry Tracker object used in telemetry - `name` (string, required) — Name of the optimizer - `uuid` (string, required) — UUID of the upcoming segment being created by the optimizer - `segment_ids` (list of integer, required) — Internal segment IDs being optimized. These are local and in-memory, meaning that they can refer to different segments after a service restart. - `segment_uuids` (list of string, required) — Segment UUIDs being optimized. Refers to same segments as in `segment_ids`, but trackable across restarts, and reflect their directory name. - `status` (TrackerStatus, required) — Represents the current state of the optimizer being tracked - `start_at` (string, required) — Start time of the optimizer - `end_at` (string, optional, nullable) — End time of the optimizer ### PayloadIndexInfoParams ### PayloadStorageType0 - `type` (enum, required) - Allowed values: `in_memory` ### PayloadStorageType1 - `type` (enum, required) - Allowed values: `on_disk` ### PayloadStorageType2 - `type` (enum, required) - Allowed values: `mmap` ### PayloadStorageType3 - `type` (enum, required) - Allowed values: `in_ram_mmap` ### VectorStorageType Storage types for vectors ### Indexes Vector index configuration ### VectorDataConfigQuantizationConfig Vector specific quantization config that overrides collection config ### VectorDataConfigMultivectorConfig Vector specific configuration to enable multiple vectors per point ### VectorDataConfigDatatype Vector specific configuration to set specific storage element type ### SparseIndexConfig Configuration for sparse inverted index. - `index_type` (SparseIndexType, required) — Sparse index types - `full_scan_threshold` (integer, optional, nullable) — We prefer a full scan search upto (excluding) this number of vectors. Note: this is number of vectors, not KiloBytes. - `datatype` (SparseIndexConfigDatatype, optional) — Datatype used to store weights in the index. ### SparseVectorStorageType ### SparseVectorDataConfigModifier Configures addition value modifications for sparse vectors. Default: none ### TrackerStatus Represents the current state of the optimizer being tracked ### Indexes0 Do not use any index, scan whole vector collection during search. Guarantee 100% precision, but may be time consuming on large collections. - `type` (enum, required) - Allowed values: `plain` - `options` (IndexesOneOf0Options, required) ### Indexes1 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` (enum, required) - Allowed values: `hnsw` - `options` (HnswConfig, required) — Config of HNSW index ### SparseIndexType Sparse index types ### SparseIndexConfigDatatype Datatype used to store weights in the index. ### TrackerStatus1 - `cancelled` (string, required) ### TrackerStatus2 - `error` (string, required) ### IndexesOneOf0Options ## Examples **Response** ```json { "usage": { "hardware": { "cpu": 1, "payload_io_read": 1, "payload_io_write": 1, "payload_index_io_read": 1, "payload_index_io_write": 1, "vector_io_read": 1, "vector_io_write": 1 }, "inference": { "models": {} } }, "time": 0.002, "status": "ok", "result": { "id": "string", "collections": { "number_of_collections": 1, "max_collections": 1, "collections": [ { "id": "string", "init_time_ms": 1, "config": { "params": { "vectors": {}, "shard_number": 1, "sharding_method": "auto", "replication_factor": 1, "write_consistency_factor": 1, "read_fan_out_factor": 1, "read_fan_out_delay_ms": 1, "on_disk_payload": true, "sparse_vectors": {} }, "hnsw_config": { "m": 1, "ef_construct": 1, "full_scan_threshold": 1, "max_indexing_threads": 0, "on_disk": true, "payload_m": 1, "inline_storage": true }, "optimizer_config": { "deleted_threshold": 1.1, "vacuum_min_vector_number": 1, "default_segment_number": 1, "max_segment_size": 1, "memmap_threshold": 1, "indexing_threshold": 1, "flush_interval_sec": 1, "max_optimization_threads": 1, "prevent_unoptimized": true }, "wal_config": { "wal_capacity_mb": 1, "wal_segments_ahead": 1, "wal_retain_closed": 1 }, "quantization_config": { "scalar": { "type": "int8", "quantile": 1.1, "always_ram": true } }, "strict_mode_config": { "enabled": true, "max_query_limit": 1, "max_timeout": 1, "unindexed_filtering_retrieve": true, "unindexed_filtering_update": true, "search_max_hnsw_ef": 1, "search_allow_exact": true, "search_max_oversampling": 1.1, "upsert_max_batchsize": 1, "max_collection_vector_size_bytes": 1, "read_rate_limit": 1, "write_rate_limit": 1, "max_collection_payload_size_bytes": 1, "max_points_count": 1, "filter_max_conditions": 1, "condition_max_size": 1, "multivector_config": {}, "sparse_config": {}, "max_payload_index_count": 1 }, "uuid": "string", "metadata": {} }, "shards": [ { "id": 1, "key": "region_1", "local": { "variant_name": "string", "status": "green", "total_optimized_points": 1, "vectors_size_bytes": 1, "payloads_size_bytes": 1, "num_points": 1, "num_vectors": 1, "num_vectors_by_name": {}, "segments": [ { "info": { "uuid": "string", "segment_type": "plain", "num_vectors": 1, "num_points": 1, "num_indexed_vectors": 1, "num_deleted_vectors": 1, "vectors_size_bytes": 1, "payloads_size_bytes": 1, "ram_usage_bytes": 1, "disk_usage_bytes": 1, "is_appendable": true, "index_schema": {}, "vector_data": {} }, "config": { "vector_data": {}, "sparse_vector_data": {}, "payload_storage_type": { "type": "in_memory" } }, "vector_index_searches": [ { "index_name": "string", "unfiltered_plain": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" }, "unfiltered_hnsw": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" }, "unfiltered_sparse": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" }, "filtered_plain": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" }, "filtered_small_cardinality": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" }, "filtered_large_cardinality": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" }, "filtered_exact": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" }, "filtered_sparse": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" }, "unfiltered_exact": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" } } ], "payload_field_indices": [ { "field_name": "string", "index_type": "string", "points_values_count": 1, "points_count": 1, "histogram_bucket_size": 1 } ] } ], "optimizations": { "status": "ok", "optimizations": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" }, "log": [ { "name": "string", "uuid": "string", "segment_ids": [ 1 ], "segment_uuids": [ "string" ], "status": { "cancelled": {} }, "start_at": "2024-01-15T09:30:00Z", "end_at": "2024-01-15T09:30:00Z" } ] }, "async_scorer": true, "indexed_only_excluded_vectors": {}, "update_queue": { "length": 1, "op_num": 1 } }, "remote": [ { "shard_id": 1, "peer_id": 1, "searches": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" }, "updates": { "count": 1, "fail_count": 1, "avg_duration_micros": 1.1, "min_duration_micros": 1.1, "max_duration_micros": 1.1, "total_duration_micros": 1, "last_responded": "2024-01-15T09:30:00Z" } } ], "replicate_states": {}, "partial_snapshot": { "ongoing_create_snapshot_requests": 1, "is_recovering": true, "recovery_timestamp": 1 } } ], "transfers": [ { "shard_id": 1, "to_shard_id": 1, "from": 1, "to": 1, "sync": true, "method": "stream_records", "comment": "string" } ], "resharding": [ { "direction": "up", "shard_id": 1, "peer_id": 1, "shard_key": "region_1" } ], "shard_clean_tasks": {} } ], "snapshots": [ { "id": "string", "running_snapshots": 1, "running_snapshot_recovery": 1, "total_snapshot_creations": 1 } ] }, "app": { "name": "string", "version": "string", "features": { "debug": true, "service_debug_feature": true, "recovery_mode": true, "gpu": true, "rocksdb": true, "staging": true }, "runtime_features": { "all": false, "payload_index_skip_rocksdb": true, "payload_index_skip_mutable_rocksdb": true, "payload_storage_skip_rocksdb": true, "incremental_hnsw_building": true, "migrate_rocksdb_id_tracker": true, "migrate_rocksdb_vector_storage": true, "migrate_rocksdb_payload_storage": true, "migrate_rocksdb_payload_indices": true, "appendable_quantization": true, "single_file_mmap_vector_storage": false }, "hnsw_global_config": { "healing_threshold": 0.3 }, "system": { "distribution": "string", "distribution_version": "string", "is_docker": true, "cores": 1, "ram_size": 1, "disk_size": 1, "cpu_flags": "string", "cpu_endian": "little", "gpu_devices": [ { "name": "string" } ] }, "jwt_rbac": true, "hide_jwt_dashboard": true, "startup": "2024-01-15T09:30:00Z" }, "cluster": { "enabled": true, "status": { "number_of_peers": 1, "term": 1, "commit": 1, "pending_operations": 1, "role": "Follower", "is_voter": true, "peer_id": 1, "consensus_thread_status": { "consensus_thread_status": "working", "last_update": "2024-01-15T09:30:00Z" } }, "config": { "grpc_timeout_ms": 1, "p2p": { "connection_pool_size": 1 }, "consensus": { "max_message_queue_size": 1, "tick_period_ms": 1, "bootstrap_timeout_sec": 1 } }, "peers": {}, "peer_metadata": {}, "metadata": {}, "resharding_enabled": true }, "requests": { "rest": { "responses": {} }, "grpc": { "responses": {} } }, "memory": { "active_bytes": 1, "allocated_bytes": 1, "metadata_bytes": 1, "resident_bytes": 1, "retained_bytes": 1 }, "hardware": { "collection_data": {} } } } ``` **SDK Code** ```python import requests url = "http://localhost:6333/telemetry" headers = {"api-key": ""} response = requests.get(url, headers=headers) print(response.json()) ``` ```javascript const url = 'http://localhost:6333/telemetry'; const options = {method: 'GET', headers: {'api-key': ''}}; try { const response = await fetch(url, options); const data = await response.json(); console.log(data); } catch (error) { console.error(error); } ``` ```go package main import ( "fmt" "net/http" "io" ) func main() { url := "http://localhost:6333/telemetry" req, _ := http.NewRequest("GET", url, nil) req.Header.Add("api-key", "") res, _ := http.DefaultClient.Do(req) defer res.Body.Close() body, _ := io.ReadAll(res.Body) fmt.Println(res) fmt.Println(string(body)) } ``` ```ruby require 'uri' require 'net/http' url = URI("http://localhost:6333/telemetry") http = Net::HTTP.new(url.host, url.port) request = Net::HTTP::Get.new(url) request["api-key"] = '' response = http.request(request) puts response.read_body ``` ```java import com.mashape.unirest.http.HttpResponse; import com.mashape.unirest.http.Unirest; HttpResponse response = Unirest.get("http://localhost:6333/telemetry") .header("api-key", "") .asString(); ``` ```php request('GET', 'http://localhost:6333/telemetry', [ 'headers' => [ 'api-key' => '', ], ]); echo $response->getBody(); ``` ```csharp using RestSharp; var client = new RestClient("http://localhost:6333/telemetry"); var request = new RestRequest(Method.GET); request.AddHeader("api-key", ""); IRestResponse response = client.Execute(request); ``` ```swift import Foundation let headers = ["api-key": ""] let request = NSMutableURLRequest(url: NSURL(string: "http://localhost:6333/telemetry")! as URL, cachePolicy: .useProtocolCachePolicy, timeoutInterval: 10.0) request.httpMethod = "GET" request.allHTTPHeaderFields = headers let session = URLSession.shared let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in if (error != nil) { print(error as Any) } else { let httpResponse = response as? HTTPURLResponse print(httpResponse) } }) dataTask.resume() ```