development

Best Embedding Models

The best text embedding models in 2026 compared on price, licence, dimensions, context length and measured retrieval quality — Qwen3-Embedding, voyage-4, Gemini Embedding 2, Cohere Embed v4, OpenAI text-embedding-3, EmbeddingGemma, IBM Granite, Microsoft Harrier and Jina v5 — with every published rate card, the licence traps that catch commercial users, and an honest account of why the current commercial flagships have almost no benchmark coverage.

Updated August 2026

Quick answer: The best embedding model for most teams in 2026 is Qwen3-Embedding-8B — Apache 2.0, free to self-host, 70.75 on MTEB(Multilingual, v2), and the strongest off-the-shelf model on the independent CORE-Bench code-retrieval evaluation. If you want a managed API, voyage-4-large at $0.12 per million tokens is the strongest commercial option and the only one that lets you change models without re-embedding your corpus, because all four Voyage 4 models share one embedding space. Gemini Embedding 2 at $0.20 per million text tokens is the pick if you need images, audio or video in the same vector space — but Google states plainly that its embedding space is incompatible with gemini-embedding-001, so upgrading means re-embedding everything. For anything running on a laptop or a phone, EmbeddingGemma fits in under 200 MB of RAM.

The caveat that matters more than any ranking: the current commercial flagships are barely benchmarked at all. Our analysis of MTEB’s own published results repository (commit f4cc6c8b3, 20 August 2026) found voyage-4, voyage-4-large and Cohere-embed-v4.0 each have results for 2 of the 131 tasks on MTEB(Multilingual, v2) and 0 of 38 on MTEB(eng, v2), while gemini-embedding-2 has no results at all. Any “MTEB score” you see quoted for those four models is not a benchmark result. Buy them on their published specifications, their pricing and your own evaluation — not on a leaderboard position that does not exist.

The current state of embedding models: August 2026

Four things have changed since 2025, and a mental model built on last year’s cast will now be wrong in specifics.

First, the open-weight tier caught the commercial tier, and then the commercial tier stopped publishing. The top of MTEB(Multilingual, v2) is now entirely open weights. On our computation from MTEB’s results repository, microsoft/harrier-oss-v1-27b leads at 74.31, followed by tencent/KaLM-Embedding-Gemma3-12B-2511 at 72.32 and Qwen/Qwen3-Embedding-8B at 70.75. The best-scoring closed model with complete coverage is google/gemini-embedding-001 at 68.84 — and that model has already been superseded. The commercial vendors that shipped in 2026 did not submit their new models for evaluation.

Second, several of 2025’s default recommendations have stopped shipping. BAAI has released no new general-purpose text embedder since July 2024, though FlagEmbedding v1.4.0 shipped on 22 April 2026 and bge-m3 is still downloaded 35.6 million times a month. intfloat’s E5 family is functionally frozen at February 2024. Nomic has published no 2026 embedding model and has repositioned as an architecture and construction document-AI company. OpenAI has not refreshed its embeddings since January 2024. Qwen3-Embedding, still the best all-round open model, was released on 5 June 2025 and has had no text successor.

Third, the new entrants are not the companies you would guess. Microsoft, NVIDIA, IBM and Perplexity all shipped open-weight embedding models in 2026. Microsoft’s harrier-oss-v1 family (270M, 0.6B and 27B, MIT licence, March 2026) tops the multilingual board, with a 32,768-token context across all three sizes. NVIDIA’s Nemotron-3-Embed-8B (16 July 2026) was launched specifically on RTEB rather than MTEB. IBM Granite embedding 311m multilingual r2 (29 April 2026) is Apache 2.0 with a 32,768-token window at 311M parameters. Perplexity released pplx-embed-v1 under MIT in February 2026.

Fourth, the category consolidated into other people’s companies. Voyage AI was acquired by MongoDB on 24 February 2025 for $220 million. Jina AI’s acquisition by Elastic completed on 9 October 2025. ZeroEntropy was acquired by Notion on 24 July 2026, and all ZeroEntropy hosted products sunset after 4 September 2026 — its models were relicensed Apache 2.0 and remain self-hostable, but do not build on the API. Of the independent specialists, only Cohere and Nomic are still standing, and Cohere’s flagship embedding model is now sixteen months old.

The three ways to get embeddings

Almost every buying decision in this category collapses into one of three choices, and the price difference between them is roughly three orders of magnitude.

Call a commercial API. You pay per million tokens, you get a maintained model, you accept that the vendor decides when it retires. Prices run from $0.02 per million tokens (OpenAI text-embedding-3-small, Voyage voyage-4-lite) to $0.20 (Gemini Embedding 2). This is right for most teams, most of the time, because the arithmetic is trivial: embedding ten million tokens a month costs between $0.20 and $2.00.

Self-host an open-weight model. You pay nothing per token and you own the operational burden. Every model in the sub-600M class runs on a laptop CPU; the 7B–8B class needs a real GPU. At small volumes this is not a cost decision — using IBM’s published throughput of 2,935 documents per second for granite-embedding-english-r2 on a single H100, ten million tokens at 512-token chunks is about 6.7 seconds of GPU time per month. Any always-on rented GPU costs far more than the $1.50 that gemini-embedding-001 would have charged for the same work at $0.15 per million tokens. Self-host for data residency, air-gapped operation, deprecation immunity, the ability to fine-tune, or because you already own idle hardware — not to save money at low volume.

Use whatever your database or platform bundles. Amazon Bedrock, Azure AI Foundry and Vertex AI all resell embedding models inside a governed environment. You trade a little choice and some price transparency for procurement that has already happened.

A fourth option now exists at the edge of the category and is worth naming: do not embed at all. Agentic search over a filesystem with grep has displaced vector retrieval in several high-profile coding products. That debate has real evidence on both sides and gets its own section below.

Best embedding models ranked (August 2026)

The rank column is our recommendation, not a score ordering. Where a model scores well but is expensive to store, hard to serve or restrictively licensed, we have ranked it lower than its score alone would put it — and said why in the notes below. The score column is Mean (Task) on MTEB(Multilingual, v2), computed by us from MTEB’s published results repository at commit f4cc6c8b3 (20 August 2026), counting only models with complete results across all 131 tasks. Models marked “no comparable score” have too little leaderboard coverage for a valid mean; models marked “not published” have not been submitted. Both are statements about benchmark participation, not about quality. EmbeddingGemma’s figure is from its own model card.

Two entries on MTEB’s English board are deliberately absent from this table. jcorners/ingot-8b-r3 ranks first on MTEB(eng, v2) at 75.06 but is registered as closed weights served from a third-party endpoint, and its declared parameter count, embedding dimension and maximum sequence length are byte-identical to Qwen3-Embedding-8B’s. We could not establish who publishes it or whether it is independent of Qwen3, so we have not ranked it. Kingsoft-LLM/QZhou-Embedding at 74.89 declares bge_m3_training_data among its training sets, which affects its zero-shot standing. Neither omission is an accusation; both are cases where we could not verify enough to rank responsibly.

The commercial APIs in depth

1. Voyage AI — best commercial API

Voyage is the strongest paid option in 2026 and the only vendor in the category that has designed against lock-in. The Voyage 4 family shipped on 15 January 2026 with a mixture-of-experts backbone and one property no competitor matches: all four models produce compatible embeddings. You can embed documents with voyage-4-large and queries with voyage-4-nano, or upgrade your query model later, without re-vectorising anything. Voyage also keeps legacy models callable back to voyage-01 rather than shutting them off.

Every model in the family supports 2048, 1024 (default), 512 and 256 dimensions and five output precisions — float32, int8, uint8, binary and ubinary — at a 32,000-token context. Prices from Voyage’s own rate card (last modified 13 August 2026): voyage-4-large $0.12, voyage-4 $0.06, voyage-4-lite $0.02 per million tokens, with the first 200 million tokens free and a 33% Batch API discount over a twelve-hour window (free credits do not apply to batch).

voyage-4-nano is open weights under Apache 2.0 — Voyage’s first — which makes it the only model here you can run yourself and still keep space-compatible with a hosted frontier model.

The catch is data policy, and it is the sharpest provider finding on this page. Voyage’s FAQ (modified 3 August 2026) states that opting out of Voyage storing and training on your data requires that you “have a payment method on file and be an organization Admin.” The default is labelled Opted In. Anyone using the free 200-million-token allowance therefore has no route to opt out and no route to zero-day retention. Voyage also warns that opting out is one-way: “You won’t be able to opt-in again in the dashboard after you opt out.”

Specialist models: voyage-code-4 (13 August 2026, $0.12), voyage-context-4 (29 June 2026, $0.12, auto-chunking to a 120,000-token document window), voyage-multimodal-3.5 (15 January 2026, $0.12 per million text tokens plus $0.60 per billion pixels), and rerankers covered below.

2. Google Gemini Embedding 2 — best multimodal, worst lock-in

Gemini Embedding 2 is Google’s first natively multimodal embedding model: text, images (up to six per request), video (up to 120 seconds), native audio, and PDFs up to six pages directly into one vector space. Text context is 8,192 tokens — four times gemini-embedding-001’s 2,048 — with continuous Matryoshka dimensions from 128 to 3072 and automatic re-normalisation on truncation.

Pricing from Google’s own page: $0.20 per million text tokens, $0.45 per million image tokens, $6.50 per million audio tokens, $12.00 per million video tokens. Google’s pages disagree with each other on release status and batch availability — the announcement blog is dated 10 March 2026 as a public preview, the deprecations table records a 22 April 2026 release, the all-models index still carries a -preview suffix as of 14 August 2026,. Treat the GA status as unsettled.

The reason not to default to Google is written in Google’s own documentation, verbatim: “The embedding spaces between gemini-embedding-001 and gemini-embedding-2 are incompatible. This means you cannot directly compare embeddings generated by one model with embeddings generated by the other. If you are upgrading to gemini-embedding-2, you must re-embed all of your existing data.” Google’s deprecation record shows it means it: text-embedding-004 was announced for shutdown on 3 December 2025 and switched off on 14 January 2026 — about six weeks’ notice. The embedding-001 and embedding-gecko-001 models got the same six weeks in 2025. gemini-embedding-001 is currently scheduled to shut down on 14 May 2028.

Free-tier data policy is explicit: Google’s terms (effective 23 March 2026) say unpaid services use submitted content to improve Google products, that “human reviewers may read, annotate, and process your API input and output,” and instruct users “Do not submit sensitive, confidential, or personal information to the Unpaid Services.” Paid-tier content is not used for training. Users in the EEA, Switzerland and the UK receive paid-tier treatment on free quota, and Google requires paid services for API clients serving those regions.

3. Cohere Embed v4 — the longest context, and the oldest flagship

Cohere Embed v4 shipped on 15 April 2025 and remains Cohere’s newest embedding model as of 21 August 2026 — sixteen months without a refresh, in a window where Cohere shipped Command A+, Rerank 4 and Transcribe. It is still the specification leader on one axis that matters: 128,000 tokens of context, roughly fifteen times OpenAI’s 8,192 and four times Voyage’s 32,000. It returns a single unified vector from interleaved text and images, supports 256, 512, 1024 and 1536 (default) dimensions as a closed set, and offers float, int8, uint8, binary and ubinary precisions.

There is no native “upload a PDF” endpoint; AWS’s guidance is to rasterise each page and send it as an image. Limits are 96 items per call and 5 MB per image, with image tokens calculated as roughly (pixels ÷ 784) × 4.

Cohere’s per-token embedding price is data not available. cohere.com/pricing renders its retrieval-model rates client-side and we could not read them. Third-party trackers report $0.12 per million text tokens and $0.47 per million image tokens; we have not been able to confirm either against Cohere and will not print them as fact.

Cohere’s data policy is opt-out, not opt-in. Its enterprise data commitments instruct customers to “Adjust the toggle to ‘Off’ to opt out,” and state that personal information is stripped from prompts and generations “if you are opted in.” Logged data is deleted after 30 days. The commitments apply to paying customers only — trial API keys fall under the standard Terms of Use. Note that Cohere’s language covers “prompts and generations” and nowhere addresses embedding vectors as a distinct category.

4. OpenAI — the default that stopped moving

OpenAI has shipped no new embedding model since 25 January 2024. text-embedding-3-large (3072 dimensions, 8,192 tokens, $0.13 per million) and text-embedding-3-small (1536 dimensions, $0.02 per million) are still the flagship pair, and text-embedding-ada-002 ($0.10) is not deprecated — it remains in the live catalogue and absent from the deprecations page, which is a common wrong assumption.

Two things keep OpenAI on this list despite the age. The first is that its dimensions parameter accepts any integer, not a closed set of four — the most flexible truncation implementation of any commercial model. The second is ecosystem: nearly every RAG framework, vector database tutorial and evaluation harness defaults to it, which makes it the least surprising choice in any codebase someone else will maintain.

Two things should give you pause. It has no multilingual story to compare with Qwen3’s 100+ languages or Cohere’s 128k context, and text-embedding-3-large has results for only 109 of 131 tasks on the multilingual board and 8 of 38 on the English one, so even the incumbent is not fully measured.

A widely circulated “$0.065” price for text-embedding-3-large is a misreading, not a discount: OpenAI’s model card renders per-million and Batch API prices through a single client-side toggle, and $0.065 is exactly the 50% batch rate. Both official pages agree on $0.13 standard.

On data: OpenAI’s policy is the clearest of the four. Training is opt-in and off by default, and the per-endpoint table is explicit for /v1/embeddings — training “No”, abuse-monitoring retention 30 days, application-state retention “None”, zero-data-retention eligible “Yes”. If you use /v1/vector_stores, note that it retains application state “Until deleted” and is not ZDR eligible.

5. Mistral, Amazon and Azure

Mistral still lists mistral-embed-2312 ($0.10 per million, 1024 fixed dimensions, 8k context) and codestral-embed-2505 (28 May 2025, $0.15 per million, 1536 default dimensions to a 3072 maximum, 8,192 context). Both are Premier models with no open weights. Mistral’s comparison charts are published as images with no extractable numbers, and the “85% average score” figure circulating in secondary write-ups does not appear on Mistral’s own page. Data policy is opt-out: the help centre (12 August 2026) instructs users to disable the “Anonymous improvement data” toggle.

Amazon Bedrock offers amazon.titan-embed-text-v2:0 (1024/512/256 dimensions, 8,192 tokens) and amazon.nova-2-multimodal-embeddings-v1:0 (3072/1024/384/256, 8,192 tokens). Both prices are data not available — the Bedrock pricing page renders its embedding-model table empty while other tabs on the same page populate. AWS has historically carried the strongest no-training language in the industry, but reports in June 2026 of a possible data-sharing carve-out for some third-party models on Bedrock could not be confirmed against AWS’s own pages, so verify your own contract rather than relying on the general statement.

Azure OpenAI resells text-embedding-3-large and -small. Price is data not available — both Azure pricing pages render placeholder cells. Two structural notes: Azure quotes per 1,000 tokens, not per million, and runs a separately priced “DataZone” SKU. Azure’s embedding deployments are unusually stable, with every embedding deployment scheduled to retire on 9 February 2028 and no announced replacement — a sharp contrast with Azure chat models, which typically retire within months.

The open-weight models in depth

Qwen3-Embedding — still the best all-round open model

Released 5 June 2025 under Apache 2.0 in three sizes, and still the model we would default to fourteen months later.

Weights are 1.21 GB, 8.06 GB and 15.2 GB at BF16; official GGUF builds land at 639 MB (0.6B, Q8_0), 2.5 GB (4B, Q4_K_M) and 4.68 GB (8B, Q4_K_M), which is what Ollama pulls by default. It supports 100+ languages and is instruction-aware, taking Instruct: {task}\nQuery: {q} on queries only, with instructions written in English even for non-English corpora. Qwen’s own testing puts the instruction benefit at 1–5%.

Three honest caveats. The “No. 1 on MTEB multilingual” line on the model cards is a 5 June 2025 snapshot frozen into the card and is no longer true. The cards claim 32K context while Qwen’s own sample code sets max_length=8192. And the cards describe the series as “the latest proprietary model of the Qwen family,” which is sloppy phrasing for “first-party” — the licence tag on all six repositories is apache-2.0 and Qwen’s blog says open-sourced under Apache 2.0. Do not repeat “proprietary” as a licence descriptor.

There is no text successor. Qwen3.5, 3.6 and 3.8 are all language models. The only newer Qwen embedder is Qwen3-VL-Embedding (8 January 2026), which scores worse on text — MMTEB 67.88 at 8B against Qwen3-Embedding-8B’s 70.75 — and covers 30+ languages rather than 100+. It does not supersede it.

Microsoft Harrier — the top of the multilingual board

harrier-oss-v1 landed in March 2026 in three sizes under MIT, and on our computation it leads MTEB(Multilingual, v2): 74.31 for the 27B, 69.17 for the 0.6B, 66.61 for the 270M. All three carry a 32,768-token context; the 27B outputs 5,376 dimensions.

The 0.6B is the interesting one. At 596M parameters it scores 69.17 — within half a point of Qwen3-Embedding-4B (69.57), a model nearly seven times its size, and above every commercial model with complete MTEB coverage. If you want close-to-frontier multilingual quality on hardware that fits in a container, this is currently the strongest candidate.

Two things to hold lightly. We verified Harrier from its Hugging Face model cards and from MTEB’s results repository, where it has complete 131-of-131 coverage; we did not locate an independent Microsoft announcement. And a 5,376-dimension vector at float32 is 21,504 bytes each — before you index a million of them, read the storage section.

Microsoft Research separately publishes bitnet-embedding (270M and 0.6B, MIT, MTEB v2 66.26 and 67.49) for extreme-quantisation deployments.

IBM Granite — the cleanest enterprise story

granite-embedding-311m-multilingual-r2 (29 April 2026, Apache 2.0) is the model to reach for when procurement is the hard part. It is a ModernBERT architecture with a 32,768-token context at 311M parameters, Matryoshka support at 768, 512, 384, 256 and 128 dimensions, 200+ pretrained languages with enhanced retrieval on 52 plus nine programming languages, and it needs no instruction prefix at all — which quietly removes the most common migration bug in this category.

IBM’s published figures: multilingual retrieval 65.2 across 18 tasks, LongEmbed 71.7 across six, overall average 56.3. The 97M sibling scores 52.2 and ships at 195 MB of safetensors or 98 MB as a quantised ONNX build. IBM claims the 97M ranks first among multilingual embedding models under 100M parameters and the 311M second under 500M.

The differentiator most enterprise buyers care about: Granite was trained without MS-MARCO, whose licence is non-commercial. IBM also ships ONNX, OpenVINO and OpenVINO INT8 builds in-repo, and publishes a rare honest regression — the 97M scores 52.9 on Belebele against R1’s 55.1, a disclosed pruning trade-off.

One hard operational constraint, stated on IBM’s own cards: “Ollama does not currently support ModernBERT-based models.” We confirmed this independently — Ollama has no ModernBERT converter and the pull request adding one was abandoned on 12 January 2026. llama.cpp is the route instead: full ModernBERT support merged on 19 February 2026 and Granite multilingual R2 on 2 June 2026.

EmbeddingGemma — best on-device, worst licence surprise

EmbeddingGemma (4 September 2025, 308M parameters) is still the best answer for embeddings that run on a phone, a browser or a laptop with no GPU. Google’s claim is exact and verified on the card: quantisation-aware training reduces RAM usage to sub-200MB. The Ollama QAT Q4_0 build is 239 MB on disk. Scores at full precision and 768 dimensions: MTEB Multilingual v2 61.15, MTEB English v2 69.67, MTEB Code v1 68.76 — with QAT Q4_0 costing about half a point.

Two limits shape where it fits. The context window is 2,048 tokens, the shortest of any model we recommend, and throughput is poor for its size — IBM’s H100 benchmark puts it at 1,277 documents per second, slower than models three times its parameter count. Activations do not support float16; use float32 or bfloat16.

The licence is the trap. EmbeddingGemma is not Apache 2.0. It is governed by the Gemma Terms of Use, gated on Hugging Face, and its obligations flow down to model derivatives explicitly including distillation and synthetic-data training. Redistribution requires passing the use restrictions on as an enforceable term, shipping a copy of the agreement, marking modified files and including a specific notice. The prohibited use policy bars automated decisions affecting material rights in finance, legal, employment, healthcare, housing, insurance and social welfare. Google reserves the right to remotely restrict usage.

This matters more in 2026 than it did in 2025, because Gemma 4 was relicensed to Apache 2.0 on 31 March 2026 — and EmbeddingGemma was not included. The liberalisation did not reach Google’s embedding model. Anyone writing “Gemma models are Apache 2.0 now” is wrong about this one. There is no successor and no second size.

The legacy defaults: BGE, E5 and Nomic

These three families still account for an enormous share of production traffic and are worth knowing precisely, because all three have stopped moving.

bge-m3 — MIT, 568M parameters, 1024 dimensions, 8,192 context, 100+ languages, and dense, sparse and multi-vector output from a single pass with no query instruction required. Released 30 January 2024, still downloaded 35.6 million times a month. It remains a perfectly reasonable default and the easiest migration target because of the no-prefix design. bge-large-en-v1.5 and siblings (MIT, MTEB averages 64.23/63.55/62.17) are English-only with a 512-token limit — legacy, and best treated as such. One licence trap inside an otherwise clean family: bge-multilingual-gemma2 carries the Gemma licence, not MIT, because it is built on gemma-2-9b.

intfloat E5 — multilingual-e5-large-instruct (MIT, 0.6B, 1024 dimensions, 512 context, 94 languages) is still downloaded 2.1 million times a month, and multilingual-e5-large 7.5 million. The query: / passage: prefixes are mandatory and omitting them measurably degrades retrieval. No E5 card publishes a headline MTEB average; the widely quoted 64.41 comes from Alibaba’s gte-modernbert comparison table, not from intfloat. Newest intfloat model is mmE5-mllama-11b-instruct from February 2025.

Nomic — nomic-embed-text-v1.5 (Apache 2.0, 768 dimensions with Matryoshka at any dimension from 64 to 768, 8,192 context, MTEB 62.28) is a solid small model with the most flexible truncation of any open weight. The fact most comparison pages get wrong: nomic-embed-text-v2-moe has a 512-token maximum — a sixteen-fold regression from v1.5’s 8,192. The MoE model is also open-weights-only and is not served on Nomic’s hosted API, which still runs v1.5. Nomic no longer publishes a per-token price; billing is seat-based at $20 per month individual and $40 per user per month business, with indexing billed per page parsed.

The ones with a licence you need to read twice

• Jina v5 — jina-embeddings-v5-text-small (677M) scores 67.15 on MMTEB, second only to Microsoft’s Harrier 0.6B among models under a billion parameters on our computation, and -nano (239M) is not far behind. Every model in the current Jina line is CC-BY-NC-4.0 — non-commercial. jina-embeddings-v4 is the odd one out under the Qwen Research License, and Jina’s own card notes a previous CC-BY-NC listing for v4 “was an error.” Commercial use requires a waiver from Elastic. The multimodal v5-omni models have one genuinely useful property: only 0.35% of weights were trained, so text embeddings are byte-identical to v5-text and existing text indexes need no reindexing.
• NVIDIA Nemotron-3-Embed-8B — OpenMDW-1.1, not Apache or MIT. The card says “ready for commercial use,” but OpenMDW is its own licence family and is not OSI-approved. Treat it as a third category rather than open-source shorthand. NVIDIA built the launch around leading RTEB rather than MTEB, reporting 78.46 across sixteen RTEB tasks for the 8B and 72.38 for the 1B.
• Snowflake arctic-embed-l-v2.0 — Apache 2.0 and confirmed on the card, 568M parameters, 1024 dimensions, 8,192 context via RoPE, 74 languages. Its published Matryoshka data is unusually specific and useful: truncating to 256 dimensions costs 0.18% on BEIR, 2.70% on MIRACL. Combined with int4 that is 128 bytes per vector. Note truncation is to 256 specifically, not a free range.

Pricing compared

Every figure below was read from the vendor’s own pricing page or documentation on 21 August 2026. Where a page rendered its rates client-side and we could not read them, the cell says “data not available” rather than repeating a third-party number.

What that actually costs. Embedding ten million tokens a month — roughly 20,000 documents at 512 tokens each — costs $0.20 on voyage-4-lite, $1.20 on voyage-4-large, $1.30 on text-embedding-3-large and $2.00 on Gemini Embedding 2. Re-embedding a large corpus is also cheaper than most teams expect: ten million chunks at 512 tokens is 5.12 billion tokens, which is $102 on voyage-4-lite, $307 on voyage-4 and $614 on voyage-4-large — or $412 through the Batch API. The API bill is almost never the reason to choose one embedding model over another. Engineering time, index rebuild, dual-running two indexes through cutover and re-validating retrieval quality are the real costs.

Benchmarks: what is actually trustworthy

This is the section that should change how you read every other embedding comparison, including this one.

MTEB is a good coarse filter and a bad tiebreaker

We tested the standard criticism rather than repeating it. Taking the 34 models with complete results on both MTEB(eng, v2) and the fourteen open RTEB English retrieval tasks — held-out legal, finance, healthcare and code sets designed to defeat contamination — the rank correlation is Spearman ρ = 0.940.

So “MTEB is meaningless” is overstated: within that 34-model subset the top five is stable, and Qwen3-Embedding-8B is first on both boards. But the mid-field moves badly. mixedbread-ai/mxbai-embed-large-v1 falls nine places (rank 16 to 25), intfloat/e5-mistral-7b-instruct and MongoDB/mdbr-leaf-mt fall eight each. Absolute scores compress even more sharply — Qwen3-8B scores 74.25 on MTEB and 73.68 on the held-out set, while mxbai drops from 65.35 to 46.25. The models that fall hardest are older instruction-tuned ones with heavy public-benchmark exposure.

Practical rule: use MTEB to build a shortlist of five, then evaluate those five on your own data. Do not use a two-point MTEB gap to choose between two models.

MTEB’s maintainers agree, and have acted on it. MTEB(eng, v2) explicitly “removes common fine-tuning datasets such as MSMARCO for more comparable scores” and fixes a scoring bug in v1 — which means v1 and v2 scores are not comparable, and any “MTEB score” quoted from 2024 or 2025 is a v1 number. The leaderboard also tracks a zero-shot percentage per model derived from declared training data, and the live page sorts by Borda count rank rather than mean score, so row order there will not always match a mean-ordered table like ours.

RTEB is the right idea and not yet usable as a ranking

RTEB, introduced on 1 October 2025 by MongoDB and the MTEB maintainers, mixes open and private held-out datasets specifically so that a large open-versus-private gap exposes teaching to the test. It is the correct design. It is also still beta, its private-score column has been temporarily removed pending an open governance issue, and only six of 674 models have complete coverage on the multilingual board. The current top entry there is a small model that ranks 24th on MTEB — a coverage artefact, not a result. Read RTEB per-model; do not read its rank order.

Code retrieval is where the numbers get uncomfortable

Two independent findings deserve to be quoted more than they are.

On SWE-bench code retrieval, BM25 beats most neural embedding models. Across every model in MTEB’s results repository that has run the task, mteb/baseline-bm25s scores 7.76 nDCG@10 and beats six of the eight neural embedders tested. The best score by any model is 8.41. Only nine of 674 models have attempted it at all. MTEB added BM25 baselines in February and May 2026, which suggests the maintainers share the concern.

On CORE-Bench, performance collapses between code search and agentic code retrieval. CORE-Bench (arXiv 2606.11864v2, 13 July 2026, Beihang, Peking and Tongyi) covers 180,000+ queries across three levels built from SWE-bench Verified and Pro. Qwen3-Embedding-8B leads the stock models at 42.2 average nDCG@10 / 62.1 Recall@100, ahead of Qwen3-4B (41.3), e5-mistral-7b-instruct (35.6), jina-code-embeddings-1.5b (34.9) and bge-m3 (12.4). But the same model scores 71.7 on Level 1 (code understanding) and 20.3 on Level 2 (issue-to-edit localisation). The authors’ conclusion is worth lifting verbatim: “Strong performance on existing benchmarks may therefore overstate a model’s usefulness for coding agents.” A 0.6B model fine-tuned in-domain on pull-request data beat every stock 8B model.

No closed commercial API appears in CORE-Bench’s published tables.

Vendor benchmarks in this category are unusually unreliable

Three concrete examples from 2026, all from vendors’ own pages:

• Voyage published no absolute nDCG@10 for voyage-code-4 — only relative deltas (+27.54% over voyage-code-3, +28.25% over Cohere Embed v4, +31.03% over Gemini Embedding 2, +48.58% over OpenAI v3-large), on its own 19-benchmark suite, with the raw numbers in a linked spreadsheet. Voyage states it is “in the process of adding these benchmarks to the RTEB evaluation suite” — meaning they are not yet third-party checkable.
• Voyage’s voyage-multimodal-3.5 post contradicts itself. Its summary claims 4.56% over Cohere Embed v4 across fifteen datasets; its results section says 2.26% across eighteen. The same post concedes it “rounded [Google’s 51.78%] up to 65% for the visualization purposes.”
• Cohere published no numeric table for Rerank 4 — only a chart image. Any “+X%” or ELO figure for Rerank 4 circulating online is third-party invention.

Where two sources disagree, we have said so rather than picked one.

Specialist models: code, multimodal and reranking

Code embeddings

Recommendation: start with Qwen3-Embedding-8B, because it is the only model with a strong result on an independent, adversarially designed code benchmark, and it costs nothing. Move to voyage-code-4 if you want a managed service and are willing to run your own evaluation, since Voyage’s claims are not yet independently checkable. And read the CORE-Bench result before you assume any of them will help a coding agent: an in-domain fine-tune of a 0.6B model beat every stock 8B model, which suggests the highest-leverage move in code retrieval is fine-tuning, not model shopping. If you are choosing tooling around this, see Best AI for coding and Best AI code review tools.

Multimodal and document embeddings

The most useful finding in this space is counterintuitive and comes with a human ceiling attached. Mixedbread’s OHR-Bench v2 evaluation (14 May 2025, 8,500+ human-verified PDF pages) measured the best OCR pipelines at 0.738 and 0.737 nDCG@5, human-verified ground-truth text at 0.773, and embedding the page screenshot directly at 0.865 — roughly 12% above perfect text. The gap widens on hard layouts.

But the same study found the obvious follow-through is wrong: feeding the retrieved page images to the language model for generation was the worst configuration tested at 0.627, 30.3% below perfect OCR. Visual retrieval combined with OCR text for generation recovered 70% of the accuracy lost to bad OCR.

The practical architecture is therefore: embed screenshots to find the page, feed OCR text to the model to answer.

The second finding is a storage tax that decides most deployments. NVIDIA’s February 2026 analysis priced one million page images at fp16: a late-interaction model at 5,897.5 GB against a single-vector model at 3.8 GB, because the first stores 773 vectors per page and the second stores one. That is roughly a 1,550-fold difference in storage. Late interaction genuinely wins on pure accuracy in a controlled comparison (+9.36% at 8B over mean-pooled single vectors), but a single vector plus a reranker scored 54.41 against late interaction’s 55.48 — 98% of the accuracy for a fraction of a percent of the storage. Elastic’s guidance is blunter: “our recommendation for late-interaction models is to generally only use them for reranking the top k search results.”

Current options: Cohere Embed v4 (128k context, one unified vector), voyage-multimodal-3.5 (15 January 2026, adds video, $0.12 per million text tokens plus $0.60 per billion pixels), Gemini Embedding 2 (native audio and video, PDFs up to six pages directly), jina-embeddings-v5-omni (12 May 2026, CC-BY-NC-4.0), and the open ColNomic family for late-interaction document retrieval. On the ViDoRe V3 leaderboard snapshot of 3 February 2026, NVIDIA’s nemotron-colembed-vl-8b-v2 led at 63.42, with jina-embeddings-v4 at 57.52 and colnomic-embed-multimodal-7b at 57.33. The seminal colpali-v1.3 scores 0.530 on ILLUIN’s own English split, roughly ten points behind colnomic-embed-multimodal-7b at 0.630 on that same split. It is a foundational method, not a current recommendation. We could not verify the live leaderboard state, which renders client-side.

Rerankers: the cheapest quality you can buy

A reranker is a second-stage model that re-scores your top-k retrieved results. It is the single highest-leverage addition to a retrieval pipeline — when it is the right one for your data, which is a real qualification.

The case for: in Anthropic’s contextual retrieval evaluation, adding reranking on top of contextual embeddings plus BM25 cut retrieval failure rate from 5.7% to 1.9%, a 67% relative reduction. On financial text-and-table retrieval across 23,088 queries (arXiv 2604.01733, 2 April 2026), Recall@5 went from 0.695 with hybrid retrieval to 0.816 with Cohere Rerank v4.0 Pro — the authors called reranking “the single most impactful component.”

The case against: an independent evaluation from Universität Hamburg (EncouRAGe, arXiv 2511.04696, 31 October 2025) across 24,968 QA pairs found “only marginal performance improvements accompanied by higher response latency.” On HotPotQA, adding a reranker moved F1 from 37.1 to 36.1 and Recall@10 from 82.5 to 78.4 — worse on both. Hybrid BM25 beat every reranked configuration on all four datasets. Reranking increased execution time two to four times. Their recommendation: use a reranker only when it is trained on your data format and throughput is not your key metric.

Both are true, and the reconciling variable is candidate depth. The financial study ran the ablation: at a candidate pool of 20, Recall@5 fell to 0.458 and the authors state plainly that “reranking is ineffective” at that depth. The benefit climbs steadily as the pool deepens to 50 and then 100. A reranker over a shallow candidate pool can be worse than no reranker at all.

Hugging Face’s independent evaluation (19 May 2026) is the neutral scoreboard, and it publishes the line that matters: “Anything below [the retriever-only baseline] means the reranker actively hurts the pipeline on average.” Means across six retrievers on MTEB(eng, v2) Retrieval: Qwen3-Reranker-4B 0.6367, mxbai-rerank-large-v2 0.6115, ettin-reranker-1b 0.6114, Qwen3-Reranker-0.6B 0.5940, bge-reranker-v2-m3 0.5526, zerank-2 0.5300. Note that zerank-2, marketed as first across public reranker leaderboards at 0.7625 on its own suite, places fourteenth of 23 here. No Cohere or Voyage model appears — closed APIs are absent from the neutral leaderboard entirely.

One billing trap worth knowing: Cohere bills per search, and long documents silently become several billed units. Rerank v4.0 splits documents into chunks of just under its 32,768-token window — 32,764 tokens — and scores each, taking the maximum chunk score as the document’s relevance. Voyage’s formula multiplies instead — (query tokens × number of documents) + sum of all document tokens — which its own worked example puts at $0.0025 per request at 100 documents, roughly level with Cohere.

Two more cautions. Reranker scores are not comparable across queries — Cohere states plainly that you cannot assume a 0.91 document is twice as relevant as a 0.044 one, and prescribes calibrating on 30–50 of your own queries. And latency scales worse than linearly with document length: on Jina’s own BEIR figures for jina-reranker-v3.5, moving from 145-token documents to 1,904-token documents — a 13-fold increase — took latency from 305ms to 10,291ms, a 34-fold increase.

Dimensions, quantisation and what you actually store

This section will save more money than switching vendors will.

Matryoshka truncation is nearly free until it isn’t

Google’s published truncation curve for gemini-embedding-001 is the clearest data any vendor has released. These are Google’s own MTEB figures on its own task selection, so they are not comparable with the MTEB(Multilingual, v2) means used earlier on this page — read the shape of the curve, not the absolute numbers:

Voyage’s code-domain figures agree on shape: relative to 1024-dimension float, 512 costs 0.30% and 256 costs 1.02%. Truncating to 512 dimensions is close to free; truncating to 128 is not.

Two gotchas. Truncated vectors must be re-normalised — gemini-embedding-2 does this automatically, gemini-embedding-001 does not, and Google’s docs say so explicitly. And Matryoshka support is not uniform: Snowflake arctic-embed-l-v2.0 truncates to 256 only, IBM’s 97M has none while its 311M sibling supports five fixed dimensions, Nomic v1.5 supports any dimension from 64 to 768, and Jina v5 goes down to 32. “Supports MRL” is not a binary property.

Quantisation is the bigger win

Hugging Face and mixedbread’s measurement across the MTEB retrieval subset gives the numbers everyone should be working from:

Rescoring is what makes binary viable: binary mxbai-embed-large-v1 went from 92.53% to 96.45% of float32 performance with rescoring alone, and raising the rescore multiplier past 4 or 5 gave no further gain. Voyage independently reports rescoring worth up to +4.25% on code and +5.84% on general retrieval.

Two caveats most summaries drop. Quantisation is not uniform across models — e5-base-v2 loses roughly a quarter of its performance under binary quantisation, attributed to dimension collapse. And all-MiniLM-L6-v2 is actually better at binary than int8, so “int8 is always safer” is false. Test your own model.

One caveat we have not seen stated anywhere: the published rescoring protocol retrieves top-100 on binary vectors and then rescores against full-precision vectors, so you must retain the float vectors somewhere. The 32× saving applies to the hot indexed tier only. Anyone claiming 32× storage savings and rescored quality simultaneously is not counting the cold tier.

Bytes per vector

The under-reported consequence: on Pinecone, read pricing is 1 request unit per 1 GB of namespace per query. Dimension truncation and quantisation therefore cut your query bill, not just your storage bill — a stronger argument for Matryoshka than storage economics alone, and one no vendor page makes. See Best vector databases for how each system prices this.

Chunking, late chunking and contextual retrieval

The chunking literature is the weakest-evidenced part of this field and we will not pretend otherwise. What is verifiable:

Late chunking (Jina, arXiv 2409.04701) embeds the whole document first and mean-pools over chunk spans. It beat or matched traditional chunking on all five BEIR datasets tested — but the margin was 0.6 to 1.9 points on three of them, +6.5 on NFCorpus, and exactly zero on Quora, whose documents average 62 tokens. On two of the five, not chunking at all scored higher than late chunking. It is document-length-dependent, not a universal win.

Contextual retrieval (Anthropic, 19 September 2024) prepends generated context to each chunk before embedding. Measured on 1−recall@20: contextual embeddings alone cut retrieval failures 35% (5.7% to 3.7%), adding contextual BM25 cut them 49% (to 2.9%), and adding reranking cut them 67% (to 1.9%). Cost is $1.02 per million document tokens, one-time, using prompt caching. Anthropic’s own advice bears repeating: if your knowledge base is under about 200,000 tokens — roughly 500 pages — skip retrieval entirely and put it all in the prompt.

Contextualised chunk embeddings do the same job inside the model. voyage-context-4 (29 June 2026, $0.12 per million) auto-chunks to a 120,000-token document window and claims a +7.11% improvement over single-vector embedding of the same documents on LongEmbed. Note that chunk_overlap tokens are billed as input tokens.

Do you actually need an embedding model?

The most interesting argument in retrieval right now is whether embeddings are necessary at all. It deserves a straight account, because both sides have shipped production evidence and both have commercial interests.

The case against embeddings. Claude Code uses no vector index. Boris Cherny, its creator: “Early versions of Claude Code used RAG + a local vector db, but we found pretty quickly that agentic search generally works better. It is also simpler and doesn’t have the same issues around security, privacy, staleness, and reliability.” Anthropic’s Cat Wu frames the same decision more modestly — “You can get to the same accuracy level with agentic search and it’s just a much cleaner deployment story” — which is a tie plus an operations win, not a rout. The two Anthropic accounts differ, and both reach us second-hand. Notably, Anthropic’s answer to “grep matches characters, not meaning” was native language-server support in Claude Code v2.0.74 (December 2025), not embeddings.

The strongest independent evidence on that side is “Is Grep All You Need?” (14 May 2026), which found inline grep beat inline vector search for every harness-and-model pair tested — but also found the harness swamps the retrieval choice entirely. The same Claude Opus 4.6 scored 93.1% under one harness and 76.7% under another. The authors are careful: “We do not claim that grep ‘beats’ vector in general.” Their corpus is chat memory, not documents.

The case for embeddings. Cursor shipped both, and says so. Its January 2026 post reports that semantic search “improved response accuracy by 12.5% on average” in production, with code-retention gains rising to +2.6% on codebases with 1,000+ files and satisfaction falling 2.2% when semantic search was removed. Then in March 2026 Cursor built a regex index too, and inverted the staleness argument in the process: “We don’t have to continuously update our semantic index because re-computing the embeddings for a file after it is modified does not cause the new embedding to significantly displace itself. However, if the agent is searching for specific text and it does not find it, it’ll often go into a wild goose chase, waste tokens.”

On documents rather than code, the financial-retrieval study across 23,088 queries found BM25 alone (nDCG@10 0.515) beat dense retrieval with text-embedding-3-large (0.466), hybrid fusion beat both (0.551), and hybrid plus reranking beat everything (0.683). Their conclusion — “We recommend hybrid retrieval as the minimum viable baseline for any RAG deployment” — is the most defensible position anyone has published on this. Notably, Corrective RAG lost to single-shot hybrid, and HyDE actively hurt.

LlamaIndex ran the test against its own commercial interest and found the agent more accurate at five documents but RAG better at 100 and 1,000 — “scaling is easier with RAG than with agentic file search.” Sample size was five questions at every scale point.

Where the evidence actually converges. Anthropic, NVIDIA, LlamaIndex and Cursor have all arrived at the same architecture: give the agent a structured-search tool alongside grep and let it choose. NVIDIA’s engineer, describing work with Electronic Arts on multi-million-line C++ codebases, put it best: “We don’t replace the agent’s normal grep-and-read loop. We give it one more tool.” He also concedes the other half: “For the median repo, ‘just navigate’ is probably correct.”

Our read: grep wins on small, plain-text, literal-token corpora. Embeddings win on large, multi-format corpora with vocabulary mismatch — where the user types “revenue recognition” and the document says “ASC 606”. Neither one wins on its own, and the phrase “RAG is dead” originated in a blog post by a RAG vendor selling an agentic router that still runs vector retrieval and reranking underneath. The slogan was never “delete your embeddings.”

Worth noting on market reality: Datadog’s State of Postgres report (3 August 2026), drawn from telemetry across tens of thousands of production databases, found pgvector is the fastest-growing non-bundled extension at +24% between December 2025 and May 2026 — while also finding that fewer than 6% of organisations and under 1% of tables use a vector index at all. Neither “Postgres ate the vector database market” nor “everyone has a vector index” survives contact with the telemetry.

Security, privacy and what your vectors leak

Embeddings are not anonymised text, and the research on this has moved fast enough that a 2024 mental model is now wrong.

Text can be recovered from embeddings. The foundational result (Morris et al., EMNLP 2023) is precise and worth quoting correctly: the method “can recover 32-token inputs with a near-perfect BLEU score of 97.3, and can recover 92% of the examples exactly.” The scoping matters — that is 92% of 32-token inputs from Natural Questions, embedded with GTR-base, using 50 rounds of iterative correction with live query access to the embedding model. Do not write “92% of text can be recovered.” An earlier attack (CCS 2020) recovered 50–70% of input words rather than exact strings.

The “you need query access” defence eroded in 2025. vec2vec (NeurIPS 2025) introduced “the first method for translating text embeddings from one vector space to another without any paired data, encoders, or predefined sets of matches,” reporting cosine similarities up to 0.92 and top-1 accuracies up to 100%. Combined with zero-shot inversion, an attacker who steals a vector dump and does not know which encoder produced it can translate it into a space they control and invert it there — with no access to your embedding model at all.

But no published attack targets a current commercial embedding model. Everything in the literature works against GTR-base, ada-002 and open models. We found no inversion result against text-embedding-3, Cohere Embed v4, Voyage or Gemini Embedding. Absence of a found result is not proof of absence — treat it as an unanswered question rather than a clean bill of health. Also note the circulating claim that attackers can reconstruct sensitive content “from just 10,000 embeddings” is not from the vec2vec paper.

Defences that have measured results: embedding quantisation reduces inversion effectiveness according to an independent reproducibility study (July 2025); Gaussian noise works and is confirmed by the attack authors themselves, though the noise-versus-retrieval-quality trade-off curve has not been published; and Eguard (AAAI 2026) reports “protecting over 95 percent of tokens from inversion while maintaining high performance.” No vendor markets Matryoshka truncation or quantisation as a privacy control, and you should not treat them as one.

The realistic 2026 risk is not inversion — it is unauthenticated vector stores. UpGuard’s research found that “One third of exposed instances discovered by UpGuard Research are lacking authentication,” and its breach log records securing a Chroma database holding 341 collections of AI application data. Most vector stores hold the source text alongside the vector anyway. Inversion matters because it removes the fallback argument that leaked vectors are “only numbers.”

On regulation: no regulator has published guidance specifically on embeddings or vector databases. The nearest anchor is the European Data Protection Board’s Opinion 28/2024, adopted 17 December 2024, which holds that “AI models trained on personal data cannot, in all cases, be considered anonymous” and that anonymity must be assessed case by case. Germany’s Hamburg DPA takes the opposite view for large language models. The two positions coexist unreconciled. Treat any argument that embeddings are personal data as reasoning by analogy — a defensible one, given the inversion literature, but not regulator guidance.

Best for each situation

For most teams starting today

Winner: Qwen3-Embedding-8B, or voyage-4-lite at $0.02 if you would rather not run anything

Apache 2.0, 70.75 on MTEB(Multilingual, v2), 100+ languages, 32k context, and the best independently measured code-retrieval result of any off-the-shelf model. Move on when you need a managed SLA, or when a licence-clean training-data provenance is a procurement requirement.

For the best commercial API

Winner: voyage-4-large at $0.12 per million tokens

The shared embedding space across the whole Voyage 4 family is the only real answer anyone has to migration lock-in, and voyage-4-nano being Apache 2.0 means you can even keep a self-hosted fallback in the same vector space. Caveat: the free tier cannot opt out of Voyage training on your data — that requires a payment method on file and organisation-admin rights.

For images, audio, video or PDFs in one vector space

Winner: Gemini Embedding 2 at $0.20 per million text tokens

Native audio and video, six images per request, PDFs up to six pages directly, and 128–3072 continuous dimensions. Caveat: the embedding space is incompatible with gemini-embedding-001, Google has retired embedding models on roughly six weeks’ notice, and free-tier content is used to improve Google products.

For very long documents

Winner: Cohere Embed v4 at 128,000 tokens

Roughly fifteen times OpenAI’s window and four times Voyage’s. Caveats: the model is sixteen months old, and Cohere’s per-token price is data not available. Alternative: voyage-context-4 handles a 120,000-token document through auto-chunking at a published $0.12.

For on-device, browser or edge deployment

Winner: EmbeddingGemma

Sub-200MB RAM with quantisation-aware training, 100+ languages, and support across llama.cpp, Ollama, LM Studio, transformers.js, MLX and LiteRT. Caveats: 2,048-token context and the Gemma Terms of Use, not Apache 2.0 — Gemma 4’s March 2026 relicensing did not include it. Alternative: granite-embedding-97m-multilingual-r2 at 98 MB quantised, Apache 2.0, if the licence is the blocker.

For enterprise procurement and clean training data

Winner: granite-embedding-311m-multilingual-r2

Apache 2.0, trained without the non-commercially licensed MS-MARCO, 32,768-token context at 311M parameters, no instruction prefixes required, and ONNX plus OpenVINO builds shipped in-repo. Caveat: ModernBERT-based, so Ollama cannot import it — use llama.cpp or Text Embeddings Inference.

For the top of the open leaderboard

Winner: harrier-oss-v1-27b

MIT licence and the top score on MTEB(Multilingual, v2) at 74.31, on a standard 32,768-token context. Caveat: 5,376 dimensions is 21,504 bytes per vector at float32 — truncate and quantise before you index at scale. Alternative: harrier-oss-v1-0.6b at 69.17 for almost all of the quality at 1/45th the parameters.

For code retrieval

Winner: Qwen3-Embedding-8B, then fine-tune it

The best stock model on CORE-Bench at 42.2 average nDCG@10 — but a 0.6B model fine-tuned on in-domain pull-request data beat every stock 8B. Alternative: voyage-code-4 at $0.12 if you want it managed, accepting that its benchmark claims are not yet third-party checkable. And run a BM25 baseline first: on SWE-bench retrieval, BM25 beats most neural embedders outright.

For the lowest possible cost

Winner: voyage-4-lite or text-embedding-3-small, both at $0.02 per million tokens

Voyage adds a 200-million-token free allowance, a 33% batch discount, 32,000 tokens of context against OpenAI’s 8,192, and space-compatibility with the larger Voyage models. OpenAI adds the ecosystem default position that most frameworks and tutorials still assume. Cheaper still: any open-weight model on hardware you already own.

For the strictest licence requirements

Winner: anything Apache 2.0 or MIT — Qwen3-Embedding, IBM Granite, Microsoft Harrier, bge-m3, Snowflake Arctic Embed, Nomic

Avoid without a legal read: all Jina v5 models (CC-BY-NC-4.0, non-commercial), jina-embeddings-v4 (Qwen Research License), EmbeddingGemma and bge-multilingual-gemma2 (Gemma Terms), and NVIDIA Nemotron-3-Embed (OpenMDW-1.1, not OSI-approved).

How to choose an embedding model

1. Decide whether you need one at all. Under about 500 pages, Anthropic’s own advice is to skip retrieval and put the corpus in the prompt. For small, plain-text, literal-token corpora, agentic grep is competitive and much simpler to operate.
2. Run a BM25 baseline first. On the two independent benchmarks cited above, sparse retrieval beat dense retrieval on both financial documents and SWE-bench code. If dense retrieval cannot beat BM25 on your data, you have learned something cheap.
3. Check the context length against your chunks. This is where the surprises live: nomic-embed-text-v2-moe is 512 tokens, EmbeddingGemma is 2,048, all E5 models are 512, OpenAI is 8,192, Voyage is 32,000, Cohere is 128,000.
4. Read the licence, not the badge. Three of the strongest open models in this field are not commercially usable without a waiver, and the licence tag on Hugging Face is the authority, not the family name.
5. Shortlist five on MTEB, then evaluate on your own data. Our own correlation analysis puts MTEB at ρ = 0.940 against held-out domain retrieval — a good coarse filter and an unreliable tiebreaker, with mid-field models moving up to nine places.
6. Ask what happens when the model retires. Google forced a full re-embed between gemini-embedding-001 and gemini-embedding-2 and has retired models on six weeks’ notice. Voyage’s shared embedding space is the only structural answer to this on the market.
7. Set dimensions and precision before you shop for cheaper storage. Truncating to 512 dimensions costs under 1%; int8 costs about 0.7% for a 4× saving; binary with rescoring costs about 4% for 32×. That combination will save more than switching vendors.
8. Add a reranker, over a deep enough candidate pool. Reranking the top 100 lifted Recall@5 from 0.695 to 0.816 in one independent study; reranking the top 20 made it worse. Then measure it against your retriever-only baseline, because rerankers do sometimes hurt.

Related pages

Build with AI: Best LLM APIs · Best vector databases · Best LLM observability tools · Best AI agent frameworks

Run it yourself: Best open-source LLMs · Best local LLMs

Build with code: Best AI for coding · Best AI code review tools

Understand the field: Best AI models · What is agentic AI · Best AI for data analysis

Providers: Google · OpenAI · Microsoft · Alibaba · Mistral

Frequently asked questions

What is an embedding model?

An embedding model converts text — or in newer models, images, audio and video — into a fixed-length list of numbers called a vector, positioned so that items with similar meaning sit close together in that space. This is what makes semantic search possible: a query for “revenue recognition” can retrieve a document that only ever says “ASC 606”, because the two are near each other in the vector space even though they share no words. Embeddings are the retrieval layer underneath most retrieval-augmented generation systems, recommendation engines, deduplication pipelines and clustering tools.

What is the best embedding model in 2026?

For most teams the best embedding model in 2026 is Qwen3-Embedding-8B, which is Apache 2.0, free to self-host, scores 70.75 on MTEB(Multilingual, v2), supports 100+ languages at a 32,768-token context, and is the strongest off-the-shelf model on the independent CORE-Bench code-retrieval evaluation. If you want a managed API instead, voyage-4-large at $0.12 per million tokens is the strongest commercial option and the only one that lets you change models without re-embedding your corpus. Microsoft’s harrier-oss-v1-27b tops MTEB(Multilingual, v2) outright at 74.31 under an MIT licence, but its 5,376 dimensions make it expensive to store at scale.

What is the cheapest embedding model?

The cheapest embedding models that are still worth using are voyage-4-lite and OpenAI’s text-embedding-3-small, both at $0.02 per million tokens. Voyage adds a 200-million-token free allowance, a 33% Batch API discount and a 32,000-token context against OpenAI’s 8,192. Cheaper still is any open-weight model on hardware you already own, which costs nothing per token — though at low volume the API is almost always cheaper in total, because embedding ten million tokens a month is roughly seven seconds of GPU time and about $0.20 to $2.00 of API spend.

Which embedding models are open source?

Qwen3-Embedding (0.6B, 4B, 8B), IBM Granite embedding R2, Microsoft harrier-oss-v1, BAAI bge-m3 and the bge-en-v1.5 family, intfloat E5, Snowflake Arctic Embed v2.0, Alibaba gte, Nomic Embed and Voyage’s voyage-4-nano are all released under Apache 2.0 or MIT and are free for commercial use. Three prominent families are not: every current Jina v5 model is CC-BY-NC-4.0 and requires an Elastic waiver for commercial use, EmbeddingGemma and bge-multilingual-gemma2 are governed by the Gemma Terms of Use rather than Apache 2.0, and NVIDIA’s Nemotron-3-Embed uses OpenMDW-1.1, which is not OSI-approved.

Is OpenAI’s text-embedding-3-large still good?

It is still competent and still the safest choice for ecosystem compatibility, but it has not been updated since 25 January 2024 and is no longer competitive at the top of the field. Its 8,192-token context is a quarter of Voyage’s and a small fraction of Cohere’s 128,000, it has no multilingual result comparable with Qwen3-Embedding’s 100+ languages, and it has been evaluated on only 109 of MTEB’s 131 multilingual tasks. Choose it when you want the least surprising option in a codebase someone else will maintain, or when you need the flexible dimensions parameter that accepts any integer. Note that text-embedding-ada-002 is not deprecated — it remains in OpenAI’s live catalogue at $0.10 per million tokens.

How much does it cost to re-embed a large corpus?

Less than most teams expect. Ten million chunks at 512 tokens each is 5.12 billion tokens, which costs $102 on voyage-4-lite, $307 on voyage-4 and $614 on voyage-4-large — or about $412 through the Batch API at a 33% discount. The API spend is rarely the obstacle. The real migration cost is engineering time, rebuilding the index, dual-running two indexes through cutover, and re-validating retrieval quality on your own evaluation set.

Do I have to re-embed everything when I change embedding model?

Almost always, yes. Vectors from different models occupy different spaces and cannot be compared with each other. Google states this explicitly: the embedding spaces of gemini-embedding-001 and gemini-embedding-2 are “incompatible” and “you must re-embed all of your existing data.” The one structural exception is Voyage’s 4 family, where voyage-4-large, voyage-4, voyage-4-lite and the open-weight voyage-4-nano all produce compatible embeddings — so you can upgrade your query model, or run asymmetric retrieval with a large document model and a small query model, without re-vectorising anything.

How much quality do I lose by shortening embeddings?

Very little down to 512 dimensions, and then it accelerates. Google’s published curve for gemini-embedding-001 on MTEB shows 768 dimensions costing 0.26%, 512 costing 0.91%, 256 costing 2.91% and 128 costing 7.13%. Voyage’s code-domain figures agree on shape. One gotcha most write-ups miss: truncated vectors must be re-normalised — gemini-embedding-2 does it automatically but gemini-embedding-001 does not. Support also varies in kind, not just degree: Snowflake’s Arctic Embed truncates only to 256, IBM’s 97M model has no Matryoshka support at all, and Nomic v1.5 supports any dimension from 64 to 768.

Is binary quantisation safe for production embeddings?

Usually, with rescoring. Hugging Face and mixedbread’s measurement across the MTEB retrieval subset found int8 quantisation retains about 99.3% of float32 performance at a 4× memory saving, and binary quantisation retains about 96% at a 32× saving once you rescore the top-100 results against full-precision vectors. Two caveats matter: the loss is not uniform across models — e5-base-v2 loses roughly a quarter of its performance under binary quantisation — and the rescoring step means you must keep the float vectors somewhere, so the 32× saving applies to the hot indexed tier only, not to total storage.

Can text be reconstructed from embeddings?

Yes, under specific conditions, and the research has strengthened. The foundational 2023 result recovered 92% of 32-token inputs exactly from GTR-base embeddings, using 50 rounds of iterative correction with live query access to the embedding model. In 2025, the vec2vec method removed the query-access requirement by translating vectors between embedding spaces without paired data, which means an attacker holding a stolen vector dump may be able to invert it without ever touching your model. No published attack targets a current commercial embedding model such as text-embedding-3-large or Cohere Embed v4 — but absence of a published result is not a guarantee. Treat embeddings as sensitive data, not as anonymised data.

Do embedding providers train on my data?

It varies, and the defaults differ. OpenAI is opt-in and off by default, with the /v1/embeddings endpoint explicitly marked as not used for training and eligible for zero data retention. Google does not train on paid-tier content but does use free-tier content to improve its products, with human reviewers able to read API inputs and outputs. Cohere is opt-out, not opt-in, on self-serve accounts. Voyage AI is opted in by default, and opting out requires a payment method on file and organisation-admin rights — so free-tier users have no route to opt out. Jina AI has the cleanest statement: “We never use your API requests, inputs, or outputs to train our embedding, reranker, or any other models.” Note that most of these policies are written around “prompts and generations” and do not name embeddings as a distinct category.

Are embedding models being replaced by agentic search?

Not replaced, but their default status is genuinely contested. Claude Code removed its vector database in favour of agentic grep, and an independent May 2026 study found inline grep beat inline vector search for every model-and-harness pair it tested on a chat-memory corpus. But Cursor reports that semantic search improves its agent’s response accuracy by 12.5% on average in production, and shipped a regex index alongside its semantic index rather than replacing it. On financial documents across 23,088 queries, hybrid retrieval beat both BM25 and dense retrieval alone, and hybrid plus reranking beat everything. The convergent position — held by Anthropic, NVIDIA, Cursor and LlamaIndex alike — is to give the agent a structured-search tool alongside grep and let it choose.

What is a reranker, and do I need one?

A reranker is a second-stage model that re-scores your top-k retrieved documents for relevance before they reach the language model. It is often the highest-leverage single addition to a retrieval pipeline: Anthropic measured retrieval failures falling from 5.7% to 1.9% when reranking was added on top of contextual embeddings and BM25, and one independent financial-retrieval study found Recall@5 rising from 0.695 to 0.816. But rerankers can also make things worse — an independent evaluation across 24,968 QA pairs found only marginal gains and a two-to-fourfold latency increase, with F1 and recall both falling on HotPotQA. The reconciling factor is candidate depth: reranking the top 20 was measured as ineffective, the top 100 as strongly effective. Always measure against your retriever-only baseline.

Which embedding model is best for code?

Qwen3-Embedding-8B is the strongest off-the-shelf model on CORE-Bench, the most rigorous independent code-retrieval benchmark published in 2026, at 42.2 average nDCG@10 across its three levels. Two findings should temper that. First, CORE-Bench shows performance collapsing between code search and agentic code retrieval — the same model scores 71.7 on straightforward code understanding but 20.3 on issue-to-edit localisation — and a 0.6B model fine-tuned on in-domain pull-request data beat every stock 8B model. Second, on SWE-bench code retrieval, plain BM25 outperforms most neural embedding models, with the best score of any model reaching only 8.41 nDCG@10. Run a keyword baseline before you buy anything.

Prices, licences, dimensions, context limits and data policies were read from each vendor’s own documentation and pricing pages on 21 August 2026. Benchmark scores marked as our own computation were derived from MTEB’s published results repository at commit f4cc6c8b3 (20 August 2026), counting only models with complete coverage. Where a vendor publishes rates only through a client-side calculator or an image, we have written “data not available” rather than repeat unverified third-party figures — this applies to Cohere’s embedding rates, Amazon Bedrock’s and Azure’s embedding rates, and Jina’s hosted pricing. Vendor-run benchmarks are labelled as such, and where a vendor’s own pages contradict each other we have said so rather than pick a number. Rate cards and leaderboard positions in this category change weekly; confirm anything you are budgeting or standardising against.