HEURISTICS.md

Embedding-on-Jobs heuristics — what we measured, and what to try

A field guide for the embeddings/ recipes, for humans and agents. Everything here is measured on HF Jobs (2026-07), not folklore. If you're an agent picking settings for a user's data: read the TL;DR, match the data shape, use the defaults; the recipe's --batch-size auto

• token sniffer handle the rest.

First: pick a current model, not the frozen list below

Embedding quality moves fast. The specific models in this guide are what we benchmarked in 2026-07 — a durable baseline, not a permanent answer. Before committing, find the current best (an agent should do this automatically, not trust a hard-coded name):

• MTEB leaderboard — the canonical ranking: https://huggingface.co/spaces/mteb/leaderboard
• The Hub, from the CLI (scriptable, always current):

  hf models ls --filter sentence-transformers --sort trending_score --limit 20   # what's hot now
  hf models ls --filter sentence-transformers --sort downloads --limit 20        # proven workhorses
  hf models ls --search embedding --num-parameters min:0,max:1B --sort trending_score
  

  Sort by trending_score or downloads, not created_at — the newest list is mostly empty test repos. Then check the model card for its prompt convention (see Prompts) and license.

The heuristics here are model-independent — token-bound throughput, batch ~128, L4-for-encoders, prompts-matter, seq-len cost hold whatever tops the leaderboard next week. Use them; swap in the current model. (E.g. as of this writing the CLI surfaced newer options like jina-embeddings-v5, voyage-4-nano, and LiquidAI's ColBERT that postdate parts of this guide.)

TL;DR decision table

(benchmarked examples, 2026-07 — run the queries above for the current best)

Your situation	Model	Flavor	Notes
Default / fast / cheap (English)	all-MiniLM-L6-v2	l4x1	~900 rows/s, ~$0.24/1M rows, dim 384
Better English quality	BAAI/bge-base-en-v1.5	l4x1	~120 rows/s, ~$1.87/1M, dim 768
Multilingual / long-context	BAAI/bge-m3	l4x1/a10g-large	slower (dim 1024); use only if you need it
Top open quality (decoder)	Qwen/Qwen3-Embedding-0.6B	a100-large + vLLM variant	A100 is 4× the L4 here AND cheaper/1M
Max quality, cost no object	Qwen/Qwen3-Embedding-8B (4B benched)	a100-large + vLLM	~$7/1M, dim 2560
Images, fast	clip-ViT-B-32	l4x1	~395 img/s (bs=32), dim 512
Images, higher quality	clip-ViT-L-14 or SigLIP-2-large	l4x1/a10g-large	slower, larger dim

One-line scale proof: 241,787 Wikipedia articles → a searchable Lance vector DB on the Hub in 4.5 min for ~$0.07 on a single L4 (all-MiniLM). Cheap at scale is real.

Text: the load-bearing heuristics

1. Throughput is token-bound, not row-bound. Same model (all-MiniLM, L4): short text (AG News, median 53 tokens) = 2866 rows/s; long text (IMDB, median ~300 tokens) = 912 rows/s. A 3× swing from text length alone. So estimate cost in tokens, not rows, and know that "rows/s" quoted anywhere is only meaningful with a text length attached.

2. Batch size peaks around ~128 — bigger is usually slower. Counter-intuitive but consistent: at batch 128/256/512/1024, all-MiniLM on short text ran 2443 / 1981 / 1355 / 796 rows/s — monotonically down. sentence-transformers length-sorts internally, and larger batches pad to the longest member + add overhead. Don't crank the batch. --batch-size auto probes and lands here for you; the token sniffer widens the probe range for short text (and it still picks ~128).

3. Sequence length is a real cost lever — and bigger models feel it more. On long text (IMDB), capping --max-seq-len 512 → 128 sped things up 1.8× for all-MiniLM (912 → 1682 rows/s) and 2.8× for bge-base (119 → 332 rows/s). The larger model benefits more because attention is O(n²), so shorter sequences help disproportionately, not just linearly.

Model	seq-cap 128	seq-cap 512	speedup from capping
all-MiniLM-L6-v2	1682 rows/s	912 rows/s	1.8×
bge-base-en-v1.5	332 rows/s	119 rows/s	2.8×

Rule of thumb: RAG-sized chunks live under 512 tokens, so the --max-seq-len 512 default is right for most retrieval corpora. Lower the cap for a big, cheap speedup when your text is short anyway or you can tolerate truncation (the token sniffer tells you what fraction you'd lose). Raise it only if the sniffer warns you're truncating a lot AND you need the tail — budget for the slowdown, especially on bigger models.

4. GPU: L4 for encoders, A100 only for decoders. $/1M rows (encode-only):

Model (type)	L4 $0.80	A10G $1.50	A100 $2.50
all-MiniLM (encoder)	$0.24	$0.38	$0.51
bge-base (encoder)	$1.87	$2.02	$2.66
bge-m3 (encoder)	$6.17	$6.22	$8.27
Qwen3-Embedding-0.6B (decoder)	$3.77	$4.48	$2.78

Encoders (MiniLM, bge) are cheapest on the L4 — the bigger GPU doesn't earn its price. Decoder embedders (Qwen3-Embedding) are the exception: the A100 runs them ~4× faster AND cheaper per 1M, because decoders actually use the extra compute.

5. Engine: sentence-transformers by default; vLLM ~2× for decoder embedders. On the same Qwen3-Embedding-0.6B/L4, vLLM pooling hit 121 rows/s vs sentence-transformers' 59 (~2×). For small encoders, sentence-transformers is already fast and far simpler — use the default. Switch to generate-embeddings-vllm.py only for large decoder embedders at scale.

6. Prompts are a correctness issue, not a nicety. Many retrieval models need a different prefix for documents vs queries, and mismatching them silently hurts retrieval. Gotcha we verified: sentence-transformers reports an empty placeholder {"query":"","document":""} for models that ship NO prompts — so e5 ("passage: "/"query: ") and nomic ("search_document: "/"search_query: ") look prompt-less but aren't; their prefixes live only in the model card. The recipe's built-in family table handles e5 / nomic / bge / Qwen3 automatically for a document corpus; pass --query-mode for a query set, or --prompt '<prefix>' to override.

Images: heuristics

• Model choice: clip-ViT-B-32 (395 img/s on L4 at bs=32, dim 512) is the fast default; clip-ViT-L-14 (40 img/s, dim 768) or SigLIP-2-large (46 img/s, dim 1024) for quality. SigLIP-2 wins at the large tier but needs the transformers path (4× the code); CLIP-via-sentence-transformers is the clean one-liner.
• Flavor + cost: L4 is the cost pick for every image model. clip-ViT-B-32 ≈ $0.56/1M images (pre-sized) or $1.03/1M (full-res); siglip2-large ≈ $4.84/1M. A10G is ~1.3× faster but 1.875× the rate ($0.92/1M for B-32) → use it only when wall-clock, not cost, matters.
• --batch-size auto uses 32/64/128 for images; 64 is a safe manual default (only ~6% off the bs=32 peak on full-res images, and more robust).
• Batch: images favor small batches — the opposite of the "fixed-size → batch big" hunch. clip-ViT-B-32 on L4: bs=32 = 395 img/s (fastest), then flat/slower above (343 / 330 / 333 / 331 / 329 at bs 64 / 128 / 256 / 512 / 1024). Peak GPU mem stays tiny (0.7–4 GB even at bs=1024), so it's not a memory ceiling — it's per-batch pipeline overhead. So "don't crank the batch" holds for images too, at an even smaller optimum than text. --batch-size auto probes from 32 and lands on it — no image-specific tuning needed.
• GPU memory = f(batch × model) only — models resize to a fixed 224px, so source resolution never touches GPU memory (verified: identical peak across a 32px and a full-res dataset). BUT full-res images run ~1.8× slower than tiny ones (395 → 215 img/s for B-32) — decode/resize is a real CPU tax, negligible only for pre-sized/small images.

Storage / dimensions

Bigger embedding dim = more storage + slower vector search. If your model supports Matryoshka truncation (nomic-embed, Qwen3-Embedding), you can keep the first N dims (e.g. 256 of 768) for much cheaper storage/search at a small quality cost — worth it for large indexes. Always normalize (the recipe does) so cosine = dot product.

Other modalities

Text and images are what these recipes cover. Audio (CLAP / speech-encoder embeddings) and code (code-specialized text embedders) use different models — a separate recipe, not this one. Note it and route users there rather than forcing them through the image/text path.

The evidence (measured on HF Jobs, 2026-07)

Measured on HF Jobs (2026-07) with the scripts in this folder. Text: 20k rows, batch 64, seq-cap 512 unless noted. All datasets used were public; all test outputs were private.