What is Jina Reranker v3, and how does it rerank documents?

In this article

1. Before you start
2. Why interviewers ask this
3. Jina Reranker v3 from first principles
4. Worked example
5. Trade-offs and edge cases
6. How to answer it in an interview
7. Common mistakes
8. Follow-up questions
9. Sources

Before you start

This page sits inside the retrieval-augmented generation (RAG) guide, where a reranker is one stage of the pipeline.

Why interviewers ask this

Reranking is a stage of almost every serious RAG design, so a design round on retrieval quality tends to reach it. Interviewers use it to see whether a candidate knows why the first search is cheap but rough, and what a second, slower model buys.

A weak answer says "a reranker sorts the results better." A strong answer names the cost model: the first stage must scan everything cheaply, while the reranker looks at a short list and can afford more compute per document. A Staff-level answer also separates the designs: one pair at a time, documents encoded apart, or many documents in one window. It then says how to measure the gain on your own data, as in how to evaluate a RAG system, and what the extra stage adds to latency, covered in where RAG latency and cost go. More practice prompts are in RAG interview questions and answers.

Jina Reranker v3 from first principles

Listwise reranking

Listwise reranking is a way of reordering search results in which one model reads the query together with a whole list of candidate documents in a single pass, instead of scoring each query and document pair alone.

Last but not late interaction

Last but not late interaction (LBNL) is a scoring design in which the query and all candidate documents are placed in one context window and mixed by causal attention, so the query reads every document, and only afterwards is one vector taken from each document for scoring.

Last-token pooling

Last-token pooling is a way of turning a passage into one vector by taking the model's hidden state at the passage's final token, which in a causal model has already attended to everything before it. In Jina Reranker v3 that position is a special <|doc_emb|> token after each document, and a <|query_emb|> token after the query.

In plain words

A reranker is a model that takes the short list a search returned and puts it in a better order. Think of a hiring manager who gets 100 illustrative résumés from a keyword filter. A recruiter skims all of them quickly. The manager then reads a short list properly and ranks it. The analogy breaks here: Jina Reranker v3 does not read candidates one at a time. It reads the whole pile together, so each document is judged alongside the ones before it, and the query reads them all.

In one precise sentence, the model is a 0.6-billion-parameter multilingual listwise reranker that applies causal attention across the query and all candidates in one window and then extracts one embedding per document.

A cross-encoder is a model that reads a query and one document together. It outputs one relevance score for that pair. Late interaction is a design, used by ColBERT. In it, documents are encoded separately and matched to the query afterwards.

Step 1: The query and a list of documents share one context window

The model packs one query and many candidate documents into a single input. Each document is wrapped in passage tags with sequential identifiers, so the model can tell where one ends and the next begins. Jina Reranker v3 puts one query and up to 64 documents into one context window, and 64 is the stated limit per pass within a 131,072-token window. Jina AI describes the design in its paper. The window holds a fixed number of tokens, so every extra document leaves less room for the others.

Input: the query plus the candidate texts from the first-stage search. Output: one long token sequence. You now know what the model reads: not a pair, but a list.

Step 2: Causal attention mixes the query and the documents

Causal attention is a rule of a language model's attention layers in which each token may look only at tokens that come before it. In Jina's prompt template the passages come first and the query, wrapped in query tags, comes after all of them. So each document can see the documents before it, and the query vector is read at the end, after the query has attended to every document. The backbone is Qwen3-0.6B with 28 layers and 1,024 hidden dimensions, a transformer.

Input: the packed sequence. Output: a hidden state for every token, each shaped by everything before it. This is the "not late" half of the name: the interaction happens before any embedding is extracted, unlike ColBERT, which encodes documents separately.

Step 3: The final token of each document becomes its vector

The "last" half of the name is last-token pooling. The paper's abstract says embeddings are extracted from each document's final token. In the prompt template, each document ends with a special <|doc_emb|> token, and the query ends with a <|query_emb|> token placed after all passages. Each such token sits after its text in a causal model, so it has aggregated everything before it; the query's has seen every document. A small projector network then maps the hidden state down, 1024 to 512 to 256 numbers, which matches the "Final Embedding Size 256" line of Jina's architecture table.

Input: hidden states at the <|doc_emb|> and <|query_emb|> tokens. Output: one short vector per document and one for the query. This is the detail the lead promised: the score is read from one token per document, not from generated text and not from every token.

Step 4: Cosine similarity scores each document and the list is reordered

The relevance score of a document is the cosine similarity between its vector and the query vector, written si = cos(q, di) in the paper. The documents are sorted by that score, highest first, and the top few go to the language model that writes the answer. Sorting changes only the order of the documents, never their text.

Input: the query vector and the document vectors. Output: a reordered list. When a candidate list is larger than one pass can hold, Jina says larger collections are processed in batches, keeping the query consistent across them. The whole path is: shared window, causal attention, last-token vectors, cosine scores.

1 · Shared window2 · Causal attention3 · Last-token vectors4 · Cosine scoresReplay

Step-by-step description

1. One query and many documents share one window.
2. Each token attends to everything before it; the query comes last.
3. Each document gives one vector.
4. Cosine similarity reorders the list.

• Jina Reranker v3 puts one query and up to 64 documents into one context window.
• Causal attention lets the query vector see every document and each document see the ones before it.
• A vector is read from the last token of each document.
• The score is the cosine similarity of the query vector and each document vector.

Worked example

Take a first-stage search that returns 100 candidates (an illustrative number). At 64 documents per pass, that list needs 2 passes, one of 64 and one of 36.² If 64 documents each run about 2,000 tokens (an illustrative length), they use 128,000 of the 131,072 tokens, which leaves 3,072 tokens for the query and the tags.² The window, not only the document cap, limits how long each document may be.

Now the scoring step. The vectors below are invented and have 4 numbers instead of the real 256, so the arithmetic fits on a page. In this illustrative example the first stage returned Doc 2, Doc 3, Doc 1, in that order. The cosine scores are 0.978 for Doc 1, 0.846 for Doc 3 and 0.301 for Doc 2, so the reranked order is Doc 1, Doc 3, Doc 2.²

Jina says the model is 6× smaller than Qwen3-Reranker-4B; the exact ratio of four billion to 0.6 billion is about 6.67.² The 62.10 and 63.20 figures come from Jina's v3.5 page.

Text description of the diagram

• Doc 1 scores 0.978, Doc 3 scores 0.846 and Doc 2 scores 0.301 in this illustrative example.
• The reranked order is Doc 1, Doc 3, Doc 2.

Trade-offs and edge cases

Jina Reranker v3 trades a hard cap per pass for the benefit of seeing documents together. Where the three designs differ is shown below.

A cross-encoder scores each query and document pair in isolation, which Jina's model page contrasts with its listwise approach. The bge-reranker-v2-m3 page covers a pairwise reranker you can compare. ColBERT encodes documents separately before multi-vector matching. Jina Reranker v3 applies causal attention between the query and all candidate documents in one window, then reads one vector per document.

Text description of the diagram

• A cross-encoder scores each query and document pair in isolation.
• ColBERT encodes documents separately before multi-vector matching.
• Jina Reranker v3 applies causal attention between the query and all candidate documents in one window.

Edge cases to name in a round:

• Batching. Lists longer than one pass are split into batches. The paper says query embeddings are maintained consistently across batches to ensure ranking coherence; it gives no timing or score-drift figures, so test that on your data.
• Long documents. Tokens in the window are shared, so long passages crowd out candidates; chunk first, as in chunking strategies for RAG.
• Vendor numbers. Every benchmark figure here is Jina's own reporting: 61.94 on BEIR (a public benchmark made of many retrieval tasks), 66.83 on MIRACL (a multilingual retrieval benchmark), 67.92 on MKQA (a multilingual question-answering benchmark) and 70.64 on CoIR (a code retrieval benchmark). The BEIR score is normalized discounted cumulative gain at rank 10 (nDCG@10), a ranking score where higher is better; the model card lists the other columns without a metric note here, so check the paper before quoting one.
• Figures differ by protocol. The v3.5 page lists 62.10 for v3 under a unified top-100 protocol, while the model card lists 61.94 and the paper's main results table reports 61.85 for descending candidate order (62.24 for random), with top-100 candidates from jina-embeddings-v3, so state the protocol and version whenever you quote a number.
• Input order. Under causal attention, documents later in the window see more context than earlier ones, so the order of the candidates can change the scores. Jina's paper tests descending-relevance, ascending-relevance and random candidate orders in an ordering-sensitivity study, and reports average scores of 62.24 for random order, 61.85 for descending and 61.45 for ascending, calling the variations modest and not conclusive. Either way, test with shuffled candidate orders on your own data and watch how much the ranking moves.
• Latency. The pages cited here give no timing figures, so measure; see where RAG latency and cost go.
• Newer model and license. Jina Reranker v3.5 exists. The v3 model card lists a CC BY-NC 4.0 license, which is non-commercial, so a commercial product needs another arrangement. Check the card of the version you plan to use.

How to answer it in an interview

The spoken structure: say what goes into the window, say where the vector comes from, give the score, then name the cap and the measurement.

Common mistakes

• "It is a cross-encoder." (wrong) A cross-encoder scores one pair at a time. (right) "It uses joint attention like a cross-encoder, but over a whole list in one window."
• "It is ColBERT-style late interaction." (wrong) ColBERT encodes documents separately and matches them afterwards. (right) "Interaction happens first, then one vector per document is pooled."
• "It writes the ranking as text." (wrong) It extracts last-token embeddings and scores them by cosine. (right) "It scores vectors; it does not generate a ranked list."
• "A reranker replaces the retriever." (wrong) It only reorders candidates a first stage supplied. (right) "Retrieve broadly and cheaply, then rerank a short list."
• "The big window means unlimited documents." (wrong) The cap is 64 per pass. (right) "Longer lists are split into batches."

Follow-up questions

Is Jina Reranker v3 a cross-encoder?

Not in the pairwise sense. It uses joint attention between query and documents, as a cross-encoder does, but it reads a list of documents in one window and scores by cosine similarity of last-token vectors.

How is Jina Reranker v3 different from ColBERT?

ColBERT encodes documents separately and matches them to the query afterwards. Jina Reranker v3 puts the query and all documents in one window under causal attention, so the query reads every document, and only then takes one vector per document.

How many documents can Jina Reranker v3 rerank at once?

Up to 64 per pass within a 131,072-token window, with larger sets processed in batches. A 100-candidate list therefore takes 2 passes.

Does Jina Reranker v3 generate a ranked list as text?

No. Jina's model card contrasts it with generative listwise rerankers, calling it 10× smaller than them, because it extracts embeddings and scores them by cosine similarity instead of generating an ordering.

Is Jina Reranker v3 still the newest Jina reranker?

As of October 2026, no. Jina lists a successor, jina-reranker-v3.5, which on Jina's top-100 protocol scores 63.20 on BEIR against 62.10 for v3. Both figures are vendor-reported. For retrieval basics, see embeddings and vector search.

Sources

1. jina-reranker-v3: Last but Not Late Interaction for Listwise Document Reranking (arXiv 2509.25085) — arXiv (Wang, Li, Xiao; Jina AI), 29 Sep 2025
2. jina-reranker-v3: Last but Not Late Interaction for Listwise Document Reranking (arXiv 2509.25085v4) — arXiv (Wang, Li, Xiao; Jina AI), 6 Oct 2025
3. jina-reranker-v3 model card — Hugging Face (jinaai), 26 Oct 2026
4. Jina Reranker v3: 0.6B Listwise Reranker for SOTA Multilingual Retrieval — Jina AI, 26 Oct 2026
5. jina-reranker-v3 model page — Jina AI, 26 Oct 2026
6. jina-reranker-v3.5 model page — Jina AI, 26 Oct 2026