Qdrant: High-Performance Vector Search Engine & Database

Creating a Collection & Configuring HNSW

Collections in Qdrant hold vectors and their payloads. Configure HNSW parameters and quantization at creation time.

pip install qdrant-client openai

from qdrant_client import QdrantClient
from qdrant_client.models import (
    VectorParams, Distance, HnswConfigDiff,
    ScalarQuantizationConfig, ScalarType, QuantizationConfig
)

# Connect to self-hosted or Qdrant Cloud
client = QdrantClient(url="http://localhost:6333")
# client = QdrantClient(url="https://YOUR.qdrant.io", api_key="YOUR_KEY")

# Create a collection with HNSW + scalar quantization
client.create_collection(
    collection_name="articles",
    vectors_config=VectorParams(
        size=1536,               # must match embedding model
        distance=Distance.COSINE
    ),
    hnsw_config=HnswConfigDiff(
        m=16,                    # graph connections per node (higher = better recall)
        ef_construct=200,        # build-time search width
        on_disk=False            # set True for large collections to save RAM
    ),
    quantization_config=QuantizationConfig(
        scalar=ScalarQuantizationConfig(
            type=ScalarType.INT8,   # 4x memory reduction
            quantile=0.99,
            always_ram=True         # keep quantized index in RAM for speed
        )
    )
)
print(client.get_collection("articles"))

Batch Upsert & Filtered Vector Search

Upsert vectors with payloads in batches, then search with complex payload filters.

import openai
from qdrant_client.models import PointStruct, Filter, FieldCondition, MatchValue, Range

oa = openai.OpenAI()

docs = [
    {"id": 1, "text": "RAG improves LLM accuracy with external knowledge", "category": "ai",  "year": 2024},
    {"id": 2, "text": "Qdrant supports scalar quantization",               "category": "db",  "year": 2024},
    {"id": 3, "text": "Sparse vectors enable keyword-aware search",         "category": "ai",  "year": 2023},
]

# Generate embeddings
texts = [d["text"] for d in docs]
resp = oa.embeddings.create(model="text-embedding-3-small", input=texts)
embeddings = [r.embedding for r in resp.data]

# Batch upsert
points = [
    PointStruct(
        id=d["id"],
        vector=emb,
        payload={"text": d["text"], "category": d["category"], "year": d["year"]}
    )
    for d, emb in zip(docs, embeddings)
]
client.upsert(collection_name="articles", points=points)

# Filtered search — only ai category, year >= 2024
query_vec = oa.embeddings.create(
    model="text-embedding-3-small",
    input=["how does retrieval augmented generation work"]
).data[0].embedding

results = client.search(
    collection_name="articles",
    query_vector=query_vec,
    query_filter=Filter(
        must=[
            FieldCondition(key="category", match=MatchValue(value="ai")),
            FieldCondition(key="year", range=Range(gte=2024))
        ]
    ),
    limit=3,
    with_payload=True
)
for r in results:
    print(f"score={r.score:.4f} | {r.payload['text']}")

Hybrid Search: Sparse + Dense Vectors

Combine dense semantic vectors with sparse keyword vectors in the same collection for true hybrid search.

from qdrant_client.models import (
    SparseVectorParams, SparseIndexParams,
    SparseVector, NamedSparseVector, NamedVector,
    SearchRequest, Prefetch, FusionQuery, Fusion
)

# Create collection with both dense and sparse vectors
client.create_collection(
    collection_name="hybrid_docs",
    vectors_config={"dense": VectorParams(size=1536, distance=Distance.COSINE)},
    sparse_vectors_config={"sparse": SparseVectorParams(
        index=SparseIndexParams(on_disk=False)
    )}
)

# Upsert with both vector types (sparse = BM25/SPLADE indices+values)
client.upsert(
    collection_name="hybrid_docs",
    points=[PointStruct(
        id=1,
        vector={
            "dense": dense_embedding,
            "sparse": SparseVector(indices=[42, 100, 300], values=[0.8, 0.5, 0.3])
        },
        payload={"text": "Qdrant hybrid search guide"}
    )]
)

# Hybrid query using Reciprocal Rank Fusion
results = client.query_points(
    collection_name="hybrid_docs",
    prefetch=[
        Prefetch(query=NamedVector(name="dense", vector=dense_query), limit=20),
        Prefetch(query=NamedSparseVector(name="sparse", vector=sparse_query), limit=20),
    ],
    query=FusionQuery(fusion=Fusion.RRF),   # Reciprocal Rank Fusion
    limit=5
)

Qdrant vs Pinecone vs Weaviate vs Milvus