Order the steps for correctly using a prefix-required embedding model (BGE-M3) end to end

Order steps·Medium·4.0 · 0·~1 min

Attempt it

1At query time: ANN search the index with the query vector
2At index time: L2-normalize the output vectors and upsert to the vector DB
3At query time: encode the prefixed query and L2-normalize
4At query time: prepend 'query: ' to the user query
5At index time: encode the prefixed passages with the embedding model
6At index time: prepend 'passage: ' to each document chunk

A prefix-required embedding pipeline has **two parallel paths**: one runs offline at index time over your document corpus, and one runs online at query time per user request. Both paths follow the same three-step pattern: prepare the input, encode it with the model, normalize and use the resulting vector. **Index time** (runs once per corpus or whenever you re-embed): 1. Prepend 'passage: ' to each document chunk. 2. Encode the prefixed passages with BGE-M3. 3. L2-normalize the output vectors and upsert them to the vector database. **Query time** (runs per user query): 4. Prepend 'query: ' to the user query. 5. Encode the prefixed query with the same model and L2-normalize. 6. ANN search the vector database with the query vector to retrieve the top-K nearest passages. The parallelism matters. Both sides use the same model, the same prefix convention (different prefix per side, but applied consistently), and the same L2 normalization. If you skip the prefix on one side, the vectors live in different sub-regions of the embedding space and recall drops silently. If you skip normalization on one side, cosine similarity stops being equivalent to dot product and the ANN index returns wrong results. The order within each path is also fixed. You cannot encode before you prefix (the encoder consumes the prefixed string), you cannot normalize before you encode (you need the vector first). You cannot upsert or search before you have a normalized vector.

The pipeline has six steps in two phases. The order is forced by data dependencies and by the model's training contract. **Phase 1: index time, offline, runs over the corpus.** 1. Prepend 'passage: ' to each document chunk. The model card for BGE-M3 specifies this prefix; it is part of the training contract. 2. Batch-encode the prefixed passages with BGE-M3. Encoding is the expensive step; batching maximizes GPU utilization. 3. L2-normalize each output vector and upsert to the vector database (Pinecone, Weaviate, Qdrant, etc.). Normalization is critical: with unit-norm vectors, cosine similarity reduces to dot product, which is what most ANN indices natively compute. **Phase 2: query time, online, runs per user query.** 4. Prepend 'query: ' to the user's query string. Same training-contract requirement as the passage side, just a different prefix. 5. Encode the prefixed query with the same model and L2-normalize the output. The 'same model' part is non-negotiable, cross-model vectors are incomparable. 6. ANN search the vector database with the normalized query vector to retrieve the top-K nearest passages. The data-dependency structure is strict. You cannot encode before prefixing (the encoder consumes the full prefixed string). You cannot normalize before encoding (normalization operates on the vector output). You cannot upsert or search before the vector exists. And the two phases happen in temporal order: index time must complete before query time can return useful results. The parallel structure is the critical pattern: same prefix discipline on both sides (different prefix string, same convention), same encoder, same normalization. Break the parallelism and recall drops.

Quick reference

TL;DR

Index time: prefix passages, encode, normalize, upsert. Query time: prefix query, encode, normalize, ANN search. Same model, same normalization, parallel structure both sides.

Memory aid

Easy to grasp

Think of it like cooking a meal in two phases. First, prep day: you cut and label all the vegetables (prefix passages), cook them (encode), store them in labeled containers (normalize and upsert). Later, dinner time: you take your specific order (prefix the query), prepare it the same way (encode and normalize), then pull matching ingredients from the fridge (ANN search). The labeling is the prefix; you have to label both at prep and at dinner so the system matches them up.

Key concepts

Embeddings

Detailed answer & concept explanation

~6 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.

Quick scan · 2–4 min

Everything important, quickly.

6 to 8 min: two-phase parallel structure + data-dependency ordering within each phase + four common parallelism bugs + chunking + reranking extension.

Real-world examples

Real products, models, and research that use this idea.

BGE-M3 from BAAI is the dominant open-weight multilingual embedder in 2026 and uses this exact pipeline shape.
Pinecone, Weaviate, Qdrant, and Milvus all assume L2-normalized vectors as the input primitive for cosine-equivalent dot-product ANN.
Anthropic's RAG documentation shows the parallel index-time and query-time pipeline as the canonical pattern.
OpenAI text-embedding-3-large returns vectors that are already L2-normalized, but you still match the index and query model versions yourself.
Voyage v3-large and Cohere embed-v4 accept an `input_type` parameter ('document' vs 'query') that internally applies the right prefix or routing.

Interviewer follow-ups

What an interviewer would ask next. Try answering before peeking at the approach.

QWhere in this pipeline does chunking fit, and how do you size chunks?

QHow would you add a reranker as step 7?

QWhat changes if you switch to a managed API like OpenAI text-embedding-3-large?

Don't say this

Red flags and common mistakes that signal junior thinking. Click to expand.

Most common mistake

Skipping the prefix on one side. The most common production bug is prefixing passages at index time but forgetting to prefix queries at query time, the silent 5 to 15 percent recall drop.

60-second cheat sheet

The night-before-the-interview bullets. Scan these on the way to the call.

References

Primary sources. Skim if you want the original framing.