ColBERTSaR: Sparsified ColBERT Index via Product Quantization @EYangTW et al. present an embedding quantization method that turns a ColBERT index into a true inverted index, yielding an index 50-70% smaller than 1-bit PLAID. https://arxiv.org/abs/2606.05568 https://github.com/hltcoe/ColBERTSaR…

ColBERTSaR: Sparsified ColBERT Index via Product Quantization

Source: https://arxiv.org/html/2606.05568 ,Andrew YatesJohns Hopkins UniversityBaltimoreMDUSA[email protected],Dawn LawrieJohns Hopkins UniversityBaltimoreMDUSA[email protected],James MayfieldJohns Hopkins UniversityBaltimoreMDUSA[email protected],Saron SamuelJohns Hopkins UniversityBaltimoreMDUSA[email protected]andRohan JhaJohns Hopkins UniversityBaltimoreMDUSA[email protected]

(2026)

Abstract.

While ColBERT is an effective neural retrieval architecture, it requires a heavy index structure to support candidate set retrieval based on approximated token embeddings, gathering and decompressing document token embeddings, and applying the MaxSim operation. Indexes in PLAID and similar ColBERT implementations require five to ten times the disk storage of the original raw text, which limits their scalability. Furthermore, prior work has identified that the gathering and decompression stages are the primary inefficiencies at query time. Limiting the number of document tokens that must be gathered by thresholding and score approximation does not eliminate the need for the entire index to support ad hoc queries. In this work, we propose an embedding quantization approach that turns a ColBERT index into a true inverted index. We show that, theoretically, ColBERT with embedding quantization is equivalent to learned-sparse retrieval except for the scoring mechanism. Empirically, we demonstrate that our index is 50-70% smaller than a one-bit PLAID index while retaining retrieval effectiveness.

sparse compression, score approximation, K-means clustering

††journalyear:2026††copyright:cc††conference:Proceedings of the 49th International ACM SIGIR Conference on Research and Development in Information Retrieval; July 20–24, 2026; Melbourne, VIC, Australia††booktitle:Proceedings of the 49th International ACM SIGIR Conference on Research and Development in Information Retrieval (SIGIR ’26), July 20–24, 2026, Melbourne, VIC, Australia††doi:10.1145/3805712.3809920††isbn:979-8-4007-2599-9/2026/07††ccs:Information systems Retrieval efficiency††ccs:Information systems Search index compression††ccs:Information systems Search engine indexing## 1.Introduction

Multi-vector dense retrieval models, such as ColBERT(Khattab and Zaharia,2020)and XTR(Lee et al.,2024)are effective because of their expressiveness in modeling. While similar to single-vector dense models that represent information with a single contextualized embedding, such as DPR(Karpukhin et al.,2020)and Qwen3-Embedding(Zhang et al.,2025), multi-vector models use multiple vectors for each document to capture more granular information(Formal et al.,2021c). However, the number of vectors produced depends on the length of the documents; this creates efficiency challenges because this number is typically several orders of magnitude greater than for single vector representations. Subsequent work (PLAID(Santhanam et al.,2022a)) addresses this problem by storing the vectors in an inverted file index (IVF) and by using product quantization via heavily compressed residuals(Johnson et al.,2019; Ge et al.,2013; Santhanam et al.,2022a). Abstractly, at search time, PLAID first gathers document vectors that are similar to the query token vectors from the IVF, filters them using heuristics, and finally decompresses all document token vectors of the candidate documents to perform the actual scoring. Prior work has explored techniques such as token routing(Li et al.,2023), score imputation(Lee et al.,2024; Scheerer et al.,2025), fast decompression(Scheerer et al.,2025), instruction set optimization(Nardini et al.,2024), and replacing the initial candidate search with more efficient models(MacAvaney and Tonellotto,2024; Formal et al.,2024)or even replacing the entire backbone with a smaller model(Wang et al.,2023)to reduce query latency. However, these lines of work do not address the index size problem. For one million documents, each with 512 tokens (a moderate size for a collection taking 1 to 3 GB to store without compression), PLAID still takes more than 7.8 GB to store aggressive 1-bit compressed residuals for the default ColBERT embedding size of 128. This size doubles or quadruples if using 2 or 4-bit compression(Santhanam et al.,2022a), becoming an order of magnitude larger than the raw text.

Sparse retrieval, on the other hand, has a much smaller storage footprint. Since each document is represented by its unique tokens and impact scores(Mackenzie et al.,2022), the index size is much smaller than in ColBERT, where each token maps to a dense vector (see Table3for comparison). Recent work in learned sparse retrieval (LSR) such as SPLADE(Formal et al.,2021b; Formal et al.,2021a; Lassance et al.,2024)and MILCO(Nguyen et al.,2025)has improved model effectiveness substantially by mapping each document to a set of inferred tokens; this still keeps the index size manageable(Nguyen et al.,2023; Mallia et al.,2021).

Interestingly, without the residual, PLAID is essentially a sparse retrieval with a binary document weight (more in the next section). However, residuals, while composing most of the index storage, are critical for calculating the approximated ColBERT score in PLAID (see Table2for empirical results). To remove the dependency on residual vectors we introduce ColBERTSaR, a sparse approximation of the MaxSim score of any ColBERT-style model without retraining the retrieval model and storing the residuals. ColBERTSaR is a drop-in replacement for PLAID that transforms ColBERT into a sparse retrieval model. ColBERTSaR substantially reduces PLAID’s index size while providing competitive effectiveness. In this work, we 1) provide a theoretical derivation of the ColBERTSaR sparse approximation; 2) establish strong connections between ColBERT and LSR models; and 3) present empirical results on monolingual, cross-language, and multilingual retrieval using a proof-of-concept implementation.111https://github.com/hltcoe/ColBERTSaR

2.ColBERTSaR

2.1.Sparse Approximation of MaxSim

MaxSim, proposed byKhattab and Zaharia (2020), aggregates the pairwise similarities between query and document token embeddings, which are implemented as the dot products of L2-normalized embeddings. Letqi∈qq_{i}\in qanddj∈dd_{j}\in dbe the token embeddings of queryqqand documentdd. MaxSim can be written as

(1)S​c​o​r​e​(q,d)=∑i=1|q|maxj=1|d|⁡(qi⋅dj)Score(q,d)=\sum_{i=1}^{|q|}\max_{j=1}^{|d|}\left(q_{i}\cdot d_{j}\right)where|q||q|and|d||d|denote the length of the query and document.

While expressive and effective, this process is expensive in two ways. First, while all inner product pairs are needed to find the maximum, only a few contribute to the final score (specifically|q|/|d||q|/|d|, which is 6.25% when query and document lengths are 32 and 512, a common setting). Second, storing|d||d|embeddings is expensive. ColBERT(Khattab and Zaharia,2020)stored all embeddings with 16-bit floats for each of the 128 dimensions. PLAID(Santhanam et al.,2022a)further compressed the embeddings as a cluster centroid and a residual with several bits per coordinate. The MaxSim scoring function can be rewritten as:

(2)S​c​o​r​e​(q,d)=∑i=1|q|maxj=1|d|⁡(qi⋅(cdj+rj))Score(q,d)=\sum_{i=1}^{|q|}\max_{j=1}^{|d|}\left(q_{i}\cdot\left(c_{d_{j}}+r_{j}\right)\right)wherecdjc_{d_{j}}is the closest anchor todjd_{j}andrj=dj−cdjr_{j}=d_{j}-c_{d_{j}}is the residual embedding (which can be assigned at indexing time).222To avoid defining excessive variables, we abuse notation to usedjd_{j}in subscript to denote the closest anchor ID, which formally iscdj=arg​maxck⁡ck⋅djc_{d_{j}}=\operatorname*{arg\,max}_{c_{k}}c_{k}\cdot d_{j}.Anchor matrixCC, withKKcentroids, each as a column vector,ckc_{k}, is fitted using K-means clustering on a sample of the document token embeddings. MaxSim calculation can be further optimized by only taking the maximum of document embeddings that are in thennclosest partitions ofqiq_{i}instead of over all anchorsckc_{k}, which is thenprobeparameter in ANN algorithms(Jayaram Subramanya et al.,2019).

If the residual norms are small (generally the assumption when using small nprobe), residual vectors can be omitted. This approximation makes the function depend only on the query/centroid inner products, which are free since we already calculated them to determine the closest clusters toqiq_{i}when usingn​p​r​o​b​enprobe. The scoring function can then be further simplified as:

S​c​o​r​eS​(q,d)\displaystyle Score^{S}(q,d)=∑i=1|q|maxj=1|d|⁡(qi⋅cdj)=∑i=1maxk∈vd⁡qi⋅ck\displaystyle=\sum_{i=1}^{|q|}\max_{j=1}^{|d|}\left(q_{i}\cdot c_{d_{j}}\right)=\sum_{i=1}\max_{k\in v_{d}}q_{i}\cdot c_{k}(3)=∑i=1|q|maxk=1K⁡qi⋅ck⋅𝟙​(k∈vd)\displaystyle=\sum_{i=1}^{|q|}\max_{k=1}^{K}q_{i}\cdot c_{k}\cdot\mathbb{1}(k\in v_{d})wherevd={cdj|∀dj∈d}v_{d}=\{c_{d_{j}}|\forall d_{j}\in d\}is the set of anchors that all tokens in documentddare closest to and𝟙​(⋅)\mathbb{1}(\cdot)is the indicator function. This is also the first stage candidate gathering process in PLAID.

The core of Equation3is a dynamic TF-IDF function. Interpreting the anchorsckc_{k}as a sparse index vocabulary, the inner product between eachqiq_{i}andckc_{k}can be seen as a query token weighting, or a query-specific inverse document frequency. This allows us to use the inverted index infrastructure for sparse retrieval. Using thisresidual-free product quantization, ColBERT is a learned sparse retrieval model with complex score aggregation.

2.2.Query-Aware and Unsupervised Anchor Optimization

Fitting the anchors using K-means clustering minimizes the distance from each training sample embedding to the centroids; this can be written as a minimization problem(Armacki et al.,2022). AssumingMMtraining examples andKKcentroids, the target can be written:

(4)minC∑j=1Mmink=1K(ck−xj)2\min_{C}\sum_{j=1}^{M}\min_{k=1}^{K}\left(c_{k}-x_{j}\right)^{2}wherexjx_{j}are the training embeddings. In other words, K-means minimizes the L2 norm of residual vectorsrr, which is the difference between its closest centroid and itself. Optimization usually uses an iterative algorithm such as E-M but can also be done with gradient descent(Armacki et al.,2022); this gives us more flexibility for extensions.

However, the approximation error between true MaxSim and the residual-free quantization depends not only on the size but also on the direction of the residual vectors, which differs from the K-means clustering optimization goal. If all residual vectors are zero there is no approximation error. Otherwise, letm​(i)=arg​maxj⁡qi⋅djm(i)=\operatorname*{arg\,max}_{j}q_{i}\cdot d_{j}, the approximation error can be written as:

S​c​o​r​e​(q,d)−S​c​o​r​eS​(q,d)\displaystyle Score(q,d)-Score^{S}(q,d)=∑iqi⋅(dm​(i)−cm​(i))=∑iqi⋅rm​(i)\displaystyle=\sum_{i}q_{i}\cdot\left(d_{m(i)}-c_{m(i)}\right)=\sum_{i}q_{i}\cdot r_{m(i)}which is the sum of the dot product between each query token embedding and the residual vector of its matching document token. Although minimizing the norm of the residual vectorsrrcan indirectly reduce approximation error, we can directly optimize for the approximation error by modifying Equation4to be query-aware:

(5)minC∑i=1N∑j=1Mqi⋅arg​minck,∀k∈[K](ck−xj)2\min_{C}\sum_{i=1}^{N}\sum_{j=1}^{M}q_{i}\cdot\operatorname*{arg\,min}_{c_{k},\forall k\in[K]}\left(c_{k}-x_{j}\right)^{2}whereNNis the number of training queries. We call thisquery-aware anchor optimization.

However, Equation5requires training queries, which are usually not present during indexing. Although they can be mined from existing or publicly available query logs (feasible in production settings), the assumed query distribution may be different from actual queries. We can, instead, use in-batch training examples as pseudo-queries to remove the dependency on training queries. LetBBbe training mini-batch size. Mini-batch minimization can be written as:

(6)minC∑i=1B∑j=1Bxi⋅arg​minck,∀k∈[K](ck−xj)2\min_{C}\sum_{i=1}^{B}\sum_{j=1}^{B}x_{i}\cdot\operatorname*{arg\,min}_{c_{k},\forall k\in[K]}\left(c_{k}-x_{j}\right)^{2}which forms theunsupervised anchor optimizationproblem.

Equation6assumes that query embeddings and document token embeddings are similar, which sometimes is false. However, it augments training optimization using only document token vectors without additional resources. To simulate scenarios where query logs or external queries exist, we explore using Equation5with training queries from evaluation collections and from MS MARCO (see Section4.1).

2.3.Sparse Indexing and Retrieval

Indexing begins by sampling document token embeddings to form a training set for the anchor matrixCC. The number of anchorsKKis a hyperparameter dependent on the number of documents being indexed. Anchors created during training are used to sparsify the document token embeddings. Each document token is assigned to its closest anchor based on the token embedding, forming a set of documents associated with each anchor point. At search time, thennclosest anchors to each query token embedding are identified. All documents in at least one anchor set are considered candidate documents. We then use a forward index that maps each document to its corresponding anchors to produceS​c​o​r​eS​(q,d)Score^{S}(q,d)(Equation3).

2.3.1.Sparse Indexing

To reduce disk I/O, the collection is processed in mini-batches and stored in multiple chunks. After producing ColBERT token embeddingsdjd_{j}for each documentdd, we calculate the dot product ofdjd_{j}with the trained anchor matrixcc. The coordinate ID of the highest scoring anchor is used as the mapped anchor for each document tokendjd_{j}. Each chunk is an inverted mapping from an anchor ID to the set of doc IDs containing it.

After all chunks are stored, we merge them usingnn-way merge to produce the final inverted index. For simplicity, we use SciPy CSR Matrix to store the inverted index and produce the forward index by inverting the inverted matrix. While engineering optimizations such as blocking and sketch vectors can further improve efficiency, this simple process is a proof-of-concept for storing sparse document representations to support ColBERT scoring approximation.

2.3.2.Searching

Each query is first encoded using ColBERT to get query token embeddingsqiq_{i}. The dot product with the anchor matrixCCproduces full query token-to-anchor scoresS∈ℝN×KS\in\mathbb{R}^{N\times K}.

First stage scoring selects the topnnanchors (i.e.,nprobe) for each query tokenqiq_{i}. For eachqiq_{i}, we collect all document IDs from the postings list across thennanchors to approximate Equation3with only the top-nnanchors, identical to PLAID(Santhanam et al.,2022a). This can be done efficiently with only a single pass over the inverted index.

Second stage scoring uses the forward index to map the topkkfirst-stage documents to the anchor IDs they contain. It then slices the query token-anchor score matrixSSusing these IDs and uses Equation3to produceS​c​o​r​eSScore^{S}.

Since the inverted index traversal is not a standard SciPy operation, we implemented the single-pass traversal algorithm in Cython, which produced executable Python functions. Optimization of the max operator in an inverted index requires more investigation, which we leave to future work. Therefore, in this work, we omit the latency analysis and focus on the trade-off between index size and retrieval effectiveness.

3.Experiments

We evaluate ColBERTSaR on BEIR(Thakur et al.,2021), NeuCLIRBench(Lawrie et al.,2025)(English queries with Chinese, Persian and Russian documents), and NeuCLIRTech(Lawrie et al.,2026)(English queries and Chinese academic abstracts), which cover monolingual, cross-language (CLIR), and multilingual (MLIR) ad hoc retrieval. In the CLIR setting of NeuCLIRBench, we use English queries and retrieve documents from each of the three language-specific collections (Chinese, Persian and Russian). In the MLIR setting, queries are still in English, but the document collection is a mixture of the three.

As baselines, we compare with BM25 (machine-translated documents, i.e., DT, on NeuCLIRBench and NeuCLIRTech provided by the benchmark to perform lexical matching on English tokens) as the lexical sparse retrieval alternative. We also compare with SPLADEv3(Lassance et al.,2024)for BEIR, and MILCO(Nguyen et al.,2025), a state-of-the-art multilingual LSR model, for CLIR and MLIR as the LSR alternatives.

Table 1.nDCG@20 on NeuCLIRBench and NeuCLIRTech (Tech). The CLIR column is the average over three languages: Chinese (zho), Persian (fas), and Russian (rus). Since BM25 can only support lexical matching, we translated the documents (DT) into English.For fitting ColBERTSaR anchors, we fix the number of anchors at 500k for NeuCLIRTech and small BEIR datasets (datasets with fewer than 1M passages; results summarized at the left of Table2), and one million for others. The number of sampled training passages follows the sampling rate in PLAID for fitting the K-means clusters, which is16×|d|¯×D16\times\sqrt{\bar{|d|}\times D}where|d|¯\bar{|d|}is the assumed document length (120 by default) andDDis the number of documents in the collection. We use eight NVIDIA V100 GPUs and a learning rate of10−410^{-4}with a per-device batch size of 2048 vectors for 100k training steps using fp16.

Table 2.nDCG@10 on BEIR datasets using ColBERTSaR and PLAID with one bit residual compression with two ColBERT backbone models. The bottom two rows provide ablations on using different training queries during anchor optimization.argufiqanfcquorascidocscifacttouccovidcli.dbp.feverhotpotmsmnqAvgBM250.3000.2360.3220.7890.1490.6790.6410.5950.1650.3180.6510.6330.5120.3050.450SPLADEv30.5090.3740.3570.8140.1580.7100.2930.7480.2330.4500.7960.6920.4400.5860.511ColBERT Model:PLAID XLMR ETPLAID 1bit0.3240.4100.3430.8500.1640.6980.2470.4280.2140.4120.8170.5900.7030.5350.481ColBERTSaR0.3390.3760.3470.7980.1640.6710.3260.5500.1470.3340.6740.4810.5650.4560.445ColBERT Model:colbert-small-v1PLAID 1bit0.3140.3980.3530.8680.1790.7340.3670.8350.2500.4400.8950.7460.7140.5810.548PLAID 0bit0.2990.3300.3150.7690.1640.6930.3500.7820.1550.2250.6310.4860.4160.3220.424ColBERTSaR0.3220.3760.3620.8400.1760.7370.3890.7710.1520.3450.7160.5890.6180.4620.490+ BM250.3430.3380.3550.8440.1690.7300.5600.7170.1770.3660.7410.6700.6120.4390.505w/ Official Train–0.3830.367––0.735––––0.7210.5930.632––w/ MSMARCO0.3230.3770.3660.8380.1770.7380.3970.8100.1600.3470.7180.5830.6320.4660.495

Figure 1.ColBERTSaR nDCG@20 on NeuCLIRBench with differentnprobeusing MTD PLAID-X.Table 3.Index Size in GB on NeuCLIRBench using different retrieval engines. The top row reports the number of documents in each subset.

4.Results

Our experiments show that our ColBERTSaR engine provides competitive effectiveness compared to the PLAID engine with one bit residual compression while substantially reducing the index size. Summarized in Table1, ColBERTSaR is capable of representing document token vectors effectively without being aware that query vectors will be in a very different distribution (i.e., in a different language). ColBERTSaR demonstrates competitive effectiveness to MILCO, the state-of-the-art multilingual LSR model, indicating that our proposed method is an effective way to sparsify a multi-vector dense retrieval model. The gap between PLAID and ColBERTSaR on the NeuCLIRTech CLIR task is slightly bigger than on NeuCLIRBench variants, indicating that technical terminology in the documents creates challenges for ColBERTSaR when representing the document tokens.

ColBERTSaR reduces the index size from 77% (zho) to 53% (MLIR),666Scipy requires int64 for larger indices (rus and fas) to store the document IDs instead of int32 for smaller ones.as the index size of each subset in the NeuCLIRBench collection is summarized in Table3. While ColBERTSaR indices are still larger than MILCO’s, which are Lucene indices, engineering tricks such as bit packing can minimize the ColBERTSaR indices.

Table2summarizes the nDCG@10 scores on the 13 BEIR subsets with two ColBERT base models. ColBERTSaR maintains 92% (0.481 to 0.445) and 89% (0.548 to 0.490) effectiveness compared to PLAID with one bit residual compression, withPLAID XLMR ETandcolbert-small-v1, respectively. The larger effectiveness gaps appear mostly in question-answering subsets such as Quora, Fever, Hotpot QA, MSMARCO, and Natural Questions. These subsets generally contain entities with specific meanings that are challenging for contextualized token embeddings to capture; this is a known weakness for ColBERT-style models(Santhanam et al.,2022b). ColBERTSaR amplifies such weakness since each document token embedding is further mapped to a centroid that may be mixed with other meanings for each token. By fusing with BM25 (last row in Table2) using reciprocal rank fusion(Cormack et al.,2009)we are able to recover some effectiveness on these QA-style queries while hurting other subsets, resulting in a slight increase in the average nDCG@10. However, with some reasonable prior knowledge in query distribution it is feasible to pick a suitable stack for the task without much overhead in index size or retrieval, since the BM25 index is relatively cheap to store and search (see Table3). Furthermore, compared to PLAID with no residuals (0 bit), essentially ColBERTSaR by using K-means centroids as anchors, ColBERTSaR optimization substantially improves the anchor when representing document tokens with no residuals.

4.1.Query Source for Anchor Optimization

While ColBERTSaR uses in-batch documents as pseudo queries when fitting the anchors, we can use other queries during this process by assuming certain query characteristics. At the bottom of Table2, we observe that using the official BEIR training queries or the MS MARCO training queries may lead to a slight improvement. However, training queries are not always available, and assuming that queries are similar to MS MARCO-style may also be less optimal (although many ColBERT models were trained on MS MARCO queries(Yang et al.,2024b,a; Khattab and Zaharia,2020), so it may be a fair assumption to reintroduce them at the indexing phase). Here, using in-batch document tokens as the query is still likely to be the most robust solution, as it only requires a sample of documents; these will always be available at the indexing phase.

4.2.Searching with Differentnprobe

One of the critical hyperparameters at query time isnprobe, which is a key parameter in ANN search(Jayaram Subramanya et al.,2019)to control the search space at search time. Naturally, the highernprobe, i.e., the more anchors we explore, the more accurate the first stage of ColBERTSaR retrieval is. In Figure1, we observe a diminishing return when increasingnprobe. Particularly when there is a second stage that uses a forward index to calculate the actual scores the final effectiveness saturates at around two to four probes. When using only the inverted index, effectiveness saturates on smaller collections (zho and fas in NeuCLIRBench) but continues to improve on larger ones. This shows that the amount of exploration depends on the size of the collection, which is expected since there are more points in the index to gather scores.

5.Conclusion and Future Work

This work introduces ColBERTSaR, a sparse approximation of ColBERT, that substantially reduces index size with competitive effectiveness. This novel approach provides critical insight into connecting multi-vector dense retrieval and LSR. Further engineering, such as document term weightings and index traversal tricks, will be critical to move beyond this proof-of-concept implementation.

References

• (1)
• Armacki et al.(2022)Aleksandar Armacki, Dragana Bajovic, Dusan Jakovetic, and Soummya Kar. 2022.Gradient based clustering. InInternational Conference on Machine Learning. PMLR, 929–947.
• Clavié (2024)Benjamin Clavié. 2024.JaColBERTv2.5: Optimising Multi-Vector Retrievers to Create State-of-the-Art Japanese Retrievers with Constrained Resources.arXiv preprint arXiv:2407.20750(2024).
• Cormack et al.(2009)Gordon V Cormack, Charles LA Clarke, and Stefan Buettcher. 2009.Reciprocal rank fusion outperforms condorcet and individual rank learning methods. InProceedings of the 32nd international ACM SIGIR conference on Research and development in information retrieval. 758–759.
• Formal et al.(2024)Thibault Formal, Stéphane Clinchant, Hervé Déjean, and Carlos Lassance. 2024.Splate: Sparse late interaction retrieval. InProceedings of the 47th International ACM SIGIR Conference on Research and Development in Information Retrieval. 2635–2640.
• Formal et al.(2021a)Thibault Formal, Carlos Lassance, Benjamin Piwowarski, and Stéphane Clinchant. 2021a.SPLADE v2: Sparse lexical and expansion model for information retrieval.arXiv preprint arXiv:2109.10086(2021).
• Formal et al.(2021b)Thibault Formal, Benjamin Piwowarski, and Stéphane Clinchant. 2021b.SPLADE: Sparse lexical and expansion model for first stage ranking. InProceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval. 2288–2292.
• Formal et al.(2021c)Thibault Formal, Benjamin Piwowarski, and Stéphane Clinchant. 2021c.A white box analysis of ColBERT. InEuropean Conference on Information Retrieval. Springer, 257–263.
• Ge et al.(2013)Tiezheng Ge, Kaiming He, Qifa Ke, and Jian Sun. 2013.Optimized product quantization.IEEE transactions on pattern analysis and machine intelligence36, 4 (2013), 744–755.
• Jayaram Subramanya et al.(2019)Suhas Jayaram Subramanya, Fnu Devvrit, Harsha Vardhan Simhadri, Ravishankar Krishnawamy, and Rohan Kadekodi. 2019.Diskann: Fast accurate billion-point nearest neighbor search on a single node.Advances in neural information processing Systems32 (2019).
• Johnson et al.(2019)Jeff Johnson, Matthijs Douze, and Hervé Jégou. 2019.Billion-scale similarity search with GPUs.IEEE Transactions on Big Data7, 3 (2019), 535–547.
• Karpukhin et al.(2020)Vladimir Karpukhin, Barlas Oguz, Sewon Min, Patrick SH Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih. 2020.Dense Passage Retrieval for Open-Domain Question Answering.. InEMNLP (1). 6769–6781.
• Khattab and Zaharia (2020)Omar Khattab and Matei Zaharia. 2020.Colbert: Efficient and effective passage search via contextualized late interaction over bert. InProceedings of the 43rd International ACM SIGIR conference on research and development in Information Retrieval. 39–48.
• Lassance et al.(2024)Carlos Lassance, Hervé Déjean, Thibault Formal, and Stéphane Clinchant. 2024.SPLADE-v3: New baselines for SPLADE.arXiv preprint arXiv:2403.06789(2024).
• Lawrie et al.(2026)Dawn Lawrie, James Mayfield, Eugene Yang, Andrew Yates, Sean MacAvaney, Ronak Pradeep, Scott Miller, Paul McNamee, and Luca Soldaini. 2026.NeuCLIRTech: Chinese Monolingual and Cross-Language Information Retrieval Evaluation in a Challenging Domain.arXiv preprint arXiv:2602.05334(2026).
• Lawrie et al.(2025)Dawn Lawrie, James Mayfield, Eugene Yang, Andrew Yates, Sean MacAvaney, Ronak Pradeep, Scott Miller, Paul McNamee, and Luca Soldani. 2025.NeuCLIRBench: A Modern Evaluation Collection for Monolingual, Cross-Language, and Multilingual Information Retrieval.arXiv preprint arXiv:2511.14758(2025).
• Lee et al.(2024)Jinhyuk Lee, Zhuyun Dai, Sai Meher Karthik Duddu, Tao Lei, Iftekhar Naim, Ming-Wei Chang, and Vincent Zhao. 2024.Rethinking the role of token retrieval in multi-vector retrieval.Advances in Neural Information Processing Systems36 (2024).
• Li et al.(2023)Minghan Li, Sheng-Chieh Lin, Barlas Oguz, Asish Ghoshal, Jimmy Lin, Yashar Mehdad, Wen-tau Yih, and Xilun Chen. 2023.CITADEL: Conditional token interaction via dynamic lexical routing for efficient and effective multi-vector retrieval. InProceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). 11891–11907.
• MacAvaney and Tonellotto (2024)Sean MacAvaney and Nicola Tonellotto. 2024.A reproducibility study of plaid. InProceedings of the 47th International ACM SIGIR Conference on Research and Development in Information Retrieval. 1411–1419.
• Mackenzie et al.(2022)Joel Mackenzie, Antonio Mallia, Alistair Moffat, and Matthias Petri. 2022.Accelerating learned sparse indexes via term impact decomposition. InFindings of the Association for Computational Linguistics: EMNLP 2022. 2830–2842.
• Mallia et al.(2021)Antonio Mallia, Omar Khattab, Torsten Suel, and Nicola Tonellotto. 2021.Learning passage impacts for inverted indexes. InProceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval. 1723–1727.
• Nardini et al.(2024)Franco Maria Nardini, Cosimo Rulli, and Rossano Venturini. 2024.Efficient multi-vector dense retrieval with bit vectors. InEuropean Conference on Information Retrieval. Springer, 3–17.
• Nguyen et al.(2025)Thong Nguyen, Yibin Lei, Jia-Huei Ju, Eugene Yang, and Andrew Yates. 2025.Milco: Learned Sparse Retrieval Across Languages via a Multilingual Connector.arXiv preprint arXiv:2510.00671(2025).
• Nguyen et al.(2023)Thong Nguyen, Sean MacAvaney, and Andrew Yates. 2023.A unified framework for learned sparse retrieval. InEuropean Conference on Information Retrieval. Springer, 101–116.
• Santhanam et al.(2022a)Keshav Santhanam, Omar Khattab, Christopher Potts, and Matei Zaharia. 2022a.PLAID: an efficient engine for late interaction retrieval. InProceedings of the 31st ACM International Conference on Information & Knowledge Management. 1747–1756.
• Santhanam et al.(2022b)Keshav Santhanam, Omar Khattab, Jon Saad-Falcon, Christopher Potts, and Matei Zaharia. 2022b.Colbertv2: Effective and efficient retrieval via lightweight late interaction. InProceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. 3715–3734.
• Scheerer et al.(2025)Jan Luca Scheerer, Matei Zaharia, Christopher Potts, Gustavo Alonso, and Omar Khattab. 2025.WARP: An efficient engine for multi-vector retrieval. InProceedings of the 48th international ACM SIGIR conference on research and development in information retrieval. 2504–2512.
• Thakur et al.(2021)Nandan Thakur, Nils Reimers, Andreas Rücklé, Abhishek Srivastava, and Iryna Gurevych. 2021.Beir: A heterogenous benchmark for zero-shot evaluation of information retrieval models.arXiv preprint arXiv:2104.08663(2021).
• Wang et al.(2023)Xiao Wang, Craig Macdonald, Nicola Tonellotto, and Iadh Ounis. 2023.Reproducibility, replicability, and insights into dense multi-representation retrieval models: from colbert to col. InProceedings of the 46th International ACM SIGIR Conference on Research and Development in Information Retrieval. 2552–2561.
• Yang et al.(2024a)Eugene Yang, Dawn Lawrie, and James Mayfield. 2024a.Distillation for multilingual information retrieval. InProceedings of the 47th International ACM SIGIR Conference on Research and Development in Information Retrieval. 2368–2373.
• Yang et al.(2024b)Eugene Yang, Dawn Lawrie, James Mayfield, Douglas W Oard, and Scott Miller. 2024b.Translate-distill: learning cross-language dense retrieval by translation and distillation. InEuropean Conference on Information Retrieval. Springer, 50–65.
• Zhang et al.(2025)Yanzhao Zhang, Mingxin Li, Dingkun Long, Xin Zhang, Huan Lin, Baosong Yang, Pengjun Xie, An Yang, Dayiheng Liu, Junyang Lin, et al.2025.Qwen3 Embedding: Advancing Text Embedding and Reranking Through Foundation Models.arXiv preprint arXiv:2506.05176(2025).