Embeddings

What an embedding actually is

Historical line: from Word2Vec to sentence transformers

1. 2013

   Word2Vec (Mikolov et al., Google)

   Two architectures — skip-gram and CBOW — trained on the prediction task of "given a word, predict its neighbors" (or vice versa). Produced dense word vectors, typically 100–300 dimensions. The king/queen arithmetic demo made the technique famous. Paper: "Efficient Estimation of Word Representations in Vector Space" (arxiv.org/abs/1301.3781).

2. 2014

   GloVe (Pennington, Socher, Manning, Stanford)

   Global Vectors for Word Representation. Reformulated word embedding training as a matrix factorization problem on global word-word co-occurrence counts, rather than local context windows. Often comparable to Word2Vec; sometimes better on analogy tasks. Paper: "GloVe: Global Vectors for Word Representation" (nlp.stanford.edu/pubs/glove.pdf).

3. 2016

   fastText (Bojanowski et al., Facebook AI)

   Extended Word2Vec with subword (character n-gram) information. Big win on morphologically rich languages and out-of-vocabulary words. Paper: "Enriching Word Vectors with Subword Information" (arxiv.org/abs/1607.04606).

4. 2018

   ELMo and BERT — contextual embeddings

   ELMo (Peters et al.) and then BERT (Devlin et al., Google) replaced static word vectors with contextual ones — the same word gets a different vector depending on its sentence. BERT's [CLS] token or mean-pooled hidden states became the de facto sentence representation, though imperfectly.

5. 2019

   Sentence-BERT (Reimers and Gurevych)

   The pivotal paper. Showed that raw BERT [CLS] embeddings are bad for semantic similarity, and that fine-tuning BERT with a siamese-network objective on NLI data produces sentence embeddings that work well with cosine similarity. The sentence-transformers library (SBERT.net) became the open-source standard. Paper: "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks" (arxiv.org/abs/1908.10084).

6. 2022

   OpenAI text-embedding-ada-002

   The first widely-adopted commercial embedding API at scale. 1536 dimensions, single model for everything, cheap. Became the default for most production RAG systems through 2023.

7. 2023–2024

   The encoder renaissance

   BGE (BAAI), E5 (Microsoft), GTE (Alibaba), Cohere embed-v3, Voyage AI, mxbai-embed-large, NV-Embed. All push hard on MTEB. Many open-weight models match or beat proprietary ones on retrieval benchmarks. Matryoshka embeddings (Kusupati et al., NeurIPS 2022) and quantization-aware training enter the mainstream.

8. 2024–2026

   Long context vs RAG tension

   Frontier models with 1M+ token context windows force a rethink of when RAG is the right architecture. Embeddings remain dominant for very large corpora, latency-sensitive lookups, and cost-bound workloads, but the boundary keeps moving. The discipline matures from "always RAG" to "measure and decide."

The current model landscape

Best-effort snapshot as of mid-2026. Model lineups, dimensions, and leaderboard positions shift monthly — check the MTEB leaderboard (huggingface.co/spaces/mteb/leaderboard) and each provider's docs before you commit. Dimensions listed are native; many of these models support Matryoshka-style truncation to smaller sizes with a quality tradeoff.

Cosine, dot product, Euclidean — which one to use

MTEB: read it carefully

Semantic search workflow, end to end

The minimum-effective-dose pipeline. Skip a step only after you've measured what it gives you.

• Chunk your documents. Typically 200–800 tokens per chunk with some overlap (50–100 tokens). Chunking quality dominates most retrieval outcomes; it's underrated.
• Embed each chunk with your chosen model. Store the vectors plus the source text plus metadata (document ID, position, timestamps).
• Build a vector index. HNSW (Hierarchical Navigable Small World, Malkov & Yashunin 2016, arxiv.org/abs/1603.09320) is the dominant ANN structure. IVF, ScaNN, DiskANN are alternatives.
• At query time: embed the query with the same model (and the same input-type prefix if the model is asymmetric, like E5 or Cohere v3). Retrieve top-k candidates by cosine or inner product.
• Optionally apply hybrid search — combine dense vector retrieval with sparse keyword retrieval (BM25) using reciprocal rank fusion. Wins consistently on domain-specific terms, model numbers, and proper nouns that embeddings sometimes blur.
• Rerank the top-k with a cross-encoder. Usually the largest quality jump per dollar in the whole pipeline.
• Feed reranked context to your LLM (for RAG) or return directly to the user (for search).
• Measure end-to-end. Recall@k and nDCG on a labeled eval set are the standard metrics. If you don't have an eval set, you don't have a retrieval system — you have a vibe.

RAG: retrieve, augment, generate

Vector databases

The vector database landscape is crowded and the differences matter less than vendors imply. Most production workloads at moderate scale (under ~10M vectors, sub-100ms p99 latency targets) can be served by any of these. Differences become real at scale, at multi-tenancy, or when filters and hybrid search complicate the query.

Reranking with cross-encoders

When embeddings + RAG beats long-context — and when it doesn't

The honest decision matrix. Long-context frontier models (Claude with 200K, GPT-4 Turbo / GPT-4o, Gemini 1.5/2 with 1M+) made many RAG pipelines from 2022–2023 obsolete. They also did not replace RAG everywhere. Use this matrix as a starting point, not a verdict.

Honest gotchas

Things that bite production embedding systems that aren't on the leaderboard pages.

• Model drift — re-embedding millions of documents because you switched models is expensive. Pick a model you can live with for a year, or design for dual-indexing during migrations.
• Asymmetric models — E5, BGE, Cohere v3 and others expect different prefixes or input types for queries vs documents (e.g., 'query: ' vs 'passage: ' for E5). Forgetting this silently degrades retrieval by 5–15 points.
• Truncation — most embedding models have a max input length (often 512 tokens, sometimes 8192). Documents longer than that get silently truncated. Chunk first.
• Language mismatch — most leaderboards are English-heavy. For non-English or multilingual corpora, evaluate on multilingual benchmarks (MIRACL, MTEB multilingual) and prefer models explicitly trained multilingually (multilingual-e5-large, Cohere embed-multilingual-v3, BGE-M3).
• Domain mismatch — generic embedding models trained on web text underperform on legal, medical, financial, and code domains. Domain-specific fine-tuning or domain-trained models (Voyage's vertical variants, code-specific embedders) often beat a generic SOTA model on your specific task.
• Quantization — float32 vectors are wasteful. int8 quantization typically loses <1% recall and quarters the storage. Binary quantization with rescoring is even more aggressive and surprisingly competitive in recent benchmarks. Worth evaluating.
• Cosine traps — two vectors with similarity 0.85 sound close. They aren't necessarily. Calibrate against your own distribution; "high similarity" is relative to your corpus, not absolute.

Minimum-effective-dose checklist