Maximal Marginal Relevance (MMR)

Why Does This Exist?

Imagine you are using a RAG (Retrieval-Augmented Generation) pipeline to ask the question, "What were the causes of the 2008 financial crisis?"

If your dense vector search simply returns the top 5 most similar documents, those 5 documents might all be different news articles covering the exact same event on the exact same day. They are all highly relevant to the query, but they are completely redundant with each other. If you feed those 5 identical articles into an LLM, the LLM won't learn about the housing bubble, the credit rating agencies, and the deregulation; it will just get the same narrow perspective repeated 5 times.

Maximal Marginal Relevance (MMR) is a reranking algorithm designed to solve this exact problem. It forces the retrieval system to balance relevance (how well the document matches the query) with diversity (how different the document is from the ones you've already selected). By introducing a diversity penalty, MMR ensures that the final list of documents covers the broadest possible semantic space for the user's query.

Think of It Like This

How It Actually Works

The Tradeoff Formula

MMR is applied as a second-stage reranker. First, you retrieve a candidate pool of documents (e.g., the top 20) using standard semantic search. Then, MMR iteratively selects the best documents from that pool to form the final result list (e.g., the top 5).

At each step, MMR chooses the document $D_i$ from the unselected pool that maximizes the following formula:

Let's break this down:

• $Q$: The user's query.
• $D_i$: The candidate document we are evaluating.
• $S$: The set of documents we have already selected.
• $\text{Sim}_1(D_i, Q)$: The relevance score. How similar is the document to the query?
• $\max \text{Sim}_2(D_i, D_j)$: The redundancy penalty. We compare the candidate document to every document we've already selected ($D_j \in S$) and find the maximum similarity. If it's highly similar to any already-selected document, the penalty is high.
• $\lambda$ (Lambda): The tradeoff parameter between 0 and 1.

Tuning the Lambda ($\lambda$) Parameter

The $\lambda$ parameter is the dial you turn to control the behavior of the search:

• $\lambda = 1.0$: Pure relevance. The redundancy penalty is multiplied by zero $(1 - 1 = 0)$. The algorithm behaves exactly like standard vector search.
• $\lambda = 0.5$: A balanced approach. Equal weight is given to matching the query and avoiding redundancy.
• $\lambda = 0.0$: Pure diversity. The algorithm completely ignores the query and just tries to pick documents that are as different from each other as possible. (Rarely used in practice).

In most RAG applications, $\lambda$ is tuned empirically, usually landing between 0.5 and 0.8.

Show Me the Code

You can easily implement MMR in Python using numpy and cosine similarity. Notice how the list of selected documents is built up iteratively.

1import numpy as np2
3def cosine_similarity(a, b):4    # Dot product of normalized vectors5    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))6
7def mmr(query_vector, doc_vectors, top_k=3, lambda_param=0.5):8    """9    Selects top_k documents using Maximal Marginal Relevance.10    """11    unselected = list(range(len(doc_vectors)))12    selected = []13    14    # Step 1: Compute relevance scores for all documents to the query15    relevance_scores = [cosine_similarity(query_vector, doc) for doc in doc_vectors]16    17    # Step 2: Iteratively select the best document18    while len(selected) < top_k and unselected:19        mmr_scores = []20        21        for i in unselected:22            relevance = relevance_scores[i]23            24            # If nothing is selected yet, there is no redundancy penalty25            if not selected:26                redundancy = 0.027            else:28                # Find the maximum similarity between candidate i and all selected docs29                redundancy = max([cosine_similarity(doc_vectors[i], doc_vectors[s]) for s in selected])30            31            # The core MMR formula32            score = lambda_param * relevance - (1 - lambda_param) * redundancy33            mmr_scores.append((score, i))34        35        # Pick the document with the highest MMR score in this iteration36        best_score, best_idx = max(mmr_scores, key=lambda x: x[0])37        38        selected.append(best_idx)39        unselected.remove(best_idx)40        41    return selected42
43# --- Dummy Data ---44# Let's say these are 1D vectors for simplicity45query = np.array([1.0, 0.0])46
47# Docs 0, 1, and 2 are highly relevant (high X value) but nearly identical to each other.48# Doc 3 is less relevant but entirely different (high Y value).49docs = [50    np.array([0.99, 0.10]), # highly relevant to [1, 0]51    np.array([0.98, 0.15]), # highly relevant, redundant with Doc 052    np.array([0.97, 0.20]), # highly relevant, redundant with Doc 053    np.array([0.60, 0.80])  # less relevant, but very diverse54]55
56print("Standard Search (Lambda=1.0):", mmr(query, docs, top_k=2, lambda_param=1.0))57# -> Standard Search (Lambda=1.0): [0, 1] (Returns two identical documents)58
59print("MMR Search (Lambda=0.5):", mmr(query, docs, top_k=2, lambda_param=0.5))60# -> MMR Search (Lambda=0.5): [0, 3] (Returns Doc 0, penalizes Doc 1 & 2, grabs diverse Doc 3)

Watch Out For

The Quick Version

• Standard vector search returns the most relevant documents, which often results in highly redundant, overlapping content.
• MMR (Maximal Marginal Relevance) is a reranking algorithm that balances relevance with diversity.
• It iterates through a candidate pool, scoring documents positively for matching the query, but penalizing them if they are too similar to documents already selected.
• The $\lambda$ parameter allows you to tune the exact tradeoff: $\lambda=1$ is pure relevance, while lower values introduce more diversity.

What to Read Next

• Read Reranking for an overview of the two-stage retrieval pipeline where MMR is typically deployed.
• Read Late Interaction Retrieval (ColBERT) to learn about another powerful, computationally heavy reranking strategy.
• Read Similarity Metrics to understand the mathematical distance functions (like Cosine Similarity) that power the MMR formula.