Embedding Models Compared: OpenAI vs Cohere vs Open Source in 2026

Text embeddings convert words, sentences, or entire documents into dense numerical vectors that capture semantic meaning. Two pieces of text that mean similar things end up close together in vector space, even if they share zero words in common. This property is what makes modern AI search, retrieval augmented generation (RAG), recommendation engines, and classification systems possible.

The embedding model you choose sits at the foundation of your entire AI pipeline. If your embeddings are mediocre, no amount of clever re-ranking, prompt engineering, or vector database tuning will fix the retrieval quality downstream. We have seen teams burn weeks debugging their RAG system only to discover the root cause was a poorly chosen embedding model that could not distinguish between domain-specific concepts.

The market has expanded dramatically since 2024. OpenAI is no longer the only serious contender. Cohere, Google, Voyage AI, and a wave of open source models now compete on quality, cost, and specialization. The differences between them are not academic. On domain-specific benchmarks, the gap between the best and worst performer can be 15 to 20 percentage points in retrieval accuracy. Choosing the right model for your use case is one of the highest-leverage decisions you will make.

This guide compares every major embedding model available in 2026 across real benchmarks, production costs, and practical tradeoffs. We are opinionated here: OpenAI text-embedding-3 is overused because it is the default, not because it is the best. For many domains, Cohere and open source models deliver stronger results at lower cost.

Let us start with the API-based commercial options that most teams evaluate first.

OpenAI text-embedding-3-large and text-embedding-3-small

OpenAI text-embedding-3-large produces 3,072-dimensional vectors and scores 64.6 on the MTEB benchmark (average across all tasks). The smaller variant, text-embedding-3-small, outputs 1,536 dimensions and scores 62.3 on MTEB. Both support Matryoshka representations, meaning you can truncate vectors to 256, 512, or 1,024 dimensions with graceful accuracy degradation. Pricing sits at $0.13 per million tokens for the large model and $0.02 per million tokens for the small model.

The OpenAI models are competent general-purpose embeddings. Their biggest advantage is ecosystem integration: every vector database, framework, and tutorial defaults to OpenAI. Their weakness is that they are not best-in-class on any specific task category. On retrieval-focused benchmarks (the ones that matter most for RAG), Cohere and several open source models consistently outperform them.

Cohere embed-v4

Cohere embed-v4 is, in our assessment, the strongest commercial embedding API available today. It produces 1,024-dimensional vectors by default, scores 66.2 on MTEB overall, and dominates retrieval-specific benchmarks with a score of 58.4 on MTEB retrieval tasks (compared to 55.4 for OpenAI text-embedding-3-large). Pricing is $0.10 per million tokens.

The model supports both search_document and search_query input types, which lets it optimize representations differently for documents vs queries. This asymmetric embedding approach consistently improves retrieval quality by 2 to 4% in our testing. Cohere also supports 100+ languages natively, making it the default choice for any multilingual application.

Google text-embedding-005

Google updated its embedding model in late 2025. text-embedding-005 outputs 768 dimensions and scores 63.8 on MTEB. It handles up to 2,048 tokens of input and integrates tightly with Vertex AI and Google Cloud. Pricing is $0.025 per 1,000 characters (roughly $0.10 per million tokens depending on tokenization). It is a solid mid-tier option, particularly if you are already deep in the Google Cloud ecosystem, but it does not lead on any benchmark category.

Voyage AI voyage-3-large

Voyage AI has carved out a niche as the specialist embedding provider. Their voyage-3-large model produces 1,024-dimensional vectors and scores 67.1 on the MTEB overall benchmark, the highest of any commercial API. On code retrieval tasks specifically, voyage-code-3 scores 71.2, making it the clear winner for codebases and technical documentation. Pricing is $0.18 per million tokens for voyage-3-large and $0.06 for the smaller voyage-3-lite. If your use case involves code search or technical content, Voyage AI is worth the premium.

Open source embedding models have improved dramatically. Several now match or exceed commercial APIs on standard benchmarks, and self-hosting eliminates per-token costs entirely.

BGE-en-icl (BAAI)

BAAI General Embedding (BGE) models have been open source leaders since 2023, and the latest BGE-en-icl model pushes the bar further. Built on a Mistral-7B backbone, it scores 65.8 on MTEB overall and 57.9 on retrieval tasks. The "icl" refers to in-context learning, meaning you can provide task-specific examples in the prompt to improve performance without fine-tuning. Output dimensions are 4,096. The model requires a GPU with at least 16GB VRAM to run efficiently. On an A10G instance, it processes roughly 300 passages per second.

E5-mistral-7b-instruct (Microsoft)

Microsoft E5-mistral-7b-instruct scores 66.6 on MTEB, outperforming every commercial API except Voyage AI. It uses 4,096-dimensional vectors and accepts instruction-style prompts, letting you specify the embedding task (e.g., "Retrieve relevant documents for this query"). This instruction tuning gives it an edge on retrieval benchmarks specifically. Like BGE-en-icl, it runs on a 7B parameter backbone and needs a 16GB+ GPU.

GTE-Qwen2-7B-instruct (Alibaba)

Alibaba GTE-Qwen2-7B-instruct is built on the Qwen2 language model and scores 65.4 on MTEB. Its standout feature is multilingual performance. It handles Chinese, English, Japanese, Korean, and 20+ other languages with strong cross-lingual retrieval capabilities. If your application serves Asian language markets, GTE-Qwen2 is the open source model to evaluate first.

Nomic-embed-text-v1.5 (Nomic AI)

Nomic-embed-text-v1.5 is the lightweight champion. At only 137M parameters, it scores 62.2 on MTEB, which is remarkably close to OpenAI text-embedding-3-small (62.3) at a fraction of the compute cost. It produces 768-dimensional vectors and runs comfortably on a CPU, processing about 500 passages per second on a 4-core machine. For teams that want to self-host without GPU infrastructure, Nomic is the practical choice. It also supports Matryoshka dimensionality reduction down to 64 dimensions.

Choosing between open source models

If retrieval accuracy is your primary goal and you have GPU infrastructure, E5-mistral-7b-instruct is the top pick. For multilingual use cases, go with GTE-Qwen2. If you need to run on CPUs or edge devices, Nomic-embed-text-v1.5 delivers the best accuracy-per-compute ratio. BGE-en-icl is the most flexible option thanks to its in-context learning capability, which lets you adapt it to new tasks without retraining.

The Massive Text Embedding Benchmark (MTEB) is the standard evaluation suite for embedding models. It covers seven task categories: classification, clustering, pair classification, re-ranking, retrieval, semantic textual similarity (STS), and summarization. The overall score is an average across all categories, but for most production applications, the retrieval and re-ranking scores matter far more than the others.

Here is how the major models stack up on retrieval tasks specifically (MTEB Retrieval subset, nDCG@10):

• Voyage voyage-3-large: 59.8
• Cohere embed-v4: 58.4
• E5-mistral-7b-instruct: 58.1
• BGE-en-icl: 57.9
• OpenAI text-embedding-3-large: 55.4
• GTE-Qwen2-7B-instruct: 55.1
• Nomic-embed-text-v1.5: 53.0
• Google text-embedding-005: 52.8
• OpenAI text-embedding-3-small: 51.7

Notice that OpenAI text-embedding-3-large, the most widely used embedding model, ranks fifth on retrieval. Both Cohere and two open source models beat it. This is the core argument for not blindly defaulting to OpenAI. If you are building a RAG system or semantic search product, the models at the top of this list will retrieve more relevant documents for the same query, which directly translates to better answers from your LLM.

A caveat: MTEB scores reflect performance on academic datasets. Your domain-specific data may behave differently. We strongly recommend running a retrieval evaluation on 100+ real queries from your application before committing to a model. Use nDCG@10 and recall@5 as your primary metrics. Build a golden set of query-document pairs, run each embedding model against it, and let the numbers decide.

API pricing per million tokens is the easy comparison. Total cost of ownership, including infrastructure for self-hosted models, is where the real decision gets made.

API pricing (per million tokens, as of early 2026)

• OpenAI text-embedding-3-small: $0.02
• OpenAI text-embedding-3-large: $0.13
• Cohere embed-v4: $0.10
• Google text-embedding-005: ~$0.10 (character-based pricing)
• Voyage voyage-3-large: $0.18
• Voyage voyage-3-lite: $0.06

Self-hosted cost modeling

Running E5-mistral-7b-instruct or BGE-en-icl on a single AWS g5.xlarge instance (A10G GPU, 24GB VRAM) costs roughly $740 per month on-demand or $470 per month with a 1-year reserved instance. At 300 passages per second, that instance can embed approximately 780 million passages per month, assuming continuous operation. The effective per-token cost drops to near zero at scale.

For Nomic-embed-text-v1.5 on CPU, a c6i.xlarge instance (4 vCPUs, 8GB RAM) costs about $125 per month and handles roughly 500 passages per second. This is the lowest-cost embedding infrastructure available.

Break-even analysis

At what volume does self-hosting beat API pricing? If you are using OpenAI text-embedding-3-large at $0.13 per million tokens, self-hosting a 7B open source model on a reserved GPU instance breaks even at roughly 3.6 million tokens per month. That is about 2,700 pages of text. Most production applications exceed this threshold within the first month.

If you are using OpenAI text-embedding-3-small at $0.02 per million tokens, the break-even point jumps to roughly 23.5 million tokens per month. At that volume, the API is genuinely cheap, and the operational overhead of managing GPU infrastructure may not be worth it. For small-scale applications, text-embedding-3-small is a perfectly reasonable choice despite not leading on benchmarks.

The hidden cost most teams miss: re-embedding. When you switch models or update your chunking strategy, you need to re-embed your entire corpus. A 10 million document corpus at $0.13 per million tokens costs roughly $3,400 to re-embed through OpenAI. With self-hosted models, re-embedding is just compute time. Plan for at least 2 to 3 re-embedding cycles during your first year of development.

Embedding dimensionality directly affects three things: retrieval accuracy, storage cost, and query latency. Higher dimensions capture more semantic nuance but increase your vector database bill and slow down similarity search.

Typical dimension counts across models:

• 4,096 dimensions: BGE-en-icl, E5-mistral-7b-instruct
• 3,072 dimensions: OpenAI text-embedding-3-large
• 1,536 dimensions: OpenAI text-embedding-3-small
• 1,024 dimensions: Cohere embed-v4, Voyage voyage-3-large
• 768 dimensions: Google text-embedding-005, Nomic-embed-text-v1.5

Storage math: each float32 dimension takes 4 bytes. A 3,072-dimensional vector is 12 KB. At 10 million vectors, that is 120 GB of raw vector data before indexing overhead. A 1,024-dimensional vector is 4 KB, bringing the same corpus down to 40 GB. With HNSW indexing, expect 1.5x to 2x overhead on top of raw vector size.

Matryoshka embeddings help here. OpenAI and Nomic both support truncating their vectors to smaller dimensions. In practice, truncating OpenAI text-embedding-3-large from 3,072 to 512 dimensions retains about 97% of retrieval accuracy while reducing storage by 83%. Always benchmark truncated dimensions on your specific dataset before committing, but do not assume you need the full output.

Multilingual performance

If your application handles multiple languages, model choice narrows quickly. Cohere embed-v4 supports 100+ languages and maintains strong cross-lingual retrieval, meaning a query in English can retrieve relevant documents written in French or Japanese. GTE-Qwen2-7B-instruct handles 20+ languages with particular strength in CJK (Chinese, Japanese, Korean). OpenAI text-embedding-3 handles multilingual input but performs measurably worse on cross-lingual retrieval tasks, dropping 8 to 12% compared to English-only queries in our testing.

For English-only applications, language support is irrelevant and you should optimize for retrieval accuracy and cost. For anything multilingual, Cohere is the safest API choice and GTE-Qwen2 is the safest open source choice.

Off-the-shelf embedding models work well for general-purpose text. But if your domain uses specialized vocabulary (medical terminology, legal jargon, internal product names, financial instruments), fine-tuning can close the gap between generic and domain-specific performance.

Cohere offers fine-tuning through their dashboard with as few as 256 labeled examples. You provide query-document pairs with relevance labels, and they train a custom version of embed-v4 on your data. In our experience, fine-tuned Cohere models improve retrieval nDCG@10 by 5 to 12% on domain-specific benchmarks compared to the base model. The fine-tuned model runs at the same API cost.

OpenAI does not currently support fine-tuning their embedding models. This is a significant limitation. If your domain needs customization and you want to stay with a commercial API, OpenAI is not an option.

Open source models offer the most flexibility. You can fine-tune any open source embedding model using frameworks like Sentence Transformers. The standard approach uses contrastive learning with hard negative mining:

• Collect 1,000 to 10,000 query-document pairs from your domain
• Mine hard negatives (documents that are topically similar but not relevant to the query)
• Train with MultipleNegativesRankingLoss or InfoNCE loss
• Evaluate on a held-out test set using nDCG@10 and recall@5

Fine-tuning Nomic-embed-text-v1.5 (137M parameters) takes about 2 hours on a single A10G GPU with 5,000 training pairs. Fine-tuning E5-mistral-7b-instruct takes 8 to 12 hours on an A100 80GB. The quality improvement is typically 8 to 15% on domain-specific retrieval, which translates directly to better RAG answers.

Our rule of thumb: if your off-the-shelf retrieval accuracy (measured on real queries) is below 80% recall@5, fine-tuning is almost certainly worth the effort. If it is above 90%, focus your optimization time elsewhere in the pipeline.

After deploying embedding models across dozens of production systems, here are our concrete recommendations.

For RAG and semantic search (English-only): Start with Cohere embed-v4. It offers the best balance of retrieval accuracy, reasonable pricing, and fine-tuning support. If you have GPU infrastructure and want to eliminate API costs, E5-mistral-7b-instruct is the open source equivalent. Avoid defaulting to OpenAI text-embedding-3-large unless you have already benchmarked it against these alternatives on your specific data.

For multilingual applications: Cohere embed-v4 is the clear winner for commercial APIs. For self-hosted, GTE-Qwen2-7B-instruct handles Asian languages better than any alternative. Do not use OpenAI for cross-lingual retrieval without extensive testing first.

For code search and technical documentation: Voyage voyage-code-3 is purpose-built for this and leads every code retrieval benchmark. If Voyage pricing is a concern, BGE-en-icl with code-specific in-context examples performs within 3% of Voyage at no API cost.

For cost-sensitive or high-volume applications: Nomic-embed-text-v1.5 on CPU infrastructure. You get 97% of OpenAI text-embedding-3-small quality at a fraction of the cost, with the ability to scale horizontally on cheap compute instances. For very large corpora (50M+ documents), the savings are significant.

For prototyping and early-stage products: OpenAI text-embedding-3-small at $0.02 per million tokens. The cost is negligible, the API is reliable, and every framework has first-class support. Just plan to re-evaluate when you reach production scale.

The single biggest mistake we see teams make: choosing an embedding model once and never revisiting the decision. The landscape changes every 3 to 6 months. Build your pipeline so that swapping embedding models requires updating a configuration, not rewriting application code. Abstract the embedding step behind an interface, store model metadata alongside your vectors, and maintain an evaluation dataset that you can re-run against new models as they release.

If you are building an AI search system, RAG pipeline, or any product that depends on embedding quality, we can help you evaluate models against your specific data and deploy a production-grade solution. Book a free strategy call and let us help you pick the right embedding model for your use case.