Deep Dive Comparison: Milvus vs. Qdrant

🔶 Qdrant: ACORN Filtering & Custom HNSW

Qdrant's ACORN (Approximate Closest Observed Reach Neighbors) algorithm is the standout innovation for filtered search. Instead of post-filtering HNSW results (which degrades recall), ACORN integrates filtering directly into the graph traversal:

• In-graph filtering — Payload conditions are evaluated during traversal, maintaining recall even with 99% filter selectivity
• Adaptive expansion — Dynamically increases beam width when filter ratio is high
• Benchmarks (2026): On 10M vectors with 95% filter selectivity, ACORN achieves 98.5% recall at 2ms p99 vs. traditional post-filter HNSW at 87% recall / 8ms p99

🔷 Milvus: GPU-Accelerated Indexing & Horizontal Scale

Milvus leverages NVIDIA RAPIDS CAGRA for GPU-accelerated graph construction and search:

• GPU_IVF_PQ — Builds billion-scale indices 10–20× faster than CPU; search at 50k+ QPS per GPU node
• Horizontal query scaling — Add query nodes dynamically; each node loads a subset of segments
• Streaming insert + search — Growing segments serve real-time data while sealed segments use optimized indices
• Benchmarks (2026): 1B vectors (768d), 4×A100: 42k QPS at 95% recall, p99 < 12ms

Binary Quantization (BQ)

Both databases now support binary quantization, reducing memory by 32× (float32 → 1-bit). In 2026, BQ has matured with rescoring pipelines:

Hybrid Search (Dense + Sparse Vectors)

Both engines now natively support fusing dense and sparse vectors in a single query — critical for RAG and e-commerce search:

• Milvus — SPANN-based sparse index; supports Reciprocal Rank Fusion (RRF) and weighted sum; sparse vectors stored alongside dense in the same collection
• Qdrant — Integrated FastEmbed for SPLADE/sparse encoding; named vectors allow multiple vector types per point; native fusion via query API

Serverless Performance (2026 Benchmarks)

SDK Comparison

# === Milvus (pymilvus 2.5+) ===
from pymilvus import MilvusClient
client = MilvusClient(uri="http://localhost:19530")
client.create_collection("docs", dimension=768,
    metric_type="COSINE", auto_id=True)
client.insert("docs", [
    {"vector": [0.1]*768, "text": "hello world", "category": "greet"}
])
results = client.search("docs", [[0.1]*768], limit=5,
    filter='category == "greet"',
    output_fields=["text"])

# === Qdrant (qdrant-client 1.12+) ===
from qdrant_client import QdrantClient, models
client = QdrantClient(url="http://localhost:6333")
client.create_collection("docs",
    vectors_config=models.VectorParams(size=768,
        distance=models.Distance.COSINE))
client.upsert("docs", points=[
    models.PointStruct(id=1, vector=[0.1]*768,
        payload={"text": "hello world", "category": "greet"})
])
results = client.query_points("docs", query=[0.1]*768, limit=5,
    query_filter=models.Filter(must=[
        models.FieldCondition(key="category",
            match=models.MatchValue(value="greet"))
    ]))

// Qdrant has a first-class Rust client (it's written in Rust)
use qdrant_client::prelude::*;
use qdrant_client::qdrant::{CreateCollectionBuilder,
    Distance, VectorParamsBuilder, SearchPointsBuilder};

let client = QdrantClient::from_url("http://localhost:6334").build()?;
client.create_collection(
    CreateCollectionBuilder::new("docs")
        .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine)),
).await?;

let results = client.search_points(
    SearchPointsBuilder::new("docs", vec![0.1; 768], 5)
        .with_payload(true)
).await?;
// Milvus: No official Rust SDK — community crate `milvus-sdk` available

// === Milvus (official Go SDK) ===
import "github.com/milvus-io/milvus-sdk-go/v2/client"
c, _ := client.NewClient(ctx, client.Config{Address: "localhost:19530"})
// Create collection, insert, search with full Go API

// === Qdrant (official Go client) ===
import pb "github.com/qdrant/go-client/qdrant"
conn, _ := grpc.Dial("localhost:6334", grpc.WithInsecure())
qc := pb.NewPointsClient(conn)
// Full gRPC-based API

Self-Hosted TCO (100M vectors, 768d, 99.9% uptime)