Best embedding models for RAG: proprietary and open models compared

Comparison · RAG

An embedding model turns a chunk of text, or in multimodal models an image, a PDF page, or a clip of audio or video, into a fixed-length vector, and that choice sets the quality ceiling, storage cost, and hosting options of a RAG index. This guide compares the best embedding models for retrieval-augmented generation as of November 2026: six proprietary APIs and six open-weight families, each checked against its developer's documentation or model card. The embedding and reranking directory catalogs the wider field; this page narrows it and recommends models by use case. For the pipeline these models plug into, start with What is RAG.

What is an embedding model?#

An embedding model is a neural network that maps text, images, or other inputs to fixed-length vectors, called embeddings, placing inputs with similar meaning close together.

In a RAG system the model runs on two paths. At indexing time it embeds every chunk of every document. At query time it embeds each question, and the retriever compares the query vector with the stored vectors using a measure such as cosine similarity, usually through an approximate nearest-neighbor index in a vector database.

Offline, chunks pass through the embedding model into a vector index; online, the same model embeds the query, which is searched, reranked, and sent to the LLM. Indexing (offline)Query (online)DocumentsText, PDFs, imagesChunkWithin input limitEmbedding modelDocument promptVector indexANN, often plus BM25User queryQuery promptInstruction or prefixEmbedding modelSame model or spaceANN searchTop 50-100RerankKeep top 5-10LLMAnswers from chunksvectorsshared space
Figure 1: The embedding model runs once per chunk at indexing time and once per query at search time, so both paths must share one vector space.

Three practical rules follow from Figure 1. Both paths must use the same model, or models trained into one shared space, such as the Voyage 4 family or Cohere's Embed 5 Pro and Fast. Switching to a model with a different space means re-embedding the whole corpus. And many models expect different prompts on each path: a query instruction for Qwen3-Embedding, text prefixes for Gemini Embedding 2, and an embeddingPurpose value for Amazon Nova.

Selection criteria for embedding models#

The models below were chosen and compared on seven criteria that decide whether an embedding model fits a RAG system: retrieval quality on MTEB-family retrieval tasks, maximum input length, output dimensions and Matryoshka truncation, multilingual and code coverage, multimodal input, license and self-hosting, and API availability. Each entry reports these from the developer's own documentation.

  • Retrieval quality. Retrieval scores on MTEB and its multilingual extension, MMTEB, rather than the headline average, read with the caveats in the next section.
  • Maximum input tokens. The longest input embedded before truncation, which caps chunk size; the chunking strategies guide covers how to size chunks.
  • Output dimensions and Matryoshka truncation. Models trained with Matryoshka Representation Learning (Kusupati et al., 2022) pack the most information into the first dimensions, so a vector can be cut to a prefix with a modest quality loss. Int8 and binary output shrink storage further.
  • Multilingual and code support. The languages covered, cross-lingual retrieval, and whether code search is built in.
  • Multimodal support. Whether images, PDF pages, audio, or video share one vector space with text.
  • License and self-hosting. Open weights under a license that permits commercial use, non-commercial terms, or API-only access.
  • API availability. Which APIs and clouds serve the model, which affects data residency and procurement.

Hosted APIs expose truncation as a request setting, such as the dimensions parameter in OpenAI's API. With an open Matryoshka model you slice the vector yourself and re-normalize it, the procedure NVIDIA's Nemotron 3 Embed model card describes:

import numpy as np
 
def truncate(embeddings, dims):
    """Keep the first `dims` values of Matryoshka embeddings, then
    re-normalize so cosine similarity and dot product agree again."""
    v = np.asarray(embeddings, dtype=np.float32)[:, :dims]
    return v / np.linalg.norm(v, axis=1, keepdims=True)
 
full = np.random.default_rng(0).normal(size=(4, 1024))  # stand-in for model output
print(truncate(full, 256).shape)  # (4, 256)

Dimensions and number format drive storage directly. The table shows raw vector bytes per million chunks, before index overhead such as HNSW graph links:

Vector format Bytes per vector Raw storage per 1M vectors
3,072 dimensions, float32 12,288 12.3 GB
1,024 dimensions, float32 4,096 4.1 GB
256 dimensions, float32 1,024 1.0 GB
1,024 dimensions, int8 1,024 1.0 GB
1,024 dimensions, binary 128 0.13 GB

Check which formats your vector database can store and search before choosing int8 or binary output.

How to read MTEB and MMTEB scores#

MTEB, the Massive Text Embedding Benchmark, is a public benchmark suite for embedding models, and its multilingual extension MMTEB covers more than 500 tasks in over 250 languages. Its scores help build a shortlist, but they are weak evidence for a specific RAG system, because benchmark versions differ, many results come from model developers, and training data can overlap test sets.

  • Compare like with like. The MTEB leaderboard hosts several benchmarks, including MTEB (eng, v2), MTEB (Multilingual), MTEB (Code), and the retrieval-only RTEB, and their scores are not comparable. OpenAI's 64.6% for text-embedding-3-large comes from the model's January 2024 launch, not from MTEB (Multilingual), where Qwen reports 70.58 for Qwen3-Embedding-8B.
  • Read the retrieval score. The overall mean includes task types that matter little for RAG. Qwen3-Embedding-8B's card reports its retrieval score, 70.88, separately.
  • Check for training overlap. In Maintaining MTEB (2025), the maintainers describe replacing self-reported model card results with a central results repository and adding a zero-shot score, the share of benchmark datasets a model did not train on, which they call a coarse estimate. Training on data that overlaps the test sets can lift a rank without improving retrieval.
  • Look at private test sets. RTEB, released by the MTEB team as a beta on October 1, 2025, adds private datasets held by the maintainers, and its announcement says a large drop from open to private results suggests overfitting.
  • Do not assume bigger is better. In the MMTEB paper (Enevoldsen et al., 2025), the best publicly available model overall was multilingual-e5-large-instruct, with 560 million parameters, though billion-parameter LLM-based models led some languages and task types.

Launch posts and model cards from Voyage AI, Cohere, Google, and NVIDIA report results on datasets and competitor versions each vendor chose. The entries below attribute those figures; treat them as signals to test.

Embedding models compared at a glance#

The table summarizes the twelve models in this guide by access, maximum input, output dimensions, input types, and license, as listed in each developer's documentation or model card in November 2026. Dimensions are the default or maximum output; most models also accept smaller Matryoshka sizes, and several return int8 or binary vectors.

Model Developer Access Max input Dimensions Inputs License
Voyage 4 (large, base, lite) Voyage AI (MongoDB) API; voyage-4-nano open 32,000 tokens 256 to 2,048 (default 1,024) Text Proprietary; nano Apache 2.0
Embed 5 (Pro, Fast) Cohere API, clouds, private deployment 128K tokens 256 to 2,048 (default 2,048) Text, images, text plus image Proprietary
Gemini Embedding 2 Google API 8,192 tokens 128 to 3,072 (default 3,072) Text, images, video, audio, PDF Proprietary
text-embedding-3-large, -small OpenAI API 8,192 tokens Up to 3,072 and 1,536 Text Proprietary
Nova Multimodal Embeddings Amazon Amazon Bedrock 8K tokens or 30 s of media 256, 384, 1,024, 3,072 Text, documents, images, video, audio Proprietary
codestral-embed, mistral-embed Mistral AI API 8K tokens Up to 3,072 (default 1,536); 1,024 Code; text Proprietary
Qwen3-Embedding (0.6B, 4B, 8B) Alibaba Qwen Open weights 32K tokens 1,024, 2,560, 4,096 Text Apache 2.0
Nemotron 3 Embed (1B, 8B) NVIDIA Open weights 32,768 tokens 2,048, 4,096 Text OpenMDW-1.1
BGE-M3 BAAI Open weights 8,192 tokens 1,024 dense, plus sparse and multi-vector Text MIT
EmbeddingGemma 2 Google DeepMind Open weights 8,192 tokens 768, down to 128 Text, code, images, video, audio Apache 2.0
jina-embeddings-v5-text-small Jina AI (Elastic) API; open weights 32,768 tokens 1,024, down to 32 Text CC BY-NC 4.0
Arctic Embed L 2.0 Snowflake Open weights 8,192 tokens 1,024, down to 256 Text Apache 2.0

Best proprietary embedding models#

Hosted embedding APIs suit teams that want no GPU operations and are comfortable sending documents to a provider. As of November 2026, Voyage 4, Cohere Embed 5, and Gemini Embedding 2 are the newest general-purpose families, OpenAI's text-embedding-3 models date from January 2024, Amazon Nova covers multimodal retrieval on Bedrock, and Mistral serves a code-specific model.

Voyage 4#

Voyage 4 is Voyage AI's text embedding family, launched January 15, 2026: voyage-4-large, voyage-4, voyage-4-lite, and the open-weight voyage-4-nano, all trained into one shared embedding space. Voyage AI is part of MongoDB.

  • Dimensions and context: 32,000 input tokens and 1,024 dimensions by default, with 256, 512, and 2,048 available. The Voyage docs list int8, uint8, binary, and ubinary output for large, base, and lite, plus domain models such as voyage-code-4.
  • License and hosting: Proprietary, through the Voyage API and MongoDB Atlas. voyage-4-nano's weights are on Hugging Face under Apache 2.0.
  • Strengths: Asymmetric retrieval, such as indexing with voyage-4-large and querying with voyage-4-lite. In Voyage's launch evaluation on 29 RTEB datasets, scored with NDCG@10, voyage-4-large led Gemini Embedding 001, Cohere Embed v4, and OpenAI text-embedding-3-large by average margins of 3.87%, 8.20%, and 14.05%.
  • Trade-offs: Text only; images and video need the separate voyage-multimodal-3.5. The vendor's comparison predates Gemini Embedding 2 and Cohere Embed 5.
  • Best for: Quality-first text retrieval, mixing model sizes for indexing and querying, and MongoDB Atlas users.

Cohere Embed 5#

Embed 5 is Cohere's embedding family released September 30, 2026, in Pro and Fast variants that share one embedding space and accept text, images, and fused text-and-image input.

  • Dimensions and context: 128K input tokens and 2,048 dimensions by default, down to 256, in float, int8, or binary, per Cohere's documentation. Both variants cover more than 100 languages.
  • License and hosting: Proprietary, on Cohere's API, Model Vault, Microsoft Foundry, Amazon SageMaker, and private deployments, which Cohere says can run on vLLM.
  • Strengths: Long reports, slides, and scanned pages. Cohere recommends indexing with Pro and querying with Fast, and its launch post reports Embed 5 Pro ahead of voyage-4-large and Gemini Embedding 2 on ViDoRe V3 and parsed-PDF evaluations, which are Cohere's own runs.
  • Trade-offs: No audio or video, and PDFs must be parsed or embedded as page images. A 128K window does not remove the need to chunk, since one vector for a long document blurs its topics.
  • Best for: Enterprise document search, multilingual corpora, and private deployments.

Gemini Embedding 2#

Gemini Embedding 2 is Google's first natively multimodal embedding model, gemini-embedding-2, released in preview on March 10, 2026, and generally available on April 22, 2026. It embeds text, images, video, audio, and PDFs into one space.

  • Dimensions and context: 8,192 input tokens shared across modalities, and 3,072 dimensions by default, adjustable down to 128, with 768 and 1,536 also recommended. Google's guide caps a request at six images, 120 seconds of video, 180 seconds of audio, and one six-page PDF.
  • License and hosting: Proprietary, through the Gemini API and Google Cloud's Gemini Enterprise Agent Platform (formerly Vertex AI).
  • Strengths: Cross-modal search, such as a text query that finds a video segment or a slide, configured with text prefixes like task: search result | query: ....
  • Trade-offs: The token budget is shared across modalities, audio tracks inside video are not processed, and vectors are incompatible with the text-only gemini-embedding-001, so upgrading means re-embedding.
  • Best for: Multimodal RAG over mixed media, especially on Google Cloud.

OpenAI text-embedding-3#

text-embedding-3-small and text-embedding-3-large, released January 25, 2024, are still the newest models in OpenAI's embeddings guide as of November 2026.

  • Dimensions and context: 8,192 input tokens, and 1,536 dimensions (small) or 3,072 (large), shortened with the dimensions parameter.
  • License and hosting: Proprietary, through OpenAI's API.
  • Strengths: No new vendor for teams on OpenAI. The guide lists MTEB scores of 64.6% (large) and 62.3% (small), and says large cut to 256 dimensions still beats the full text-embedding-ada-002.
  • Trade-offs: Text only and nearly three years old. Voyage AI's and Cohere's 2026 launch evaluations both reported it behind their new models.
  • Best for: English text retrieval on the OpenAI API, and as an evaluation baseline.

Amazon Nova Multimodal Embeddings#

Amazon Nova Multimodal Embeddings (amazon.nova-2-multimodal-embeddings-v1:0) is one Amazon Bedrock model for text, documents, images, video, and audio, launched October 28, 2025.

  • Dimensions and context: 8K tokens or 30 seconds of video or audio per synchronous request, and 3,072 dimensions by default, or 1,024, 384, or 256, per the Nova embeddings guide. The asynchronous API segments longer text and media.
  • License and hosting: Proprietary and Bedrock only. On November 16, 2026, its model card listed US East (N. Virginia) and AWS GovCloud (US-West), with no cross-Region inference. Titan Text Embeddings V2 is the text-only alternative, with 8,192 tokens and up to 1,024 dimensions.
  • Strengths: Built-in media segmentation, and an embeddingPurpose field that tunes vectors for indexing (GENERIC_INDEX) or for a query type (TEXT_RETRIEVAL, VIDEO_RETRIEVAL, and others). AWS says text works in up to 200 languages.
  • Trade-offs: Two Regions, a 30-second limit on synchronous media, and no way to run it outside AWS.
  • Best for: Video, audio, and document-image retrieval inside Bedrock.

Mistral Embed and Codestral Embed#

Mistral AI serves mistral-embed (December 2023) for general text and codestral-embed (May 28, 2025) for code.

  • Dimensions and context: An 8K context for both. mistral-embed returns 1,024 dimensions; Codestral Embed defaults to 1,536, goes up to 3,072, and its docs list int8, uint8, binary, and ubinary output.
  • License and hosting: Proprietary, through Mistral's embeddings and batch endpoints.
  • Strengths: Mistral says Codestral Embed's dimensions are ordered by relevance, so vectors can be truncated, and its launch post compares the model with Voyage Code 3, Cohere Embed v4.0, and OpenAI's large model on code retrieval.
  • Trade-offs: mistral-embed is the oldest model here, with fixed 1,024-dimension output, and neither model accepts images.
  • Best for: Code search for coding agents, and teams already on Mistral's API.

Best open source embedding models#

Open-weight embedding models run on your own hardware, which keeps documents inside your environment and replaces per-token fees with GPU or CPU operations. Licenses differ: Qwen3-Embedding, EmbeddingGemma 2, Arctic Embed, and BGE-M3 use Apache 2.0 or MIT, NVIDIA uses OpenMDW-1.1, and Jina's v5 weights are non-commercial.

Qwen3-Embedding#

Qwen3-Embedding is the Alibaba Qwen team's open text embedding series, released June 5, 2025, in 0.6B, 4B, and 8B sizes with matching Qwen3-Reranker models.

  • Dimensions and context: 32K input tokens, and 1,024, 2,560, and 4,096 dimensions, each reducible to as few as 32. The models take task instructions, and the cards list code retrieval among their tasks.
  • License and hosting: Apache 2.0, on Hugging Face and ModelScope.
  • Strengths: The 8B model card reports a 70.58 task mean and a 70.88 retrieval score on MTEB (Multilingual), says the model ranked first on that leaderboard as of June 5, 2025, and lists more than 100 languages. Qwen3-VL-Embedding, released in January 2026 in 2B and 8B sizes under Apache 2.0, adds images, screenshots, and video.
  • Trade-offs: Queries need a task instruction, and the card says omitting it can cost about 1% to 5% in retrieval performance. Full 4,096-dimension vectors are expensive to store, and the rank dates from June 2025.
  • Best for: Self-hosted multilingual retrieval under a permissive license, at a size that fits your hardware.

NVIDIA Nemotron 3 Embed#

Nemotron 3 Embed is NVIDIA's open text embedding family, released July 16, 2026, in 1B and 8B sizes. The 8B model is based on Ministral-3-8B-Instruct-2512.

  • Dimensions and context: 32,768 input tokens, though NVIDIA evaluated at 4,096, and 4,096 dimensions for 8B or 2,048 for 1B, which the cards say can be sliced and re-normalized.
  • License and hosting: OpenMDW-1.1, which the model card describes as ready for commercial use. It runs on PyTorch and vLLM on NVIDIA Ampere, Hopper, and Blackwell GPUs.
  • Strengths: NVIDIA reports an average NDCG@10 of 75.45 (8B) and 71.04 (1B) on MMTEB retrieval, and says the 8B model topped the multilingual RTEB leaderboard as of July 16, 2026.
  • Trade-offs: Text only, 34 listed languages, and retrieval figures from NVIDIA's own evaluation that are not directly comparable with Qwen's.
  • Best for: Self-hosted multilingual text retrieval on NVIDIA GPUs.

BGE-M3#

BGE-M3 is the Beijing Academy of Artificial Intelligence's multilingual embedding model, which outputs dense vectors, sparse lexical weights, and ColBERT-style multi-vector embeddings from one model.

  • Dimensions and context: 8,192 input tokens and 1,024-dimension dense vectors, trained from XLM-RoBERTa-large extended to 8,192 tokens.
  • License and hosting: MIT, with the FlagEmbedding library.
  • Strengths: Dense plus sparse output supports hybrid search without a separate keyword model, across more than 100 languages. Snowflake's Arctic Embed L 2.0 builds on the same base.
  • Trade-offs: The dense vectors have no Matryoshka truncation. Sparse and multi-vector output need an index that stores them, and the model's paper dates from February 2024.
  • Best for: Self-hosted hybrid retrieval across many languages.

EmbeddingGemma 2#

EmbeddingGemma 2 is Google DeepMind's open multimodal embedding model, released October 6, 2026, and built on Gemma 4, for text, code, images, audio, and video.

  • Dimensions and context: 8,192 input tokens and 768 dimensions, truncatable to 512, 256, or 128. Of its 740M parameters, text-only use needs 270M; the vision and audio encoders are optional.
  • License and hosting: Apache 2.0, replacing the first version's Gemma Terms of Use, with weights on Hugging Face and Kaggle and on-device builds through LiteRT.
  • Strengths: Google reports about 191 MB of active RAM for quantized text-only use on a Pixel 11 Pro. The model card reports task means of 61.36 on MTEB (Multilingual, v2), 68.46 on MTEB (English, v2), and 78.68 on MTEB (Code, v1).
  • Trade-offs: 768 dimensions at most, no separate retrieval score, and a warning against float16 inference, which can return NaN or degraded vectors without an error.
  • Best for: On-device, offline, and edge RAG.

Jina embeddings v5#

Jina AI's v5 family includes jina-embeddings-v5-text-small (677M parameters, released February 18, 2026), text-nano (239M), and omni models for text, images, video, audio, and PDFs. Elastic acquired Jina AI in October 2025.

  • Dimensions and context: text-small takes 32,768 tokens and returns 1,024 dimensions, truncatable to 32; text-nano takes 8,192. Task adapters cover retrieval, text matching, clustering, and classification, and the text-small card lists 119-plus languages.
  • License and hosting: Jina's API. The Hugging Face weights are CC BY-NC 4.0, so commercial self-hosting needs a license from Jina.
  • Strengths: The text-small card reports 71.7 on MTEB English v2 and 67.7 on MMTEB, high for a sub-1B model. Jina researchers introduced late chunking, which long-context models like these suit.
  • Trade-offs: Non-commercial weights, and the reported scores are task averages, not retrieval scores.
  • Best for: Jina API and Elastic users, and research on compact multilingual models.

Snowflake Arctic Embed 2.0#

Arctic Embed 2.0 is Snowflake's multilingual retrieval family, released in December 2024 as snowflake-arctic-embed-l-v2.0 and m-v2.0.

  • Dimensions and context: The L model (568M parameters) returns 1,024 dimensions and supports 8,192 tokens, with Matryoshka truncation to 256 and quantization-aware training for 128-byte vectors at 4 bits.
  • License and hosting: Apache 2.0, free for commercial use, and callable in Snowflake through AI_EMBED.
  • Strengths: The model card reports an average NDCG@10 of 55.6 on 15 BEIR datasets and 55.8 on four MIRACL languages, and 54.3 on BEIR at 256 dimensions.
  • Trade-offs: Text only, no newer release since December 2024, and Snowflake's Cortex docs list a 512-token window for the hosted L model, with a separate 8K variant.
  • Best for: Compressed English and multilingual indexes, and data already in Snowflake.

Other open models worth testing#

Nomic Embed text v1.5 (Apache 2.0, 8,192 tokens, Matryoshka from 768 down to 64 dimensions) fits lightweight local pipelines. IBM's Granite Embedding Multilingual R2, released April 29, 2026, is a 311M-parameter Apache 2.0 model with 32,768-token input. Perplexity's MIT-licensed pplx-embed models come in 0.6B and 4B sizes with 32K input, including contextual variants that embed each chunk with respect to its document.

Which embedding model should you use?#

Choose by constraint first and quality second. Data residency, license, modality, and the cloud you already use usually narrow the field to two or three models, and a small evaluation on your own queries picks between them. The table maps common RAG situations to a shortlist from this guide.

Situation Shortlist Why
Hosted text retrieval, quality first voyage-4-large, Cohere Embed 5 Pro, Gemini Embedding 2 Newest hosted families, with Matryoshka output
PDFs, slides, and scanned pages Cohere Embed 5, Gemini Embedding 2, voyage-multimodal-3.5 Image and fused text-and-image input
Video and audio Gemini Embedding 2, Amazon Nova Multimodal Embeddings, EmbeddingGemma 2 One space for text, video, and audio
Already on the OpenAI API, English text text-embedding-3-large or -small No new vendor; use as the baseline
AWS-native stack Nova Multimodal Embeddings, Titan Text Embeddings V2 Served inside Bedrock
Code search for agents voyage-code-4, codestral-embed, Qwen3-Embedding, EmbeddingGemma 2 Code-specific models, or code retrieval listed on the model card
Self-hosted, permissive license Qwen3-Embedding, Nemotron 3 Embed, BGE-M3 Apache 2.0, OpenMDW-1.1, and MIT weights
Dense and sparse vectors from one model BGE-M3 Hybrid retrieval without a separate keyword model
On-device or offline EmbeddingGemma 2, Qwen3-Embedding-0.6B, voyage-4-nano Under 1B parameters with open weights
Tight storage budget Arctic Embed L 2.0, Voyage 4, Cohere Embed 5 Truncation plus low-bit vectors (int8, int4, or binary)

How to evaluate embedding models on your own data#

The reliable way to choose an embedding model is to test finalists on your own corpus: label a set of real queries, embed the same chunks with each model, and measure recall@k and MRR. Run the comparison with your production chunking and reranker in place, because both change how much the embedding model matters.

Real queries are labeled, a fixed chunk set is embedded with each candidate model, results are retrieved and reranked, then scored against the labels. Real queriesLogs, ticketsLabel chunksHuman-checkedFixed chunksSame for allEmbedModel A, B, CRetrieve top kDense or hybridRerankSame rerankerScoreRecall@k, MRRPick a modelQuality vs costlabels
Figure 2: An embedding evaluation holds the queries, chunks, labels, and reranker fixed so the embedding model is the only variable.
  1. Collect real queries. Pull them from search logs, support tickets, and chat transcripts, including hard cases such as product codes, misspellings, paraphrases, and every language you serve. Aim for at least 50 labeled queries, and more for each language or document type.
  2. Label relevant chunks. Record the chunk IDs that answer each query. An LLM can draft labels, but a person should check them.
  3. Hold chunking fixed. Embed the same chunks with every candidate so chunk IDs stay stable, size them to fit the smallest input limit among the candidates, and use each model's query and document prompts.
  4. Measure recall and rank. Compute recall@k at the k your reranker receives, such as 50, and at the k the LLM receives, such as 5 or 10, plus MRR for the rank of the first relevant chunk.
  5. Add the rest of the pipeline. Re-run with BM25 hybrid retrieval and your reranker. A reranker reorders candidates, so the gap between two embedding models in the final top 5 can shrink; measure it, since a smaller model may then be good enough.
  6. Compare at equal cost. Test truncated dimensions and int8 or binary output, and record embedding latency and throughput at your expected load.
  7. Re-test after pipeline changes. A new chunk size, contextual retrieval, or a model upgrade can reorder the candidates.

The scoring itself is a few lines. This function follows the standard definitions, with recall@k as the share of each query's relevant chunks found in the top k:

def score_retrieval(search, eval_set, k=10):
    """search(query, k) returns a ranked list of chunk IDs.
    Each eval item: {"query": str, "relevant": set of chunk IDs}."""
    recall_sum, rr_sum = 0.0, 0.0
    for item in eval_set:
        ranked = search(item["query"], k)
        relevant = item["relevant"]
        recall_sum += len(relevant.intersection(ranked)) / len(relevant)
        first = next((i for i, cid in enumerate(ranked, 1) if cid in relevant), None)
        rr_sum += 1 / first if first else 0.0
    n = len(eval_set)
    return {f"recall@{k}": recall_sum / n, "mrr": rr_sum / n}
 
# One search function per candidate index, same eval set for all:
# for name, search in candidates.items():
#     print(name, score_retrieval(search, eval_set, k=50))

Keep the eval set versioned next to the index configuration. When a new model launches with better leaderboard numbers, the same set shows whether it retrieves better on your documents before you re-embed anything.

Where to go next#

The embedding model is one stage of a pipeline, and the stages around it often matter more. If retrieval is not the right fix for a quality gap, RAG vs fine-tuning covers the alternative. The RAG topic hub collects every guide and glossary entry on retrieval, chunking, and vector search.

Frequently asked questions

What is the best embedding model for RAG?

No single embedding model is best for every RAG system. As of November 2026, strong hosted options include Voyage 4, Cohere Embed 5, and Gemini Embedding 2, and strong open-weight options include Qwen3-Embedding, NVIDIA Nemotron 3 Embed, and BGE-M3. The right choice depends on your languages, modalities, license needs, and hosting. Shortlist two or three models, then compare them with recall@k and MRR on labeled queries from your own users.

What are the best open source embedding models?

Open-weight embedding models with licenses that allow commercial use include Qwen3-Embedding (Apache 2.0, 0.6B to 8B parameters), NVIDIA Nemotron 3 Embed (OpenMDW-1.1, 1B and 8B), BGE-M3 (MIT, with dense, sparse, and multi-vector output), EmbeddingGemma 2 (Apache 2.0, multimodal, and small enough for phones), and Snowflake Arctic Embed 2.0 (Apache 2.0). Jina's v5 weights use CC BY-NC 4.0, which requires a commercial license from Jina for production use.

How many dimensions should an embedding have?

Use the smallest size that keeps recall on your own evaluation set. Raw storage grows linearly with dimensions: one million float32 vectors take about 12.3 GB at 3,072 dimensions and about 4.1 GB at 1,024. Models trained with Matryoshka Representation Learning, such as Gemini Embedding 2, Voyage 4, Cohere Embed 5, and Qwen3-Embedding, can be truncated, and int8 or binary output cuts storage further. Measure the quality loss before you commit.

Do I need to re-embed my documents when I change embedding models?

Usually yes. Each model produces vectors in its own space, so queries embedded with a new model cannot search an index built with an old one. Google states that gemini-embedding-001 and Gemini Embedding 2 embeddings are incompatible. Families trained into a shared space are the exception. The Voyage 4 models can query each other's indexes, and Cohere's Embed 5 Pro and Fast share one embedding space.

What is the MTEB leaderboard?

The MTEB leaderboard is a Hugging Face leaderboard run by the Massive Text Embedding Benchmark project. It ranks embedding models on benchmarks such as MTEB (English, v2), MTEB (Multilingual), MTEB (Code), and the retrieval-only RTEB. For RAG, read retrieval scores rather than the overall average, check how much benchmark data a model saw in training, and treat the ranking as a shortlist, because your own documents can order models differently.

Are OpenAI embeddings still good for RAG?

OpenAI's text-embedding-3-large and text-embedding-3-small are a practical baseline for English text retrieval, with 8,192-token input and a dimensions parameter for shorter vectors. They date from January 2024, and newer models from Voyage AI and Cohere scored higher in their developers' own launch evaluations, which used text-embedding-3-large as a comparison. Test OpenAI against one or two newer models on your own queries before deciding to switch.

Terms in this guide

Cite this guide

The AI Engineering Editors. "Best embedding models for RAG: proprietary and open models compared." The AI Engineering, updated Nov 19, 2026. https://theaiengineering.com/articles/best-embedding-models

Title
Best embedding models for RAG: proprietary and open models compared
Author
The AI Engineering Editors
Publisher
The AI Engineering
Published
Updated
View as Markdown

The AI Engineering Editors ·