8 Best Embedding Models for Search, RAG, and Agents (2026)

Cohere shipped Embed 5 on September 30, Google followed with EmbeddingGemma 2 a week later, and Gemini Embedding 2 has been stable since April. Each launch came with benchmarks showing the new model ahead, usually on a test its vendor picked.

The choice carries more weight than it looks, because the embedding model decides which chunks your RAG pipeline or agent ever gets to see. Switching later means re-embedding your whole corpus, since vectors from two different models don't share a space.

That leaves a more useful question: which model fits the job you're building for, and how you'll confirm it on your own queries before you commit.

Here are the 8 best embedding models for search, RAG, and agents in 2026, with one pick per use case.

TL;DR: The 8 Best Embedding Models in 2026

Each pick below covers a different job, from a cheap hosted default to a model that runs on a phone. If you're building text RAG on a hosted API and aren't sure where to start, begin with text-embedding-3-small and test one of the other picks against it on your own queries.

• Default API - OpenAI text-embedding-3-small, at $0.02 per million tokens, with text-embedding-3-large when you need a higher score.
• Multimodal search - Gemini Embedding 2, which puts text, images, video, audio, and PDFs in one vector space.
• Retrieval quality - Cohere Embed 5 Pro, which comes out ahead of Voyage 4 Large and Gemini Embedding 2 in Cohere's own retrieval tests.
• Text retrieval - Voyage 4, a family of models that share one embedding space, starting at $0.02 per million tokens.
• Open weights - Qwen3-Embedding, Apache 2.0 in three sizes with a 32K-token context.
• Multilingual and hybrid search - BGE-M3, which returns dense, sparse, and multi-vector output from one model.
• Small and on-device - EmbeddingGemma 2, at 740M parameters and about 191MB of RAM for text.
• Ollama - nomic-embed-text, the embedding model with the most pulls in Ollama's library.

All of the benchmark scores below were published by the model's own vendor, so treat them as a way to build a shortlist and test the top two or three on your own data.

What Is an Embedding Model?

An embedding model converts text, images, or other content into a vector, a fixed-length list of numbers, so that inputs with similar meaning end up close together. Applications compare those vectors to find related content, which is how semantic search and RAG retrieval work.

Unlike an LLM, an embedding model doesn't generate anything a person reads. You embed your documents once and store the vectors in a vector database, then embed each incoming query with the same model and pull back the nearest documents by cosine similarity. That's the retrieval step behind semantic search, and in a RAG pipeline it decides which chunks the LLM reads before it answers.

Two properties shape most of the tradeoffs in the picks below. Dimensions set how much storage each vector takes: 1 million vectors stored as 32-bit floats take about 12.3GB at 3,072 dimensions and about 3.1GB at 768, before index overhead. Many current models support Matryoshka truncation, which lets you shorten vectors at a small accuracy cost, and the context window caps how much text one input can hold, which in turn limits how large your chunks can be.

Switching models has a price you can estimate up front. Re-embedding 1 million chunks of about 500 tokens each comes to 500 million tokens, roughly $10 on text-embedding-3-small or $65 on text-embedding-3-large, plus the time to rebuild the index.

How to Read Embedding Model Benchmarks

The Massive Text Embedding Benchmark (MTEB) is the common reference point for comparing embedding models. It averages scores across task types like retrieval, classification, clustering, and reranking, and it comes in several versions, including English v2 and a multilingual edition, which can score the same model differently.

Because of that, an MTEB number only compares cleanly against another number from the same version and aggregation method. For search and RAG, the retrieval column on the MTEB leaderboard tells you more than the overall average, since gains in classification or clustering can lift the average without changing what you'd retrieve. Vendors also publish results on retrieval-only benchmarks, such as the RTEB suite Voyage uses and the RCP-nDCG@10 method Cohere introduced, and those numbers don't map onto MTEB at all.

Use benchmarks to cut the field to two or three candidates, then run them on a sample of your own queries and documents and compare recall@k and nDCG. A few hundred real queries is usually enough to see a difference, with the expected documents for each one labeled by hand or pulled from your logs, and each candidate needs its own index since their vectors can't be mixed. That's a small-scale version of RAG evaluation, and it shows whether a two-point gap on a leaderboard makes any difference to what you retrieve.

If retrieval still falls short, test a reranker or hybrid keyword search alongside the model swap, since either one can move results as much as a new embedding model.

8 Best Embedding Models Compared

Each model below is the pick for one use case, with specs taken from the vendor's own docs.

Prices are per million text tokens, and the open-weight models cost whatever your own GPUs or CPUs cost to run.

Best Default API: OpenAI text-embedding-3

OpenAI's text-embedding-3 family has two models, and text-embedding-3-small is a low-cost starting point for a text-only search or RAG app at $0.02 per million tokens. text-embedding-3-large costs $0.13 for a higher MTEB score, and both accept a dimensions parameter, so you can store shorter vectors without switching models.

What you give up is range. Both models take text only and cap each input at 8,192 tokens, and their published scores come from OpenAI's own evaluation at the models' 2024 launch, which makes them hard to set against newer v2 results. OpenAI hasn't released a newer embedding family since, so if you need images, long documents, or open weights, you'll need a different model.

Best for: A low-cost default for text-only search and RAG

Dimensions: 1,536 (small) and 3,072 (large), shortenable with dimensions

Context: 8,192 tokens

Price: $0.02 (small) and $0.13 (large) per 1M tokens

Benchmark: MTEB average of 62.3 (small) and 64.6 (large), OpenAI-reported

How to run it: OpenAI API

Best Multimodal: Gemini Embedding 2

Google's Gemini Embedding 2 maps text, images, video, audio, and PDFs into one vector space, so a text query can retrieve a slide, a product photo, or a clip of a recorded call without a separate pipeline for each media type. It went stable in April 2026, supports Matryoshka output from 128 to 3,072 dimensions, and accepts up to 8,192 tokens of text per input.

Pricing changes with the modality. Text costs $0.20 per million tokens, or $0.10 through the Batch API, while images cost $0.45, audio $6.50, and video $12.00 per million tokens, so a video-heavy corpus can cost far more to index than a text one of similar size. Each request is capped at 6 images, 180 seconds of audio, 120 seconds of video, and one PDF of up to 6 pages. Its vectors also aren't compatible with gemini-embedding-001's, so moving from 001 means re-embedding, and 001 is still available at $0.15 per million tokens if your pipeline is text-only.

Best for: Search across images, video, audio, and documents

Dimensions: 128 to 3,072 (Google recommends 768, 1,536, or 3,072)

Context: 8,192 tokens of text

Price: $0.20 per 1M text tokens ($0.10 batch), with higher rates for other modalities

Benchmark: No score in Google's docs, which list MTEB results only for gemini-embedding-001 (68.17 at 1,536 dimensions)

How to run it: Gemini API or Vertex AI

Best Retrieval Quality: Cohere Embed 5

Cohere Embed 5 comes in two tiers that share one embedding space: Embed 5 Pro for indexing and Embed 5 Fast for queries, so you can index a corpus with Pro once and serve live queries with the cheaper model. Both take text, images, or fused text-and-image documents, cover 100+ languages, and accept 128K tokens per input, which fits long contracts and filings that would need heavy chunking at an 8K limit.

In Cohere's own launch tests, Embed 5 Pro averaged 84.8 on a parsed-document retrieval suite, ahead of Voyage 4 Large at 83.6 and Gemini Embedding 2 at 80.8. Those results are self-reported and scored with RCP-nDCG@10, a method Cohere introduced alongside the model, and since Embed 5 only shipped on September 30, independent results are still thin. Pro costs $0.12 and Fast $0.08 per million text tokens, images cost $0.40 per million on both, and Cohere also offers private deployment in your own VPC or on-premises.

Best for: Retrieval quality on long, mixed text-and-image documents

Dimensions: 256 to 2,048, as float, int8, or binary

Context: 128K tokens

Price: $0.12 (Pro) and $0.08 (Fast) per 1M text tokens, $0.40 per 1M image tokens

Benchmark: 84.8 parsed-document average vs Voyage 4 Large's 83.6 (Cohere-run, self-reported, RCP-nDCG@10)

How to run it: Cohere API, Microsoft Foundry, Amazon SageMaker, or private deployment

Best for Text Retrieval: Voyage 4

Voyage 4 is a family of text embedding models that share one embedding space across voyage-4-large, voyage-4, voyage-4-lite, and the open-weight voyage-4-nano. You can embed documents once with voyage-4-large, query them with lite at $0.02 per million tokens, and move queries up a tier later without re-embedding anything.

On Voyage's RTEB results, a 29-dataset retrieval benchmark, voyage-4-large averaged 3.87% above Gemini Embedding 001, 8.20% above Cohere Embed v4, and 14.05% above OpenAI's text-embedding-3-large. That comparison predates Gemini Embedding 2 and Embed 5, and Cohere's later tests put Embed 5 Pro ahead. The family is text-only, so images need Voyage's separate multimodal model, and code retrieval has its own voyage-code-4, while the first 200 million tokens on each 4-series model are free.

Best for: Text retrieval where query volume drives cost

Dimensions: 256 to 2,048 (1,024 default), with int8 and binary options

Context: 32K tokens

Price: $0.12 (large), $0.06 (standard), and $0.02 (lite) per 1M tokens, first 200M free

Benchmark: voyage-4-large 3.87% above Gemini Embedding 001 and 14.05% above text-embedding-3-large on RTEB (Voyage-run)

How to run it: Voyage API or MongoDB Atlas, with voyage-4-nano weights on Hugging Face

Best Open-Weight: Qwen3-Embedding

Qwen3-Embedding is the Qwen team's open embedding family under Apache 2.0, in 0.6B, 4B, and 8B sizes, all with a 32K-token context and support for 100+ natural and programming languages. Qwen3-Embedding-8B outputs up to 4,096 dimensions that you can cut to anything from 32 up, and the models take a task instruction with each query, which the model card says typically improves results by 1% to 5%.

Qwen reports 69.44 on MTEB English v2 retrieval and 70.88 on MTEB multilingual retrieval for the 8B, though those numbers date from June 2025. Running the 8B also means serving an 8-billion-parameter model on your own GPUs, so the 0.6B is the more practical choice for CPU or small-GPU setups. Qwen publishes matching reranker models in the same three sizes if you add a reranking step later.

Best for: Self-hosted retrieval with open weights

Dimensions: 1,024 (0.6B), 2,560 (4B), and up to 4,096 (8B)

Context: 32K tokens

License: Apache 2.0

Benchmark: 8B scores 69.44 on MTEB English v2 retrieval and 70.88 on MTEB multilingual retrieval (Qwen-reported)

How to run it: Hugging Face weights, or qwen3-embedding in Ollama

Best for Multilingual and Hybrid Search: BGE-M3

BAAI's BGE-M3 produces three kinds of output from one model: a dense 1,024-dimension vector, sparse lexical weights that work like a keyword index, and ColBERT-style multi-vector representations. That lets you run hybrid search, matching on exact terms and meaning together, without a second model, across 100+ languages and inputs up to 8,192 tokens.

It's an older model, with its paper published in February 2024, and its model card shows MIRACL and MKQA results only as charts, without an aggregate number to compare. Storing multi-vector output also takes far more space than one vector per chunk, so plan the index around the modes you'll use. BGE-M3 is MIT-licensed and runs in Ollama as bge-m3, and the BGE-M3 on Respan model page lists its hosted providers and pricing.

Best for: Multilingual search that mixes keyword and semantic matching

Dimensions: 1,024 (dense)

Context: 8,192 tokens

License: MIT

Benchmark: No aggregate score in the model card's text, with MIRACL and MKQA results shown as charts

How to run it: Hugging Face weights, or bge-m3 in Ollama

Best Small Model: EmbeddingGemma 2

Google's EmbeddingGemma 2, released October 6, 2026, fits text, code, images, audio, and video into one 768-dimension space with 740M parameters, and text-only use loads only the 270M text encoder. Quantized on a Pixel 11 Pro, Google measured about 191MB of active RAM for text and 567MB for the full multimodal model, which is small enough to run on a recent phone.

It's Apache 2.0 with an 8K-token context, four times the original EmbeddingGemma's, and supports Matryoshka truncation to 512, 256, or 128 dimensions. Google reports its MTEB Code score rising from 68.76 to 78.68 over the first version, but the announcement gives no general retrieval average, and a 768-dimension ceiling leaves less headroom than server-scale models. It's available on Hugging Face, Kaggle, Ollama, llama.cpp, and transformers.js.

Best for: On-device and private search, including multimodal

Dimensions: 768, truncatable to 512, 256, or 128

Context: 8K tokens

License: Apache 2.0

Benchmark: MTEB Code 78.68, up from 68.76 for EmbeddingGemma 1 (Google-reported)

How to run it: Hugging Face, Kaggle, Ollama (embeddinggemma-2), llama.cpp, or transformers.js

Best for Ollama: nomic-embed-text

nomic-embed-text has 96M pulls in Ollama's library, more than any other embedding model there. It's a 274MB download, small enough to run on a laptop CPU next to a local LLM, and it expects a task prefix like search_query: or search_document: on each input.

Its age shows in the limits, though. Ollama's build lists a 2K-token context and was last updated two years ago, so longer chunks get cut off, while newer models in the same library, including embeddinggemma-2 and qwen3-embedding, take much longer inputs. Nomic's model card reports an MTEB score of 62.28 at 768 dimensions for v1.5, with Matryoshka sizes down to 64.

Best for: Local RAG with Ollama on modest hardware

Dimensions: 768, truncatable down to 64

Context: 2K tokens in Ollama's build

License: Apache 2.0

Benchmark: MTEB 62.28 at 768 dimensions (Nomic-reported, v1.5)

How to run it: nomic-embed-text in Ollama

How to Prove Your Embedding Model on Real Traffic

A leaderboard tells you which models to try, and your production traffic tells you which one to keep. What you need to see is whether retrieval pulled the right chunks for real queries, whether answers held up after you switched models or re-embedded, and what each embedding call cost.

With Respan, that workflow runs through the same gateway and traces you'd use for chat calls. Respan's AI gateway serves an OpenAI-compatible /v1/embeddings endpoint, so the only code change is the base URL and the key:

import os
from openai import OpenAI
 
client = OpenAI(
    base_url="https://gateway.respan.ai/v1",
    api_key=os.environ["RESPAN_API_KEY"],
)
 
result = client.embeddings.create(
    model="text-embedding-3-small",
    input=["How do I reset my password?"],
    extra_body={
        "customer_identifier": "user_123",
        "metadata": {"index_version": "v2"},
    },
)

From there, proving a model choice takes a few steps:

1. Tag every embedding call - Each call through the gateway is logged as its own trace with its input tokens and cost, and the log keeps the input text rather than the vectors, unless you set disable_log to keep the text out while still recording tokens and cost. A customer_identifier and metadata like the index version become properties you can filter Logs by, so spend and requests split cleanly by customer or by index. The gateway serves embedding models from OpenAI, Gemini, Mistral, Fireworks, Together, and Bedrock (Cohere and Titan).
2. Trace the retrieval step - Wrap your pipeline with Respan's @workflow and @task decorators so retrieval becomes its own span in the same trace as the LLM call it feeds, with the query as input and the returned chunks as output. When an answer goes wrong, the trace shows whether the right chunks came back or the model ignored them, which is the core of RAG observability. This works the same for self-hosted models like Qwen3-Embedding or EmbeddingGemma 2, which don't go through the gateway but still show up as retrieval spans.
3. Build one dataset per candidate - Run a sample of real queries through your pipeline against an index built with each candidate model, tagging the spans with that index's version. On the Spans page, filter to the retrieval task and one index version at a time, then export each set to its own dataset.
4. Score the retrieval, not the leaderboard - Attach the same evaluators to every dataset, such as an LLM judge for context relevance (is the retrieved context relevant to the query?) and context completeness (does it contain enough to answer it?), or a code check that compares retrieved document IDs against the expected ones. Run each dataset as a Dataset outputs experiment, which scores the stored results without generating anything new, and compare the score distributions side by side in the Analytics tab.
5. Watch production after the swap - Embedding calls count against the same limit policies and customer budgets as chat, so a hard spend cap on the key that runs a bulk re-embed stops it at the ceiling. After the switch, online AI evals score a sample of live spans with scorers like Relevance, and monitors alert you in Slack, email, or a webhook when cost, errors, or latency cross a threshold.

Instead of reading logs after the fact, use Respan to run observability in production, know when production shifts, and act before it spreads.

FAQ

What is the difference between an embedding model and an LLM?

An LLM generates text, while an embedding model turns input into a vector that software compares for similarity, and nobody reads its output directly. In a RAG app the two work together: the embedding model finds the relevant chunks, and the LLM writes the answer from them. They're two of the types of AI models you'll combine in production, and Respan's gateway routes both kinds of calls through one API and one key.

Is GPT an embedding model?

No. GPT models generate text, and OpenAI's embedding models are a separate family: text-embedding-3-small and text-embedding-3-large, with text-embedding-ada-002 as the older generation. Dedicated embedding models are trained so that inputs with similar meaning land close together, which is what retrieval depends on.

What is the most popular embedding model?

By request volume, it's OpenAI's text-embedding-3-small. OpenRouter's embedding rankings for the week through November 5, 2026, put it at 152M requests, ahead of Qwen3 Embedding 8B at 68.7M and Gemini Embedding 2 at 46M, while nomic-embed-text leads Ollama's library for local use with 96M pulls. Popularity tends to reflect price and how long a model has been around, so it's a reasonable default rather than proof that a model fits your data.

What are OpenAI's embedding models?

OpenAI currently offers text-embedding-3-small at $0.02 per million tokens with 1,536 dimensions and text-embedding-3-large at $0.13 with 3,072 dimensions, plus the older text-embedding-ada-002. Both v3 models take up to 8,192 tokens per input and can return shorter vectors through the dimensions parameter, which the OpenAI embeddings guide covers alongside batching and vector store setup. You can also call both through Respan's gateway on the same key as your chat models, with each call's cost logged.

What are the best Ollama embedding models?

For most local setups, embeddinggemma-2 or qwen3-embedding, with bge-m3 for hybrid search and nomic-embed-text as the long-standing lightweight option. embeddinggemma-2 takes text and images in Ollama's build with an 8K context, qwen3-embedding offers a 32K context in three sizes, bge-m3 adds sparse and multi-vector output, and nomic-embed-text is a 274MB download limited to a 2K context in Ollama's build.