Top 20 Embedding Models 2026: Ultimate Ranking for Local RAG & Semantic Search

Last Updated: October 20, 2026

The 2026 Embedding Landscape: What Changed

Embedding models are the foundation of retrieval-augmented generation (RAG), semantic search, code search, recommendation, and clustering. They turn text, images, and other inputs into vectors so that similar meaning lands close together in vector space.

The 2026 open-weight market is materially different from the one this guide covered in August. The biggest shifts are not just higher leaderboard scores; they are better small models, native multimodality, longer context, and more explicit task instruction tuning.

• January 2026: Qwen released the Qwen3-VL-Embedding family, bringing 32K-context, instruction-aware multimodal retrieval under Apache 2.0.
• February 2026: Jina Embeddings v5 introduced task-targeted retrieval distillation, pushing 4B-class retrieval behavior into sub-1B models.
• March 2026: Microsoft's Harrier-OSS-V1 family reset the open text-embedding bar, with the 27B model reporting 74.3 on MTEB v2 and the 0.6B model reporting 69.0.
• May 2026: LiquidAI's LFM2.5-Embedding-350M made multilingual, CPU-friendly retrieval practical at a very small footprint.
• October 2026: Google's EmbeddingGemma 2 combined text, images, video, and audio in one 768-dimensional space at 740M parameters.

That does not make older models obsolete. BGE-M3 remains the most practical single-model hybrid retriever, Nomic Embed v2 MoE remains a strong fully open multilingual option, and the 7B-class E5 and GTE models still make sense when you need a mature MIT or Apache pipeline. But the default recommendation has moved: a 270M-0.6B model can now match or beat several 2024-era 7B embedders on standard retrieval benchmarks, and multimodal retrieval is no longer a proprietary-only feature.

Quick Picks

Workload	Best starting point	Why
Maximum text accuracy	Harrier-OSS-V1-27B	Highest reported MTEB v2 score in this update; MIT licensed.
Commercial text RAG	Qwen3-Embedding-8B	70.58 MMTEB, 32K context, Apache 2.0, mature tooling.
Best small text model	Harrier-OSS-V1-0.6B	69.0 MTEB v2 with a 32K context and a permissive license.
Multimodal retrieval	Qwen3-VL-Embedding-8B	Strong combined text/image/video retrieval under Apache 2.0.
On-device multimodal	EmbeddingGemma 2	Text, image, video, and audio in one 740M model.
Hybrid retrieval	BGE-M3	Dense, sparse, and multi-vector outputs from one MIT model.
Noncommercial retrieval	Jina Embeddings v5 Small	Sub-1B retrieval specialist with 32K context.
Tiny CPU deployment	LFM2.5-Embedding-350M	11 languages and a 350M footprint for short chunks.

Ranking Methodology

This is an editorial ranking for local deployment, not a single-leaderboard sort. Each model was weighted on six criteria:

• Retrieval and downstream quality (35%): reported MTEB v2, MMTEB, MMEB, MIEB, NanoBEIR, or domain evidence, plus task behavior.
• Local practicality (20%): parameter count, quantization behavior, memory use, and whether the model fits a realistic single-GPU or CPU setup.
• Context and dimensionality (15%): maximum input length, Matryoshka support, vector size, and index-storage cost.
• Input flexibility (10%): text, code, image, video, audio, and interleaved inputs.
• License clarity (10%): commercial usability, gating, and custom terms.
• Ecosystem maturity (10%): Sentence Transformers, llama.cpp/GGUF, TEI, vLLM, ONNX, and tooling.

Benchmark caution: vendor scores are not always directly comparable. Harrier reports MTEB v2, Qwen reports MMTEB, EmbeddingGemma 2 reports MTEB v2 plus MMEB v2, and LFM reports NanoBEIR. Different task mixes, languages, instruction prefixes, and pooling methods can move a score by several points. Treat these numbers as directional and validate on your own corpus.

Top 20 Embedding Models for Local RAG in 2026

Ranked for capability and local usefulness as of October 20, 2026. Noncommercial models remain in the list when their capability is strong, but their license is flagged in the card.

1. Harrier-OSS-V1-27B (Microsoft)

Best for: maximum-accuracy text retrieval when accuracy matters more than VRAM or index size.

Harrier-OSS-V1-27B is the largest model in Microsoft's 2026 Harrier family and the strongest pure-text embedder in this update. It is a decoder-only multilingual model with last-token pooling, L2 normalization, and instruction-aware queries. The reported 74.3 MTEB v2 score is the highest in the family and the top open text result here. It also supports retrieval, clustering, classification, semantic similarity, bitext mining, and reranking.

• Parameters: 27B
• Context / dimensions: 32,768 tokens / 5,376
• License / access: MIT
• Local fit: about 54GB in BF16, 16-18GB at 4-bit; a 24GB GPU is the practical minimum for quantized inference.
• Watch out: 5,376-dimensional vectors are expensive. One million vectors cost roughly 21.5GB at FP32 or 10.75GB at FP16 before index overhead.

Verdict: the quality ceiling for open text embeddings, but not the default for a million-document index. Use it for high-value corpora, hard retrieval tasks, or as a teacher/reranking-adjacent model. View model card.

2. Qwen3-Embedding-8B (Alibaba)

Best for: the safest high-accuracy commercial text embedder.

Qwen3-Embedding-8B remains the best all-round Apache-2.0 option. It combines a 70.58 MMTEB score, 32K context, 100+ language support, instruction-aware queries, and broad ecosystem support. It is larger than the newest small models but far easier to host than Harrier 27B, and its 4,096-dimensional vectors are already supported by most vector databases.

• Parameters: 8B
• Context / dimensions: 32,768 tokens / 4,096, with custom output dimensions
• License / access: Apache 2.0
• Local fit: about 16GB in BF16 or 5GB at 4-bit; 8-12GB of VRAM for quantized inference.
• Watch out: instruction prefixes matter. Test query instructions and document formatting before indexing.

Verdict: still the reference point for commercial open-weight text RAG. If you do not need Harrier's last few points, this is the lower-risk choice. View local model.

3. Qwen3-VL-Embedding-8B (Alibaba)

Best for: one retrieval space for text, images, screenshots, charts, and video frames.

Qwen3-VL-Embedding-8B is the strongest open multimodal embedder in this list for general retrieval. It reports 67.88 MMTEB and 77.9 MMEB, supports 32K context, and produces vectors up to 4,096 dimensions. Apache 2.0 licensing makes it unusually practical for commercial multimodal search.

• Parameters: 8B
• Context / dimensions: 32,768 tokens / up to 4,096
• License / access: Apache 2.0
• Local fit: about 16GB in BF16; a 6-bit GGUF is roughly 6.8GB, so 12GB of VRAM is a realistic starting point.
• Watch out: image and video tokens consume context quickly. Cap visual resolution and frame count before indexing large media collections.

Verdict: the best default when your corpus is genuinely multimodal and you want one index instead of separate CLIP and text pipelines. View local model.

4. Qwen3-Embedding-4B (Alibaba)

Best for: near-8B text quality on an 8GB GPU.

The 4B Qwen3 embedder reports 69.45 MMTEB, only about one point behind the 8B model, while using half the parameters. It keeps the 32K context, multilingual coverage, instruction tuning, and Apache 2.0 license. For many teams this is the best quality-per-dollar text model in the entire list.

• Parameters: 4B
• Context / dimensions: 32,768 tokens / 2,560, with custom output dimensions
• License / access: Apache 2.0
• Local fit: about 8GB in BF16 or 2.4GB at 4-bit; 6-8GB of VRAM is enough.

Verdict: the practical sweet spot for a commercial text RAG system that cannot justify an 8B model. View local model.

5. Harrier-OSS-V1-0.6B (Microsoft)

Best for: the best small text embedder for CPU, edge, or high-throughput indexing.

Harrier-OSS-V1-0.6B is the headline efficiency win of 2026. It reports 69.0 MTEB v2, essentially matching the Qwen3-Embedding-4B's reported quality at roughly one-seventh the parameter count, and it keeps a 32K context plus MIT licensing. That combination is rare.

• Parameters: 0.6B
• Context / dimensions: 32,768 tokens / 1,024
• License / access: MIT
• Local fit: about 1.2GB in BF16; comfortable on 4GB of RAM or VRAM.
• Watch out: like the 27B model, it expects task instructions for best retrieval quality.

Verdict: the new default for most local text RAG deployments. It is small enough to run anywhere and permissively licensed enough for commercial products. View model card.

6. EmbeddingGemma 2 (Google DeepMind)

Best for: on-device multimodal retrieval across text, images, video, and audio.

EmbeddingGemma 2 is the most interesting release in this update. It maps four modalities into one 768-dimensional space using a 270M text backbone plus optional 170M vision and 300M audio encoders. It reports 61.36 on multilingual MTEB v2, 78.68 on code, and 59.01 overall on MMEB v2. The 8K context and Matryoshka support make it practical for phones, laptops, and local media search.

• Parameters: 740M total; 270M text-only, 440M text+image, 570M text+audio
• Context / dimensions: 8,192 tokens / 768, truncatable to 512, 256, or 128
• License / access: Apache 2.0 per the model card, with Gemma prohibited-use terms still referenced
• Local fit: about 1.5GB for all modalities in BF16; about 0.54GB for text-only.
• Watch out: do not run it in float16. The model card explicitly requires bfloat16 or float32 because its activation range can overflow float16 and silently produce bad embeddings.

Verdict: choose it for modality coverage or edge deployment, not for raw text leaderboard position. The selective encoder loading is genuinely useful. View local model.

7. BGE-M3 (BAAI)

Best for: hybrid dense, sparse, and multi-vector retrieval from one model.

BGE-M3 is no longer the accuracy leader, but it remains the most practical hybrid retriever in the open ecosystem. One model produces dense vectors, lexical weights, and multi-vector ColBERT-style representations, supports 100+ languages, handles 8K context, and is MIT licensed. That is still a unique combination at 568M parameters.

• Parameters: 568M
• Context / dimensions: 8,192 tokens / 1,024 dense, plus sparse and multi-vector outputs
• License / access: MIT
• Local fit: about 1.1GB in BF16; 2-4GB of RAM is enough for inference, with more for the index.
• Watch out: storing all three representations increases index size and pipeline complexity. Start with dense plus sparse if you need a compromise.

Verdict: the model to beat for hybrid search, especially in multilingual corpora with exact terms, product codes, or names. View local model.

8. Jina Embeddings v5 Small Retrieval (Jina AI)

Best for: a sub-1B retrieval specialist with long context, if noncommercial licensing works for you.

Jina Embeddings v5 Small Retrieval is a 677M retrieval-targeted model built through task-specific distillation. It supports 32K context, 1,024 dimensions, Matryoshka truncation down to 32 dimensions, and last-token pooling. Jina reports that the v5 distillation approach brings 4B-class retrieval quality into a sub-1B model; validate that claim on your own data.

• Parameters: 677M
• Context / dimensions: 32,768 tokens / 1,024, truncatable to 32-768
• License / access: CC BY-NC 4.0; commercial use requires a Jina license
• Local fit: about 1.4GB in BF16; 2-4GB of RAM or VRAM.
• Watch out: use the retrieval variant and its query/document prompts. The v5 family also has matching and classification variants, which are not interchangeable.

Verdict: excellent retrieval quality per parameter, but the noncommercial license keeps it out of the top commercial recommendation. View local model.

9. Qwen3-VL-Embedding-2B (Alibaba)

Best for: multimodal retrieval under 4GB of VRAM.

The 2B Qwen3-VL embedder keeps the 32K context, Apache 2.0 license, and text/image/video support of its larger sibling while cutting the footprint to about 2B parameters. It reports 63.87 MMTEB and 2,048 dimensions. It is the right starting point for a local visual search prototype that must stay small.

• Parameters: 2B
• Context / dimensions: 32,768 tokens / 2,048
• License / access: Apache 2.0
• Local fit: about 4GB in BF16 or 1.2GB at 4-bit; 4-6GB of VRAM.

Verdict: the best compact multimodal model with a permissive license. Step up to the 8B version when visual retrieval quality is the bottleneck. View local model.

10. Jina Embeddings v4 (Jina AI)

Best for: visual-document retrieval and multimodal search with a single 3.8B model.

Jina Embeddings v4 is a 3.8B multilingual multimodal embedder built on a Qwen2.5-VL backbone. It handles text and images, supports 32K context, and produces 2,048-dimensional dense or multi-vector representations. It remains a strong option for PDFs, slides, charts, and screenshot-heavy knowledge bases.

• Parameters: 3.8B
• Context / dimensions: 32,768 tokens / 2,048
• License / access: Qwen Research License; review commercial restrictions before deployment
• Local fit: about 7.6GB in BF16; 8-12GB of VRAM, less with quantization.

Verdict: a capable visual-document specialist, but its license and age put it behind Qwen3-VL-Embedding for new commercial builds. View local model.

11. Nomic Embed Text v2 MoE (Nomic AI)

Best for: a fully open, multilingual, commercially friendly embedder for short chunks.

Nomic Embed Text v2 MoE uses a mixture-of-experts architecture with about 475M total parameters and 305M active parameters. It supports roughly 100 languages, produces 768-dimensional vectors with Matryoshka truncation, reports 52.86 on BEIR and 65.8 on MIRACL, and ships with open training code and data details. The 512-token context is the main limitation.

• Parameters: about 475M total, 305M active
• Context / dimensions: 512 tokens / 768, truncatable to 512 or 256
• License / access: Apache 2.0
• Local fit: about 1GB in BF16; 2-4GB of RAM.

Verdict: a dependable fully open baseline, but do not feed it long documents without chunking. View local model.

12. LFM2.5-Embedding-350M (LiquidAI)

Best for: tiny multilingual retrieval on CPU and edge devices.

LFM2.5-Embedding-350M is a 354M dense bi-encoder covering 11 languages with a 1,024-dimensional output and a 512-token context. It reports 0.577 on NanoBEIR and is designed for short-passage retrieval where latency and memory matter more than maximum context.

• Parameters: 354M
• Context / dimensions: 512 tokens / 1,024
• License / access: LFM Open License v1.0; review the custom terms
• Local fit: about 0.7GB in BF16; runs comfortably on a small CPU or 2GB device.

Verdict: a strong CPU-first option for FAQ, product, and support retrieval. Its 512-token limit rules out long-document RAG. View local model.

13. Jina Embeddings v5 Nano Retrieval (Jina AI)

Best for: the smallest long-context retrieval model in this list.

Jina Embeddings v5 Nano Retrieval packs a 239M-parameter retrieval model with an 8K context, 768 dimensions, and Matryoshka truncation down to 32 dimensions. It is built for resource-constrained environments where 32K context is unnecessary but 512 tokens is too little.

• Parameters: 239M
• Context / dimensions: 8,192 tokens / 768, truncatable to 32-512
• License / access: CC BY-NC 4.0; commercial use requires a Jina license
• Local fit: about 0.5GB in BF16; 1-2GB of RAM.

Verdict: impressive efficiency and context for its size, but the noncommercial license limits production use. View local model.

14. Jina Code Embeddings 1.5B (Jina AI)

Best for: semantic code search, repository navigation, and code-to-text retrieval.

Jina Code Embeddings 1.5B is built on Qwen2.5-Coder-1.5B and tuned for 15+ programming languages. It supports 32K context and 1,536-dimensional embeddings, with task-specific prefixes for code retrieval and code-to-code matching. General-purpose embedders often underperform on identifiers, APIs, and repository structure; this model is purpose-built for that gap.

• Parameters: 1.5B
• Context / dimensions: 32,768 tokens / 1,536
• License / access: CC BY-NC 4.0; commercial use requires a Jina license
• Local fit: about 3GB in BF16; 4-6GB of VRAM, less with quantization.

Verdict: the specialist to test if code search quality matters, provided the license fits. View local model.

15. Harrier-OSS-V1-270M (Microsoft)

Best for: the best tiny long-context text embedder.

The 270M Harrier model reports 66.5 MTEB v2 with a 32K context, 640 dimensions, and an MIT license. It is smaller than many 2024-era English-only models while offering multilingual retrieval and a much longer context window. For CPU indexing at scale, it is hard to beat.

• Parameters: 270M
• Context / dimensions: 32,768 tokens / 640
• License / access: MIT
• Local fit: about 0.54GB in BF16; runs on 1-2GB of RAM.

Verdict: the best budget text embedder in the list. Use it when the 0.6B model is just slightly too large. View model card.

16. Snowflake Arctic Embed L v2.0

Best for: a simple Apache-2.0 multilingual embedder with no instruction-prefix complexity.

Arctic Embed L v2.0 is a 568M multilingual model with 8K context, 1,024 dimensions, and Apache 2.0 licensing. It does not lead the 2026 benchmarks, but it is stable, well documented, and easy to deploy across languages. It is a sensible fallback when newer models have license or tooling friction.

• Parameters: 568M
• Context / dimensions: 8,192 tokens / 1,024
• License / access: Apache 2.0
• Local fit: about 1.1GB in BF16; 2-4GB of RAM.

Verdict: not exciting, but reliable. A good Apache-2.0 baseline for multilingual search. View local model.

17. EmbeddingGemma 300M (Google)

Best for: proven on-device text embeddings with mature tooling.

EmbeddingGemma 300M is the predecessor to EmbeddingGemma 2. It is a 308M text embedder with 2K context, 768 dimensions, 100+ language support, and a 61.15 multilingual MTEB v2 score. It has been widely integrated into local inference stacks and remains a safe text-only choice.

• Parameters: 308M
• Context / dimensions: 2,048 tokens / 768, with Matryoshka truncation
• License / access: Gemma Terms of Use
• Local fit: about 0.6GB in BF16; 1-2GB of RAM.

Verdict: still useful, but Harrier 270M offers a longer context and a more permissive license, while EmbeddingGemma 2 adds multimodality. View local model.

18. E5-Mistral-7B-Instruct (Microsoft)

Best for: a mature MIT-licensed large embedder for existing pipelines.

E5-Mistral-7B-Instruct was one of the first strong instruction-tuned open embedders. It pairs a 7B Mistral backbone with 32K context, 4,096-dimensional embeddings, and English-focused training. It is no longer the accuracy leader, but the MIT license and broad compatibility keep it relevant.

• Parameters: 7.1B
• Context / dimensions: 32,768 tokens / 4,096
• License / access: MIT
• Local fit: about 14GB in BF16; 16GB of VRAM, less with quantization.

Verdict: keep it if it is already validated in production. For new builds, Harrier 0.6B or Qwen3-Embedding-4B deliver better quality per resource. View local model.

19. GTE-Qwen2-7B-Instruct (Alibaba)

Best for: a stable Apache-2.0 large text embedder with strong multilingual coverage.

GTE-Qwen2-7B-Instruct combines a Qwen2 7B backbone with instruction tuning, 32K context, and 3,584-dimensional embeddings. It was a top open model in 2024 and still works well for multilingual semantic search, especially where Apache 2.0 is required and newer tooling has not caught up.

• Parameters: 7.6B
• Context / dimensions: 32,768 tokens / 3,584
• License / access: Apache 2.0
• Local fit: about 15GB in BF16; 16-24GB of VRAM, less with quantization.

Verdict: a solid legacy choice, but the 2026 Qwen3 embedders are better per parameter. View local model.

20. Qwen3-Embedding-0.6B (Alibaba)

Best for: a small, long-context Apache-2.0 embedder that still handles multilingual retrieval.

Qwen3-Embedding-0.6B is the compact member of the Qwen3 embedding family. It reports 64.33 MMTEB, supports 32K context and 1,024 dimensions, and keeps the same instruction-aware query format and Apache 2.0 license as its larger siblings. It is the better choice than most 2024-era English-only baselines when portability and language coverage both matter.

• Parameters: 0.6B
• Context / dimensions: 32,768 tokens / 1,024, with custom output dimensions
• License / access: Apache 2.0
• Local fit: about 1.2GB in BF16; 2-4GB of RAM, or under 1GB with 4-bit quantization.

Verdict: a strong compact fallback when Harrier's instruction format or tooling does not fit your stack. View local model.

How to Choose by Workload

General-purpose text RAG

Start with Qwen3-Embedding-4B if you have an 8GB GPU, or Harrier-OSS-V1-0.6B if you want CPU-friendly inference or high indexing throughput. Use Qwen3-Embedding-8B when you need the best Apache-2.0 quality and can afford the memory. Reserve Harrier-OSS-V1-27B for high-value corpora where the last few points justify the index cost.

Multilingual retrieval

BGE-M3 remains the best hybrid multilingual default, especially when exact terms and names matter. Harrier-OSS-V1-0.6B is the stronger dense-only option for broad language coverage. If you need a fully open training pipeline, Nomic Embed v2 MoE is still attractive for short chunks.

Long documents

Harrier, Qwen3-Embedding, Qwen3-VL-Embedding, and Jina Embeddings v5 all advertise 32K context. Longer context does not guarantee better retrieval at 32K: attention dilution, chunk boundaries, and instruction prefixes still matter. Chunk with overlap, prepend document titles, and test Recall@10 at realistic lengths.

Images, screenshots, video, and audio

Use Qwen3-VL-Embedding-8B for the strongest general multimodal retrieval and Qwen3-VL-Embedding-2B for a compact Apache-2.0 option. Choose EmbeddingGemma 2 when you need audio, true on-device deployment, or selective modality loading. Jina Embeddings v4 is still relevant for visual documents, but check its research license.

Code search

Jina Code Embeddings 1.5B is the dedicated option, with task prefixes for code retrieval and code-to-code matching. EmbeddingGemma 2 is a strong generalist with a 78.68 code score. For mixed code and prose, test both before committing to a separate code index.

CPU and edge

Harrier-OSS-V1-270M is the best tiny text model with a 32K context. Harrier-OSS-V1-0.6B and Qwen3-Embedding-0.6B are the better quality step-ups. LFM2.5-Embedding-350M is a good multilingual choice for short passages. EmbeddingGemma 2 in text-only mode is the smallest path to multimodal capability, and Jina Embeddings v5 Nano is compelling if its license fits.

Local Hardware and Index Costs

Embedding inference is usually lighter than LLM generation, but vector storage and memory bandwidth become the bottleneck at scale. Plan for both model memory and index memory.

Hardware tier	Realistic models	Notes
8GB RAM, CPU only	Harrier 270M, Harrier 0.6B, Qwen3-Embedding-0.6B, LFM2.5 350M, EmbeddingGemma 2 text-only, Jina v5 Nano	Use 4-bit or ONNX where available; expect batch latency to dominate indexing.
8-12GB GPU	Qwen3-Embedding-4B at 4-bit, Qwen3-VL-Embedding-2B, BGE-M3, Jina v5 Small, EmbeddingGemma 2 full	The best quality-per-watt tier for local RAG.
16-24GB GPU	Qwen3-Embedding-8B at 4-8 bit, Qwen3-VL-Embedding-8B at 6-bit, Jina v4 at 4-bit	Comfortable for 8B text and multimodal models with modest batches.
32GB+ GPU or 64GB unified memory	Harrier 27B at 4-bit, Qwen3-Embedding-8B in BF16	Harrier 27B in BF16 needs about 54GB and is usually not worth it outside evaluation.

Index size matters as much as model size. A 4,096-dimensional FP32 vector costs 16KB per document; one million documents cost about 16GB before HNSW overhead. At 5,376 dimensions, Harrier 27B costs about 21.5GB per million FP32 vectors. Matryoshka models such as EmbeddingGemma 2, Jina v5, and Nomic v2 can cut storage by 2-6x with modest quality loss. Always benchmark at the dimension you will actually store.

License Traps to Check Before Shipping

License family	Models in this guide	Commercial guidance
MIT	Harrier 27B/0.6B/270M, BGE-M3, E5-Mistral-7B	The simplest permissive option. Keep copyright notices.
Apache 2.0	Qwen3-Embedding, Qwen3-VL-Embedding, EmbeddingGemma 2, Nomic v2 MoE, Arctic L v2, GTE-Qwen2, mxbai	Commercial-friendly with patent and notice terms. EmbeddingGemma 2 still references Gemma prohibited-use terms.
CC BY-NC 4.0	Jina Embeddings v5 Small/Nano, Jina Code 1.5B	Noncommercial only unless you obtain a commercial license from Jina.
Qwen Research License	Jina Embeddings v4	Research-oriented; review before any production or commercial deployment.
Gemma Terms	EmbeddingGemma 300M	Permissive but with use restrictions; not equivalent to Apache 2.0.
LFM Open License	LFM2.5-Embedding-350M	Custom terms; check redistribution and commercial-use clauses.

Licenses can change and model cards can contradict repository metadata. For a commercial launch, verify the exact model revision you download and keep a copy of its license with your model artifacts. This table is a starting point, not legal advice.

How to Evaluate Before You Re-Index

• Build a real query set: 200-500 queries from logs, support tickets, or domain experts. Include exact identifiers, names, paraphrases, and multilingual queries.
• Measure retrieval, not just similarity: track Recall@10/20, nDCG@10, and MRR. A model with a higher average MTEB score can still lose on your corpus.
• Test chunking and prefixes: instruction-tuned models are sensitive to query prefixes and document formatting. Test the exact prompts you will ship.
• Benchmark the stored dimension: compare full-dimensional vectors against Matryoshka truncation at 512, 256, and 128 dimensions.
• Measure p95 latency and index size: include embedding time, index build time, and RAM/VRAM during a realistic batch.
• Never mix embedding spaces: if you change models, re-embed the entire corpus. Vectors from different models are not comparable even at the same dimension.

Conclusion

The open embedding market has split into three strong paths. Harrier-OSS-V1 leads raw text accuracy and gives small models that punch far above their weight. Qwen3-Embedding and Qwen3-VL-Embedding offer the best combination of accuracy, context, multimodality, and Apache 2.0 licensing. BGE-M3 remains the hybrid-retrieval specialist, while EmbeddingGemma 2 makes on-device multimodal search practical.

For most local RAG systems, the 2026 default is now Harrier-OSS-V1-0.6B or Qwen3-Embedding-4B. Choose Qwen3-Embedding-8B for maximum commercial text quality, Harrier-OSS-V1-27B for the accuracy ceiling, and Qwen3-VL-Embedding-8B or EmbeddingGemma 2 when the corpus is multimodal. Pair the embedder with a strong reranker, evaluate on real queries, and re-index whenever you change the model.

Sources and Further Reading

• Harrier-OSS-V1 model family (Microsoft)
• Qwen3-Embedding-8B (Alibaba)
• Qwen3-VL-Embedding-8B (Alibaba)
• EmbeddingGemma 2 (Google DeepMind)
• Jina Embeddings v5 Small Retrieval (Jina AI)
• LFM2.5-Embedding-350M (LiquidAI)
• BGE-M3 (BAAI)
• Nomic Embed Text v2 MoE (Nomic AI)
• Jina Embeddings v4 (Jina AI)
• Jina Code Embeddings 1.5B (Jina AI)

Related guides: Top Reranker Models 2026 | Top OCR Models 2026 | Embedding, Reranker, and OCR Deep Dive.

---

📖 Educational Content Index

🏆 Model Rankings

Use Case	Description	Link
Coding Assistant	Best models for programming	View Guide
Research Assistant	Top models for academic research	View Guide
Analysis & BI	Models for data analysis	View Guide
Embedding	Top models for RAG and semantic search	View Guide ← You are here
Reranker	Precision re-ranking models	View Guide
OCR	Document text extraction models	View Guide
Multilingual	Models with superior language support	View Guide

---

🔄 Last Updated: October 2026 | 📧 Feedback