Reciprocal Rank Fusion (RRF)

What is Reciprocal Rank Fusion (RRF)?

Reciprocal Rank Fusion (RRF) is a rank aggregation method that merges multiple ranked lists of results into a single combined ranking. For each document it sums a small score derived from the document's position in each list, then sorts documents by that combined sum. Because it uses only ranks and not the raw relevance scores, it can fuse results from systems whose scores are on completely different scales.

RRF was introduced in the 2009 paper Reciprocal Rank Fusion outperforms Condorcet and individual Rank Learning Methods by Cormack, Clarke, and Buettcher. It is the standard fusion step in hybrid search, where it combines a keyword retriever such as BM25 with a dense vector retriever.

• Combines several ranked lists into one final ranking.
• Uses ranks only, so it needs no score normalization across systems.
• The default fusion method for hybrid keyword plus vector search.

The RRF formula

For a document d, RRF sums one over a constant k plus the document's rank in each result list that contains it. A document that ranks high across multiple lists accumulates a larger total than one that ranks high in only a single list.

Why fuse on rank instead of score

Different retrievers produce scores that are not comparable. A BM25 score can be any positive number while a cosine similarity is bounded near zero to one, so adding them directly would let one system dominate purely because of its scale. Normalizing scores is fragile because the distributions shift with the query and the corpus. RRF sidesteps this by discarding scores and using only ordinal position, which is comparable across any retriever.

The constant k controls how much the very top ranks dominate. With a moderate k such as 60, the gap between rank 1 and rank 2 is small, so a document that appears consistently across lists, even at middling ranks, can outrank a document that is first in one list but absent from the others. This agreement-rewarding behavior is why RRF works reliably for hybrid search.

• Scores from different retrievers are not on a common scale; ranks are.
• Avoids brittle score normalization that shifts per query and corpus.
• A larger k rewards consensus across lists over a single strong placement.

Code example

The function below fuses any number of ranked lists. Each list is a sequence of document IDs in rank order, and the result is a single list sorted by combined RRF score.

from collections import defaultdict

def reciprocal_rank_fusion(ranked_lists, k=60):
    scores = defaultdict(float)
    for ranking in ranked_lists:
        for position, doc_id in enumerate(ranking, start=1):
            scores[doc_id] += 1.0 / (k + position)
    return sorted(scores, key=scores.get, reverse=True)

# Example: fuse keyword (BM25) and vector search results
bm25_results   = ["docA", "docB", "docC", "docD"]
vector_results = ["docC", "docA", "docE", "docB"]

fused = reciprocal_rank_fusion([bm25_results, vector_results])
print(fused)  # docA and docC rank highest: both appear near the top in both lists

Where RRF is used and its limits

RRF is built into hybrid search in systems such as Azure AI Search, OpenSearch, and Elasticsearch, where it merges lexical and semantic result sets. It is simple, has a single tunable parameter, requires no training, and works even when the component retrievers are of different types.

Its main limitation is that it ignores the magnitude of relevance: a document that is overwhelmingly the best match in one list is treated only slightly better than the runner-up because the method sees ranks, not scores. When the absolute quality gap between results carries real signal, a score-aware fusion or a learned reranker applied after RRF can recover information that pure rank fusion discards.

• Native in Azure AI Search, OpenSearch, and Elasticsearch hybrid search.
• Simple, training-free, and one parameter to tune.
• Ignores score magnitude; a reranker after RRF can recover that signal.