What is Inverted File Index (IVF)?

Inverted File Index, or IVF, is an Approximate Nearest Neighbor indexing method that speeds up vector search by dividing the vector space into groups and searching only the most relevant groups for each query.

Instead of comparing a query with every stored vector, IVF first asks:

Which cluster is this query closest to?

Then it searches vectors mainly inside a small number of nearby clusters.

Core idea

Suppose a RAG system contains 10 million embeddings.

A flat search may compare the query with all 10 million vectors.

IVF first partitions those vectors into many clusters.

For example:

10 million vectors → divided into 1,000 clusters → each cluster contains vectors from a similar region of the embedding space

At query time, IVF finds the cluster centroids closest to the query and searches only those selected clusters.

How is the index created?

IVF typically uses a clustering step, commonly based on k-means.

The process is roughly:

Embeddings → learn cluster centroids → assign each vector to its nearest centroid → maintain a list of vectors for each centroid

Each centroid therefore acts like an entry point to a region of the vector space.

The lists associated with those centroids are the “inverted lists.”

How does search work?

For a query:

Query → create query embedding → compare query with cluster centroids → choose the nearest clusters → search vectors inside those clusters → return Top-K results

Because only part of the database is searched, retrieval can be much faster than exhaustive search.

Why is IVF approximate?

A relevant vector may exist in a cluster that was not selected.

If IVF searches only one cluster, it is fast but may miss good candidates near cluster boundaries.

Searching more clusters improves recall, but also increases latency.

This trade-off is controlled by a parameter commonly called nprobe.

Higher nprobe:

• Searches more clusters
• Usually improves recall
• Increases query cost

Lower nprobe:

• Searches fewer clusters
• Reduces latency
• May miss relevant neighbors

Important index parameter: number of clusters

IVF also depends on how many clusters are created.

Too few clusters:

• Each cluster becomes large
• More vectors must be scanned inside each selected cluster

Too many clusters:

• Clusters become smaller
• Index training and tuning become more sensitive
• You may need to probe more clusters to maintain recall

So cluster count and nprobe should be tuned together.

Why IVF is useful in RAG

IVF is useful when:

• The vector collection is large
• Exact search is too slow
• Memory efficiency matters
• Some approximation is acceptable
• You want explicit control over how much of the index is searched

It can also be combined with Product Quantization to create IVF-PQ, which reduces memory usage further.

IVF vs HNSW at a high level

HNSW navigates a graph.

IVF narrows the search using clusters.

HNSW is often chosen for strong low-latency recall when memory is available.

IVF can be attractive for very large collections, especially when combined with compression techniques such as PQ.

The better choice depends on scale, latency targets, recall requirements, memory, and update patterns.

Interview takeaway

IVF is a vector index that partitions embeddings into clusters and stores vectors in inverted lists associated with cluster centroids. At query time, it searches only the nearest clusters instead of the full vector collection. This reduces latency, but recall depends on how well the vectors are clustered and how many clusters are searched, usually controlled by nprobe.