◆ VECTOR DB RAG

Qdrant

v1.19.0 open-source

Qdrant - High-performance, massive-scale Vector Database and Vector Search Engine for the next generation of AI. Also available in the cloud https://cloud.qdrant.io/

source ↗ website ↗ rss ↗ last repo push Aug 29, 2026

import tempfile, requests, time
from pathlib import Path
from qdrant_edge import EdgeShard

data_dir = Path('./qdrant-edge-directory/immutable')
manifest = immutable_shard.snapshot_manifest()
url = f'{QDRANT_URL}/collections/edge-collection/shards/0/snapshot/partial/create'
sync_timestamp = time.time()

with tempfile.TemporaryDirectory(dir=data_dir) as temp_dir:
    partial_snapshot_path = Path(temp_dir) / 'partial.snapshot'
    response = requests.post(
        url,
        headers={'api-key': QDRANT_API_KEY},
        json=manifest,
        stream=True,
    )
    response.raise_for_status()
    with open(partial_snapshot_path, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    immutable_shard.update_from_snapshot(str(partial_snapshot_path))
from qdrant_edge import Filter, FieldCondition, RangeFloat, UpdateOperation

mutable_shard.update(
    UpdateOperation.delete_points_by_filter(
        Filter(
            must=[
                FieldCondition(
                    key='timestamp',
                    range=RangeFloat(lte=sync_timestamp)
                )
            ]
        )
    )
)
curl -X GET \
  "${QDRANT_URL}/collections/edge-collection/shards/0/snapshot" \
  -H "api-key: ${QDRANT_API_KEY}" \
  --output shard.snapshot
{
  "filter": {
    "must": [
      {
        "key": "category",
        "match": {
          "prefix": "sports/"
        }
      }
    ]
  }
}
{
  "filter": {
    "must": [
      {
        "key": "id",
        "slice": {
          "divider": 10,
          "part": 3
        }
      }
    ]
  }
}
{
  "vectors": {
    "memory": "pinned"
  },
  "payload": {
    "memory": "cold"
  }
}
{
  "filter": {
    "must": [
      {
        "key": "category",
        "match": {
          "prefix": "electronics/"
        }
      }
    ]
  }
}
{
  "strict_mode_config": {
    "max_resident_memory_percent": 85
  }
}
curl -X PUT 'http://localhost:6333/collections/{collection_name}/vectors' \
  -H 'Content-Type: application/json' \
  -d '{
    "vectors": {
      "my-new-vector": {
        "size": 768,
        "distance": "Cosine"
      }
    }
  }'
curl -X PUT 'http://localhost:6333/collections/my_collection/points' \
  -H 'Content-Type: application/json' \
  -d '{
    "update_mode": "insert",
    "points": [
      {"id": 1, "vector": [0.1, 0.2, 0.3], "payload": {"label": "example"}}
    ]
  }'
service:
  metrics:
    prefix: qdrant_
POST /collections/{collection_name}/points/recommend
{
  "positive": [1, 2, 3],
  "negative": [4],
  "strategy": "sum_scores",
  "limit": 10
}
curl -X PUT 'http://localhost:6333/collections/my_collection' \
  -H 'Content-Type: application/json' \
  -d '{
    "vectors": {
      "size": 1536,
      "distance": "Cosine",
      "datatype": "float16"
    }
  }'
curl -X POST 'http://localhost:6333/collections/events/points/scroll' \
  -H 'Content-Type: application/json' \
  -d '{
    "limit": 50,
    "order_by": {
      "key": "timestamp"
    }
  }'
curl -X PUT 'http://localhost:6333/collections/events/index' \
  -H 'Content-Type: application/json' \
  -d '{
    "field_name": "created_at",
    "field_schema": "datetime"
  }'
curl -X POST 'http://localhost:6333/collections/products/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "limit": 10,
    "filter": {
      "min_should": {
        "conditions": [
          {"key": "category", "match": {"value": "electronics"}},
          {"key": "in_stock", "match": {"value": true}},
          {"key": "rating", "range": {"gte": 4.0}}
        ],
        "min_count": 2
      }
    }
  }'
curl -X PUT 'http://localhost:6333/collections/my_collection' \
  -H 'Content-Type: application/json' \
  -H 'api-key: <your-api-key>' \
  -d '{
    "vectors": {
      "dense": {"size": 768, "distance": "Cosine"}
    },
    "sparse_vectors": {
      "bm25": {}
    }
  }'
curl -X GET 'http://localhost:6333/collections' \
  -H 'Authorization: Bearer <read-only-api-key>'
curl -X POST 'http://localhost:6333/collections/my_collection/points/discover' \
  -H 'Content-Type: application/json' \
  -H 'api-key: <your-api-key>' \
  -d '{
    "target": "<point-id>",
    "context": [
      {"positive": "<pos-id>", "negative": "<neg-id>"}
    ],
    "limit": 10
  }'
curl -X POST 'http://localhost:6333/collections/{collection_name}/points/recommend' \
  -H 'Content-Type: application/json' \
  -d '{
    "positive": [[0.1, 0.2, 0.3, 0.4]],
    "negative": [[0.9, 0.8, 0.7, 0.6]],
    "limit": 10
  }'
curl -X POST 'http://localhost:6333/collections/{collection_name}/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3, 0.4],
    "filter": {
      "must": [{
        "key": "location",
        "geo_polygon": {
          "exterior": {
            "points": [
              {"lat": 48.9, "lon": 2.2},
              {"lat": 48.9, "lon": 2.5},
              {"lat": 48.7, "lon": 2.5},
              {"lat": 48.7, "lon": 2.2},
              {"lat": 48.9, "lon": 2.2}
            ]
          }
        }
      }]
    },
    "limit": 10
  }'
curl -X POST 'http://localhost:6333/collections/my_collection/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "limit": 10,
    "params": {
      "indexed_only": true
    }
  }'
curl -X POST 'http://localhost:6333/collections/my_collection/shards/0/snapshots'
curl -f http://localhost:6333/readyz
curl -X PUT 'http://localhost:6333/collections/my_collection/index' \
  -H 'Content-Type: application/json' \
  -d '{
    "field_name": "description",
    "field_schema": {
      "type": "text",
      "tokenizer": "multilingual"
    }
  }'
curl -X PATCH 'http://localhost:6333/collections/my_collection' \
  -H 'Content-Type: application/json' \
  -d '{
    "vectors": {
      "on_disk": true
    }
  }'
curl -X POST 'http://localhost:6333/collections/{collection_name}/points/search/groups' \
  -H 'Content-Type: application/json' \
  -H 'api-key: <your-api-key>' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "group_by": "document_id",
    "group_size": 3,
    "limit": 10
  }'
curl -X POST 'http://localhost:6333/collections/{collection_name}/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "filter": {
      "must": [
        {
          "nested": {
            "key": "attributes",
            "filter": {
              "must": [
                { "key": "name", "match": { "value": "color" } },
                { "key": "value", "match": { "value": "red" } }
              ]
            }
          }
        }
      ]
    },
    "limit": 5
  }'
curl -X POST 'http://localhost:6333/collections/my_collection/snapshots?wait=false'
curl -X POST 'http://localhost:6333/collections/my_collection/snapshots/recover?wait=false' \
  -H 'Content-Type: application/json' \
  -d '{"location": "http://snapshots-store/my_collection-snapshot.snapshot"}'
POST /collections/{collection_name}/points/search
{
  "vector": [0.1, 0.2, 0.3],
  "limit": 10,
  "params": {
    "exact": true
  }
}
curl -X PUT 'http://localhost:6333/collections/my_collection/points' \
  -H 'Content-Type: application/json' \
  -d '{
    "points": [
      {
        "id": 1,
        "vectors": {
          "image": [0.9, 0.1, 0.1, 0.2],
          "text": [0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2]
        }
      }
    ]
  }'
curl -X POST 'http://localhost:6333/collections/my_collection/points/search/batch' \
  -H 'Content-Type: application/json' \
  -d '{
    "searches": [
      { "vector": [0.2, 0.1, 0.9, 0.7], "limit": 3 },
      { "vector": [0.5, 0.3, 0.2, 0.3], "limit": 3 }
    ]
  }'
curl -X GET 'http://localhost:6333/collections/my_collection' | jq '.result.indexed_vectors_count'
curl -X PUT 'http://localhost:6333/collections/{collection_name}/points' \
  -H 'Content-Type: application/json' \
  -d '{"points": [{"id": "550e8400-e29b-41d4-a716-446655440000", "vector": [0.1, 0.2, 0.3], "payload": {"city": "Berlin"}}]}'
curl -X POST 'http://localhost:6333/collections/{collection_name}/points/scroll' \
  -H 'Content-Type: application/json' \
  -d '{"filter": {"must": [{"key": "city", "match": {"value": "London"}}]}, "limit": 100}'
curl -X POST 'http://localhost:6333/collections/{collection_name}/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "filter": {
      "should": [
        {
          "key": "city",
          "match": {
            "keyword": "London"
          }
        }
      ]
    },
    "top": 5
  }'

Summary

Qdrant is an open-source vector similarity search engine and vector database written in Rust, available under the Apache 2.0 license. It functions as a service with an API for storing, searching, and managing points, and it supports extended filtering for applications requiring semantic or faceted search, positioning it alongside other vector databases. The tool is intended for developers building AI applications and can be used via a self-hosted deployment or through a managed Qdrant Cloud service that includes a free tier.

Qdrant - High-performance, massive-scale Vector Database and Vector Search Engine for the next generation of AI. Also available in the cloud https://cloud.qdrant.io/

What Qdrant answers

Does the underlying technology language affect performance under heavy use?

it is written in Rust, which provides speed and reliability even when processing large volumes of data.

What kind of search capabilities does it support beyond just vector similarity?

it supports extended filtering, enabling use cases requiring semantic or faceted searching.

What mechanisms are available for deployment if we do not want to manage the infrastructure ourselves?

it can be used through a managed cloud service that includes a free tier.

What is the scope of the API interface for adding or changing points?

it provides a convenient API for storing, searching, and managing points, which are vectors attached to additional payload data.

Does the system handle the relationship between search results and structured metadata?

it supports filtering alongside vector search, making it useful for applications needing both semantic matching and faceted search.

What are the prerequisites for using the system's core functionality?

it is a service accessible via an API, allowing developers to build applications around it.

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

docs update Aug 30, 2026 · issue 011

Qdrant Edge gains a server synchronization guide covering dual-shard architecture, partial snapshots, and dual-write patterns.
└──▷ USE IT
Fetch a partial snapshot from the server and apply it to an already-running immutable Edge Shard to pull in only new changes since the last sync.
python
```
import tempfile, requests, time
from pathlib import Path
from qdrant_edge import EdgeShard

data_dir = Path('./qdrant-edge-directory/immutable')
manifest = immutable_shard.snapshot_manifest()
url = f'{QDRANT_URL}/collections/edge-collection/shards/0/snapshot/partial/create'
sync_timestamp = time.time()

with tempfile.TemporaryDirectory(dir=data_dir) as temp_dir:
    partial_snapshot_path = Path(temp_dir) / 'partial.snapshot'
    response = requests.post(
        url,
        headers={'api-key': QDRANT_API_KEY},
        json=manifest,
        stream=True,
    )
    response.raise_for_status()
    with open(partial_snapshot_path, 'wb') as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    immutable_shard.update_from_snapshot(str(partial_snapshot_path))
```
After a partial-snapshot sync, remove duplicate points from the mutable shard that are now covered by the immutable shard, using the recorded sync timestamp.
python
```
from qdrant_edge import Filter, FieldCondition, RangeFloat, UpdateOperation

mutable_shard.update(
    UpdateOperation.delete_points_by_filter(
        Filter(
            must=[
                FieldCondition(
                    key='timestamp',
                    range=RangeFloat(lte=sync_timestamp)
                )
            ]
        )
    )
)
```
Bootstrap an immutable Edge Shard from a full shard snapshot on the server for initial setup or disaster recovery.
```
$ curl -X GET \
  "${QDRANT_URL}/collections/edge-collection/shards/0/snapshot" \
  -H "api-key: ${QDRANT_API_KEY}" \
  --output shard.snapshot
```
- ›Adds EdgeShard.snapshot_manifest() method to retrieve the current shard manifest, used as the request body when requesting a partial snapshot from the server via POST /collections/{collection}/shards/0/snapshot/partial/create.
- ›Adds EdgeShard.update_from_snapshot() (Python) and EdgeShard::recover_partial_snapshot() (Rust) to incrementally update an immutable Edge Shard from a server-side partial snapshot without a full re-download.
- ›Adds EdgeShard.unpack_snapshot() / EdgeShard::unpack_snapshot() and EdgeShard.load() / EdgeShard::load() to restore an immutable Edge Shard from a full shard snapshot fetched from GET /collections/{collection}/shards/0/snapshot.
- ›Introduces a dual-shard synchronization architecture: a mutable EdgeShard for local writes and an immutable EdgeShard that mirrors a server collection shard, with results merged at query time.
- ›Introduces a dual-write pattern using an upload queue and SYNC_TIMESTAMP_KEY payload field to deduplicate points between the mutable and immutable shards after each sync cycle.
+2 moreshow less
- ›Supports UpdateOperation.delete_points_by_filter() with a RangeFloat(lte=sync_timestamp) condition on the timestamp payload field to prune deduplicated points from the mutable shard after a successful partial-snapshot restore.
- ›Documents EdgeConfig / EdgeConfigBuilder initialization with named vectors via EdgeVectorParams / EdgeVectorParamsBuilder for bootstrapping mutable shards from scratch.
v1.19.0 Aug 5, 2026 · issue -014

Qdrant v1.19.0 adds TurboQuant 4-bit primary storage, prefix match filters, per-query IDF, slice filtering, a global quota API, and routing tokens for read affinity.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.19.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.19.0
```
└──▷ USE IT
Filter results to only points whose 'category' keyword field starts with a given prefix, useful for hierarchical tag lookups.
json
```
{
  "filter": {
    "must": [
      {
        "key": "category",
        "match": {
          "prefix": "sports/"
        }
      }
    ]
  }
}
```
Use a slice filter to deterministically sample or paginate a large collection without cursor drift.
json
```
{
  "filter": {
    "must": [
      {
        "key": "id",
        "slice": {
          "divider": 10,
          "part": 3
        }
      }
    ]
  }
}
```
- ›Adds "memory": "cold" / "cached" / "pinned" configuration per individual collection component to enable fine-grained control over memory behavior and performance.
- ›Adds "match": {"prefix": "..."} in filter to match keywords by prefix (must be enabled in the keyword index).
- ›Introduces a Global Quota API for managing resource quotas across the cluster.
- ›Adds a routing token for deterministic read routes, enabling read-affinity consistency guarantees.
- ›Introduces a Slice filtering condition supporting sliced scroll and deterministic sampling.
+8 moreshow less
- ›Adds per-query IDF corpus for sparse vector search, enabling per-tenant IDF statistics in full-text search.
- ›Adds TurboQuant 4-bit as a datatype for primary vector storage, storing only 4-bit quantized vectors and eliminating the need to retain full-precision originals.
- ›Web UI gains a management interface for payload indexes and their configuration.
- ›Web UI gains a management interface for global resource quotas.
- ›Web UI adds a multi-delete feature for collections.
- ›Web UI adds display and editing for collection metadata.
- ›Web UI adds a display for resharding progress.
- ›Significantly more performant vector visualization and dimensionality reduction in the Web UI using a WASM-based UMAP implementation and WebGL rendering.
└──▷ BREAKING ON UPGRADE
- !The default update queue length is reduced from 1,000,000 to 200; deployments relying on the previous high-water mark will need to reconfigure.
- !max_resident_memory_percent in strict mode is deprecated in favor of the new global quota API; existing configurations using this field should migrate.
v1.19.0 Aug 5, 2026 · issue 002

Qdrant v1.19.0 adds TurboQuant 4-bit primary storage, per-component memory tiers, prefix-match filters, a global quota API, and major Web UI upgrades.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.19.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.19.0
```
└──▷ USE IT
Pin the vector storage in RAM while keeping payload on cold storage, for collections where ANN speed matters more than memory cost.
json
```
{
  "vectors": {
    "memory": "pinned"
  },
  "payload": {
    "memory": "cold"
  }
}
```
Filter points whose 'category' payload field starts with a given prefix — useful for hierarchical tag or path matching.
json
```
{
  "filter": {
    "must": [
      {
        "key": "category",
        "match": {
          "prefix": "electronics/"
        }
      }
    ]
  }
}
```
- ›Adds "memory": "cold" / "cached" / "pinned" configuration per individual collection component to control memory behavior and performance with fine-grained precision.
- ›Adds "match": {"prefix": "..."} in filter to match keywords by prefix (must be enabled in keyword index).
- ›Introduces a global quota API replacing the max_resident_memory_percent strict-mode setting.
- ›Adds a routing token for deterministic read routes to support read-affinity consistency guarantees.
- ›Adds a slice filtering condition enabling sliced scroll and deterministic sampling.
+12 moreshow less
- ›Introduces TurboQuant 4-bit as a datatype for primary vector storage, storing only 4-bit quantized vectors to eliminate disk usage for original vectors.
- ›Adds per-query IDF corpus for sparse vector search, enabling per-tenant IDF statistics in full-text search.
- ›New Web UI for managing payload indexes and their configuration.
- ›New Web UI for managing global resource quotas.
- ›Significantly more performant vectors visualization using a WASM implementation of UMAP and WebGL rendering in the Web UI.
- ›Adds multi-delete feature for collections in the Web UI.
- ›Adds display and editing for collection metadata in the Web UI.
- ›Adds resharding progress display in the Web UI.
- ›Adds an option to explicitly disable the BM25 stemmer (deprecating the previous 'none' hack).
- ›Single-file mmap vector storage now enabled by default for immutable segments.
- ›Utilizes io_uring for payload storage, improving I/O performance.
- ›Reports effective (cgroup) CPU, RAM, and disk metrics in telemetry.
└──▷ BREAKING ON UPGRADE
- !The max_resident_memory_percent strict-mode setting is deprecated in favor of the new global quota API; configurations relying on it should migrate to the quota API.
- !Deprecated search endpoints are removed from OpenAPI and deprecated in gRPC; clients using those endpoints will need to migrate.
v1.18.0 May 11, 2026 · issue -100

Qdrant v1.18.0 adds TurboQuant 8x compression, named-vector CRUD APIs, low-memory mode, and a strict memory cap parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.18.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.18.0
```
└──▷ USE IT
Prevent OOM-induced crashes on memory-constrained nodes by rejecting writes once resident memory crosses a threshold.
json
```
{
  "strict_mode_config": {
    "max_resident_memory_percent": 85
  }
}
```
Add a new named vector to an existing collection without recreating it.
```
$ curl -X PUT 'http://localhost:6333/collections/{collection_name}/vectors' \
  -H 'Content-Type: application/json' \
  -d '{
    "vectors": {
      "my-new-vector": {
        "size": 768,
        "distance": "Cosine"
      }
    }
  }'
```
- ›Adds max_resident_memory_percent strict-mode parameter to reject update requests when resident memory usage exceeds the configured threshold.
- ›Adds API endpoints to create and delete named vectors in an existing collection without recreating it.
- ›Adds config option to disable snapshot restore from URL, reducing the remote-fetch attack surface.
- ›Enforces API key / JWT authentication on internal gRPC endpoints.
- ›Introduces TurboQuant quantization variant delivering 8x vector compression with minimal recall degradation.
+14 moreshow less
- ›Adds low-memory mode that forces all data open on disk to minimise out-of-memory crashes on startup.
- ›Adds deep memory reporting API that exposes a memory-usage breakdown per storage component.
- ›Records API method path in audit log events.
- ›Reports tracing ID in audit log events.
- ›Reports audit log configuration and data size in telemetry and metrics.
- ›Skips audit logging on telemetry endpoints to reduce noise.
- ›Web UI adds a memory and disk inspector showing usage breakdown per storage component.
- ›Web UI adds a high-contrast theme.
- ›Web UI renders inline documentation in the collection info panel.
- ›Web UI adds a refresh button to collection views.
- ›Uses a dynamic CPU pool for search workers, improving search performance under high IO wait.
- ›Uses operation-size-based batching in shard transfers for higher throughput.
- ›Reduces immutable geo index memory usage by 7x.
- ›Fully removes RocksDB support, simplifying storage handling.
└──▷ BREAKING ON UPGRADE
- !RocksDB support is fully removed; any deployment relying on RocksDB storage must migrate before upgrading.
v1.17.1 Mar 27, 2026 · issue -145

Qdrant v1.17.1 adds deferred point updates with prevent_unoptimized=true, request tracing IDs in audit logs, and non-blocking Gridstore flushes.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.17.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.17.1
```
- ›Defers point updates and efficiently applies/optimizes points when prevent_unoptimized=true is set, reducing write amplification under high ingest load.
- ›Adds request tracing ID into the audit log, enabling correlation of individual API calls through audit trails.
- ›Makes Gridstore flushes non-blocking to reduce search tail latencies during concurrent writes.
- ›Improves filtered search performance for queries on payload fields with a single (singular) value.
- ›Allows a peer to bootstrap using a previously used URI when the current URI is empty, improving cluster recovery ergonomics.
v1.17.0 Feb 20, 2026 · issue -178

Qdrant v1.17.0 adds Relevance Feedback, audit logging, weighted RRF, cluster telemetry, and Qdrant Edge (in-process mode).
└──▷ GET THIS VERSION
```
$ git clone --branch v1.17.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.17.0
```
└──▷ TRY IT
Control whether an upsert call strictly inserts new points, updates existing ones, or does both — useful for write pipelines that need to enforce idempotency.
```
$ curl -X PUT 'http://localhost:6333/collections/my_collection/points' \
  -H 'Content-Type: application/json' \
  -d '{
    "update_mode": "insert",
    "points": [
      {"id": 1, "vector": [0.1, 0.2, 0.3], "payload": {"label": "example"}}
    ]
  }'
```
- ›Adds update_mode parameter to upsert operations, accepting upsert, update, or insert to control insert/update behavior per request.
- ›Adds secondary API key configuration for zero-downtime key rotation in distributed clusters.
- ›Adds a dedicated HTTP port for the /metrics endpoint to support internal monitoring without exposing the main API port.
- ›Adds an API to list shard keys for collections using user-defined sharding.
- ›Adds Audit Access Logging for tracking access to the Qdrant API.
+13 moreshow less
- ›Adds Weighted RRF (Reciprocal Rank Fusion) support in hybrid queries, allowing per-query weight assignment to result sets.
- ›Adds configurable read fan-out delay to reduce tail latency in distributed clusters.
- ›Adds a config option to control update throughput and prevent searches on unoptimized segments.
- ›Adds an API for a detailed report on optimization progress and stages, including per-segment and per-shard visibility.
- ›Adds an API for aggregated telemetry across the whole cluster.
- ›Introduces Relevance Feedback, enabling search refinement using positive and negative example points.
- ›Introduces Qdrant Edge: an in-process version of Qdrant sharing the same storage format, points API, and shard snapshot compatibility as the server.
- ›Adds ability to disable extra HNSW links construction for specific payload indices.
- ›Adds a more convenient way to configure API keys for external inference providers.
- ›Adds unlimited update queue to gracefully absorb update spikes and maintain low search latency.
- ›Web UI now shows detailed visualization of optimization progress.
- ›Web UI 'Create collection' dialog previews the exact API command that will be executed.
- ›Web UI adds buttons for resharding control.
└──▷ BREAKING ON UPGRADE
- !Starting in v1.17.0, the gRPC interface changes its response format for vector fields; deprecated fields are removed — upgrade all official Qdrant client libraries before upgrading the server.
- !RocksDB support is completely removed in v1.17.x in favor of Gridstore, making direct upgrades from v1.15.x to v1.17.x unsupported — upgrade one minor version at a time.
- !The old shard key format deprecated in v1.15.0 is now disabled.
v1.16.2 Dec 4, 2025 · issue -256

Qdrant v1.16.2 adds user agent headers to outbound HTTP requests and improves telemetry/metrics timeout handling.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.16.2 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.16.2
```
- ›Adds a user agent header to all HTTP requests sent by the Qdrant server to downstream services.
- ›Improves request timeout handling for telemetry and metrics endpoints.
v1.16.1 Nov 25, 2025 · issue -265

Qdrant v1.16.1 brings up to 3× faster batch queries, active RocksDB-to-Gridstore migration on startup, and user-configurable inference request timeouts.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.16.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.16.1
```
- ›Makes timeout for inference requests user configurable.
- ›Makes batch queries up to 3× faster on full scans by reading each point only once.
- ›Actively migrates vector, payload, and payload index storage from RocksDB into Gridstore on startup for better and more predictable performance.
- ›Adds a 60-second internal timeout for telemetry/metrics endpoints to prevent long-hanging tasks.
- ›Adds validation to the restart shard transfer operation.
v1.16.0 Nov 17, 2025 · issue -273

Qdrant v1.16.0 adds ACORN-1 search, inline HNSW storage, conditional updates, tenant promotion, ASCII folding, and a wave of new Prometheus metrics.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.16.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.16.0
```
└──▷ USE IT
Prefix all exported Prometheus metrics with a custom string so Qdrant metrics are easy to distinguish in a shared monitoring namespace.
yaml
```
service:
  metrics:
    prefix: qdrant_
```
- ›Adds ReplicatePoints action to promote a payload-based tenant into a dedicated shard key, enabling tiered multitenancy workflows.
- ›Adds fallback shard key for intelligent routing to tenants that are or are not promoted to a dedicated shard.
- ›Adds inline storage option to embed vectors directly in the HNSW graph for more efficient IO usage.
- ›Adds ACORN-1 search method for accurate search over heavily filtered point sets.
- ›Adds text_any full-text filter to match points containing any of the supplied query terms.
+23 moreshow less
- ›Adds conditional update functionality so point updates are only applied to points matching a filter.
- ›Adds ASCII folding (normalization) to full-text indices, collapsing diacritics into ASCII equivalents.
- ›Adds option to customize the RRF k parameter for parametrized reciprocal rank fusion in hybrid queries.
- ›Adds custom key-value metadata to collections.
- ›Adds a profiler that logs slow point update and read requests.
- ›Adds warnings field to collection info to surface misconfiguration.
- ›In strict mode, allows specifying a maximum number of payload indices per collection.
- ›On shard key creation, allows specifying the initial state of new replicas.
- ›New metrics: collection_points and collection_vectors report point and vector counts per collection and vector name.
- ›New metric: collection_indexed_only_excluded_points reports points skipped during indexed_only search.
- ›New metrics: collection_active_replicas_min and collection_active_replicas_max report global effective minimum and maximum shard replication count.
- ›New metric: collection_dead_replicas reports the total number of non-active replicas.
- ›New metric: collection_running_optimizations reports the number of optimizers running per collection.
- ›New metrics: snapshot_creation_running, snapshot_recovery_running, and snapshot_created_total report snapshot lifecycle counts.
- ›New metric: process_threads reports the active thread count.
- ›New metrics: process_open_fds and process_max_fds report open file descriptor count and the system limit.
- ›New metrics: process_open_mmaps and system_max_mmaps report open memory maps and the system limit.
- ›New metrics: process_minor_page_faults_total and process_major_page_faults_total report cumulative page fault counts.
- ›Adds a configuration option to prefix all Prometheus metrics with qdrant_ or a custom string.
- ›Adds TARGET_CPU and JEMALLOC_SYS_WITH_LG_PAGE build parameters to the Docker image.
- ›Implements AVX-512 SIMD optimizations for binary quantization on modern x86_64 CPUs, unlocking significantly faster quantized search on compatible hardware.
- ›Enables quantization in appendable segments by default, improving search performance without manual configuration.
- ›New web UI design to match Qdrant Cloud (v0.2.0).
└──▷ BREAKING ON UPGRADE
- !The init_from collection API is removed (deprecated since Qdrant 1.15).
- !The lock API is removed (deprecated since Qdrant 1.15).
- !The old internal shard key format is removed (deprecated and migrated away from in Qdrant 1.15).
- !The payload filter from RBAC/JWT is removed (deprecated since Qdrant 1.15); API keys that use it are now rejected.
v1.15.5 Sep 30, 2025 · issue -320

Qdrant v1.15.5 adds strict mode max payload indices, remove-peer timeout, and broader API validation.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.15.5 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.15.5
```
- ›Adds timeout parameter to the remove peer operation for cluster management.
- ›Adds strict mode configuration to specify the maximum number of payload indices allowed.
- ›Adds API validation for min_should, filters, and point update batch operations.
- ›Decreases internal update batch sizes to minimize search latency spikes when processing large user batches.
- ›Acknowledges update/delete-by-filter operations on flush, preventing very slow restarts.
+2 moreshow less
- ›Peer IDs are no longer anonymized in telemetry data.
- ›Removes the vector count field from collection info responses.
└──▷ BREAKING ON UPGRADE
- !The vector count field is removed from collection info — any client code or dashboards that read that field will stop seeing it.
v1.15.4 Aug 27, 2025 · issue -354

Qdrant v1.15.4 adds SBOM and cosign-signed Docker images, reduces image size by up to 40%, and improves disk-space reliability.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.15.4 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.15.4
```
- ›Includes a Software Bill of Materials (SBOM) in the Docker image for supply-chain visibility.
- ›Signs Docker images with cosign, enabling signature verification before deployment.
- ›Reduces Docker image size by 10–40%, lowering pull times and storage overhead.
- ›Actively migrates shard key data on disk from the old format to a more robust format.
- ›Measures segment size on disk more reliably to improve available disk space checks.
+1 moreshow less
- ›Adjusts metrics histogram buckets — shows previously hidden empty buckets and removes very small ones.
v1.15.2 Aug 11, 2025 · issue -363

Qdrant v1.15.2 adds local BM25 inference, adjustable log buffer size, and a shard distribution matrix in the Web UI.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.15.2 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.15.2
```
- ›Makes log buffer size adjustable when logging to a file.
- ›Implements BM25 inference locally inside Qdrant, enabling sparse text scoring without an external inference service.
- ›Improves performance of the mutable map index, used for full-text, integer, and other payload field types.
- ›Adds a shard distribution view in the Web UI showing collection shards across a cluster as a replica/node matrix.
v1.15.1 Jul 24, 2025 · issue -364

gRPC HealthCheck now works without authentication, and indexing IO gets a sequential-access memory hint.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.15.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.15.1
```
- ›gRPC HealthCheck method now operates without authentication, matching the existing behavior of REST health endpoints.
- ›Storage components populated during indexing now use MADV_SEQUENTIAL hint for improved IO performance on large index builds.
v1.15.0 Jul 18, 2025 · issue -364

Qdrant v1.15.0 adds phrase matching, stop words, stemming, a new multilingual tokenizer, asymmetric and sub-2-bit quantization, and MMR to its query engine.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.15.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.15.0
```
- ›Adds phrase matching support to the Full-Text index, enabling exact multi-word sequence queries.
- ›Adds stop words support to the Full-Text index for filtering out common terms during indexing and search.
- ›Introduces Snowball Stemmer support in the Full-Text index for language-aware term normalization.
- ›Enables a new multilingual tokenizer by default in the Full-Text index.
- ›Adds asymmetric binary quantization, allowing query and storage vectors to use different quantization levels.
+8 moreshow less
- ›Adds 2-bit and 1.5-bit binary quantization encoding options for further vector compression beyond standard 1-bit.
- ›Adds Maximum Marginal Relevance (MMR) support in hybrid queries for diversity-aware result reranking.
- ›Inference usage is now reported in API responses.
- ›Enables pod role-based auth for S3 snapshots.
- ›Adds filesystem compatibility verification on process start.
- ›Migrates internal storage away from RocksDB.
- ›Adds a 'Create Collection' form to the Web UI and simplifies the JWT form.
- ›Adds HNSW healing on optimization to repair degraded graph connectivity automatically.
└──▷ BREAKING ON UPGRADE
- !The max_optimization_threads configuration key has been removed from config.
v1.14.1 May 23, 2025 · issue -366

Qdrant v1.14.1 adds a collection count limit config option and brings major payload index, GPU, and WAL transfer performance gains.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.14.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.14.1
```
- ›Adds a config option to limit the number of collections in a Qdrant instance.
- ›Greatly improves payload index load time by replacing RocksDB with mmaps as the persistence layer.
- ›Adds a specialized index for isEmpty and !isNull filter conditions, improving their query performance.
- ›Speeds up WAL-delta shard transfer significantly via batching and more careful synchronization.
- ›Improves GPU indexing speed for payload-related HNSW links and reuses GPU resources across operations.
+2 moreshow less
- ›Speeds up HNSW construction by improving heuristics computation.
- ›Improves IO/CPU resource scheduling for optimizers and batches IO when merging segments.
v1.14.0 Apr 22, 2025 · issue -367

Qdrant v1.14.0 adds server-side score boosting with custom formulas, a new sum_scores recommendation strategy, and full query auto-completion in the Web UI.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.14.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.14.0
```
└──▷ TRY IT
Use the sum_scores strategy in the Recommend API to implement relevance feedback — boosting results similar to liked examples and suppressing those similar to dislikes.
```
$ POST /collections/{collection_name}/points/recommend
{
  "positive": [1, 2, 3],
  "negative": [4],
  "strategy": "sum_scores",
  "limit": 10
}
```
- ›New sum_scores recommendation strategy available in the Explore API, designed for relevance feedback workflows.
- ›Adds server-side score boosting via user-defined formulas in hybrid queries, allowing custom ranking logic without client-side post-processing.
- ›Changed behavior: offset parameter in queries with prefetch is now applied only to the prefetch result and is no longer propagated into the prefetch query itself.
- ›Incremental HNSW building — segment optimizer partially re-uses the existing HNSW graph when merging segments, reducing rebuild cost.
- ›Parallelizes large segment search batches for improved throughput.
+1 moreshow less
- ›Full query auto-completion added to the Qdrant Web UI.
└──▷ BREAKING ON UPGRADE
- !The offset parameter in a query that uses prefetch now applies only to the prefetch result and is not propagated into the prefetch sub-query — queries relying on the previous propagation behavior will return different results.
v1.13.6 Mar 31, 2025 · issue -368

Qdrant v1.13.6 cuts query API network overhead and speeds up resharding transfers on constrained hardware.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.13.6 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.13.6
```
- ›Query API now reads vectors and payloads once at the shard level instead of per-segment, meaningfully improving search performance on collections with many segments.
- ›Query API defers vector and payload reads so large data is no longer sent over the internal network during distributed queries, reducing latency in multi-node deployments.
- ›Resharding transfers now complete faster under slow-disk or high-memory-pressure conditions.
v1.13.5 Mar 21, 2025 · issue -368

Qdrant v1.13.5 brings CPU/IO budget splitting, shard-level undersampling, and faster payload index filtering for large deployments.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.13.5 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.13.5
```
- ›Splits the CPU budget into separate CPU and IO budgets to better saturate resources during segment optimization.
- ›Applies undersampling at the shard level, significantly improving query performance on large deployments with large search limits.
- ›Enhances payload indices to handle IsEmpty and IsNull filter conditions much more efficiently.
- ›Optimizes the ID tracker in immutable segments by compressing point mappings and versions, reducing memory footprint.
- ›Significantly improves performance of point delete propagation during resharding on large deployments.
+2 moreshow less
- ›Uses approximate point counts at the start of shard transfers to make transfers start quicker.
- ›Emits a log message when hardware reporting is enabled.
v1.13.4 Feb 17, 2025 · issue -369

Qdrant v1.13.4 adds strict-mode enforcement of a maximum point count per collection.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.13.4 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.13.4
```
- ›Adds support for setting a maximum number of points in a collection via strict mode.
v1.13.3 Feb 11, 2025 · issue -369

Qdrant v1.13.3 adds env-var peer/bootstrap URI config, consensus compaction on by default, Retry-After rate-limit headers, and a default log format config key.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.13.3 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.13.3
```
- ›Adds support for passing peer/bootstrap URI via environment variables, simplifying cluster setup without config-file edits.
- ›Adds Retry-After HTTP header to REST responses when the rate limiter is exhausted, letting clients back off correctly.
- ›Adds a default log format property to the Qdrant configuration file.
- ›Enables consensus compaction by default, enabling faster peer joining and cluster recovery.
- ›Excludes unversioned and partially persisted points from reads and writes, preventing stale or incomplete data from appearing in search results or updates.
+2 moreshow less
- ›Deletes old point versions on update, preventing superseded point versions from surfacing in reads.
- ›Normalizes URL paths in the REST API.
v1.13.2 Jan 28, 2025 · issue -370

Qdrant v1.13.2 adds GPU support for devices without half-float capability, falling back to full floats.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.13.2 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.13.2
```
- ›Adds support for GPUs that do not feature half floats, automatically falling back to full floats to enable indexing on a broader range of GPU hardware.
v1.13.0 Jan 17, 2025 · issue -370

Qdrant v1.13.0 adds GPU-accelerated HNSW indexing, runtime resharding, strict mode, and a new Has Vector filter condition.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.13.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.13.0
```
- ›Adds has vector filtering condition to check whether a named vector is present on a point, enabling queries that target only partially-vectorized records.
- ›Adds strict mode to collections to restrict certain categories of operations, giving operators tighter control over collection behaviour.
- ›Allows max_optimization_threads to be set back to automatic after being manually configured.
- ›Adds GPU support for HNSW indexing, dramatically accelerating index build times.
- ›Adds runtime resharding in Qdrant Cloud, allowing the number of shards on a collection to be changed without downtime.
+4 moreshow less
- ›Switches payload storage to mmap by default, reducing unexpected latency spikes.
- ›Switches sparse vector storage to mmap, improving resource management.
- ›Compresses HNSW graph links to reduce memory footprint.
- ›Streams snapshots during snapshot transfer instead of writing them to disk first, reducing I/O overhead.
└──▷ BREAKING ON UPGRADE
- !Payload storage now defaults to mmap; existing deployments will use the new default on upgrade, which may change memory and disk I/O behaviour.
- !Sparse vector storage now defaults to mmap; existing deployments will use the new default on upgrade.
v1.12.6 Jan 8, 2025 · issue -370

Qdrant v1.12.6 adds 64-bit sparse vector indices, Issues API support for limited API keys, and JSON-format logging.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.12.6 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.12.6
```
- ›Adds JSON-format logging support, enabling structured log ingestion into SIEM and log-aggregation pipelines.
- ›Extends the Issues API to work with limited (scoped) API keys, not just full-access credentials.
- ›Supports 64-bit dimension indices for sparse vectors, lifting the previous 32-bit index ceiling for very high-dimensional sparse data.
- ›Bundles the web UI in the official Debian package, removing the need for a separate installation step on Debian-based deployments.
v1.12.3 Nov 12, 2024 · issue -372

Qdrant v1.12.3 exposes async scorer usage in telemetry data.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.12.3 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.12.3
```
- ›Exposes async scorer usage in telemetry, making it observable whether the async scorer is active for a given collection or request.
v1.12.2 Nov 8, 2024 · issue -372

Qdrant v1.12.2 adds memory usage metrics, CPU endianness telemetry, and quantized-data-in-RAM default alongside broad performance improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.12.2 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.12.2
```
- ›Reports memory usage in metrics and telemetry, giving operators visibility into runtime memory consumption.
- ›Reports storage bytes estimate for each segment in telemetry, enabling finer-grained capacity planning.
- ›Reports CPU endianness in telemetry output, surfacing hardware context alongside other node metadata.
- ›Adds support for reinitializing consensus with new peer URLs, easing cluster reconfiguration without a full restart.
- ›Uses streaming creation of snapshots during shard snapshot transfer, reducing peak memory pressure during transfers.
+5 moreshow less
- ›Enables Jemalloc in RocksDB and its background thread for gradual release of unused memory, lowering the long-term RSS footprint.
- ›Improves matrix API performance across multiple code paths.
- ›Improves HNSW search performance by tweaking the visited list.
- ›Improves resilience by not killing replicas eagerly when a node is out of sync.
- ›Adds a log message when shard transfer is aborted, aiding operational debugging.
v1.12.0 Oct 8, 2024 · issue -373

Qdrant v1.12.0 adds Facets API, Distance Matrix API, mmap vector storage by default, and on-disk text/geo index offloading.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.12.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.12.0
```
- ›New Facets API retrieves unique payload values with counts for a given index field under a given filter, enabling faceted search workflows.
- ›New Distance Matrix API calculates many-to-many distances between stored vectors, supporting clustering, dimensionality reduction, and data visualization use cases.
- ›Switches default vector storage to memory-mapped files (mmap), replacing rocksdb to accelerate uploads for large datasets and reduce RSS anonymous memory consumption — Qdrant now slows gracefully under memory pressure instead of OOM-crashing.
- ›Enables sparse snapshots so that allocated-but-empty files in vector storage no longer consume extra disk space in snapshot archives.
- ›Adds ability to offload text-index to disk, reducing in-memory footprint for text-indexed collections.
+4 moreshow less
- ›Adds ability to offload geo-index to disk.
- ›Triggers optimizers automatically when uploading snapshots.
- ›Instantly self-elects a Raft leader when the cluster contains a single peer, reducing startup latency in single-node deployments.
- ›Improved Web UI graph visualization allows sampling large chunks of data from a collection, with improved panning UX and more interactive tutorials.
v1.11.4 Sep 17, 2024 · issue -374

Qdrant v1.11.4 adds a grey collection status for pending optimizations, faster startups, leaner snapshots, disk logging config, and a JWT entropy warning.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.11.4 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.11.4
```
- ›Adds a logging-to-disk template in the configuration file, enabling structured log persistence without custom setup.
- ›Adds a grey collection status indicator when optimizations are pending after a node restart, distinguishing this state from healthy (green) or degraded.
- ›Prints a warning in logs when a JWT RBAC key has low entropy, surfacing credential-strength issues at runtime.
- ›Creates snapshots without intermediate temporary files, reducing disk space requirements and snapshot creation time.
- ›Parallelizes deduplication of points on startup, significantly reducing startup time for large collections.
+3 moreshow less
- ›Improves geo index memory usage by up to 30% via geohash packing.
- ›Improves error reporting for malformed JSON path strings.
- ›Removes max_segment_number from the OpenAPI definition as the field is no longer used.
v1.11.1 Aug 27, 2024 · issue -375

Qdrant v1.11.1 adds MatchAny/Except filtering for UUID indexes and non-blocking payload index builds.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.11.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.11.1
```
- ›Supports MatchAny and Except filter conditions on UUID indexes, enabling set-based inclusion/exclusion filtering on UUID payload fields.
- ›Non-blocking payload index building keeps the collection available for queries while indexes are constructed in the background.
- ›Includes the list of cluster peers in telemetry data.
- ›Improves navigation and collection view in the Web UI.
- ›Allows modifying data before writing to disk for copy-on-write operations.
v1.11.0 Aug 12, 2024 · issue -375

Qdrant v1.11.0 adds GroupBy in Query API, UUID payload index, Distribution-based Score Fusion, random sampling, and a graph-based collection explorer.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.11.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.11.0
```
└──▷ HOW TO FIND IT
Explore vector neighborhoods visually and check real-time search quality without leaving the browser.
📍In the Qdrant Web UI, open a collection and select 'Graph Exploration' to browse vector neighborhoods, or select 'Search Quality' to evaluate retrieval quality in real time.
- ›Adds group_by support to the Query API, enabling grouped vector search results in a single request.
- ›Introduces a UUID payload index type for indexing and filtering on UUID fields.
- ›Adds on-disk index support for Keyword, Integer, Datetime, Float, and UUID indexes, reducing RAM requirements for large collections.
- ›Adds random sampling support in the Query API for approximate or exploratory queries.
- ›Adds Distribution-based Score Fusion (DBSFusion) as a new score fusion strategy for hybrid search.
+2 moreshow less
- ›New graph-based collection exploration tool in the Web UI for visualizing vector neighborhoods.
- ›New real-time search quality check tool in the Web UI.
v1.10.0 Jul 1, 2024 · issue -376

Qdrant v1.10 adds a Universal Query API, multivector/ColBERT support, float16/uint8 datatypes, S3 snapshot storage, and configurable collection defaults.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.10.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.10.0
```
└──▷ TRY IT
Create a collection using float16 dense vectors to halve memory usage for large embedding datasets.
```
$ curl -X PUT 'http://localhost:6333/collections/my_collection' \
  -H 'Content-Type: application/json' \
  -d '{
    "vectors": {
      "size": 1536,
      "distance": "Cosine",
      "datatype": "float16"
    }
  }'
```
- ›Adds POST /collections/{collection_name}/points/query Universal Query API supporting search, recommendations, discovery, and payload ordering in a single request, with hybrid search via result fusion and multi-stage re-scoring.
- ›Adds float16 datatype for dense vectors, halving memory consumption with minimal accuracy loss.
- ›Adds float16 and uint8 datatype options for sparse vector indexes, reducing memory by 2x and 4x respectively.
- ›Adds Inverse Document Frequency (IDF) modifier for sparse vectors, enabling streaming updates for BM25 and BM42 embeddings.
- ›Adds S3-compatible storage backend for snapshots.
+6 moreshow less
- ›Adds ability to configure default collection parameters (quantization, vector storage, replication factor) applied to all new collections.
- ›Adds ability to overwrite global optimizer configuration per collection, enabling separation of indexing and searching roles within a single cluster.
- ›Adds support for multivectors, enabling native use of late-interaction models such as ColBERT and storing a dynamic number of vectors per point with shared payload.
- ›Adds issue reporting to surface potential performance problems and misconfigurations.
- ›Applies Delta Encoding and bitpacking compression for sparse vectors, reducing their memory footprint by up to 75%.
- ›Skips serialization of empty fields in search responses, reducing payload size and network traffic.
v1.9.5 Jun 11, 2024 · issue -377

Qdrant v1.9.5 adds Pyroscope continuous profiling and new config knobs for shards and optimizer settings.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.9.5 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.9.5
```
- ›Adds support for configuring the default number of shards per node via config.
- ›Allows optimizer settings to be overwritten via the Qdrant config file.
- ›Integrates Pyroscope for continuous profiling on demand.
- ›Improves default maximum segment size by basing it on the number of CPUs used for indexing.
- ›Improves vector size estimations, making index thresholds more reliable.
v1.9.3 May 26, 2024 · issue -378

Qdrant v1.9.3 adds graceful out-of-disk handling, faster consensus convergence, and a Web UI misconfiguration alert.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.9.3 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.9.3
```
- ›Adds Web UI notifications when collections are misconfigured, surfacing configuration problems at a glance.
- ›Handles out-of-disk conditions on insertions gracefully instead of failing hard, improving reliability under storage pressure.
- ›Speeds up consensus convergence in distributed deployments using batched updates.
- ›Deduplicates points by ID when using custom sharding, preventing duplicate-key anomalies on ingest.
v1.9.0 Apr 22, 2024 · issue -379

Qdrant v1.9.0 adds JWT-based RBAC, byte vector support, faster shard diff transfer, and a dashboard JWT token generator.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.9.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.9.0
```
- ›Adds role-based access control (RBAC) via JWT tokens, with a new dashboard page to generate RBAC JWT tokens.
- ›Adds support for byte vectors, allowing vectors to be represented as uint8 in addition to float32.
- ›Implements shard diff transfer, greatly improving shard transfer speed during node recovery (falls back to streaming records when needed).
- ›Reports pending optimizations awaiting an update operation in collection info.
- ›Improves sparse vector search performance by an additional 7%.
+1 moreshow less
- ›Improves write performance while creating snapshots of large collections.
└──▷ BREAKING ON UPGRADE
- !The vectors_count field is removed from collection info because it is unreliable — check any usage of this field before upgrading.
- !The shard transfer method field is removed from the abort shard transfer operation.
v1.8.3 Mar 19, 2024 · issue -380

Qdrant v1.8.3 adds dashboard support for finding similar points by payload key:value pair and 64-bit numbers.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.8.3 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.8.3
```
- ›Dashboard: find similar points by payload key:value pair directly in the web UI.
- ›Dashboard: supports 64-bit numbers in the web UI.
v1.8.0 Mar 6, 2024 · issue -380

Qdrant v1.8.0 adds Scroll API ordering by payload, datetime index, collection-exists API, minimum-match filters, and 16x faster sparse vector search.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.8.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.8.0
```
└──▷ TRY IT
Paginate through points in chronological order when your collection stores timestamped events and you need time-sorted results.
```
$ curl -X POST 'http://localhost:6333/collections/events/points/scroll' \
  -H 'Content-Type: application/json' \
  -d '{
    "limit": 50,
    "order_by": {
      "key": "timestamp"
    }
  }'
```
Filter points within a specific date-time range after creating a datetime payload index on the field.
```
$ curl -X PUT 'http://localhost:6333/collections/events/index' \
  -H 'Content-Type: application/json' \
  -d '{
    "field_name": "created_at",
    "field_schema": "datetime"
  }'
```
Require at least two out of several optional filter conditions to match, useful for fuzzy multi-criteria searches.
```
$ curl -X POST 'http://localhost:6333/collections/products/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "limit": 10,
    "filter": {
      "min_should": {
        "conditions": [
          {"key": "category", "match": {"value": "electronics"}},
          {"key": "in_stock", "match": {"value": true}},
          {"key": "rating", "range": {"gte": 4.0}}
        ],
        "min_count": 2
      }
    }
  }'
```
- ›Adds order_by support to the Scroll API, enabling results to be ordered by payload field values.
- ›Adds a datetime payload index type for efficient filtering over date-time ranges.
- ›Adds an API endpoint to check whether a collection exists.
- ›Adds min_should (minimum number of conditions to match) support in payload filters.
- ›Improves the set_payload API to support modifying nested fields.
+11 moreshow less
- ›Adds a config property to set the default shard transfer method.
- ›Adds the ability to selectively disable the range or lookup index for integer payloads to reduce memory usage.
- ›Exposes a request timing histogram for Prometheus at the metrics endpoint.
- ›Adds a checksum for snapshot files to verify integrity.
- ›Reports progress of ongoing shard transfers.
- ›Exposes the git commit hash of the build at the root endpoint.
- ›Sparse vector search is up to 16x faster, unlocking practical use of large sparse collections.
- ›Improves CPU saturation for indexing on high-CPU systems, significantly speeding up ingestion.
- ›Adds new release artifacts: MUSL binaries for x86_64 and AArch64, a portable AppImage binary, and a Debian .deb package.
- ›Reports the timestamp of the last seen cluster error, aiding distributed debugging.
- ›Dashboard adds a button to delete points, auto-complete for required fields when inserting commands, snapshot support for demo collections, and a discovery scores visualisation.
v1.7.0 Dec 8, 2023 · issue -383

Qdrant v1.7.0 adds sparse vector support (SPLADE/BM25), discovery search, user-defined sharding, and a read-only API key.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.7.0
```
└──▷ TRY IT
Create a collection with sparse vectors to index BM25 or SPLADE embeddings alongside dense vectors.
```
$ curl -X PUT 'http://localhost:6333/collections/my_collection' \
  -H 'Content-Type: application/json' \
  -H 'api-key: <your-api-key>' \
  -d '{
    "vectors": {
      "dense": {"size": 768, "distance": "Cosine"}
    },
    "sparse_vectors": {
      "bm25": {}
    }
  }'
```
Issue a read-only API key so a search client cannot modify collections or data.
```
$ curl -X GET 'http://localhost:6333/collections' \
  -H 'Authorization: Bearer <read-only-api-key>'
```
Run a Discovery search to find vectors that fit a defined positive/negative context rather than nearest-neighbor similarity.
```
$ curl -X POST 'http://localhost:6333/collections/my_collection/points/discover' \
  -H 'Content-Type: application/json' \
  -H 'api-key: <your-api-key>' \
  -d '{
    "target": "<point-id>",
    "context": [
      {"positive": "<pos-id>", "negative": "<neg-id>"}
    ],
    "limit": 10
  }'
```
- ›Adds sparse vector support to collections, enabling SPLADE and BM25 datasets alongside dense vectors.
- ›Adds a read-only API key for restricting clients to non-mutating operations.
- ›Adds Manhattan distance metric for vector similarity calculations.
- ›Adds support for authenticating with the API key via HTTP Bearer authentication.
- ›Exposes the update rate limiter parameter in server configuration.
+9 moreshow less
- ›Adds a Discovery API for exploring and discovering vectors within a defined context.
- ›Adds user-defined sharding, allowing custom partitioning of data across a cluster.
- ›Adds shard snapshot transfer as a fast shard transfer method, including index and quantized data.
- ›Adds a geo map payload index to improve geo-filter search performance.
- ›Adds configurable timeout for search requests.
- ›Adds an interactive tutorial to the Web UI dashboard.
- ›Adds a command palette to the Web UI dashboard.
- ›Enables download/upload of snapshots with an API key in the Web UI.
- ›Improves /readyz health check to only mark a node as ready once it has caught up with cluster state.
v1.6.0 Oct 9, 2023 · issue -385

Qdrant v1.6.0 adds a new recommendation engine, polygon geo filtering, raw-vector recommendation input, and distributed search load balancing.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.6.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.6.0
```
└──▷ TRY IT
Recommend points using raw vectors as input instead of requiring stored point IDs — useful when the query vector is not yet indexed in the collection.
```
$ curl -X POST 'http://localhost:6333/collections/{collection_name}/points/recommend' \
  -H 'Content-Type: application/json' \
  -d '{
    "positive": [[0.1, 0.2, 0.3, 0.4]],
    "negative": [[0.9, 0.8, 0.7, 0.6]],
    "limit": 10
  }'
```
Filter search results to points whose geo coordinates fall within an arbitrary polygon — useful for irregularly shaped regions like city boundaries.
```
$ curl -X POST 'http://localhost:6333/collections/{collection_name}/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3, 0.4],
    "filter": {
      "must": [{
        "key": "location",
        "geo_polygon": {
          "exterior": {
            "points": [
              {"lat": 48.9, "lon": 2.2},
              {"lat": 48.9, "lon": 2.5},
              {"lat": 48.7, "lon": 2.5},
              {"lat": 48.7, "lon": 2.2},
              {"lat": 48.9, "lon": 2.2}
            ]
          }
        }
      }]
    },
    "limit": 10
  }'
```
- ›Adds a new recommendation engine that scores results directly from positive/negative examples rather than requiring point IDs.
- ›Extends the recommendation API to accept raw vectors as input alongside point IDs.
- ›Adds support for filtering geo coordinates by polygon (in addition to existing radius/bounding-box filters).
- ›Adds an option to tune shard update parallelism for improved write performance on large clusters.
- ›Distributes searches to other nodes when the current node is busy, reducing search latency on large clusters.
+7 moreshow less
- ›Adds support for specifying a payload path to retrieve only a subset of a point's payload.
- ›Adds an immutable numeric index that reduces memory usage by a factor of 3.
- ›Adds automatic selection of search rescoring mode for improved binary quantization search accuracy.
- ›Adds a gRPC-compliant health check method.
- ›FastEmbed: adds new models sentence-transformers/all-MiniLM-L6-v2 and intfloat/multilingual-e5-large.
- ›FastEmbed: adds an API to list supported models, including BAAI/bge-small-en and BAAI/bge-base-en.
- ›FastEmbed: removes bulky dependencies, reducing dependency size by a factor of 25.
v1.5.1 Sep 12, 2023 · issue -386

Qdrant v1.5.1 adds an unprivileged Docker image for hardened deployments.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.5.1
```
- ›Adds an unprivileged Docker image better suited for secure, least-privilege container environments.
v1.5.0 Sep 7, 2023 · issue -386

Qdrant v1.5.0 adds binary quantization, batch point updates, shard snapshot API, and Kubernetes health endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.5.0
```
└──▷ TRY IT
Speed up ANN search in a collection where some segments are not yet indexed by skipping unindexed segments entirely — useful during bulk ingestion when freshness matters less than latency.
```
$ curl -X POST 'http://localhost:6333/collections/my_collection/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "limit": 10,
    "params": {
      "indexed_only": true
    }
  }'
```
Create a snapshot of a single shard for targeted backup or migration without snapshotting the entire collection.
```
$ curl -X POST 'http://localhost:6333/collections/my_collection/shards/0/snapshots'
```
Probe the readiness endpoint in a Kubernetes readinessProbe to gate traffic until Qdrant has fully loaded its data.
```
$ curl -f http://localhost:6333/readyz
```
- ›Adds indexed_only parameter to search requests to skip unindexed segments, speeding up search over large collections.
- ›Adds a batch update endpoint for the points API, enabling multiple point operations in a single request.
- ›Adds binary quantization support as a new quantization method for vector compression.
- ›Adds shard snapshot API for creating and managing per-shard snapshots in distributed deployments.
- ›Adds healthz, livez, and readyz HTTP endpoints for standard Kubernetes liveness and readiness health checking.
+7 moreshow less
- ›Adds a stack trace API endpoint to expose the current state of all threads for runtime debugging.
- ›Adds a recovery mode flag surfaced in metrics.
- ›Adds optimizer status and history to telemetry output to aid in debugging optimizer failures.
- ›Adds gRPC reflection server, enabling gRPC tooling to discover and introspect the service schema at runtime.
- ›Adds a collection info tab to the web UI dashboard.
- ›Web UI dashboard now supports downloading and uploading snapshots with an API key.
- ›The qdrant-client Python library now integrates with the FastEmbed package for lightweight retrieval embedding generation, enabling document upsert and search without manual encoding.
v1.4.1 Aug 10, 2023 · issue -387

Qdrant v1.4.1 whitelists the root endpoint for API-key-free health checks and improves search consistency and RAM usage.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.4.1
```
- ›Whitelists the root endpoint so it no longer requires an API key, simplifying health-check configuration in Kubernetes environments.
- ›Improves search result consistency by using seeded randomness for ID tracker point sampling.
- ›Reduces RAM usage for the keywords index.
- ›Reduces consensus networking footprint by skipping outdated Raft heartbeats.
v1.4.0 Aug 3, 2023 · issue -387

Qdrant v1.4.0 adds binary payload indexing, runtime HNSW/quantization tuning, multilingual tokenizer, and snapshot management in the dashboard.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.4.0
```
└──▷ TRY IT
Enable multilingual tokenization on a text payload field so that names or descriptions in Arabic, Japanese, or Chinese are indexed correctly.
```
$ curl -X PUT 'http://localhost:6333/collections/my_collection/index' \
  -H 'Content-Type: application/json' \
  -d '{
    "field_name": "description",
    "field_schema": {
      "type": "text",
      "tokenizer": "multilingual"
    }
  }'
```
Switch an existing collection to on-disk vector storage at runtime without recreating it, useful when memory pressure grows after initial deployment.
```
$ curl -X PATCH 'http://localhost:6333/collections/my_collection' \
  -H 'Content-Type: application/json' \
  -d '{
    "vectors": {
      "on_disk": true
    }
  }'
```
- ›Adds multilingual tokenizer for full-text payload fields, supporting non-latin alphabets including optional CJK (Chinese, Japanese, Korean) character sets.
- ›Supports changing hnsw, quantization, and on_disk parameters of an existing collection at runtime without recreating it.
- ›Adds a binary index for boolean payload fields, enabling faster filtering on true/false values.
- ›Adds search request cancellation with a configurable timeout — searches stop early if the client drops the request.
- ›Allows configuring the name of the init file via an environment variable.
+3 moreshow less
- ›New dashboard UI for collection snapshot management: upload, create, download, and delete snapshots from the browser.
- ›New dashboard UI for editing point payloads directly in the browser.
- ›New dashboard UI for vector visualization using t-SNE dimensionality reduction.
v1.3.1 Jul 3, 2023 · issue -388

Qdrant v1.3.1 adds SIGTERM shutdown support and uses configured temp directory for snapshot uploads.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.3.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.3.1
```
- ›Supports SIGTERM signal for graceful shutdown of Qdrant.
- ›Snapshot uploads now use the configured temporary directory instead of a hardcoded path.
- ›Improves validation of search API requests.
v1.3.0 Jun 23, 2023 · issue -389

Qdrant v1.3.0 adds a self-hosted Web UI, group lookup, io_uring async IO, and quantized vector oversampling.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.3.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.3.0
```
└──▷ HOW TO FIND IT
Explore collections and run ad-hoc vector queries with autocomplete against your local Qdrant instance — no client library needed.
📍Open http://localhost:6333/dashboard in your browser, select a collection, and use the interactive query editor to run searches.
- ›Adds experimental io_uring async IO support (opt-in) for significantly improved performance on network-mounted storages, using a recent Linux kernel feature.
- ›Adds oversampling for quantized vector queries, letting you retrieve more candidate points with quantized vectors and re-score with originals to tune the speed/accuracy tradeoff at query time.
- ›Adds lookup in grouping requests, enabling shared group metadata to be stored in a dedicated collection to minimize memory usage.
- ›Adds a self-hosted Web UI dashboard at http://localhost:6333/dashboard, including a collection viewer and an interactive query editor with autocomplete.
- ›Adds recovery_mode flag to the telemetry output.
+1 moreshow less
- ›Adds configurable location for temporary files.
v1.2.0 May 24, 2023 · issue -390

Qdrant v1.2.0 adds API key auth, Product Quantization, Group-By API, optional vectors, recovery mode, and nested object filters.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.2.0
```
└──▷ TRY IT
Group search results by a payload field (e.g. 'document_id') to retrieve the top-k matches per group — useful for document-level RAG retrieval.
```
$ curl -X POST 'http://localhost:6333/collections/{collection_name}/points/search/groups' \
  -H 'Content-Type: application/json' \
  -H 'api-key: <your-api-key>' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "group_by": "document_id",
    "group_size": 3,
    "limit": 10
  }'
```
Filter on individual objects inside a payload array using nested object filter — e.g. match only array entries where both 'key' and 'value' align.
```
$ curl -X POST 'http://localhost:6333/collections/{collection_name}/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "filter": {
      "must": [
        {
          "nested": {
            "key": "attributes",
            "filter": {
              "must": [
                { "key": "name", "match": { "value": "color" } },
                { "key": "value", "match": { "value": "red" } }
              ]
            }
          }
        }
      ]
    },
    "limit": 5
  }'
```
- ›Adds built-in API key authentication support for securing Qdrant endpoints.
- ›Enables Product Quantization (PQ) for vectors, providing a new vector compression strategy alongside existing quantization options.
- ›Adds Group-By API, allowing search results to be grouped by a payload field for top-results-per-group retrieval.
- ›Adds optional vectors, allowing points to be created with only a subset of named vectors defined — two new APIs manage vectors independently from payload.
- ›Adds recovery mode for handling Out-of-Disk and Out-of-Memory errors, enabling the node to recover rather than crash.
+5 moreshow less
- ›Adds nested object filter, enabling filtering by individual objects inside payload arrays.
- ›Adds dynamic mmap vector storage, allowing vectors to be stored in mmap files immediately on insert without requiring a separate optimization step.
- ›Adds Cluster management API in gRPC, bringing cluster operations to the gRPC interface.
- ›Adds support for TLS certificate rotation without requiring a full restart.
- ›Releases pre-built binaries for multiple platforms alongside Docker images.
v1.1.1 Apr 12, 2023 · issue -391

Qdrant v1.1.1 adds per-vector HNSW/quantization config, TLS for gRPC and REST, isNull payload filter, and snapshot multipart upload.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.1.1
```
└──▷ TRY IT
Trigger snapshot creation without waiting for it to finish, so long-running snapshot jobs do not block your API call.
```
$ curl -X POST 'http://localhost:6333/collections/my_collection/snapshots?wait=false'
```
- ›Adds isNull condition for payload filtering, enabling queries that distinguish null values from empty or missing fields in specific payload keys.
- ›Adds wait parameter to the snapshot API, allowing callers to skip blocking on snapshot creation and return immediately — useful for long-running operations.
- ›Adds last-used and startup timing fields to the telemetry API response.
- ›Adds aggregated vector count to the /metrics endpoint.
- ›Adds per-vector-field HNSW and quantization configuration, so each named vector field in a collection can carry independent index and quantization settings.
+4 moreshow less
- ›Adds TLS support for gRPC and REST API, plus TLS for internal inter-node communication, with mutual (client and server) certificate verification.
- ›Adds ability to upload and recover snapshot files via multipart HTTP requests.
- ›Adds parameter validation to REST and gRPC APIs and to the config file, providing clearer error messages on misconfiguration.
- ›Introduces an internal rate limiter for the transport channel pool, improving cluster stability under high-concurrency load.
v1.1.0 Mar 17, 2023 · issue -392

Qdrant v1.1.0 adds Scalar Quantization, Match Any filtering, listener mode, and a Prometheus-compatible /metrics endpoint.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.1.0
```
└──▷ TRY IT
Trigger a snapshot recovery in the background without waiting for completion, useful in automation scripts where the connection may drop.
```
$ curl -X POST 'http://localhost:6333/collections/my_collection/snapshots/recover?wait=false' \
  -H 'Content-Type: application/json' \
  -d '{"location": "http://snapshots-store/my_collection-snapshot.snapshot"}'
```
- ›Adds /metrics API endpoint serving telemetry in OpenMetrics format, compatible with Prometheus and similar collectors.
- ›Adds wait=false parameter support to the snapshot recovery API, which also now tolerates disconnections mid-request.
- ›Introduces Scalar Quantization: compress vectors from float32 to int8 for up to 4x memory reduction and up to 2x speed improvement with minimal accuracy loss.
- ›Adds 'Match Any' filtering condition, allowing a set of values to be matched in a single filter expression.
- ›Adds experimental listener mode for dedicated backup machines and cross-regional backup topologies.
+3 moreshow less
- ›Adds Raft consensus checkpointing to optimize operations on long-running distributed clusters.
- ›Supports filtering conditions on nested data structures via nested key syntax.
- ›Snapshot recovery API now supports recovering snapshots taken in distributed mode on local deployments, and can recover into non-existent collections.
v1.0.0 Feb 8, 2023 · issue -393

Qdrant v1.0 adds collection alias listing, snapshot deletion, collection initialization from another collection, and opt-in read/write consistency guarantees.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v1.0.0
```
- ›New API to list collection aliases.
- ›New API to delete snapshots.
- ›New API to initialize a collection from another collection, enabling quick experiments over different indexing parameters and seamless shard-count scaling when combined with aliases.
- ›Read operations gain opt-in consistency guarantees, ensuring consistent reads even from an inconsistent cluster.
- ›Write operations gain opt-in ordering guarantees, ensuring writes are ordered across parallel overlapping requests.
+3 moreshow less
- ›Telemetry data collection is now enabled by default and can be disabled via CLI or environment variable.
- ›Adds Windows platform support.
- ›Allows overriding the maximum number of CPUs via environment variable, useful for Docker containers and Kubernetes.
v0.11.6 Dec 27, 2022 · issue -395

Qdrant v0.11.6 adds cross-collection vector lookup in the recommendation API for item-to-user recommendation scenarios.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.6 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.11.6
```
- ›Enables lookup of vectors from a different collection inside the recommendation API, supporting item-to-user recommendations where user and item embeddings live in separate collections with independent index configurations.
v0.11.5 Dec 6, 2022 · issue -395

Qdrant v0.11.5 adds overwrite-all payload API, filter-scoped payload edits, and optional global HNSW index disable
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.5 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.11.5
```
- ›Adds a new API to overwrite all existing payload fields in one step — unlike set_payload, which only replaces mentioned fields, this overwrites everything on the matched points.
- ›Enables setting and deleting payload fields by filter, so bulk payload updates can now target a subset of points using filtering conditions (useful when payloads carry a secondary key).
- ›Adds a parameter to define the source of truth for snapshot recovery, simplifying distributed-mode recovery scenarios including recovery on an empty cluster.
- ›Allows disabling the global HNSW index on a collection and building only per-payload-value HNSW sub-graphs, enabling efficient within-group-only search across sub-groups of varying sizes.
- ›Includes the peer ID in auto-generated snapshot names so snapshots from different nodes in a cluster can be distinguished.
v0.11.4 Nov 25, 2022 · issue -396

Qdrant v0.11.4 adds mmap-based HNSW storage and gRPC compression, cutting RAM requirements and network overhead.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.4 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.11.4
```
- ›Adds mmap support for HNSW graph storage, allowing the index to be kept on disk rather than in RAM — especially beneficial for collections with many small vectors.
- ›Enables compression in the gRPC protocol, reducing bandwidth for large payload transfers over slow networks.
- ›Adds probabilistic search sampling that significantly improves search speed when using large limit values, enabling fast retrieval of large numbers of nearest vectors.
- ›Switches to compact, CPU cache-friendly storage for HNSW graph links, improving search speed, memory usage, and application startup time.
v0.11.3 Nov 15, 2022 · issue -396

Qdrant v0.11.3 adds a snapshot recovery API with distributed mode support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.3 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.11.3
```
- ›Adds an API for recovering snapshots, including support for recovery in distributed (multi-node) mode.
v0.11.2 Nov 9, 2022 · issue -396

Qdrant v0.11.2 adds HTTP compression middleware and improved read-after-write consistency on replica failure.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.2 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.11.2
```
- ›Enables HTTP compression middleware for the REST API, reducing bandwidth for large responses.
- ›Ensures read-after-write consistency when a replica fails and requests are routed to the same peer.
- ›Reduces RAM usage for the ID tracker, particularly beneficial for collections with many small vectors.
v0.11.1 Nov 5, 2022 · issue -396

Qdrant v0.11.1 enables single-node snapshot recovery into cluster deployments.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.11.1
```
- ›Supports migrating collections from single-node deployments to cluster mode, including restoring single-node snapshots into a cluster deployment.
v0.11.0 Oct 26, 2022 · issue -397

Qdrant v0.11.0 adds replication for HA distributed deployments, a write-disable admin API, and an exact search parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.11.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.11.0
```
└──▷ TRY IT
Validate HNSW index accuracy by running an exact nearest-neighbor search against the same query and comparing results.
```
$ POST /collections/{collection_name}/points/search
{
  "vector": [0.1, 0.2, 0.3],
  "limit": 10,
  "params": {
    "exact": true
  }
}
```
- ›Adds exact search parameter to force exact vector search even when an HNSW ANN index is built, enabling accuracy validation of index configurations.
- ›New administration API allows disabling write operations to the service when search availability must be prioritized over updates (e.g., when a memory usage watermark is reached).
- ›Replication support enables high-availability distributed deployments, combining with sharding to scale collection size and cluster throughput while eliminating single points of failure.
- ›Info API now reports indexed payload point counts, allowing verification that payload values are correctly formatted for indexing.
└──▷ BREAKING ON UPGRADE
- !Distributed deployment in v0.11.0 is incompatible with previous versions due to changes required for replica set implementation; existing distributed clusters cannot be upgraded in place.
v0.10.0 Sep 19, 2022 · issue -398

Qdrant v0.10.0 adds multiple vectors per point, batch search, and full-text filtering across all filterable APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.10.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.10.0
```
└──▷ TRY IT
Index a point with separate image and text embeddings to enable multi-modal similarity search on the same collection.
```
$ curl -X PUT 'http://localhost:6333/collections/my_collection/points' \
  -H 'Content-Type: application/json' \
  -d '{
    "points": [
      {
        "id": 1,
        "vectors": {
          "image": [0.9, 0.1, 0.1, 0.2],
          "text": [0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2]
        }
      }
    ]
  }'
```
Run two similarity queries in one round-trip to cut latency when your application always needs results for multiple query vectors at once.
```
$ curl -X POST 'http://localhost:6333/collections/my_collection/points/search/batch' \
  -H 'Content-Type: application/json' \
  -d '{
    "searches": [
      { "vector": [0.2, 0.1, 0.9, 0.7], "limit": 3 },
      { "vector": [0.5, 0.3, 0.2, 0.3], "limit": 3 }
    ]
  }'
```
- ›Adds POST /collections/{collection_name}/points/search/batch endpoint for batching multiple vector queries in a single request, reducing network overhead and sharing filter computation across queries.
- ›Extends PUT /collections/{collection_name}/points to accept multiple named vectors per point (e.g. image and text vectors) alongside the existing anonymous single-vector format, enabling multi-modal embeddings on a single record.
- ›Adds full-text filtering to all filterable APIs, supporting ngram-prefix and word tokenizers to restrict queries to records containing specified words.
- ›Multi-platform Docker images now available for both x86_64 and aarch64, enabling native runs on ARM-based CPUs.
- ›scroll API performance improved by up to 1000x for strict filters.
└──▷ BREAKING ON UPGRADE
- !Fundamental changes to segment storage and API mean qdrant v0.10.1 (the follow-on release) will be incompatible with client v0.9.x; a two-step upgrade — first to v0.10.0, then to v0.10.1 — is required to maintain compatibility.
v0.9.0 Aug 8, 2022 · issue -399

Qdrant v0.9.0 adds dynamic cluster scaling with Move Shard and Peer Removal APIs, plus indexing progress visibility.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.9.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.9.0
```
└──▷ TRY IT
Poll indexing progress on a collection to know when vectors are fully indexed before serving ANN queries.
```
$ curl -X GET 'http://localhost:6333/collections/my_collection' | jq '.result.indexed_vectors_count'
```
- ›Adds Move Shard API to enable live redistribution of shards across cluster nodes for dynamic scaling.
- ›Adds Peer Removal API to safely remove nodes from a running cluster without downtime.
- ›Exposes indexed_vectors_count field in the Collection info API to report real-time indexing progress.
v0.8.5 Jul 26, 2022 · issue -400

Qdrant v0.8.5 adds full-storage snapshots, parallel segment loading, and a shard distribution API.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.8.5 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.8.5
```
- ›Adds a full storage snapshot endpoint that captures all collections and aliases in a single API call.
- ›New API for viewing the shard distribution of a collection across a distributed deployment.
- ›Automatic selection of the number of shards when creating a collection in a distributed deployment.
- ›Propagates the wait flag during distributed calls for consistent write-acknowledgement behavior.
- ›More even point distribution across shards in distributed deployments.
+2 moreshow less
- ›Better handling of DNS record changes for cluster peers, improving distributed deployment stability.
- ›Better defaults for internal call timeouts in distributed deployments.
v0.8.4 Jul 5, 2022 · issue -400

Qdrant v0.8.4 adds collection snapshots for backup/recovery and a Count API for filtered point counting.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.8.4 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.8.4
```
- ›New Snapshots API lets you create a portable snapshot of a running collection and restore it on another machine — supports backups, testing, and high-availability workflows.
- ›New Count API returns the number of points matching a given filter — enables pagination, facet search, and dataset debugging.
- ›Parallel HNSW index building now utilises multiple cores, significantly reducing index build time for large segments on multi-core systems.
v0.8.3 Jun 28, 2022 · issue -401

Qdrant v0.8.3 adds pagination support for search results.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.8.3 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.8.3
```
- ›Adds pagination of search results, enabling offset-based traversal of large result sets.
v0.8.1 Jun 16, 2022 · issue -401

Qdrant v0.8.1 adds a web-based UI for making requests to a local Qdrant instance directly from the browser.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.8.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.8.1
```
- ›New web-based UI at https://ui.qdrant.tech/ lets practitioners make requests to a local Qdrant instance directly from the browser.
v0.8.0 Jun 8, 2022 · issue -401

Qdrant v0.8.0 adds experimental distributed deployment with Raft consensus, sharding, score filtering, and on-disk payload storage.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.8.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.8.0
```
- ›Adds a Cluster status API for monitoring distributed deployment topology.
- ›Experimental distributed deployment support: cluster topology synchronization via Raft consensus protocol, collection sharding, and distributed search and updates.
- ›Adds filtering by similarity score, allowing search results to be constrained by a minimum or maximum score threshold.
- ›Adds on-disk payload storage to serve large payloads with reduced RAM usage.
- ›Adds on-flight payload indexing — Numeric, Keyword, and Geo indexes are updated via streaming without requiring a full segment rebuild.
+3 moreshow less
- ›HNSW index speed improvements that materially increase query throughput.
- ›Error responses are now returned as JSON for more machine-readable API error handling.
- ›CORS headers enabled for Swagger UI access.
└──▷ BREAKING ON UPGRADE
- !Collections created with any previous engine version are not compatible with v0.8.0 due to significant changes in payload storage — collections must be re-created from scratch after upgrading.
v0.7.0 Apr 13, 2022 · issue -403

Qdrant v0.7.0 adds arbitrary JSON payloads, new Bool/IsEmpty/ValuesCount filters, Alias API in gRPC, and order-of-magnitude faster Euclidean distance via SIMD.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.7.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.7.0
```
- ›Adds IsEmpty filter condition to match fields with no value set.
- ›Adds ValuesCount filter condition to match fields based on the number of values they contain.
- ›Adds Bool filter support and refactors the Match condition for payload filtering.
- ›Adds Alias API to gRPC, bringing it to parity with the REST API.
- ›Supports arbitrary JSON as payload — uploaded payload structure now exactly matches retrieved results, and the payload schema is used for field indexes only.
+2 moreshow less
- ›Adds geo payload indexing so that geolocation queries are processed with a dedicated index type.
- ›Euclidean metric distance computation now uses SIMD, delivering order-of-magnitude faster performance, with additional support for NEON on aarch64.
└──▷ BREAKING ON UPGRADE
- !Collections created with any previous engine version are not compatible with v0.7.0 due to significant changes in payload format; re-create all collections from scratch after upgrading.
v0.6.0 Mar 4, 2022 · issue -404

Qdrant v0.6.0 adds gRPC support for all endpoints and enriches recommend responses with payload and vector data.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.6.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.6.0
```
- ›Adds gRPC support for all endpoints, with Protobuf docs and a configuration guide to enable it.
- ›The recommend endpoint can now return payload and vector alongside results.
└──▷ BREAKING ON UPGRADE
- !Python client users must follow migration examples at https://github.com/qdrant/qdrant_client/releases/tag/v0.6.0 — the REST API itself is compatible, but the Python client interface has changed.
v0.5.1 Feb 16, 2022 · issue -405

Qdrant v0.5.1 adds improved error reporting in the collection info API and coordinate validation for geo payloads.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.5.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.5.1
```
- ›Improves error reporting in the collection info API, surfacing more detail when a collection is in a degraded or error state.
- ›Validates geo coordinates submitted via the API, rejecting out-of-range or malformed latitude/longitude values at ingestion time.
v0.5.0 Feb 3, 2022 · issue -405

Qdrant v0.5.0 adds UUID point IDs, filter-based deletion, per-operation endpoints, and multi-threaded optimization.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.5.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.5.0
```
└──▷ TRY IT
Use a UUID as a point ID when upserting, so external system IDs can map directly to Qdrant points without a translation layer.
```
$ curl -X PUT 'http://localhost:6333/collections/{collection_name}/points' \
  -H 'Content-Type: application/json' \
  -d '{"points": [{"id": "550e8400-e29b-41d4-a716-446655440000", "vector": [0.1, 0.2, 0.3], "payload": {"city": "Berlin"}}]}'
```
- ›Supports UUID as a point ID type in addition to integer IDs.
- ›Adds individual API endpoints for each collection and point operation (e.g. set_payload, separate upsert, delete, etc.) replacing the monolithic Update Collection and Update Points APIs.
- ›Enables deleting points by filter via a dedicated endpoint.
- ›Enables removing payload fields using filters via a dedicated endpoint.
- ›Includes payload and vector data in search results.
+2 moreshow less
- ›Limits segment size to improve indexing performance.
- ›Introduces multi-threaded optimizer for faster background indexing.
└──▷ BREAKING ON UPGRADE
- !Indexes created with versions prior to v0.5.0 are not compatible due to UUID support and configuration format changes; collections must be re-created from scratch.
v0.4.1 Oct 25, 2021 · issue -409

Qdrant v0.4.1 lets you retrieve payload and vectors in a single search request, with field selection and exclusion.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.4.1 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.4.1
```
- ›Supports retrieving payload alongside search results in a single request, with field selection and exclusion.

v0.3.4 Jun 20, 2021 · issue -413

Qdrant v0.3.4 adds a scroll API endpoint for paginating over filtered point sets.

└──▷ GET THIS VERSION

$ git clone --branch v0.3.4 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.3.4

└──▷ TRY IT

Page through all points matching a filter without loading the entire collection into memory.

$ curl -X POST 'http://localhost:6333/collections/{collection_name}/points/scroll' \
  -H 'Content-Type: application/json' \
  -d '{"filter": {"must": [{"key": "city", "match": {"value": "London"}}]}, "limit": 100}'

›Adds scroll_points API endpoint for paginating over collections of points with filter support.

v0.3.0 Jun 3, 2021 · issue -413

Qdrant v0.3.0 adds filterable HNSW indexing, per-collection config via API, a query planner, and collection status indicators.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.3.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.3.0
```
- ›Adds filterable HNSW index: the optimizer automatically builds an HNSW index for vectors after a specified threshold, with the index taking payload fields into account for filtered searches.
- ›Adds dynamic per-collection configuration: each collection now has individual settings that can be updated at any time via API request.
- ›Adds a query planner that decides whether to use the HNSW index based on estimated filtering cardinality.
- ›Adds a collection status indicator surfaced per collection.
v0.2.0 Apr 6, 2021 · issue -415

Qdrant v0.2.0 adds payload field indexing for number and keyword types and revamps the Search API filter schema.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.2.0 https://github.com/qdrant/qdrant.git
# already have the repo? check out this version:
$ git checkout v0.2.0
```
└──▷ TRY IT
Filter a search request using the new schema where key is a sibling of the condition object, not nested inside it.
```
$ curl -X POST 'http://localhost:6333/collections/{collection_name}/points/search' \
  -H 'Content-Type: application/json' \
  -d '{
    "vector": [0.1, 0.2, 0.3],
    "filter": {
      "should": [
        {
          "key": "city",
          "match": {
            "keyword": "London"
          }
        }
      ]
    },
    "top": 5
  }'
```
- ›Adds the ability to mark a payload field as 'indexed', enabling payload indexation for number and keyword field types (geo field index is in progress).
- ›Segments are now automatically rebuilt into MMap and indexed segments when enough vectors are stored, unlocking better performance at scale without manual intervention.
- ›Changes the Search API filter schema: the key property moves out of the condition object (e.g. match) and becomes a sibling field alongside it — existing filter queries using the old nested-key layout will break.
└──▷ BREAKING ON UPGRADE
- !The Search API filter schema has changed: key is no longer nested inside the condition object (e.g. match). It must now be a sibling field at the same level as the condition. Existing queries with the old layout (e.g. {"match": {"key": "city", "keyword": "London"}}) will break and must be updated to the new layout (e.g. {"key": "city", "match": {"keyword": "London"}}).

Qdrant

Summary

What Qdrant answers

Examples

Command line

Release history