Today

1. LLM embeddings: how Qwen3, Gemini and LLM2Vec turn text into vectors.
2. A short bridge: retrieve candidates, then spend more computation on ranking.
3. Language models as rerankers: judge one passage, compare two, or order a list.
4. Compare the approaches: class rankings, reasoning before judgement, and computational cost.

How do we turn a language model into this retriever?

We still need the components just described:

1. Token representations that use context from the text.
2. A rule that produces one vector per query or passage.
3. Training pairs and a loss that reward the retrieval task.
4. A matching score for the stored document vectors.

Qwen3 Embedding, LLM2Vec and Gemini Embedding make different choices for these components. Three questions separate them:

• How do we get one vector?
• What does the query encoder read?
• How is the encoder trained, and on which data?

Sources: Qwen3 Embedding technical report (2025), LLM2Vec (COLM 2024), Gemini Embedding technical report (2025); Qwen3 section 2; LLM2Vec section 2; Gemini section 3.

Retrieval input pattern

Qwen3 Embedding, Gemini Embedding and LLM2Vec all use task information on the query side for query–passage retrieval.

Sources: Qwen3 Embedding model card; Gemini Embedding, §3.2, equation 1; LLM2Vec inference and input conventions.

Nemotron turns an LLM into a retrieval encoder

Nemotron-3-Embed-8B - NVIDIA

• Architecture: Ministral-3-8B-Instruct with bidirectional attention. Average the token vectors, then L2-normalise to obtain one 4,096-dimensional vector per text.
• Training data: 50M+ samples from public question-passage datasets and LLM-generated queries and question-answer pairs.
• Retrieval: encode query: ... and passage: ... separately. Precompute passage vectors; rank by cosine similarity at query time.
• Scope: inputs up to 32,768 tokens; evaluated across 34 languages. Shorter vector prefixes, such as 1,024 dimensions, can be used after renormalisation.

Source: NVIDIA model card, architecture, outputs and training data (accessed 28 September 2026). BF16 denotes the checkpoint's numerical precision.

Voyage 4 shares a space across model sizes

• Architecture: Voyage 4 Large uses a mixture of experts (MoE). The Large, 4, Lite and Nano models produce compatible embeddings.
• Asymmetric retrieval: embed documents with Large, then queries with Lite or Nano. Change the query model without rebuilding the document index.
• Storage: Matryoshka training supports shorter embedding prefixes; quantisation reduces the bits stored per coordinate.

What about the data? The launch post describes evaluation across retrieval domains, but does not disclose the training corpus, pair construction or negative-selection recipe. Evaluation datasets are not a description of training data.

Source: Voyage AI, The Voyage 4 model family, 15 January 2026. Architecture and capabilities are the provider's report.

Octen makes data a central design choice

Reported method: LoRA adaptation of Qwen3; train domain models, then combine their weights.

• Construct relevant pairs: synthesise queries from legal, finance, healthcare and code sources. Vary query wording, intent and noise.
• Use the positive labels: retain multiple relevant documents per query and multiple queries per document.
• Choose informative negatives: mine similar but irrelevant documents; filter false negatives so relevant passages are not pushed apart.

The lesson: training examples define which relationships the encoder learns. Corpus coverage, query realism and label quality deserve as much scrutiny as architecture. Nemotron also combines public pairs with synthetic supervision.

Illustrative example: for “Python exception handling”, another relevant tutorial is a positive, not a negative merely because it comes from a different document.

Sources: Octen Team, training pipeline, 13 January 2026, sections 2.1-2.4; Nemotron model card. Octen describes several changes together; this post does not isolate their individual gains in an ablation.

Pointwise: the Qwen3 reranker

system: Judge whether the Document meets the requirements based on the Query
        and the Instruct provided. Note that the answer can only be "yes" or "no".
user:   <Instruct>: {Instruction}
        <Query>: {Query}
        <Document>: {Document}

Use the model’s next-token scores for yes and no to obtain a relevance score:

Sources: Qwen3 Embedding technical report (2025); section 2 and Table 1; the report writes the exponent as P(yes | I, q, d).

Pairwise: ask twice, in both orders

Given a query "{q}", which of the following two passages is more relevant to the query?
Passage A: "{d1}"
Passage B: "{d2}"
Output Passage A or Passage B:

Position bias: the model may favour the passage shown first. Pairwise ranking prompting (PRP) therefore asks in both orders: and .

If both answers favour the same passage, it wins. If swapping the order changes the preferred passage, count a tie.

• All pairs: each passage gets 1 point per win and 0.5 per tie. calls, all parallel.
• Sorting: heapsort with the pairwise judgement as its comparison. calls.

The paper notes the swap is hard to apply to a listwise prompt because of its combinatorial nature: a window of passages has orders.

Sources: Qin et al., pairwise ranking prompting (Findings of NAACL 2024); sections 3.1-3.3, equation 2.

Rank1: reason, then judge

Rank1 is pointwise. For each query-passage pair it generates a reasoning chain, then true or false:

<think> The user is asking ... </think> true

• R1 generated 635,264 traces on MS MARCO queries and passages.
• Filtering left 386,336: traces that disagreed with the labels were removed, then a first model filtered noisy negatives.
• Smaller models were fine-tuned on these traces.

The reasoning chain costs generated tokens for every candidate. It can also be shown to a user or to a RAG system.

Sources: Weller et al., Rank1 (COLM 2025); abstract, sections 1, 2.1 and 2.2.

Candidate depth, computation and latency

For a reranker that scores candidates one at a time, at roughly constant cost:

is the number of candidates; is the average time to score one. Batching and parallel execution can reduce elapsed time.

• Candidate coverage: increasing cannot decrease first-stage recall, but it may leave it unchanged. Reranking cannot recover a passage missing from the candidate list.
• Pairwise and listwise methods: cost depends on the number of comparisons or windows, and the text processed per call. RankGPT’s overlapping windows depend on earlier results, limiting parallelism.

Retrieve candidates cheaply, then use the language model to judge relevance within the available compute budget.

Sources: Qin et al., pairwise ranking prompting (Findings of NAACL 2024), Sun et al., RankGPT (EMNLP 2023).