Embedding Models Leaderboard 2026: Top 20 MTEB Models (Complete Scores)

TL;DR

The MTEB leaderboard 2026 is shaken up. Gemini Embedding 001 from Google dominates with an overall score of 68.32, closely followed by Qwen3-Embedding from Alibaba. On the open-source side, NV-Embed-v2 from NVIDIA and BGE-Large-v2 remain strong references. Pricing ranges from $0 (open-source) to $0.20/million tokens (Voyage). This guide details the top 20 models, their task-specific scores, and helps you choose the right embedding for your use case.

The MTEB 2026 Leaderboard: Top 20

The Massive Text Embedding Benchmark (MTEB) remains the gold standard for evaluating embedding models. Here is the complete ranking as of June 2026.

Overall ranking

MMTEB Multilingual Scores

The Multilingual MTEB (MMTEB) evaluates performance on tasks across 100+ languages. Critical for international applications.

Top 10 MMTEB

Key takeaway: For French specifically, Cohere Embed v4 is the best choice with a score of 63.8. This is the model Ailog uses for French-speaking clients.

Open-source vs proprietary

Performance comparison

Verdict: The gap between open-source and proprietary has never been smaller. Qwen3-Embedding is within 0.6% of Gemini, and it is free. For most use cases, open-source is more than sufficient.

Cost for 100M documents

Best model by use case

For RAG (Retrieval)

For classification

For clustering

Code: using the top 3 models

1. Gemini Embedding 001

DEVELOPERpython
import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

def embed_with_gemini(texts: list[str], task_type: str = "retrieval_document"):
    """Embed with Gemini - best MTEB score 2026."""
    result = genai.embed_content(
        model="models/gemini-embedding-001",
        content=texts,
        task_type=task_type  # retrieval_document, retrieval_query, etc.
    )
    return result["embedding"]

# For queries, use a different task_type
query_embedding = embed_with_gemini(
    ["How does RAG work?"],
    task_type="retrieval_query"
)

# For documents
doc_embeddings = embed_with_gemini(
    ["RAG combines retrieval and generation..."],
    task_type="retrieval_document"
)

print(f"Dimensions: {len(query_embedding[0])}")  # 3072

2. Qwen3-Embedding (open-source)

DEVELOPERpython
from sentence_transformers import SentenceTransformer

# Download model (first time only)
model = SentenceTransformer("Qwen/Qwen3-Embedding-8B")

# Document embeddings
documents = [
    "RAG combines vector search with text generation.",
    "Embeddings transform text into numerical vectors.",
    "Qdrant is a high-performance vector database."
]

doc_embeddings = model.encode(
    documents,
    batch_size=32,
    show_progress_bar=True,
    normalize_embeddings=True
)

# Query embeddings (with instruction)
queries = ["How does RAG work?"]
query_embeddings = model.encode(
    queries,
    prompt="query: ",
    normalize_embeddings=True
)

print(f"Dimensions: {doc_embeddings.shape[1]}")  # 4096

3. NV-Embed-v2 (NVIDIA, open-source)

DEVELOPERpython
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("nvidia/NV-Embed-v2", trust_remote_code=True)

# NV-Embed supports task-specific instructions
instruction = "Given a question, retrieve relevant passages that answer it"

queries = ["What is retrieval augmented generation?"]
passages = [
    "RAG combines information retrieval with text generation...",
    "Vector databases store high-dimensional embeddings..."
]

# Encode queries with instruction
query_embeddings = model.encode(
    queries,
    prompt=instruction,
    normalize_embeddings=True
)

# Encode passages without instruction
passage_embeddings = model.encode(
    passages,
    normalize_embeddings=True
)

# Similarity calculation
import numpy as np
similarities = np.dot(query_embeddings, passage_embeddings.T)
print(f"Scores: {similarities}")
print(f"Dimensions: {query_embeddings.shape[1]}")  # 4096

Key trends in 2026

1. Dimensions are exploding

The trend is toward very high-dimensional models:

Impact: more dimensions = better accuracy but more storage and latency. Quantization becomes essential.

2. Matryoshka embeddings

Matryoshka embeddings allow truncating vectors to any dimension without retraining:

DEVELOPERpython
# text-embedding-3-large supports Matryoshka
from openai import OpenAI

client = OpenAI()

# Full dimension (3072)
full = client.embeddings.create(
    model="text-embedding-3-large",
    input="Hello world",
    dimensions=3072
)

# Reduced dimension (256) - same model
compact = client.embeddings.create(
    model="text-embedding-3-large",
    input="Hello world",
    dimensions=256
)

# 12x less storage, ~3% recall loss

3. Multimodal embeddings

Cohere Embed v4 is a leading commercial multimodal model (text + image):

DEVELOPERpython
import cohere

co = cohere.Client("YOUR_API_KEY")

# Embed text + image in the same space
response = co.embed(
    texts=["A cat on a couch"],
    images=["base64_encoded_image..."],
    model="embed-v4.0",
    input_type="search_document"
)
# Text and image embeddings are comparable

4. Long context (32K+ tokens)

Long context models allow encoding entire documents without chunking:

Impact on RAG architecture choices

The embedding model choice impacts your entire architecture:

Decision matrix

Our recommendation for production RAG

For a production RAG system, we recommend:

1. Start: text-embedding-3-small ($0.02/1M tokens, simple API)
2. Growth: Cohere Embed v4 (multilingual, multimodal)
3. Scale: Qwen3-Embedding self-hosted (free, performant, full control)

At Ailog, we use a combination of models depending on the channel: Cohere for the multilingual widget, and a fine-tuned open-source model for high-volume clients. Check out our embeddings guide and embedding fine-tuning guide.

Inference speed benchmark

Embedding latency is critical for real-time RAG. Here are the measured inference times.

Per-query latency (batch=1, GPU A100)

API latency (cloud)

Conclusion

The MTEB 2026 leaderboard confirms three major trends:

1. The open-source/proprietary gap is closing: Qwen3-Embedding is within 0.6% of Gemini
2. Multilingual is no longer optional: MMTEB has become the reference benchmark
3. Costs stay low: open-source is free and affordable APIs like text-embedding-3-small start at $0.02/1M tokens

The right model depends on your context. But one thing is clear: embeddings are more accessible and performant than ever.

Want to integrate the best embeddings into your chatbot without worrying about infrastructure? Try Ailog for free - we handle the embeddings, vector database, and LLM for you.