Qdrant

Qdrant is a high-performance, open-source vector similarity search engine and database written in Rust. With over 30,000 GitHub stars, it is designed for production-grade applications requiring fast, filtered vector search with rich payload support and horizontal scalability.

Repository	github.com/qdrant/qdrant
License	Apache 2.0
Language	Rust
Stars	30K+
Category	Vector Database

Key Features

Written in Rust – Memory-safe, zero-cost abstractions, and exceptional performance without garbage collection pauses
Filterable HNSW – Extended HNSW index with filter-aware edges for efficient filtered vector search
Rich Payload Support – Attach JSON metadata to vectors with keyword, float, geo, and datetime index types
Quantization – Scalar and product quantization for memory reduction while maintaining search quality
Distributed Mode – Horizontal scaling with sharding and replication for high availability
Dual API – Both REST and gRPC interfaces for flexibility and performance
Multi-Vector Support – Store multiple named vectors per point for different embedding models

Architecture

Qdrant is designed as a standalone service with a focus on performance and operational simplicity:

Storage Engine – Segments-based architecture where each collection is divided into segments containing vectors, payloads, and indexes
HNSW Index – Multi-layered graph structure enabling sublinear search scaling (logarithmic with dataset size)
Payload Indexes – Separate indexes for structured metadata enabling efficient pre-filtering
WAL – Write-ahead log for durability and crash recovery
Consensus – Raft-based consensus for distributed deployments

graph TB subgraph API["API Layer"] REST[REST API] GRPC[gRPC API] end subgraph Engine["Search Engine"] Router[Query Router] Planner[Query Planner] Filter[Filter Engine] end subgraph Collections["Collection Layer"] C1[Collection 1] C2[Collection 2] end subgraph Segments["Segment Storage"] HNSW[HNSW Index] Payload[Payload Index] Vectors[Vector Storage] WAL[Write-Ahead Log] end subgraph Distributed["Distributed Layer"] Shard[Sharding] Replica[Replication] Raft[Raft Consensus] end API --> Engine Engine --> Collections Collections --> Segments Collections --> Distributed

HNSW Configuration

HNSW performance is controlled through three primary parameters:

m – Controls graph connectivity (edges per node). Larger values increase accuracy but require more memory. Default: 16
ef_construct – Neighbors considered during index building. Larger values improve accuracy but increase build time. Default: 100
hnsw_ef – Set at search time to balance speed vs recall. Default: 128; lower (32) for speed, higher (256) for accuracy

For small datasets below the full_scan_threshold (default 10,000 KB), Qdrant automatically uses brute-force search for better performance.

Filterable HNSW

Qdrant extends standard HNSW by adding extra edges based on indexed payload values, enabling efficient searches under structured conditions without full-scan operations. Key considerations:

Payload fields are not indexed by default – you must explicitly define which fields to index
Best practice: create payload indexes before uploading data so HNSW builds filter-aware links from the start
Supported index types: KEYWORD (categorical), FLOAT (numerical ranges), GEO (spatial), DATETIME (temporal)

Code Example

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance, VectorParams, PointStruct,
    Filter, FieldCondition, MatchValue,
    PayloadSchemaType
)
 
client = QdrantClient(host="localhost", port=6333)
 
# Create collection with HNSW configuration
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=768, distance=Distance.COSINE,
        hnsw_config={"m": 16, "ef_construct": 100}
    )
)
 
# Create payload index BEFORE inserting data
client.create_payload_index(
    collection_name="documents",
    field_name="category",
    field_schema=PayloadSchemaType.KEYWORD
)
 
# Insert vectors with payloads
client.upsert(
    collection_name="documents",
    points=[
        PointStruct(id=1, vector=[0.1] * 768,
                    payload={"title": "RAG Guide", "category": "ai"}),
        PointStruct(id=2, vector=[0.2] * 768,
                    payload={"title": "SQL Basics", "category": "database"}),
    ]
)
 
# Filtered vector search
results = client.search(
    collection_name="documents",
    query_vector=[0.15] * 768,
    query_filter=Filter(
        must=[FieldCondition(key="category", match=MatchValue(value="ai"))]
    ),
    limit=5
)
for r in results:
    print(f"{r.payload['title']}: {r.score:.4f}")

Table of Contents