Best open embedding models in November 2026: MTEB scores, licenses and memory for 18 models

Of 18 open-weight embedding models I scored from the official MTEB results on 7 November 2026, Microsoft's harrier-oss-v1-27b ranks first on MTEB(Multilingual, v2) at a 74.27 mean task score (MIT license, about 54 GB in BF16), followed by Tencent's KaLM-Embedding-Gemma3-12B-2511 at 72.32 and Qwen3-Embedding-8B at 70.58 (Apache 2.0). On MTEB(eng, v2), the best complete runs in that set are QZhou-Embedding at 75.97 and Qwen3-Embedding-8B at 75.22. For most self-hosted RAG, Qwen3-Embedding-4B or 8B is the pick: Apache 2.0, 32k context, 8 to 15 GB of weights.

• Top multilingual score: harrier-oss-v1-27b, 74.27 on MTEB(Multilingual, v2), 131 tasks.
• Best Apache 2.0 model: Qwen3-Embedding-8B, 70.58 multilingual, 75.22 English, 15.1 GB in BF16.
• Best under 1B parameters: harrier-oss-v1-0.6b at 69.01 (MIT), but it trails older models on Czech retrieval (84.0 vs 92.8).
• License traps: jina-embeddings-v5 is CC BY-NC 4.0, llama-embed-nemotron-8b is non-commercial, KaLM is "not intended for use within the European Union".
• Default reranker: Qwen3-Reranker-4B, 72.74 MMTEB-R (Qwen), Apache 2.0.

Which open embedding model scores highest on MTEB?

harrier-oss-v1-27b has the highest MTEB(Multilingual, v2) mean of the 18 open models I computed, 3.7 points above Qwen3-Embedding-8B at 3.6 times the parameter count. The live board at leaderboard.mteb.org would not load its score table from my network, so I took the raw per-task results from the results repository that feeds it (last updated 5 November 2026) and averaged them over the task lists in mteb 2.27.1: 131 tasks for MTEB(Multilingual, v2), 41 for MTEB(eng, v2). The method reproduces published figures to the second decimal: 70.58 for Qwen3-Embedding-8B, 72.32 for KaLM, 69.46 for llama-embed-nemotron-8b, 59.56 for BGE-M3.

Mean (Task), 0 to 100, my average of the per-task JSON files in embeddings-benchmark/results (last push 5 November 2026) over the task lists and eval splits in mteb 2.27.1. "Incomplete" means the repository holds results for fewer tasks than the benchmark, so no comparable mean exists. Licenses are from each model's Hugging Face card or metadata. NVIDIA's Nemotron-3-Embed-8B is missing because the repository holds only 10 of its 131 multilingual tasks; NVIDIA reports it on RTEB instead.

Why can the leaderboard order differ from the mean?

Because the live leaderboard ranks models by a Borda count across tasks, not by the mean, and because the published numbers are not all from the same runs. The llama-embed-nemotron-8b card shows the effect: in October 2025 it was Borda rank 1 with a 69.46 mean, while Qwen3-Embedding-8B had the higher 70.58 mean and sat at Borda rank 3. A model that wins many small tasks by a little can outrank one that wins fewer tasks by a lot.

Three more checks before trusting one number:

• Self-reported vs repository runs. Google's EmbeddingGemma 2 card reports 61.36 multilingual and 68.46 English; the repository runs average 60.52 and 67.53. Either way it barely moves past its predecessor (61.15 on the card).
• Training overlap. The MTEB metadata for harrier-oss-v1 lists 27 of the 131 MMTEB task names among its training datasets. Qwen3's metadata lists none, which can mean none were used or that the training data was not disclosed.
• Missing tasks. Several 8B-plus models were run only on the multilingual set. Do not compare a 21-task average with a 41-task one.

Which embedding model is best for German, French, Czech or Polish RAG?

For European-language retrieval the 4B-plus models sit within two to three points of each other, and the aggregate MTEB rank is a poor guide below 1B parameters. MTEB has language benchmarks for German, French, Polish, Dutch, Spanish, Slovak and Scandinavian languages plus a combined MTEB(Europe, v1), per the mteb 2.27.1 definitions, but no Czech one. So I pulled per-language subsets of three retrieval tasks from the same results repository.

nDCG@10 (0 to 100) for the cs, de and pl subsets of WikipediaRetrievalMultilingual (test), BelebeleRetrieval (monolingual pairs, test) and MIRACLRetrievalHardNegatives (dev), read from embeddings-benchmark/results on 7 November 2026. Every model here except jina-v5, pplx-embed and KaLM (whose metadata lists no training data) names MIRACL or MIRACL hard negatives among its MTEB training datasets, so the MIRACL columns are not zero-shot.

harrier-oss-v1-0.6b, sixth on the multilingual mean, is last of this group on Czech Wikipedia at 84.0, while multilingual-e5-large-instruct from February 2024 scores 92.8 (with a 514-token limit that rules it out for long chunks). At the top, the Wikipedia task is close to saturated. If your documents are Czech or Polish, the cheapest useful test is to embed a few hundred of your own question and passage pairs with two candidates and compare recall; the model evaluation guide covers how to build that set.

From the cards: Qwen recommends writing the query instruction in English even for multilingual use (worth 1 to 5 percent), and harrier-oss-v1 degrades without its "Instruct: ... Query: ..." prefix. If your documents start as scans, the OCR step sets the ceiling; see the local OCR model comparison.

Which open embedding models allow commercial use?

Most of the top models do; two families are non-commercial, and one license says the model is not meant for the EU. Grouped by what each Hugging Face card says:

• Permissive: Qwen3-Embedding and Qwen3-Reranker (Apache 2.0), harrier-oss-v1 (MIT), Octen-Embedding-8B (Apache 2.0, a LoRA fine-tune of Qwen3-Embedding-8B), EmbeddingGemma 2 (Apache 2.0), Granite Embedding R2 (Apache 2.0; IBM says its training data is permissively licensed), BGE-M3 (MIT), pplx-embed-v1 (MIT), and NVIDIA's Nemotron 3 and 3.5 Embed under OpenMDW-1.1, which NVIDIA's card calls ready for commercial use.
• Conditions attached: the original embeddinggemma-300m uses the Gemma Terms of Use. KaLM-Embedding combines an MIT-style grant with the Gemma terms, and its license file states: "KaLM-Embedding IS NOT INTENDED FOR USE WITHIN THE EUROPEAN UNION."
• Non-commercial: jina-embeddings-v5 and jina-reranker-v3.5 (CC BY-NC 4.0, commercial terms through Jina sales) and llama-embed-nemotron-8b ("for non-commercial/research use only").

For commercial use in the EU, that rules out the second- and fourth-ranked models in the multilingual table. Licenses for the LLM side of a RAG stack are compared in the open-weight license guide, and the GDPR side of self-hosting is on the EU compliance page.

How much memory does an embedding model and its index need?

The model is small next to an LLM; the vector index is what grows. BF16 weights are parameters times 2 bytes (parameter counts from each Hugging Face card):

• harrier-oss-v1-27b: 27.01B x 2 = 54.0 GB. Fits a 128 GB DGX Spark, not a 32 GB RTX 5090 in BF16.
• KaLM-Embedding-Gemma3-12B: 11.77B x 2 = 23.5 GB.
• Qwen3-Embedding-8B and Octen-8B: 7.57B x 2 = 15.1 GB. Qwen3-Embedding-4B: 4.02B x 2 = 8.0 GB.
• 0.6B models (Qwen3, harrier, jina-v5-small): about 1.2 GB. EmbeddingGemma 2: 1.5 GB with all modalities, about 0.54 GB for the 270M text path.

Runtimes add more on top: NVIDIA lists 3.9 GiB for Nemotron 3 Embed 1B in BF16 on Hopper in its NIM performance tables, against about 2.3 GB of raw weights. Google warns against float16 for EmbeddingGemma 2 (NaN or degraded embeddings) and recommends bfloat16.

The index, worked for 10 million chunks (vectors only, before graph-index overhead, which the Spark embeddings and vector search guide estimates):

My calculation. Matryoshka truncation ranges per card: Qwen3-Embedding 32 to 4,096, KaLM 64 to 3,840, jina-v5-text-small 32 to 1,024, Granite R2 128 to 768. pplx-embed-v1 outputs int8 natively and supports binary.

Truncation is cheaper than it sounds. The EmbeddingGemma 2 card gives 61.36 at 768 dimensions, 61.17 at 512 and 60.41 at 256 on MTEB(Multilingual, v2), so cutting the index by two thirds costs under one point. At 128 it drops to 57.89. A full 4,096-dimension Qwen3-8B index at 163.8 GB is bigger than a DGX Spark's 128 GB of memory; truncated to 1,024 it is a quarter of that.

How fast do embedding models run on a GPU?

Embedding is one compute-bound forward pass, so throughput falls with parameter count and input length. First-party figures with exact conditions:

Vendor figures, not reproduced. GPUwerk has not published embedding throughput measurements. The GB10 rows are batch 1 only; NVIDIA lists no batched GB10 rows.

Worked example: embedding 1 million 512-token chunks with Nemotron 3.5 Embed 1B at NVIDIA's batch-1 GB10 rate takes 1,000,000 / 51.6 = 19,380 s, or 5.4 hours, which is $4.25 on a Spark rented at $0.79 per hour. The same job at the H100 batch-1 rate is 1,000,000 / 206.1 = 4,852 s (1.3 hours). IBM's Granite figure would finish it in 1,000,000 / 1,828 = 547 s, about 9 minutes, on an H100. A 4B model does roughly 3.5 times the work per token of a 1.1B one, so by my estimate expect hours, not minutes, for Qwen3-Embedding-4B over a million chunks on one GB10. Large ingestion runs fit the batch processing guide. Note the NVFP4 row: 4.5 times the BF16 throughput on the same Blackwell workstation card, so look for an NVFP4 build of your embedder on Blackwell hardware.

For serving, the Qwen3 card names vLLM 0.8.5+ or Text Embeddings Inference 1.7.2, NVIDIA recommends vLLM 0.25.0 for Nemotron 3 Embed, and pplx-embed needs TEI 1.9.2+. Flags for running vLLM next to a generation model are in the vLLM install guide.

Which open reranker should you pair with it?

Qwen3-Reranker-4B: it is within 0.2 points of the 8B on Qwen's table at half the size, it beats the 0.6B to 1.5B rerankers on Jina's MIRACL and RTEB columns (jina-reranker-v3.5 edges it on English BEIR), and it is Apache 2.0. A reranker scores every query and candidate pair, so its cost grows with the candidate count.

nDCG@10, self-reported by Qwen (top 100 candidates from Qwen3-Embedding-0.6B; the embedder alone scores 64.64 on MMTEB-R) and by Jina (first stage excluded). The two vendors use different candidate sets, so compare within a column from one source only. Licenses from Hugging Face metadata.

By my estimate, scaling NVIDIA's H100 figure (148.2 inputs/s, 1.14B model, 512 tokens) by parameter count gives about 42 pairs/s for a 4B reranker: roughly 2.4 seconds per query for 100 candidates, about 0.4 seconds with the 0.6B. For interactive search I rerank the top 20 to 50.

Which embedding model would I pick?

For a commercial RAG system over German, Czech or Polish documents on one 32 GB GPU or one Spark, I'd start with Qwen3-Embedding-4B truncated to 1,024 dimensions plus Qwen3-Reranker-0.6B, then try the 8B pair only if a test on my own documents shows a gain. Both are Apache 2.0, take 32k tokens, and together need under 10 GB of weights, which leaves the rest of the memory for the LLM (the memory management guide covers sharing).

• Highest score, memory to spare: harrier-oss-v1-27b. MIT, 74.27, but 54 GB of weights and 5,376-dimension vectors.
• Small and permissive: EmbeddingGemma 2 (Apache 2.0, 8,192 tokens, 768 dimensions) or BGE-M3 (MIT) if you also want sparse and multi-vector retrieval.
• Skip for EU commercial use: KaLM-Embedding, llama-embed-nemotron-8b and the jina-v5 models, unless you get a separate license.

Every model here except harrier-27b fits a 32 GB card in BF16; the real question is whether the LLM fits beside it. To compare candidates on real documents, a rented Spark billed by the minute has room for three embedders, a reranker and a 4-bit 70B-class model at once.

FAQ

Sources

Every figure above is attributed to its source in the sentence or table where it appears. Pages were read on 7 November 2026 unless a date says otherwise.

• embeddings-benchmark/results: Data for the MTEB leaderboard, GitHub (MTEB), 2026-11-05
• mteb 2.27.1 benchmark definitions (benchmarks.py), GitHub (MTEB), 2026-11-05
• MTEB Leaderboard, MTEB
• microsoft/harrier-oss-v1-27b, Hugging Face, 2026-03-30
• Qwen/Qwen3-Embedding-8B, Hugging Face, 2025-07-07
• Qwen/Qwen3-Reranker-8B, Hugging Face, 2026-04-16
• tencent/KaLM-Embedding-Gemma3-12B-2511, Hugging Face, 2026-02-10
• KaLM-Embedding LICENSE.txt, Hugging Face
• nvidia/llama-embed-nemotron-8b, Hugging Face, 2025-10-21
• nvidia/Nemotron-3-Embed-8B-BF16, Hugging Face, 2026-07-16
• nvidia/Nemotron-3.5-Embed-8B-BF16, Hugging Face, 2026-10-20
• google/embeddinggemma-2, Hugging Face, 2026-10-28
• jinaai/jina-embeddings-v5-text-small, Hugging Face, 2026-02-18
• jinaai/jina-reranker-v3.5, Hugging Face, 2026-07-14
• ibm-granite/granite-embedding-311m-multilingual-r2, Hugging Face, 2026-04-29
• Octen/Octen-Embedding-8B, Hugging Face, 2026-10-10
• perplexity-ai/pplx-embed-v1-4b, Hugging Face, 2026-06-02
• BAAI/bge-m3, Hugging Face, 2024-07-03
• NeMo Retriever Text Embedding NIM: performance, NVIDIA