Technical Articles on Qdrant - Vector Search Engine

miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier

info@qdrant.tech (Andrey Vasnetsov) — Thu, 08 Oct 2026 09:00:00 +0200

Sparse neural retrieval finally started getting more and more attention (SPARSEUP, MILCO, sparse encoders in Sentence Transformers…). Well, amazing, we like attention!

Our miniCOIL v1 sparse neural retriever article ended with a promise: to keep working on this sparse neural retriever in-depth, improving the model’s quality, and in-width, “extending it to other dense encoders and to languages beyond English.”

Here is the next “in-width” step of the miniCOIL saga: to try and cross the language barrier, that is, make the model suitable for multilingual retrieval.
It’s a fun challenge, as sparse retrievers are hard to adapt to this scenario: exact matching in cross-lingual text search usually means translation.

Why Hyperbolic Embeddings Matter for Hierarchical Data

info@qdrant.tech (Andrey Vasnetsov) — Tue, 08 Sep 2026 00:00:00 +0000

We choose embedding models, dimensions, and indexes. The geometry usually comes with the package. But why use a flat space, and what else could we choose?

What Is a Manifold, and Where Do Our Vectors Live?

A manifold is the space our embeddings live in. For embeddings, we care about the geometry we give that space. It determines how we measure distance, what the shortest path looks like, and how much room there is as we move outward.

Predicting Weak Retrieval Without an LLM

info@qdrant.tech (Andrey Vasnetsov) — Wed, 24 Jun 2026 00:00:00 +0300

Most retrieval systems run one pipeline on every query, and it is the wrong default in both directions: a single pass under-serves the hard queries, while reranking or rewriting every query wastes compute on the easy ones. Worse, the single pass fails silently. When the relevant document never reaches the top, the system answers anyway from whatever it got, with no sign anything went wrong.

The expensive fixes are well understood, cross-encoders, ColBERT late interaction, query rewriting, and decomposition, so the real question is when to spend them: ideally you catch a weak retrieval cheaply, before paying for any of them, and escalate only the queries that need it. But what tells you, cheaply, that a retrieval is weak? That depends on how your retrieval fails, and we measure it across three corpora.

Universal I/O in Qdrant

info@qdrant.tech (Andrey Vasnetsov) — Mon, 12 Oct 2026 00:00:00 +0000

Most software is built on an unspoken assumption: data lives on disk, and is read from and written to it. The assumption usually holds, until a new way (or need) of storing data appears.

For Qdrant, that happened with serverless mode, where the data sits in object storage instead of on a disk next to the process. This blog tells the story of Universal I/O, the interface we built so that the same code could work in both worlds, and of the design choices that keep the local path cheap. This read is particularly relevant if you are a systems programmer, and some knowledge of Rust will help you follow the code, but the lessons should carry over to many other kinds of software.

Filtered Vector Search: What ACORN Fixes, and What Fixes ACORN

info@qdrant.tech (Andrey Vasnetsov) — Fri, 07 Aug 2026 00:00:00 +0000

Filtered vector search breaks when metadata filters turn a healthy nearest-neighbor graph into scattered islands. HNSW’s m parameter controls how many links each point gets. At Qdrant’s default m=16, the one-million-point collection benchmarked in this article averaged about 21 links per node on layer 0. Filter out 96% of the points and fewer than one link per node survives on average, so traversal can get stranded before it reaches the true nearest matches.

TurboQuant in Qdrant

info@qdrant.tech (Andrey Vasnetsov) — Wed, 13 May 2026 10:00:00 +0200

If you run production vector workloads, you already know the compression ladder in Qdrant: float32 is the baseline, Scalar Quantization (SQ) compresses vectors by 4x with almost no recall hit, and Binary Quantization (BQ) packs vectors at 16x or 32x.

Qdrant 1.18 ships TurboQuant, a new rotation-based vector quantization method from Google Research, with extensions that make it work on real production embeddings. Summarizing the results of benchmarks across public embedding datasets:

Relevance Feedback in Qdrant

info@qdrant.tech (Andrey Vasnetsov) — Fri, 20 Feb 2026 00:00:00 +0300

In March 2025, we dropped a statement-bomb in the “Relevance Feedback in Information Retrieval” article and then went silent.

We claimed that even though the information retrieval research field has proposed many useful mechanisms for increasing the relevance of search results, none of them made it to the neural search industry, simply because these approaches are not scalable.

Certainly, there are methods widely used to improve the relevance of retrieved results: query rewriting, for example. Yet none of the vector search solutions out there have tried to use the possibilities that come with full access to the vector search index: traversing it in the direction of relevance, instead of guessing where to shoot the query to the vector space.

miniCOIL: on the Road to Usable Sparse Neural Retrieval

info@qdrant.tech (Andrey Vasnetsov) — Tue, 13 May 2025 00:00:00 +0300

Have you ever heard of sparse neural retrieval? If so, have you used it in production?

It’s a field with excellent potential – who wouldn’t want to use an approach that combines the strengths of dense and term-based text retrieval? Yet it’s not so popular. Is it due to the common curse of “What looks good on paper is not going to work in practice”??

This article describes our path towards sparse neural retrieval as it should be – lightweight term-based retrievers capable of distinguishing word meanings.

Data Exploration with Qdrant's Distance Matrix API

info@qdrant.tech (Andrey Vasnetsov) — Tue, 11 Mar 2025 12:00:00 +0300

Hidden Structure

When working with large collections of documents, images, or other arrays of unstructured data, it often becomes useful to understand the big picture. Examining data points individually is not always the best way to grasp the structure of the data.

Datapoints without context, pretty much useless

As numbers in a table obtain meaning when plotted on a graph, visualizing distances (similar/dissimilar) between unstructured data items can reveal hidden structures and patterns.

Introducing Gridstore: Qdrant's Custom Key-Value Store

info@qdrant.tech (Andrey Vasnetsov) — Wed, 05 Feb 2025 00:00:00 +0000

Why We Built Our Own Storage Engine

Databases need a place to store and retrieve data. That’s what Qdrant’s key-value storage does—it links keys to values.

When we started building Qdrant, we needed to pick something ready for the task. So we chose RocksDB as our embedded key-value store.

It is mature, reliable, and well-documented.

Over time, we ran into issues. Its architecture required compaction (uses LSMT), which caused random latency spikes. It handles generic keys, while we only use it for sequential IDs. Having lots of configuration options makes it versatile, but accurately tuning it was a headache. Finally, interoperating with C++ slowed us down (although we will still support it for quite some time).

Relevance Feedback in Information Retrieval

info@qdrant.tech (Andrey Vasnetsov) — Thu, 27 Mar 2025 00:00:00 +0300

A problem well stated is a problem half solved.

This quote applies as much to life as it does to information retrieval.

With a well-formulated query, retrieving the relevant document becomes trivial. In reality, however, most users struggle to precisely define what they are searching for.

While users may struggle to formulate a perfect request — especially in unfamiliar topics — they can easily judge whether a retrieved answer is relevant or not.

Why Vector Search Needs a Dedicated Database

info@qdrant.tech (Andrey Vasnetsov) — Mon, 17 Feb 2025 10:00:00 +0300

Any problem with even a bit of complexity requires a specialized solution. You can use a Swiss Army knife to open a bottle or poke a hole in a cardboard box, but you will need an axe to chop wood — the same goes for software.

In this article, we will describe the unique challenges vector search poses and why a dedicated solution is the best way to tackle them.

What is Agentic RAG? Building Agents with Qdrant

info@qdrant.tech (Andrey Vasnetsov) — Fri, 22 Nov 2024 00:00:00 +0000

Standard Retrieval Augmented Generation follows a predictable, linear path: receive a query, retrieve relevant documents, and generate a response. In many cases that might be enough to solve a particular problem. In the worst case scenario, your LLM will just decide to not answer the question, because the context does not provide enough information.

A standard RAG pipeline is a fixed path. Step through it from the query to the answer.

On the other hand, we have agents. These systems are given more freedom to act, and can take multiple non-linear steps to achieve a certain goal. There isn’t a single definition of what an agent is, but in general, it is an application that uses LLM and usually some tools to communicate with the outside world. LLMs are used as decision-makers which decide what action to take next. Actions can be anything, but they are usually well-defined and limited to a certain set of possibilities. One of these actions might be to query a vector database, like Qdrant, to retrieve relevant documents, if the context is not enough to make a decision. However, RAG is just a single tool in the agent’s arsenal.

Modern Sparse Neural Retrieval: From DeepCT to SPLADE++

info@qdrant.tech (Andrey Vasnetsov) — Wed, 23 Oct 2024 00:00:00 +0000

Finding enough time to study all the modern solutions while keeping your production running is rarely feasible. Dense retrievers, hybrid retrievers, late interaction… How do they work, and where do they fit best? If only we could compare retrievers as easily as products on Amazon!

We explored the most popular modern sparse neural retrieval models and broke them down for you. By the end of this article, you’ll have a clear understanding of the current landscape in sparse neural retrieval and how to navigate through complex, math-heavy research papers with sky-high NDCG scores without getting overwhelmed.

Immutable Data Structures in Qdrant

info@qdrant.tech (Andrey Vasnetsov) — Tue, 20 Aug 2024 10:45:00 +0200

Data Structures 101

Those who took programming courses might remember that there is no such thing as a universal data structure. Some structures are good at accessing elements by index (like arrays), while others shine in terms of insertion efficiency (like linked lists).

The same twelve cells read in order, scattered and linked by pointers or contiguous in an array. Positions are illustrative.

However, when we move from theoretical data structures to real-world systems, and particularly in performance-critical areas such as vector search, things become more complex. Big-O notation provides a good abstraction, but it doesn’t account for the realities of modern hardware: cache misses, memory layout, disk I/O, and other low-level considerations that influence actual performance.

Discovery Search in Qdrant

info@qdrant.tech (Andrey Vasnetsov) — Wed, 31 Jan 2024 08:00:00 -0300

Discovery needs context

When Christopher Columbus and his crew sailed to cross the Atlantic Ocean, they were not looking for the Americas. They were looking for a new route to India because they believed the Earth was small enough to reach India by sailing west. They didn’t know anything about a new continent, but since they were going west, they stumbled upon it.

They couldn’t reach their target, because the geography didn’t let them, but once they realized it wasn’t India, they claimed it a new “discovery” for their crown. If we consider that sailors need water to sail, then we can establish a context which is positive in the water, and negative on land. Once the sailor’s search was stopped by the land, they could not go any further, and a new route was found. Let’s keep these concepts of target and context in mind as we explore the new functionality of Qdrant: Discovery search.

What is a Vector Database?

info@qdrant.tech (Andrey Vasnetsov) — Wed, 09 Oct 2024 09:29:33 -0300

An Introduction to Vector Databases

Most of the millions of terabytes of data we generate each day is unstructured. Think of the meal photos you snap, the PDFs shared at work, or the podcasts you save but may never listen to. None of it fits neatly into rows and columns.

Unstructured data lacks a strict format or schema, making it challenging for conventional databases to manage. Yet, this unstructured data holds immense potential for AI, machine learning, and modern search engines.

Late Interaction Retrieval with Dense Token Embeddings

info@qdrant.tech (Andrey Vasnetsov) — Wed, 14 Aug 2024 00:00:00 +0000

You Can Adapt Dense Embedding Models for Late Interaction

Qdrant 1.10 introduced support for multi-vector representations, with late interaction being a prominent example of this model. In essence, both documents and queries are represented by multiple vectors, and identifying the most relevant documents involves calculating a score based on the similarity between the corresponding query and document embeddings. If you’re not familiar with this paradigm, the Late Interaction Basics lesson of our Multi-Vector Search course explains why late interaction can retrieve better results than single-vector search.

Faster Disk I/O for Vector Search Using io_uring

info@qdrant.tech (Andrey Vasnetsov) — Wed, 21 Jun 2023 09:45:00 +0200

With Qdrant version 1.3.0 we introduce the alternative io_uring based async uring storage backend on Linux-based systems. Since its introduction, io_uring has been known to improve async throughput wherever the OS syscall overhead gets too high, which tends to occur in situations where software becomes IO bound (that is, mostly waiting on disk).

Input+Output

Around the mid-90s, the internet took off. The first servers used a process- per-request setup, which was good for serving hundreds if not thousands of concurrent request. The POSIX Input + Output (IO) was modeled in a strictly synchronous way. The overhead of starting a new process for each request made this model unsustainable. So servers started forgoing process separation, opting for the thread-per-request model. But even that ran into limitations.

What is Vector Quantization?

info@qdrant.tech (Andrey Vasnetsov) — Wed, 25 Sep 2024 09:29:33 -0300

Vector quantization is a data compression technique used to reduce the size of high-dimensional data. Compressing vectors reduces memory usage while maintaining nearly all of the essential information. This method allows for more efficient storage and faster search operations, particularly in large datasets.

When working with high-dimensional vectors, such as embeddings from providers like OpenAI, a single 1536-dimensional vector requires 6 KB of memory.

With 1 million vectors needing around 6 GB of memory, as your dataset grows to multiple millions of vectors, the memory and processing demands increase significantly.

BM42: Attention-Based Sparse Embeddings for Hybrid Search

info@qdrant.tech (Andrey Vasnetsov) — Mon, 01 Jul 2024 12:00:00 +0300

For the last 40 years, BM25 has served as the standard for search engines. It is a simple yet powerful algorithm that has been used by many search engines, including Google, Bing, and Yahoo.

Vector Similarity: Going Beyond Full-Text Search

info@qdrant.tech (Andrey Vasnetsov) — Tue, 08 Aug 2023 08:00:00 +0300

When making use of unstructured data, there are traditional go-to solutions that are well-known for developers:

Full-text search when you need to find documents that contain a particular word or phrase.
Vector search when you need to find documents that are semantically similar to a given query.

Today, the two usually run together: hybrid search fuses keyword and vector results into one ranking. That makes it easy to see vector similarity as just an extension of full-text search.

Filterable HNSW Without Recall Loss

info@qdrant.tech (Andrey Vasnetsov) — Sun, 24 Nov 2019 22:44:08 +0300

Note: This article describes the original design for filterable HNSW, proposed in 2019. It is not a complete description of how Qdrant performs filtered vector search today. For learning more, see our Qdrant Beginners course: Fast Approximate Search: HNSW. For the cases this page does not explain, see Filtered Vector Search: What ACORN Fixes, and What Fixes ACORN.

If you need to find some similar objects in vector space, provided e.g. by embeddings or matching NN, you can choose among a variety of libraries: Annoy, FAISS or NMSLib. All of them will give you a fast approximate neighbors search within almost any space.

Understanding Retrieval-Augmented Generation (RAG)

info@qdrant.tech (Andrey Vasnetsov) — Tue, 19 Mar 2024 09:29:33 -0300

Retrieval-augmented generation (RAG) integrates external information retrieval into the process of generating responses by Large Language Models (LLMs). It searches a database for information beyond its pre-trained knowledge base, significantly improving the accuracy and relevance of the generated responses.

Language models have exploded on the internet ever since ChatGPT came out, and rightfully so. They can write essays, code entire programs, and even make memes (though we’re still deciding on whether that’s a good thing).

Detecting Dataset Errors with Similarity Search

info@qdrant.tech (Andrey Vasnetsov) — Mon, 18 Jul 2022 10:18:00 +0000

Nowadays, people create a huge number of applications of various types and solve problems in different areas. Despite such diversity, they have something in common - they need to process data. Real-world data is a living structure, it grows day by day, changes a lot and becomes harder to work with.

In some cases, you need to categorize or label your data, which can be a tough problem given its scale. The process of splitting or labelling is error-prone and these errors can be very costly. Imagine that you failed to achieve the desired quality of the model due to inaccurate labels. Worse, your users are faced with a lot of irrelevant items, unable to find what they need and getting annoyed by it. Thus, you get poor retention, and it directly impacts company revenue. It is really important to avoid such errors in your data.

Is RAG Dead? Why Long Context Windows Don't Replace RAG

info@qdrant.tech (Andrey Vasnetsov) — Tue, 04 Aug 2026 00:00:00 +0000

Is RAG Dead? Long Context Windows versus Retrieval

Every time a model ships a larger context window, someone declares that retrieval augmented generation (RAG) is obsolete. If a model can read a million tokens, why build a retrieval pipeline?

A larger window changes the trade-off, but it does not remove it. This article reviews what published measurements say about quality, cost, and latency, and explains when each approach fits. Where a number comes from a paper, a vendor page, or our own calculation, the text says so. The sources are listed at the end.

MUVERA: Making Multivectors More Performant

info@qdrant.tech (Andrey Vasnetsov) — Fri, 05 Sep 2025 00:00:00 +0000

What are MUVERA Embeddings?

Multi-vector representations are superior to single-vector embeddings in many benchmarks. It might be tempting to use them right away, but there is a catch: they are slower to search. Traditional vector search structures like HNSW are optimized for retrieving the nearest neighbors of a single query vector using simple metrics such as cosine similarity. These indexes are not suitable for multi-vector retrieval strategies, such as MaxSim, where a query and document are each represented by multiple vectors and the final score is computed as the maximum similarity over all cross-pairings. MaxSim is inherently asymmetric and non-metric, so HNSW could potentially help us find the closest document token to a given query token, but that does not mean the whole document is the best hit for the query.

Vector Embeddings Explained: How They Work in ML & Search

info@qdrant.tech (Andrey Vasnetsov) — Tue, 06 Feb 2024 15:29:33 -0300

Embeddings are numerical machine learning representations of the semantics of the input data. They capture the meaning of complex, high-dimensional data, like text, images, or audio, into vectors. Enabling algorithms to process and analyze the data more efficiently.

You know when you’re scrolling through your social media feeds and the content just feels incredibly tailored to you? There’s the news you care about, followed by a perfect tutorial with your favorite tech stack, and then a meme that makes you laugh so hard you snort.

Neural Search 101: A Complete Guide and Step-by-Step Tutorial

info@qdrant.tech (Andrey Vasnetsov) — Thu, 10 Jun 2021 10:18:00 +0000

Neural Search 101: A Comprehensive Guide and Step-by-Step Tutorial

Information retrieval technology is one of the main technologies that enabled the modern Internet to exist. These days, search technology is the heart of a variety of applications. From web-pages search to product recommendations. For many years, this technology didn’t get much change until neural networks came into play.

In this guide we are going to find answers to these questions:

Understanding SPLADE and Sparse Vectors

info@qdrant.tech (Andrey Vasnetsov) — Sat, 09 Dec 2023 13:00:00 +0300

Think of a library with a vast index card system. Each index card only has a few keywords marked out (sparse vector) of a large possible set for each book (document). This is what sparse vectors enable for text.

What are sparse and dense vectors?

Sparse vectors are like the Marie Kondo of data: they keep only what sparks joy (or relevance, in this case).

Consider a simplified example of 2 documents, each with 200 words. A dense vector would have several hundred non-zero values, whereas a sparse vector could have, much fewer, say only 20 non-zero values.

Product Quantization for Vector Search

info@qdrant.tech (Andrey Vasnetsov) — Tue, 30 May 2023 09:45:00 +0200

Product Quantization Demystified: Streamlining Efficiency in Data Management

Qdrant 1.1.0 brought the support of Scalar Quantization, a technique of reducing the memory footprint by even four times, by using int8 to represent the values that would be normally represented by float32.

The memory usage in vector search can be reduced even further with Product Quantization, available since Qdrant 1.2.0.

What is Product Quantization?

Product Quantization converts floating-point numbers into integers like every other quantization method. However, the process is slightly more complicated than Scalar Quantization and is more customizable, so you can find the sweet spot between memory usage and search precision. This article covers all the steps required to perform Product Quantization and the way it’s implemented in Qdrant.

Advanced Introduction to Triplet Loss

info@qdrant.tech (Andrey Vasnetsov) — Thu, 24 Mar 2022 15:12:00 +0300

What is Triplet Loss?

Triplet Loss was first introduced in FaceNet: A Unified Embedding for Face Recognition and Clustering in 2015, and it has been one of the most popular loss functions for supervised similarity or metric learning ever since. In its simplest explanation, Triplet Loss encourages that dissimilar pairs be distant from any similar pairs by at least a certain margin value. Mathematically, the loss value can be calculated as $L=max(d(a,p) - d(a,n) + m, 0)$, where:

Scalar Quantization for Vector Search

info@qdrant.tech (Andrey Vasnetsov) — Mon, 27 Mar 2023 10:45:00 +0100

Efficiency Unleashed: The Power of Scalar Quantization

High-dimensional vector embeddings can be memory-intensive, especially when working with large datasets consisting of millions of vectors. Memory footprint really starts being a concern when we scale things up. A simple choice of the data type used to store a single number impacts even billions of numbers and can drive the memory requirements crazy. The higher the precision of your type, the more accurately you can represent the numbers. The more accurate your vectors, the more precise is the distance calculation. But the advantages stop paying off when you need to order more and more memory.

Metric Learning Tips & Tricks

info@qdrant.tech (Andrey Vasnetsov) — Sat, 15 May 2021 10:18:00 +0000

How to train object matching model with no labeled data and use it in production

In 2021, most machine-learning-related business cases were solved as classification problems. Classification algorithms are so well studied in practice that even if the original problem is not directly a classification task, it is usually decomposed or approximately converted into one.

However, despite its simplicity, the classification task has requirements that could complicate its production integration and scaling. E.g. it requires a fixed number of classes, where each class should have a sufficient number of training samples.

Minimal RAM to Serve 1M Vectors

info@qdrant.tech (Andrey Vasnetsov) — Wed, 07 Dec 2022 10:18:00 +0000

When it comes to measuring the memory consumption of our processes, we often rely on tools such as htop to give us an indication of how much RAM is being used. However, this method can be misleading and doesn’t always accurately reflect the true memory usage of a process.