Free Intensive Nov 21–22Free 2-day hands-on Vibecoding Intensive on Nov 21–22 at 16:00 MSK (Sat–Sun) · Live Cohort 3 starts Nov 23Join Free →Cohort 3 (Nov 23)
ReleaseInsight · On RadarQdrant Blog→ original

Qdrant 1.20 Runs BM25 Without Embeddings and Speeds Up Nested Filters 7–38x

Qdrant 1.20 ranks keyword search (the BM25 algorithm) directly over the text stored in record fields, so embeddings and sparse vectors are no longer needed. Previously, every document had to go through a model, and developers had to track average text length by hand. Now Qdrant computes that itself. Nested filters such as "store offer cheaper than N" run 7–38x faster with the new index over array elements. For hybrid RAG, it is worth testing the switch on a staging cluster.

AI-processed from Qdrant Blog; edited by Hamidun News
Qdrant 1.20 Runs BM25 Without Embeddings and Speeds Up Nested Filters 7–38x
Source: Qdrant Blog. Collage: Hamidun News.
Listen to article
Article Fact Sheet & Key Figures
ParameterDetails
Primary sourceQdrant Blog ↗
Editor-in-Chief
Test100 thousand points, three nested filters, payload already in memory
Key metric #216-bit TurboQuant halves float32 vectors without losing accuracy
Key metric #38-bit TurboQuant beats scalar quantization on 10 of 11 datasets

If you build RAG or document search, you know the awkward trade-off: vector search captures meaning well but finds exact words, function names and SKUs less reliably. That is why it is usually paired with classic keyword search ranked by BM25. This formula decides which document is more relevant: the more often a query term appears in a text and the rarer it is across the rest of the collection, the higher the result.

In the Qdrant 1.20 release, this layer became simpler: BM25 is computed directly over the text already stored in record fields (payload), without embeddings. In addition, nested filters over arrays of objects, for example over a list of store offers for one product, run 7–38x faster.

The release also adds more compact vectors and safer cluster settings.

BM25 directly from text, no embeddings

Previously, to rank full-text search with BM25, text had to be converted into sparse vectors. Every document and every query went through a separate inference step. Developers had to track average document length themselves: it was baked into each stored vector. If the data changed, updating that value required re-converting the entire collection.

In version 1.20, BM25 runs on a full-text index. You create an index on a field, for example a book title, enable BM25 scoring, and search for, say, "time travel" right away. Qdrant computes the statistics itself from the data, including average document length, so the scores are accurate without manual tuning. BM25 parameters can be changed per query, and the index does not need to be rebuilt for that. This query works everywhere in the Query API, including in hybrid setups alongside dense vectors. The older sparse-vector approach is still supported. If the text is already in the payload, you can switch to the index without re-uploading the data.

For code search, there is a new tokenizer, that is, the rule that splits text into searchable words. The standard one splits strings on spaces and punctuation, but in code, an identifier merges several words written in different styles. The new tokenizer splits them on underscores and case changes, including acronyms, so snake_case and camelCase variants match each other. The full identifier is also indexed.

Faster nested filters and more compact vectors

Imagine a product with several offers, each with its own store and price. A nested filter looks for products where a single offer satisfies all conditions at once: the right store and a price below a threshold. Previously, indexes only narrowed the set of candidates, and then Qdrant read the payload of each one, usually from disk. If many candidates remained, the filter slowed down.

Now you can create an index over array elements, where each element is stored separately. If all the filter conditions rely on such indexes for the same array, the answer is assembled without reading the payload. The API does not change, so existing queries speed up as soon as the indexes are created. In a test on 100 thousand points with three nested filters, the gain was 7 to 38 times, even when all payloads were already in memory. With disk-based storage, the authors estimate the gap is likely larger.

Quantization gained two TurboQuant types. The 16-bit variant halves the size of float32 vectors without losing accuracy. It first applies a TurboQuant rotation, which spreads values evenly across coordinates. This matters for embeddings with a few very large coordinates, such as ada-002, CLIP and Cohere. On 13 datasets, the vector reconstruction error was 7.5 times lower than float16's. On 12 datasets, the recall@10 differed from exact search by no more than 0.1 percentage points, while float16 on ada-002 and CLIP fell to 99.5%. The median search latency on an HNSW index was 81% of float16's on x86 and 83% on ARM.

The 8-bit TurboQuant accepts regular float vectors and quantizes them itself. It compresses data about fourfold, versus eightfold for the 4-bit variant. At similar latency, on 10 of 11 test datasets it delivered higher recall than scalar quantization, and on the remaining one it matched it.

Security, memory and upgrades

The ID tracker maps a point's ID to its internal location and version. Previously it always lived in RAM, at about 52 bytes per point, meaning roughly 5 GB for 100 million points. Now it can be kept on disk: either read on demand or loaded into the page cache when the segment opens. By default, it stays in RAM.

When an API key is set, the cluster's internal gRPC port now requires authentication by default and accepts only keys with write permission. The port can be bound to a separate private interface. In addition, there are snapshots to GCS and Azure Blob Storage, audit logs can be written to stdout or stderr, and log timezone can be set through an environment variable.

There are pitfalls with the upgrade. You must upgrade one minor version at a time, for example 1.18 → 1.19 → 1.20. Clusters that have only a read-only key configured will need changes before the upgrade. Inline storage now keeps original vectors only in the HNSW index file, so they follow that index's memory tier, and RAM usage may increase. Check your memory tier settings before upgrading.

The practical takeaway: if your hybrid search relies on sparse BM25 vectors, test the switch to a full-text index. For large collections, benchmark TurboQuant on your own embeddings: results on your data may differ from the authors' benchmarks.

Story

Key Questions Answered

What are the key details on BM25 directly from text, no embeddings?

Previously, to rank full-text search with BM25, text had to be converted into sparse vectors. Every document and every query went through a separate inference step. Developers had to track average document length themselves: it was baked into each stored vector. If the data changed, updating that value required re-converting the entire collection. In version 1.20, BM25 runs on a full-text index.

What are the key details on Faster nested filters and more compact vectors?

Imagine a product with several offers, each with its own store and price. A nested filter looks for products where a single offer satisfies all conditions at once: the right store and a price below a threshold. Previously, indexes only narrowed the set of candidates, and then Qdrant read the payload of each one, usually from disk. If many candidates remained, the filter slowed down. Now you can create an index over array elements, where each element is stored separately.

What are the key details on Security, memory and upgrades?

The ID tracker maps a point's ID to its internal location and version. Previously it always lived in RAM, at about 52 bytes per point, meaning roughly 5 GB for 100 million points. Now it can be kept on disk: either read on demand or loaded into the page cache when the segment opens. By default, it stays in RAM. When an API key is set, the cluster's internal gRPC port now requires authentication by default and accepts only keys with write permission. The port can be bound to a separate private interface.

ZK
Zhemal Khamidun — CPO at Alpina Digital, product manager of AlpinaGPT. Building AI products since 2019. Hamidun News is a pet project that grew into a production aggregator with 6,000+ readers.
✦ Unified AI Workspace · Nomad

Test Frontier LLMs & Autonomous Agents in One Workspace

Run Claude Opus 5.5, GPT-6, Gemini 3.1, and DeepSeek side-by-side in Nomad AI (nomadnet.ai) — unified model routing, deep research, and multimodal workflows under one subscription.

Try Nomad AI →Launch Nomad Agent
What do you think?
Loading comments…