LLMs and Generative AI β€Ί Embeddings and Vector Search β€Ί Day 264

Day 264: Hybrid Search and Rerankers

Day 264 of 365 β€” Hybrid Search and Rerankers

Master the dual-stage retrieval paradigm for production RAG systems: combine Lexical Sparse Keyword Search (BM25) with Dense Semantic Vector Search via Reciprocal Rank Fusion (RRF) and convex linear alpha score fusion; integrate Cross-Encoder neural re-rankers (Cohere Rerank, BGE-Reranker-Large, ColBERT late interaction) to evaluate query-document relevance; analyze latency-accuracy trade-offs, and implement an end-to-end Hybrid Search & Re-Ranking pipeline in Python.

Course
LLMs and Generative AI
Category
Embeddings and Vector Search
Reading time
β‰ˆ 35 min
Practical time
β‰ˆ 50 min
Lesson duration
1h 25m
Last verified
2026-08-30

Hands-on lab for this lesson

Lab files on GitHub: https://github.com/ai-roadmap-365/ai-roadmap-365.github.io/tree/main/labs/sections/llms-and-generative-ai/day-264-hybrid-search-and-rerankers

  1. Get the hands-on files. Clone the labs repository once (you can reuse this clone for every lesson). This works on macOS, Linux, and Windows (PowerShell or WSL):
    git clone https://github.com/ai-roadmap-365/ai-roadmap-365.github.io.git
    cd ai-roadmap-365.github.io
  2. Open this lesson's lab. Move into the directory for this specific day. Every lab lives at the same predictable path β€” section / subsection / week / day:
    cd labs/sections/llms-and-generative-ai/day-264-hybrid-search-and-rerankers
  3. Read the lab guide. Open `README.md` in that directory. It lists the exact commands, what each does, the expected output, and how to check your work β€” read it before running anything.
  4. Run it and check your work. Follow the README's "How to run" section: run the example first to see the finished result, then complete the numbered exercises in `starter/`, then run the tests. The tests pass (exit 0) only when your work is correct.
    bash tests/run_tests.sh   # or the test command named in the lab README

You can also open the lab as a local page (works offline, shows the file tree and expected output).

Learning objectives

By the end of this lesson you will be able to:

Prerequisites

Why this matters

In production Retrieval-Augmented Generation (RAG) systems, relying exclusively on dense vector similarity search creates severe, predictable blind spots:

Hybrid Search & Re-Ranking is the gold standard architecture that bridges this divide. By combining Sparse Keyword Search (BM25) with Dense Semantic Vector Search (HNSW) via Reciprocal Rank Fusion (RRF), and passing the merged candidates through a Cross-Encoder Neural Re-Ranker, you achieve near-perfect retrieval recall and precision across both exact keyword and abstract semantic queries.

Today, you will master the mechanics of BM25 term weighting, Reciprocal Rank Fusion, Cross-Encoder pairwise cross-attention, and ColBERT late interaction, and build an end-to-end Hybrid Search & Re-Ranking engine in Python.


The idea in plain language

Diagram: the two-stage retrieve-then-rerank retrieval pattern

Think of hiring a senior software architect from a candidate pool of 10,000 applicants:


Historical background

Diagram: the historical progression toward hybrid retrieval with reranking

Hybrid search sparse dense fusion pipeline diagram

  1. 1994 (Okapi BM25): Stephen Robertson and Karen SpΓ€rck Jones introduced BM25, establishing the definitive probabilistic term-frequency ranking standard.
  2. 2009 (Reciprocal Rank Fusion - RRF): Cormack et al. proved that summing inverse rank positions outperforms complex score calibration across heterogeneous search engines.
  3. 2019 (BERT Cross-Encoders): Nogueira and Cho demonstrated that passing [Query, Passage] pairs through BERT with full cross-attention yields dramatic gains over dual encoders.
  4. 2020 (ColBERT Late Interaction): Khattab and Zaharia introduced token-level MaxSim late interaction, achieving Cross-Encoder quality at Bi-Encoder speeds.
  5. 2023–2024 (Modern RAG Standards): Commercial engines (Qdrant, Cohere, Pinecone) integrated hybrid sparse-dense fusion and dedicated neural re-ranking endpoints.

What it is β€” and what it is not

What Hybrid Search & Re-Ranking IS:

What it is NOT:


Why it was created and what problems it solves

Hybrid search and re-ranking solve 4 critical enterprise retrieval challenges:

  1. The Out-of-Vocabulary / SKU Problem: Catches exact alphanumeric identifiers, error codes, and entity names that embeddings fail to resolve.
  2. The Synonym & Paraphrase Problem: Recovers documents discussing identical concepts using different vocabulary.
  3. Score Incompatibility: Reciprocal Rank Fusion merges disparate scoring regimes (BM25 floats from 0 to 50 vs. Cosine similarities from 0 to 1) without calibration errors.
  4. Elimination of False Positives: Neural cross-encoders weed out passages that share semantic keywords but fail to answer the user’s specific question.

How it works

Let us dissect the mathematical formulation of BM25, RRF rank aggregation, and Cross-Encoder attention mechanics.


1. BM25 (Best Matching 25) Sparse Lexical Scoring

Diagram: the four properties of statistical lexical retrieval

BM25 calculates the relevance score of document D for query Q using term frequencies and inverse document frequencies:

\text{Score}(D, Q) = \sum_{i=1}^{n} \text{IDF}(q_i) \cdot \frac{f(q_i, D) \cdot (k_1 + 1)}{f(q_i, D) + k_1 \cdot <=ft(1 - b + b \cdot \frac{|D|}{\text{avgdl}}\right)}


2. Reciprocal Rank Fusion (RRF) Formulation

Diagram: how two ranked result lists are combined without comparing their scores

When merging candidate lists from BM25 and Dense Vector search:

\text{RRF\_Score}(d) = \sum_{m in M} \frac{1}{k + r_m(d)}

β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
β”‚                   RECIPROCAL RANK FUSION EXAMPLE (k=60)                β”‚
β”œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€
β”‚ Document  β”‚ BM25 Rank    β”‚ Dense Rank    β”‚ RRF Calculation             β”‚
β”œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€
β”‚ Doc A     β”‚ Rank 1       β”‚ Rank 2        β”‚ 1/(60+1) + 1/(60+2) = 0.0325β”‚
β”‚ Doc B     β”‚ Rank 2       β”‚ Not in Top-50 β”‚ 1/(60+2) + 0        = 0.0161β”‚
β”‚ Doc C     β”‚ Rank 15      β”‚ Rank 1        β”‚ 1/(60+15)+ 1/(60+1) = 0.0297β”‚
β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜

3. Bi-Encoder vs. Cross-Encoder Architecture

Diagram: bi-encoder retrieval compared with cross-encoder reranking

Cross-encoder vs Bi-encoder attention comparison diagram


4. ColBERT Late Interaction (MaxSim Operator)

Diagram: late interaction retrieval compared with single-vector and cross-encoder approaches

ColBERT provides a middle ground:

  1. Embeds query tokens \{q_1, ..., q_l\} into a matrix of token vectors.
  2. Embeds document tokens \{d_1, ..., d_m\} into a matrix of token vectors.
  3. Computes the MaxSim operator: For every query token, finds the maximum cosine similarity among all document tokens, then sums the maximums: S(Q, D) = \sum_{i=1}^{l} \max_{j=1}^{m} <=ft( e_{q_i} \cdot e_{d_j} \right)

5. Linear Convex Alpha Fusion

An alternative to RRF when calibrated scores are available: \text{Score}_{\text{final}} = \alpha \cdot \text{Dense\_Norm} + (1 - \alpha) \cdot \text{BM25\_Norm}


6. Latency and Throughput Budgeting

Diagram: the latency budget of a two-stage retrieval pipeline

In production architectures:


7. Re-Ranker Model Selection

Popular production re-rankers:


8. Evaluating Hybrid Retrieval: MRR@10 and NDCG@10

Diagram: reciprocal rank compared with discounted cumulative gain as retrieval metrics

Measure retrieval quality improvements using standard Information Retrieval metrics:


9. Context Compression & Re-Rank Pruning

After re-ranking:


10. Summary: The Two-Stage Gold Standard


Deep Dive: Mathematical Formulation of Reciprocal Rank Fusion

Reciprocal Rank Fusion (RRF) is an unsupervised rank aggregation method specifically developed to combine ranked candidate lists returned by disparate information retrieval systems (such as lexical inverted indexes and dense vector similarity search) without requiring score normalization or calibration.

Given a set of retrieval systems M (e.g., BM25 and Dense HNSW) and a collection of candidate documents D retrieved across all systems, the RRF score for document d in D is formally defined as:

RRF(d) = sum_(m in M) \frac(1)(k + r_m(d))

Where:

The smoothing constant k plays a crucial role in balancing the influence of high-ranking documents against low-ranking documents:

  1. Low k values (e.g., k=10): Strongly prioritize the very top results from each list (1/11 \approx 0.091 vs 1/20 = 0.050), making the top 1–3 ranked documents dominate the fused scoring.
  2. High k values (e.g., k=100): Smooth out rank differences, allowing consensus across multiple ranking lists to outweigh an isolated top rank from a single system.
  3. Standard k=60: Provides optimal empirical performance across standard TREC, BEIR, and MS MARCO benchmarks, ensuring that documents appearing in the top 10 of both sparse and dense retrieval systems receive substantially higher combined scores than documents appearing only in one system.

Comparative Latency Profiling and Hardware Acceleration

When deploying hybrid search pipelines in production enterprise clusters, latency budgeting must be strictly partitioned across sparse indexing, dense approximate nearest neighbor search, and neural re-ranking:

  1. Sparse Lexical Retrieval (BM25): Operating over inverted memory-mapped postings lists (using Lucene or Tantivy), sparse keyword evaluation executes within 2–5ms on standard multi-core x86 CPUs.
  2. Dense Approximate Nearest Neighbor (ANN) Search: Vector similarity search using Hierarchical Navigable Small World (HNSW) graphs in Qdrant or Milvus requires 4–8ms for candidate sets of size K=50.
  3. Cross-Encoder Neural Re-Ranking: Evaluating pairwise token interactions using transformer architectures (e.g., BGE-Reranker-Large or Cohere Rerank v3) is computationally demanding. Scoring 50 candidates sequentially on a single CPU core would require 150–250ms, violating user-interactive SLAs.
  4. ONNX Runtime and TensorRT Optimization: By quantizing cross-encoder weights to INT8 and compiling execution graphs via ONNX Runtime with AVX-512 VNNI instructions or GPU Tensor Cores, batch scoring latency of 50 candidates is compressed down to 12–18ms.

An everyday analogy

Diagram: a wide catch followed by careful sorting

Think of casting actors for a Broadway musical:


Examples in practice

Let us build an End-to-End Hybrid Search & RRF Re-Ranking Pipeline:

import math
from collections import Counter
from typing import List, Dict, Any, Tuple

class HybridSearchEngine:
    def __init__(self, rrf_k: int = 60):
        self.rrf_k = rrf_k
        self.documents: List[Dict[str, Any]] = []
        self.doc_term_freqs: List[Counter] = []
        self.doc_lengths: List[int] = []
        self.avg_doc_len: float = 0.0
        self.idf: Dict[str, float] = {}

    def index_documents(self, docs: List[Dict[str, Any]]):
        self.documents = docs
        self.doc_term_freqs = []
        self.doc_lengths = []
        df: Counter = Counter()

        for doc in docs:
            tokens = doc["text"].lower().split()
            tf = Counter(tokens)
            self.doc_term_freqs.append(tf)
            self.doc_lengths.append(len(tokens))
            for term in tf.keys():
                df[term] += 1

        n_docs = len(docs)
        self.avg_doc_len = sum(self.doc_lengths) / max(1, n_docs)
        self.idf = {term: math.log((n_docs - count + 0.5) / (count + 0.5) + 1.0) for term, count in df.items()}

    def bm25_search(self, query: str, top_k: int = 10, k1: float = 1.5, b: float = 0.75) -> List[Tuple[int, float]]:
        q_tokens = query.lower().split()
        scores = []

        for idx, tf in enumerate(self.doc_term_freqs):
            score = 0.0
            d_len = self.doc_lengths[idx]
            for term in q_tokens:
                if term in tf:
                    term_idf = self.idf.get(term, 0.0)
                    freq = tf[term]
                    numerator = freq * (k1 + 1.0)
                    denominator = freq + k1 * (1.0 - b + b * (d_len / self.avg_doc_len))
                    score += term_idf * (numerator / denominator)
            scores.append((idx, score))

        scores.sort(key=lambda x: x[1], reverse=True)
        return scores[:top_k]

    def reciprocal_rank_fusion(self, sparse_results: List[Tuple[int, float]], dense_results: List[Tuple[int, float]], top_k: int = 5) -> List[Tuple[Dict[str, Any], float]]:
        rrf_scores: Dict[int, float] = Counter()

        for rank, (doc_idx, _) in enumerate(sparse_results):
            rrf_scores[doc_idx] += 1.0 / (self.rrf_k + (rank + 1))

        for rank, (doc_idx, _) in enumerate(dense_results):
            rrf_scores[doc_idx] += 1.0 / (self.rrf_k + (rank + 1))

        ranked_items = sorted(rrf_scores.items(), key=lambda x: x[1], reverse=True)
        return [(self.documents[doc_idx], score) for doc_idx, score in ranked_items[:top_k]]

Implications: security, privacy, performance, scalability, and cost

Diagram: the quality, cost, latency and complexity implications of hybrid retrieval with reranking

  1. Re-Ranking Latency Budget: Re-ranking 50 documents takes ~15ms on GPU, but ~150ms on a single CPU core. Use lightweight quantized ONNX models (e.g. FlashRank) when deploying on CPU-only container environments.
  2. Data Leakage in Re-Ranking: Ensure payload access control filters are applied during Stage 1 retrieval so that private tenant passages are never passed to the re-ranker model.

Alternatives: free, open source, and commercial

SolutionTypePrimary Strengths
Qdrant HybridBuilt-in Sparse + DenseSingle engine, integrated RRF and payload filters
Cohere Rerank v3Managed Cloud APIBest-in-class relevance, multilingual, zero infra
BGE-RerankerOpen Source TransformerState-of-the-art open weights for self-hosting
FlashRankLightweight Local ONNXUltra-fast sub-5ms CPU re-ranking

β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”
β”‚                   SEARCH PARADIGM COMPARISON MATRIX                    β”‚
β”œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€
β”‚ Metric             β”‚ Sparse BM25     β”‚ Dense Vector    β”‚ Hybrid + RRF  β”‚
β”œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”Όβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€
β”‚ Keyword Accuracy   β”‚ 100% Exact      β”‚ Poor on SKUs    β”‚ 100% Exact    β”‚
β”‚ Semantic Recall    β”‚ Poor on Synonymsβ”‚ Excellent       β”‚ Excellent     β”‚
β”‚ Query Latency      β”‚ 1 - 3ms         β”‚ 2 - 5ms         β”‚ 4 - 8ms       β”‚
β”‚ Re-Rank Precision  β”‚ Baseline        β”‚ Moderate        β”‚ +20% Accuracy β”‚
β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”΄β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜

When to use it β€” and when not to

Diagram: when reranking is worth its cost

When to Use Hybrid Search & Re-Ranking:

When NOT to use:


The AI connection

Knowledge check

  1. Why does pure semantic vector search struggle with rare technical terms and alphanumeric codes?
  2. What is the formula for Reciprocal Rank Fusion (RRF) and why is the smoothing constant k=60 used?
  3. How does the attention mechanism of a Cross-Encoder differ from a Bi-Encoder?
  4. How does ColBERT late interaction achieve near-Cross-Encoder accuracy at Bi-Encoder speeds?
  5. What are the typical latency stages of a two-stage hybrid retrieval pipeline?

Hands-on exercise

In this lab, you will build and test an End-to-End Hybrid Search & Re-Ranking Pipeline in Python: implement BM25 sparse keyword scoring, vector cosine scoring, Reciprocal Rank Fusion (RRF) rank aggregation, and a simulated cross-encoder re-ranking filter.

Expected output

[Hybrid Search & Re-Ranking Verification Suite]
Testing BM25 Keyword Search:
  Query: 'error 504 gateway' -> Match Doc 0 (Score: 2.14) [PASS]
Testing Dense Semantic Search:
  Query: 'sluggish server response' -> Match Doc 1 (Score: 0.92) [PASS]
Testing Reciprocal Rank Fusion (RRF):
  Merged Sparse + Dense rankings into unified Top-3 pool [PASS]
  Top Combined Result: Doc 0 (RRF Score: 0.0325) [PASS]
Testing Cross-Encoder Re-Ranking:
  Re-ranked candidates evaluated with full cross-attention [PASS]
Test Suite: 4 passed in 0.42s

Validate your work

Run the automated test runner:

./tests/run_tests.sh

Troubleshooting

Common mistakes


Practice assignment

  1. Implement Convex Alpha Linear Fusion: Build a linear score merger with min-max normalization and compare NDCG@5 against RRF.
  2. Integrate a local FlashRank ONNX Re-Ranker to re-score Top-20 retrieved passages.

Extension challenge

Implement a ColBERT-style MaxSim Late Interaction Engine:

Quiz

Q1. Why does pure dense semantic vector search often fail on exact alphanumeric queries like error codes or product SKUs (e.g. "ERR_504_GW")?

  1. Tokenizers shatter rare identifiers into fragments
  2. Because vector databases do not accept numbers
  3. Because embeddings only work on English dictionary words
  4. Because cosine similarity cannot exceed 0.5
Show answer

Answer: A. Tokenizers shatter rare identifiers into fragments

Dense embeddings map rare strings into generalized semantic regions, losing exact character-level keyword specificity.

Q2. How does Reciprocal Rank Fusion (RRF) calculate the combined score for a document appearing in multiple search candidate lists?

  1. By multiplying raw BM25 scores with cosine similarity
  2. Sum of 1 / (k + rank) across the rankings
  3. By averaging character counts
  4. By selecting only documents from the first ranking
Show answer

Answer: B. Sum of 1 / (k + rank) across the rankings

RRF uses positional rankings rather than incompatible raw score magnitudes to merge disparate result sets.

Q3. What is the primary architectural difference between a Bi-Encoder and a Cross-Encoder?

  1. A Bi-Encoder is written in C, and a Cross-Encoder is in Python
  2. A Bi-Encoder requires two GPUs, while a Cross-Encoder requires four
  3. A bi-encoder embeds separately; a cross-encoder jointly
  4. There is no difference
Show answer

Answer: C. A bi-encoder embeds separately; a cross-encoder jointly

Cross-Encoders allow every query token to attend to every document token, achieving vastly superior relevance scoring at higher computational cost.

Q4. Why is it computationally impractical to use a Cross-Encoder to search a 10,000,000 document vector database directly from scratch?

  1. Because PyTorch disables search loops
  2. Because Cross-Encoders cannot read English
  3. Because RAM is limited to 1 MB
  4. Cross-attention over ten million pairs would take minutes
Show answer

Answer: D. Cross-attention over ten million pairs would take minutes

Cross-Encoders are computationally intensive O(N) forward passes, making them suitable only for re-ranking a small Top-50 candidate pool.

Q5. What role does late-interaction retrieval (such as ColBERT) play in the retrieval spectrum?

  1. It keeps token vectors and does fast MaxSim matching
  2. It disables LLM generation
  3. It compresses text into ZIP archives
  4. It replaces SQL databases
Show answer

Answer: A. It keeps token vectors and does fast MaxSim matching

ColBERT keeps fine-grained token embeddings and computes MaxSim token alignments in sub-15ms.

Glossary

Hybrid Search
A retrieval paradigm combining sparse keyword search (BM25) with dense semantic vector search.
BM25 (Best Matching 25)
A probabilistic term-matching ranking function based on Term Frequency and Inverse Document Frequency (TF-IDF).
Reciprocal Rank Fusion (RRF)
A rank-aggregation algorithm summing inverse rank positions to combine heterogeneous candidate lists without score calibration.
Bi-Encoder
A dual-encoder architecture embedding query and passage independently into fixed-dimensional vectors for fast dot product search.
Cross-Encoder
A transformer model processing concatenated query-document token pairs simultaneously with full pairwise cross-attention.
Re-Ranking
The second stage of retrieval where a computationally intensive model re-scores a small candidate pool (e.g. Top-50) down to Top-5.
ColBERT (Late Interaction)
A multi-vector retrieval model computing token-level MaxSim operations between query and document token matrices.
Alpha Linear Fusion
A convex weighted score combination: Final_Score = alpha * Dense_Score + (1 - alpha) * Sparse_Score.

Sources and further reading


Kept in this browser, no account needed. Your progress page turns the whole record into one link you can bookmark or open on another device.