RAG and search engineeringMiddleLesson 2106 min read

Hybrid search: keywords plus vectors

Keyword search is great at exact words, codes and names. Vector search is great at meaning. Hybrid search runs both and fuses the results.

✦ Ask the tutor 🧪 Lab · 40 min 📝 Lesson test

Speed

Lesson in motion

In 60 seconds

Hybrid search: keywords plus vectors

Keyword search is great at exact words, codes and names. Vector search is great at meaning. Hybrid search runs both and fuses the results.

1/4

In simple words

You lost your friend at a crowded mela. You can ask one person who looks for your friend's exact name tag, and another who looks for "a tall boy in a blue shirt". Each finds people the other misses. Asking both, then checking who they both point to, finds your friend faster.

Vector search finds text with similar meaning. But many real questions depend on exact strings: an error code like E-4012, a form number like Form 16, a person's name, a product id, a section number. Embeddings can blur these. Keyword search matches the exact terms and is very good at them.

BM25: the classic keyword score

BM25 is a long-used formula for ranking documents by keywords. It rewards a document when:

it contains the query terms, and more times is better, but with diminishing returns (the tenth mention adds little);
the terms are rare across the collection (matching "E-4012" matters more than matching "the");
the document is not unusually long, since long documents match many words just by chance.

Two settings control this: k1 (how fast repeats stop helping) and b (how much length matters). Common starting values are around k1 = 1.2 to 2 and b = 0.75. Most search engines and many databases include BM25 or something similar.

Query	Keyword search (BM25)	Vector search
"error E-4012 on checkout"	Strong: finds the exact code	May return any checkout error
"money cut but order not placed"	Weak if documents say "payment debited, order failed"	Strong: same meaning, different words
"Form 16 kab milega" (Hinglish)	Finds "Form 16" exactly	Depends on the model's language coverage
A person's rare surname	Strong	Often weak

Fusing two ranked lists: reciprocal rank fusion

The two searches give scores on different scales, so you cannot simply add them. Reciprocal rank fusion (RRF) ignores the raw scores and uses only positions. Each document gets 1 / (k + rank) from each list it appears in, and the parts are added. A common default for k is 60. Documents that rank well in both lists rise to the top.

Python: reciprocal rank fusionpython

def rrf(rankings, k=60):
    """Fuse several ranked lists of document ids into one ranked list.

    rankings: a list of lists, each ordered best first.
    k: dampening constant; 60 is a common default.
    """
    scores = {}
    for ranking in rankings:
        for rank, doc_id in enumerate(ranking, start=1):
            scores[doc_id] = scores.get(doc_id, 0.0) + 1.0 / (k + rank)
    # Sort by fused score, highest first; ties broken by id for stable output.
    return sorted(scores, key=lambda d: (-scores[d], d))

keyword_hits = ["faq-12", "manual-3", "faq-7"]
vector_hits = ["faq-7", "faq-12", "blog-1"]
print(rrf([keyword_hits, vector_hits]))
# ['faq-12', 'faq-7', 'manual-3', 'blog-1']

faq-12 is first in one list and second in the other, so it wins. blog-1 appears only once, in third place, so it comes last. RRF needs no training and no score tuning, which is why it is a popular first choice.

A typical hybrid pipeline

1
Apply filters first
Permissions, language, date or document type, enforced in code.
2
Keyword search
Take the top results from BM25, for example the top 20 to 50.
3
Vector search
Take the top results from the vector index, the same number.
4
Fuse
Combine with reciprocal rank fusion.
5
Re-rank and send
Optionally re-rank the fused list (next lesson), then send the best few to the model.

Note

Another way to fuse is a weighted sum of normalised scores, such as 0.7 × vector plus 0.3 × keyword. It can work well but needs tuning, and the weights may need changing when you switch models. RRF is a strong, simple baseline to beat first.

Watch out

Filters must apply to both searches. A common bug: the vector search respects the user's permission filter but the keyword search does not, so a restricted document slips in through the keyword side. See Securing RAG: permissions for retrieved documents.

Try this. In the RRF code, add a third list ["manual-3", "faq-12"]. Before running it, guess the new order. Then check.

Watch and read more

Lab

A tiny hybrid search engine in pure Python: BM25 plus made-up vectors, fused with RRF.

~40 min

The problem

Run the starter with Python 3. It uses only the standard library. The vectors are made up by hand: in a real system an embedding model would produce them.

Run it and read the three result lists for each query.
Find one query where keyword search is right and vector search is wrong, and one where the opposite is true. Write both down.
Add two documents of your own, with made-up vectors, and one new query with its own made-up vector.
Change RRF's k to 1 and then to 1000. Describe what changes in the fused order.

Practice lab

Edit the code and run it. Python runs in your browser — nothing is sent to our server.

Ctrl + Enter to run

import math
import re

DOCS = {
    "d1": "Error E-4012 means the bank did not confirm the payment. Wait 30 minutes before retrying.",
    "d2": "If money was debited but the order failed, the amount is usually returned to your account.",
    "d3": "To change your delivery address, open My Orders and choose Edit Address.",
    "d4": "Error E-5001 means the delivery pincode is not serviceable yet.",
}
# Made-up 3-number vectors: [payment, delivery, error-ish]. Real ones come from a model.
VECS = {"d1": [0.7, 0.0, 0.7], "d2": [0.9, 0.1, 0.2], "d3": [0.0, 1.0, 0.0], "d4": [0.0, 0.6, 0.8]}
QUERIES = {
    "what does E-4012 mean": [0.2, 0.4, 0.9],
    "charged, purchase unsuccessful": [0.95, 0.1, 0.1],
}

def tokenize(text):
    return re.findall(r"[a-z0-9]+(?:-[a-z0-9]+)*", text.lower())

class BM25:
    def __init__(self, docs, k1=1.5, b=0.75):
        self.toks = {d: tokenize(t) for d, t in docs.items()}
        self.n = len(docs)
        self.avgdl = sum(len(t) for t in self.toks.values()) / self.n
        self.df = {}
        for toks in self.toks.values():
            for term in set(toks):
                self.df[term] = self.df.get(term, 0) + 1
        self.k1, self.b = k1, b

def idf(self, term):
        n = self.df.get(term, 0)
        return math.log(1 + (self.n - n + 0.5) / (n + 0.5))

def score(self, query, doc_id):
        toks, s = self.toks[doc_id], 0.0
        for term in tokenize(query):
            tf = toks.count(term)
            if tf:
                norm = 1 - self.b + self.b * len(toks) / self.avgdl
                s += self.idf(term) * tf * (self.k1 + 1) / (tf + self.k1 * norm)
        return s

def search(self, query, k=3):
        scored = [(self.score(query, d), d) for d in self.toks]
        return [d for s, d in sorted(scored, key=lambda x: (-x[0], x[1])) if s > 0][:k]

def cosine(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    return dot / (math.sqrt(sum(x * x for x in a)) * math.sqrt(sum(y * y for y in b)))

def vector_search(qvec, k=3):
    return sorted(VECS, key=lambda d: (-cosine(qvec, VECS[d]), d))[:k]

def rrf(rankings, k=60):
    scores = {}
    for ranking in rankings:
        for rank, doc_id in enumerate(ranking, start=1):
            scores[doc_id] = scores.get(doc_id, 0.0) + 1.0 / (k + rank)
    return sorted(scores, key=lambda d: (-scores[d], d))

bm25 = BM25(DOCS)
for q, qvec in QUERIES.items():
    kw, vec = bm25.search(q), vector_search(qvec)
    print(q)
    print("  keyword:", kw)
    print("  vector: ", vec)
    print("  fused:  ", rrf([kw, vec]))

Output

No output. Add print(...) to see values.

You are done when

The script runs and prints keyword, vector and fused lists for each query
You found a query where each method beats the other, with a one-line reason
Your new documents and query appear in the output
You described how a very small or very large k changes the fused order

Hard questions

Try to answer before you reveal. If you can answer these, you understood the lesson.

Q1In the starter, why does the tokenizer keep "e-4012" as one token instead of splitting it into "e" and "4012"?Reveal

Because the code is the meaningful unit. If it were split, "e" would match almost nothing useful and "4012" might match unrelated numbers such as prices or years. Keeping hyphenated codes together makes the rare, exact term count fully in BM25. Real search engines have analysers for this; check how yours handles codes, ids and hyphens.

Q2Keyword search returns only 1 result and vector search returns 3. How does RRF treat a document found only by vectors?Reveal

It still gets a score of 1/(k + rank) from the vector list, just nothing from the keyword list. So it can appear in the fused result, usually below documents found by both. RRF does not need both lists to be the same length, and a missing document simply adds zero from that list.

Please sign in to continue.

Questions people ask

Is keyword search old-fashioned now?

No. It is fast, cheap, easy to explain and excellent at exact terms. Many strong RAG systems use hybrid search because each method covers the other's blind spots.

Why is the k in RRF usually around 60?

It was the value used when RRF was first described, and it works well in many settings. A bigger k makes the gap between rank 1 and rank 5 smaller. You can tune it on your test set, but results are often not very sensitive to it.

How does keyword search handle Indian languages?

It depends on the tokenizer and text analysis your search engine uses. Check that it splits words correctly for each script, and remember that a query in Latin letters ("paisa") will not match text in Devanagari (पैसा) by keywords alone. The next lesson covers this.

Do I need two separate systems for hybrid search?

Not always. Some search engines and databases support both keyword and vector search in one place. Check the current docs of the tools you already run before adding another.

Lesson test

5 questions. Get 3 right (60%) to pass and complete this lesson.

Hybrid search: keywords plus vectors

Hybrid search: keywords plus vectors

BM25: the classic keyword score

Fusing two ranked lists: reciprocal rank fusion

A typical hybrid pipeline

Apply filters first

Keyword search

Vector search

Fuse

Re-rank and send

Watch and read more

The problem

Practice lab

You are done when

Hard questions

Questions people ask