Best Embedding Models for Retrieval in 2026

Quick answer (October 2026): On RTEB, the retrieval benchmark built on legal, finance, code and healthcare data, Octen-Embedding-8B posts the highest mean score on the 16 public datasets (0.795 NDCG@10). It is available as a managed API at $0.07 per million tokens, with 4B and 0.6B sizes from $0.01, or as Apache 2.0 weights. For 128K-token documents choose Cohere Embed v4, for self-hosted hybrid search choose BGE-M3, and for a zero-ops baseline choose OpenAI text-embedding-3-small. Scores are from the public MTEB leaderboard; Octen publishes one of the models compared here.

Picking the best embedding models for retrieval off the top of the MTEB (Massive Text Embedding Benchmark) leaderboard is how most Retrieval-Augmented Generation (RAG) pipelines end up worse than the keyword search they replaced. You index three million support tickets, run your first queries, and relevance falls apart. Nothing went wrong in the benchmark. The model was scored on public datasets that may have formed part of its training data, and your support tickets resemble none of them. Engineers call the difference between those two results the generalization gap, and it is why a high leaderboard rank tells you so little about how a model will handle your own corpus.

What is an embedding model? An embedding model turns text into a fixed-length vector of numbers that encodes meaning, so similar inputs land near each other in vector space. A retrieval system embeds every document chunk once, stores the vectors in a vector database, then embeds each query and returns the nearest vectors. The model defines the geometry and the vector database does the nearest-neighbor math, so the model sets the ceiling on what the database is able to find.

The Retrieval Embedding Benchmark (RTEB) was built to measure that gap. It sits under the Retrieval section of the MTEB leaderboard on Hugging Face, covers legal, finance, code and medical documents, and scores every model on NDCG@10. Its defining feature is the data behind those scores. Half the datasets are public, and half are private and held by MTEB maintainers, so submitters can't train on the private ones. Comparing a model's two scores tells you more than a single number can. A model that performs well on public data and drops on private data has learned the benchmark rather than the task.

That spread is harder to check today than it was a year ago. MTEB withdrew the private column in early 2026 and will restore it once it has a broader set of private datasets. The datasets still exist, and you can request an evaluation against them, though the live board no longer displays private scores.

Below are eight models worth a 2026 shortlist, with dimensions, context length, license, cost, and current RTEB standing where available.

The 8 best embedding models for retrieval

The table maps all eight across the dimensions that usually decide a shortlist. The pattern it shows is that nothing wins on every one. The highest RTEB scores no longer require running your own GPUs, the lowest-effort options are the oldest and score lowest on retrieval, and the cheapest model per token is also the smallest.

RTEB figures are mean NDCG@10 across the 16 public datasets on the MTEB leaderboard as of October 2026. The leaderboard's own rank column aggregates per-task ranks rather than averaging scores, so a model's rank and its mean can differ. Check the live board before you act on any of it.

1. Octen Embedding

We publish three retrieval models, octen-embedding-8b, 4b and 0.6b, fine-tuned from Qwen3-Embedding and released under Apache 2.0. You can call them through the hosted API or download the weights and run them yourself, and VL Embedding handles images and videos from the same account when your corpus holds more than text.

Octen-Embedding-8B took the top spot on RTEB on January 12, 2026, and as of October 2026 it posts the highest mean of any model on the 16 public datasets, 0.795. The 4B model scores 0.775 there, and both sit well above the 0.731 posted by Qwen3-Embedding-8B, the base of the 8B model. According to the leaderboard's metadata, 94% of RTEB's tasks are zero-shot for Octen-Embedding-8B, meaning their training data was not part of its training. NVIDIA's Nemotron 3 Embed, profiled below, is the other open-weight model at the top of the board. It ships under OpenMDW-1.1 and is served by third parties, while Octen-Embedding-8B is Apache 2.0, with a first-party API and three sizes under one contract. Independent research points the same way: The Embedder's Dilemma, a COLM 2026 paper from the MTEB team, found Octen-Embedding-8B the strongest of the 26 embedding models it tested, within 0.4 points of Gemini 3.1 Pro, which cost 1,431 times as much per benchmark pass.

• Hosting: API or self-host

• License: Apache 2.0, weights on Hugging Face

• Dimensions: 4096 (8B), 2560 (4B), 1024 (0.6B), with a dimension parameter that returns shorter vectors per call to cut storage

• Context: 32,768 tokens

• Cost: $0.07 / $0.04 / $0.01 per million tokens for 8B, 4B and 0.6B. The 0.6B sits within a rounding error of Nomic Embed, the cheapest model in this roundup, so the budget end is covered without a second vendor.

• Best for: Teams who want top RTEB accuracy at roughly a third of hosted-API pricing, with a self-hosting escape hatch and no re-indexing if they move in-house. The three sizes share a license and an API, so a cost-bound pipeline can start on the 0.6B at budget rates and step up to the 8B where accuracy pays for itself, without changing vendors or client code.

2. OpenAI text-embedding-3 (large and small)

The commercial default, and the model most teams are already running. Integration is a single SDK call, dimensions truncate, and operational burden is zero. It is also the oldest model here: its headline MTEB figure dates to January 2024, and it does not appear anywhere near the top of RTEB.

• Hosting: API

• License: Commercial, closed weights

• Dimensions: Up to 3072 (large), 1536 (small), truncatable

• Context: 8,191 tokens

• Cost: $0.13 per million tokens for large ($0.065 batched), $0.02 for small

• Best for: Teams who want a baseline nobody has to maintain, already running on OpenAI

3. Voyage AI (voyage-4 family)

Voyage, now owned by MongoDB, builds retrieval-first models with variants tuned for code, finance, and law. The voyage-4 family launched on January 15, 2026: voyage-4-large at $0.12 per million tokens, voyage-4 at $0.06, voyage-4-lite at $0.02. All three share one embedding space, so you can switch between sizes without re-indexing, which matters when your cost model changes.

• Hosting: API

• License: Commercial, closed weights

• Dimensions: 2048 / 1024 / 512 / 256

• Context: Around 32K tokens

• Cost: $0.02 to $0.12 per million tokens, with 200M free tokens to start

• Best for: Legal, financial, or code corpora where a domain-tuned model beats a generalist

4. Cohere Embed v4

The long-context option. Embed 4 takes a 128K context window, accepts text and images, and supports 256, 512, 1024 and 1536 dimensions. That window lets you embed a full contract or annual report without designing a chunking strategy for it.

• Hosting: API

• License: Commercial, closed weights

• Dimensions: 256 to 1536

• Context: 128,000 tokens, four times the 32K of most models here

• Cost: From around $0.12 per million input tokens, depending on provider

• Best for: Multilingual enterprise search, and documents that resist clean chunking

5. BAAI BGE-M3

The self-hosted hybrid search option. BGE-M3 emits dense, sparse, and multi-vector representations from one forward pass, so a single model feeds both your semantic and lexical indexes.

• Hosting: Self-host

• License: MIT

• Dimensions: 1024 dense, plus sparse and ColBERT-style multi-vector outputs

• Context: 8,192 tokens

• Cost: Your own compute

• Best for: Hybrid retrieval on your own infrastructure, especially across many languages

6. Qwen3-Embedding

The open-weight base that much of this field is built on, including Octen's models. It ships at 0.6B, 4B, and 8B under Apache 2.0, and Qwen3-Embedding-8B topped the MTEB Multilingual leaderboard at 70.58 in mid-2025. On RTEB's public datasets, it sits below its fine-tunes, at 0.731 for the 8B.

• Hosting: Self-host

• License: Apache 2.0

• Dimensions: Up to 4096, configurable

• Context: 32,768 tokens

• Cost: Your own compute

• Best for: Self-hosted stacks that plan to fine-tune on in-domain data rather than ship a model as-is

7. Nomic Embed v1.5

The efficiency pick. Matryoshka training lets you truncate to 256 or even 64 dimensions while keeping most of the retrieval quality, and at that scale your vector database bill moves more than your embedding bill ever will. At 768 dimensions and around $0.008 per million tokens through hosted providers, nothing here is cheaper.

• Hosting: API or self-host

• License: Apache 2.0

• Dimensions: 768, truncatable to 64

• Context: 8,192 tokens

• Cost: Your own compute, or fractions of a cent per million tokens hosted

• Best for: Very large corpora, edge deployment, and anywhere storage dominates retrieval cost

8. NVIDIA Nemotron 3 Embed

One of the two open-weight models at the top of RTEB. Nemotron-3-Embed-8B-BF16 ranked #1 on RTEB in July 2026 and scores 0.785 on the 16 public datasets, with NVIDIA reporting 0.755 on MMTEB Retrieval. A 1B model is available for teams that cannot carry flagship inference costs. Its strongest domains on the leaderboard are finance, German-language retrieval and code.

• Hosting: Self-host, or hosted endpoints from third parties such as DeepInfra; build.nvidia.com hosts the 1B model

• License: OpenMDW-1.1, open weights

• Dimensions: 4096, truncatable to 2048 or 1024

• Context: 32,768 tokens

• Cost: Your own compute

• Best for: Teams with spare GPUs who want open weights from NVIDIA's ecosystem

How to choose an embedding model for your data

No leaderboard predicts your result, because your corpus is not on it. What it does well is shorten the list. Four constraints usually settle the shortlist before quality enters the conversation: where you can host, what the license permits, how long your documents are, and what vector storage costs at a given dimension count. Add one more that teams discover too late: re-embedding a large corpus costs real money and takes days, so an embedding model is far stickier than an LLM, and truncatable dimensions or a shared embedding space are what buy you room to change your mind.

• Top RTEB accuracy without running your own inference → Choose Octen Embedding: a managed API priced below the closed flagship models, with the same weights under Apache 2.0 if you move in-house later.

• Self-hosted multilingual RAG on your own GPUs → Choose BGE-M3 for hybrid dense and sparse retrieval, or Qwen3-Embedding if you plan to fine-tune.

• Cheapest API baseline with no operations → Choose OpenAI text-embedding-3-small, or Nomic Embed where storage cost dominates.

• Legal, financial or code search → Choose Voyage for its domain-tuned variants or Octen Embedding, which was trained on synthetic data built for legal, finance, healthcare and code retrieval.

• Documents too long or too structured to chunk → Choose Cohere Embed v4 for the 128K window.

• Open weights from NVIDIA's ecosystem, GPUs available → Choose Nemotron 3 Embed.

Once two or three models clear your constraints, test them rather than compare specs. Pull 200 to 500 real queries from your logs, label the correct documents for each, embed the same corpus slice with each candidate, and score NDCG@10 per model broken out by document type, since averages hide the segment where a model fails. If hand-labeling stalls the process, Hit Rate or MRR on a smaller set will eliminate the weak candidates quickly, and an LLM-as-a-judge can draft relevance labels for a first pass. Both are shortcuts to a shortlist, so grade the final two by hand before you index three million documents against one of them. Price the full bill while you are there: embedding tokens, future re-embedding, and vector storage at each model's dimension count.

If two use cases pull in different directions, split them. A code search index and a customer support index have no reason to share a model, and forcing them to usually means one gets the wrong one.

Frequently asked questions

What is the best embedding model for RAG in 2026?

It depends on your data, so test on your own documents. On RTEB, the retrieval benchmark built on legal, finance, code and healthcare data, Octen-Embedding-8B has the highest mean score on the public datasets (0.795 as of October 2026). For documents over 32K tokens, Cohere Embed v4 offers a 128K window; for self-hosted hybrid search, BGE-M3 produces dense and sparse vectors in one pass.

What is the difference between MTEB and RTEB?

MTEB measures general embedding quality across many task types, including classification, clustering and retrieval. RTEB measures retrieval only, on domain data from legal, finance, code and healthcare, and was designed with private datasets to test how models perform on data they have not seen.

Are open-source embedding models as good as OpenAI's?

On RTEB's public datasets, several open-weight models score well above OpenAI text-embedding-3-large (0.611), including Octen-Embedding-8B (0.795), Nemotron 3 Embed (0.785) and Qwen3-Embedding-8B (0.731). Some, like Octen Embedding, are also available as a hosted API, so open weights no longer mean running your own GPUs.

How much does an embedding model cost?

Hosted embedding APIs in this roundup range from $0.01 to $0.13 per million tokens. Octen Embedding costs $0.01, $0.04 and $0.07 per million tokens for the 0.6B, 4B and 8B models. At scale, vector storage often costs more than embedding, so a model that lets you request shorter vectors can lower the total bill.

Conclusion

MTEB tells you a model is broadly capable. RTEB tells you whether retrieval accuracy survives contact with data the model has never seen, and the share of tasks a model was never trained on is the first number to check. Everything after that is constraints: license, hosting, context length, dimensions, and what a re-index will cost you in a year.

Two paths from here. If you are self-hosting, start with the open-weight models and plan to fine-tune on in-domain data. If you want top RTEB accuracy without standing up inference, start with the Octen Embedding docs or download the weights from Hugging Face. New accounts get $5 in free balance, enough to embed a real slice of your corpus and score it properly before you commit to anything.