Best free embedding models in 2026: open-source models, ranked
The open-source embedding models with the highest retrieval scores in October 2026, the embedding APIs with free allowances, and the small models that run on a CPU, with license, size, dimensions and max input for each.
As of October 16, 2026, Microsoft's harrier-oss-v1-27b has the highest multilingual retrieval score of any open-source embedding model you can use commercially on the MTEB leaderboard, with Octen-Embedding-8B and Qwen3-Embedding-8B next in our ranking below. For a model that runs on a laptop CPU, start with Snowflake's arctic-embed-m-v2.0, IBM's granite-embedding-english-r2 or Google's EmbeddingGemma-300m, and if you'd rather not host anything, four embedding APIs below have free allowances.
Below are three ranked tables (best open models, free APIs, small and fast), how to read the scores, what each costs to run, and a script to test your shortlist on your own data. Every score was read from the leaderboard on October 16, 2026, and every spec comes from the model's card or the provider's docs.
Best open-source embedding models
These are the six highest retrieval scores on MTEB's multilingual benchmark among open models whose license allows commercial use (MIT or Apache 2.0) and whose overlap with the benchmark's training data is known. The leaderboard reports that overlap as a "zero-shot" share.
| # | Model | License | Size | Dimensions | Max input | Retrieval, MTEB Multilingual v2 | Retrieval, MTEB English v2 |
|---|---|---|---|---|---|---|---|
| 1 | harrier-oss-v1-27b | MIT | 27B | 5,376 | 32K tokens | 78.27 | Not run |
| 2 | Octen-Embedding-8B | Apache 2.0 | 7.6B | 4,096 | 32K tokens | 71.61 | Not run |
| 3 | Qwen3-Embedding-8B | Apache 2.0 | 7.6B | Up to 4,096 | 32K tokens | 70.88 | 69.44 |
| 4 | harrier-oss-v1-0.6b | MIT | 0.6B | 1,024 | 32K tokens | 70.75 | Not run |
| 5 | pplx-embed-v1-4b | MIT | 4.0B | 2,560 | 32K tokens | 69.66 | Not run |
| 6 | Qwen3-Embedding-4B | Apache 2.0 | 4.0B | Up to 2,560 | 32K tokens | 69.60 | 68.46 |
Retrieval is the leaderboard's average over each benchmark's retrieval tasks (18 in Multilingual v2, 10 in English v2), mostly nDCG@10, out of 100. "Not run" means the model hasn't been scored on every English retrieval task yet, so it has no English average. Size is the parameter count on the model's Hugging Face page.
What sets them apart:
- harrier-oss-v1 (Microsoft, March 2026) is a family of decoder models in three sizes. The 0.6B model scores within 0.13 points of Qwen3-Embedding-8B on multilingual retrieval with under a twelfth of the parameters. Its zero-shot share is 78%, lower than the others in this table, so part of its lead may come from training data that overlaps the benchmark. Queries take its
web_search_queryprompt (model card). - Octen-Embedding-8B is fine-tuned from Qwen3-Embedding-8B, so it has the same size, dimensions and input limit (model card).
- Qwen3-Embedding (Alibaba's Qwen team, June 2025) comes in 0.6B, 4B and 8B sizes. You can ask for shorter vectors, from 32 dimensions up to the full size, and each query should carry a one-sentence instruction that describes the task, while documents don't need one (model card, paper). It's the only family in this table with a score on both benchmarks.
- pplx-embed-v1 (Perplexity, built on Qwen3) needs no instruction prefix, supports shorter vectors and returns int8 embeddings that you compare with cosine similarity (model card).
Three strong models are excluded on license. Tencent's KaLM-Embedding-Gemma3-12B-2511 (75.66), which would otherwise rank second, ships under Tencent's own community license. NVIDIA's llama-embed-nemotron-8b (68.69) is limited to non-commercial use by its NVIDIA license, and Jina's jina-embeddings-v5 weights are CC BY-NC 4.0.
What are the best free embedding models?
Every open model on this page is free to download and run within its license, so the cost is the machine it runs on. You can load most of them in a few lines with Sentence Transformers. If you'd rather call an API, these four have free allowances (listed A to Z, checked October 16, 2026):
| Provider and model | What's free | Dimensions | Max input | Retrieval, MTEB Multilingual v2 / English v2 |
|---|---|---|---|---|
| Cloudflare Workers AI, qwen3-embedding-0.6b | 10,000 Neurons a day. At 1,075 Neurons per million input tokens, that's about 9.3 million tokens a day (our arithmetic). | 1,024 | 8,192 tokens | 64.65 / 61.83 (Qwen3-Embedding-0.6B) |
| Cohere, embed-v5.0-pro or embed-v5.0-fast | A trial key for evaluation, limited to 1,000 API calls a month | 256 to 2,048 | 128K tokens | Not on the leaderboard |
| Google Gemini API, gemini-embedding-2 | Text input is free of charge on the free tier, and Google uses free-tier content to improve its products | 128 to 3,072 | 8,192 tokens | Not fully scored yet |
| Voyage AI, voyage-4 | The first 200 million tokens are free for every account | 256 to 2,048 | 32,000 tokens | Not fully scored yet |
The previous Gemini model, gemini-embedding-001, is still available for text, with a 2,048-token limit, and scores 67.71 / 64.35. Embeddings from the two Gemini models can't be compared with each other (Gemini embeddings docs). Voyage also publishes voyage-4-nano as open weights under Apache 2.0, and its docs say embeddings from all voyage-4 models are compatible with each other (Voyage docs).
Small and fast: the best local embedding models
For a CPU, a laptop or a small server, here's a shortlist of open models under 350 million parameters: the strongest recent small models from Snowflake, IBM and Google, plus bge-small-en-v1.5 and the models this post compared in 2025, with nomic-embed-text-v1.5 in place of v1. They're ordered by English retrieval score.
| # | Model | License | Size | Dimensions | Max input | Retrieval, MTEB English v2 | Retrieval, MTEB Multilingual v2 |
|---|---|---|---|---|---|---|---|
| 1 | snowflake-arctic-embed-m-v2.0 | Apache 2.0 | 305M | 768 | 8,192 tokens | 58.41 | 54.83 |
| 2 | granite-embedding-english-r2 | Apache 2.0 | 149M | 768 | 8,192 tokens | 56.43 | Not run |
| 3 | EmbeddingGemma-300m | Gemma terms | 303M | 768 | 2,048 tokens | 55.69 | 62.49 |
| 4 | bge-base-en-v1.5 | MIT | 109M | 768 | 512 tokens | 54.75 | 38.61 |
| 5 | granite-embedding-small-english-r2 | Apache 2.0 | 47.7M | 384 | 8,192 tokens | 53.93 | Not run |
| 6 | bge-small-en-v1.5 | MIT | 33.4M | 384 | 512 tokens | 53.86 | 36.26 |
| 7 | e5-base-v2 | MIT | 109M | 768 | 512 tokens | 49.67 | 40.49 |
| 8 | nomic-embed-text-v1.5 | Apache 2.0 | 137M | 768 | 8,192 tokens | 47.97 | 34.09 |
| 9 | all-MiniLM-L6-v2 | Apache 2.0 | 22.7M | 384 | 256 word pieces | 42.92 | 32.51 |
The English-only models score lower on the multilingual benchmark partly because seven of its 18 retrieval tasks include other languages, so compare them on the English column. Snowflake's older snowflake-arctic-embed-l (335M) scores a little higher on English retrieval (59.04), but reads only 512 tokens.
If you need many languages at this size, three newer models stand out on the multilingual benchmark: harrier-oss-v1-270m (MIT, 268M, 640 dimensions, 66.38), granite-embedding-311m-multilingual-r2 (Apache 2.0, 311M, 768 dimensions, 65.21) and its smaller sibling granite-embedding-97m-multilingual-r2 (Apache 2.0, 97M, 384 dimensions, 60.32). EmbeddingGemma-300m also scores well there (62.49), and it can return shorter vectors of 512, 256 or 128 dimensions (model card). Google's newer EmbeddingGemma 2 is Apache 2.0, reads 8,192 tokens and also embeds images, audio and video, but scores lower on retrieval (60.60 multilingual, 51.33 English).
The four models this post compared in 2025
When this post first ran in June 2025, it compared four models that were common defaults for RAG then. Three of them are still downloaded millions of times a month on Hugging Face, and all four still work as baselines, but newer models of the same size now score higher.
1. BAAI/bge-base-en-v1.5
An English model from BAAI with 768 dimensions and a 512-token limit. For retrieval, its card suggests adding the instruction "Represent this sentence for searching relevant passages: " to queries but not to documents, and notes that skipping it costs only a little retrieval quality (model card). It scores 54.75 on English retrieval today. bge-small-en-v1.5 is the same family at about a third of the size and scores 53.86, only 0.89 points lower.
2. intfloat/e5-base-v2
A 12-layer English model with 768 dimensions that truncates long texts to 512 tokens (model card). The E5 paper describes contrastive pre-training on about 270 million text pairs, with every input starting "query: " or "passage: ". Leave the prefixes out and the comparison isn't fair. It scores 49.67 on English retrieval.
3. nomic-ai/nomic-embed-text-v1
A 137M model that reads up to 8,192 tokens, with task prefixes such as search_query: and search_document: (model card). Its successor, nomic-embed-text-v1.5, adds Matryoshka training, so you can cut its 768 dimensions down to 512, 256, 128 or 64 (model card). On English retrieval, v1 scores 50.72 and v1.5 scores 47.97.
4. sentence-transformers/all-MiniLM-L6-v2
The smallest of the four, at 22.7M parameters and 384 dimensions. It truncates input longer than 256 word pieces, and it was trained on sequences of 128 tokens, so keep chunks short (model card). It's fast and widely used, but it scores 42.92 on English retrieval, the lowest in the small table.
Why go open source?
Open models give you control over three things an API doesn't:
- Cost. There's no per-token bill, only the hardware and the work of running it.
- Where the data goes. Text never leaves your machines, which matters for private documents and regulated data.
- The model itself. You can pin an exact version so your vectors never change underneath you, fine-tune on your domain, and read the model card to see how it was trained.
They've also caught up. On English retrieval, Qwen3-Embedding-8B (69.44) scores above Google's gemini-embedding-001 (64.35) and OpenAI's text-embedding-3-large (57.98) on the same leaderboard.
Open weights don't mean every use is allowed. MIT and Apache 2.0 allow commercial use, EmbeddingGemma-300m comes with Google's Gemma terms (its successor, EmbeddingGemma 2, is Apache 2.0), and some strong models are non-commercial only. Check the license of the exact version you download.
Benchmarking these models
The scores come from MTEB, the Massive Text Embedding Benchmark, which the open-source mteb project runs on Hugging Face. The current multilingual and English benchmarks come from the MMTEB paper (2025). Four things help when you read them:
- Retrieval is one column of many. The English v2 benchmark has 41 tasks across classification, clustering, retrieval and more. For RAG and memory, the retrieval average is the one to read. Its 10 English tasks include ArguAna, two CQADupStack forums, FEVER and ClimateFEVER, FiQA, HotpotQA, SCIDOCS, TREC-COVID and Touché 2020.
- Check zero-shot. The leaderboard reports what share of a benchmark's tasks a model didn't train on. Qwen3-Embedding is 99% zero-shot on the multilingual benchmark and harrier-oss-v1 is 78%. A lower share can lift a score without lifting quality on your data.
- Each benchmark has its own leader. On English retrieval alone, the top open score is 70.69, from IEIT's Yuan-embedding-2.0-en, a fine-tune of Qwen3-Embedding-0.6B that hasn't been run on the multilingual tasks.
- New models land every week. Two small models dated October 10, 2026 on the leaderboard already score above most of the small table. We list models with a track record, so check the leaderboard's size filter before you settle.
A leaderboard average still isn't your data. Your domain, languages, chunk size and the way your users phrase questions all change the order, which is why the test script further down matters more than any table here.
Compute cost tradeoffs
Two costs grow with the model you pick: the memory needed to run it, and the storage for every vector it produces.
| Model | Parameters | Weights in memory | Raw storage for 1M vectors |
|---|---|---|---|
| harrier-oss-v1-27b | 27B | 51,515 MB | 21.5 GB |
| Qwen3-Embedding-8B | 7.6B | 14,433 MB | 16.4 GB |
| Qwen3-Embedding-4B | 4.0B | 7,671 MB | 10.2 GB |
| harrier-oss-v1-0.6b | 0.6B | 1,137 MB | 4.1 GB |
| EmbeddingGemma-300m | 303M | 1,155 MB | 3.1 GB |
| bge-base-en-v1.5 | 109M | 390 MB | 3.1 GB |
| granite-embedding-small-english-r2 | 47.7M | 91 MB | 1.5 GB |
| all-MiniLM-L6-v2 | 22.7M | 87 MB | 1.5 GB |
Weights in memory is the leaderboard's figure for each model, at the precision each model is published in (16-bit for harrier, Qwen3 and granite, 32-bit for EmbeddingGemma, bge and MiniLM). Raw storage is our arithmetic: dimensions × 4 bytes per float32 value × 1,000,000 vectors, before indexes, IDs and metadata. Models trained for shorter vectors (Qwen3-Embedding, EmbeddingGemma, nomic-embed-text-v1.5, arctic-embed v2.0) let you store a prefix instead, which the Matryoshka guide covers.
If you pay per token instead, list prices on October 16, 2026 were $0.20 per million text tokens for gemini-embedding-2 (pricing), $0.06 for voyage-4 and $0.02 for voyage-4-lite after the free tokens (pricing), and $0.012 for qwen3-embedding-0.6b on Workers AI (pricing). OpenAI's guide lists text-embedding-3-small at about 62,500 pages per dollar, at roughly 800 tokens a page (OpenAI embeddings guide).
Switching models later has a cost too: vectors from different models aren't comparable, so a change means re-embedding everything you've stored.
What's the best embedding model for RAG?
The one that puts the right chunks in front of your model for your own questions. Shortlist two or three from the tables above, then run them on the same chunks and labeled questions. This script compares them on two numbers: how often a supporting chunk lands in the top 10, and how high it ranks.
import numpy as np
from sentence_transformers import SentenceTransformer
# Your corpus: chunk id -> text, cut the way your app cuts it
chunks = {
"billing-04": "Annual plans renew on the purchase date. Cancel in Settings > Billing before then.",
"auth-12": "To rotate an API key, create a new key, deploy it, then delete the old one.",
"errors-07": "ERR-482 means the card issuer declined the payment. Ask the customer to retry or use another card.",
# ... a few hundred more
}
# Real questions, each labeled with the chunk ids that answer it
questions = [
("how do I stop my yearly plan renewing", {"billing-04"}),
("payment failed with ERR-482", {"errors-07"}),
("swap out a leaked key without downtime", {"auth-12"}),
# ... 50 or more
]
# Query and document prefixes from each model card. None means "use the model's own prompt, if it has one".
MODELS = {
"BAAI/bge-base-en-v1.5": ("Represent this sentence for searching relevant passages: ", None),
"intfloat/e5-base-v2": ("query: ", "passage: "),
"Qwen/Qwen3-Embedding-0.6B": (None, None),
}
def evaluate(name, query_prefix, doc_prefix, k=10):
model = SentenceTransformer(name)
ids = list(chunks)
doc_vecs = model.encode_document([chunks[i] for i in ids], prompt=doc_prefix, normalize_embeddings=True)
query_vecs = model.encode_query([q for q, _ in questions], prompt=query_prefix, normalize_embeddings=True)
scores = query_vecs @ doc_vecs.T # cosine similarity, since both sides are normalized
found, reciprocal_ranks = 0, 0.0
for row, (_, relevant) in zip(scores, questions):
top = [ids[j] for j in np.argsort(-row)[:k]]
ranks = [rank for rank, chunk_id in enumerate(top, start=1) if chunk_id in relevant]
if ranks:
found += 1
reciprocal_ranks += 1 / ranks[0]
return found / len(questions), reciprocal_ranks / len(questions)
for name, (query_prefix, doc_prefix) in MODELS.items():
hit_rate, mrr = evaluate(name, query_prefix, doc_prefix)
print(f"{name}: hit rate@10 {hit_rate:.2f}, MRR@10 {mrr:.2f}")It uses encode_query and encode_document from Sentence Transformers (API reference), which apply a model's own query prompt when it ships one, as Qwen3-Embedding does. The steps below keep the comparison fair, and the RAG chatbot guide covers the rest of the pipeline.
Build a shortlist from model cards
Pick models whose license, languages, input limit and size fit your deployment before you look at scores. A model that truncates at 512 tokens can't be judged on 2,000-token chunks, and a non-commercial license rules a model out however well it scores.
Get preprocessing right before comparing scores
Follow each card's input recipe. E5 needs its "query: " and "passage: " prefixes, BGE suggests an instruction on queries only, nomic uses search_query: and search_document:, and Qwen3-Embedding wants a task instruction on queries. Missing one can sink a model's score for reasons that have nothing to do with its quality. Record truncation too: if one model silently drops the sentence that holds the answer, you're testing input handling, not meaning.
Fix the evaluation data
Write questions with labeled supporting chunk IDs. Include exact identifiers (error codes, SKUs), paraphrases, domain terms, vague follow-ups and questions that have no answer in the corpus. Keep a held-out set you don't use to tune thresholds. Record the corpus version and the chunking strategy, and use the same chunks for every model.
Use data that looks like your workload. A public biomedical set can't tell you how a model handles your support tickets or your code.
Measure retrieval, then the answer
Hit rate shows whether supporting evidence enters the candidate pool, and MRR shows how high it ranks. Then measure answers separately, with the same answer model and prompt. A better retrieval score doesn't always mean better answers: context assembly can cut the evidence, or the model can ignore it. If the right chunks show up but rank too low, test a reranking stage. If exact terms like error codes keep getting missed, try hybrid search, which adds keyword matching to vector search.
Make latency and cost comparable
Measure document embedding throughput separately from query latency, and record batch size, device, precision and input length. For an API, include network time if your users wait on it. Put re-embedding, index storage and updates into the cost model, since changing models means regenerating every stored vector.
Embeddings in a memory system
A memory layer leans on the same embeddings, then adds what retrieval alone doesn't: extracting facts, keeping them current and scoping them to a user. In supermemory's hosted API, you don't pick or run an embedding model. On the self-hosted server, you do: the default is bge-base-en-v1.5 running locally at 768 dimensions, with no API key and no text sent anywhere to be embedded. It's English-only, so for other languages the docs suggest switching to a multilingual model such as bge-m3 before you ingest. You can also point it at OpenAI, Gemini or any OpenAI-compatible endpoint, such as Ollama. The server locks the choice once it has vectors, because embeddings from different models aren't comparable, so changing it later means starting fresh or re-ingesting.
For what the hosted version costs, see pricing. For how we measure memory retrieval, see our research.
Common questions
What is the best embedding model?
On October 16, 2026, the highest multilingual retrieval score among commercially usable open models was harrier-oss-v1-27b's 78.27, and Qwen3-Embedding-8B was the strongest model in our first table with scores on both benchmarks. For your app, the best one is whichever wins the test above on your own questions.
Are open-source embedding models as good as OpenAI's?
On the leaderboard, yes. On English retrieval, Qwen3-Embedding-8B scores 69.44 against 57.98 for text-embedding-3-large and 53.48 for text-embedding-3-small. Your own data can still change the order.
Do I have to re-embed everything if I switch models?
Usually, yes. Vectors from different models live in different spaces, even when they have the same number of dimensions, unless the provider built a family to share one, as Voyage says of its voyage-4 models. Google says this of its own two Gemini embedding models, and supermemory's self-hosted docs say a model change needs a fresh data directory or a full re-ingest.
How many dimensions do I need?
Fewer than you might think, if the model was trained for it. Matryoshka-trained models keep most of their quality at a fraction of their full size, and the Matryoshka guide shows how to test it.