Bottom line: if you’re building RAG in August 2026, Cohere embed-v4 wins on cost ($0.01/1M tokens) and context window (128K tokens), Voyage 3.5 wins on retrieval accuracy, and OpenAI text-embedding-3-large wins on ecosystem maturity — pick based on which constraint actually bites your app, not on a single leaderboard number. We ran the same 50-document technical corpus through all three, logged dimension counts, quantization options, and per-1M-token cost, and the answer is not “just use the highest MTEB score.”
- Tightest budget at scale: Cohere embed-v4 — $0.01/1M tokens, roughly 13x cheaper than OpenAI text-embedding-3-large
- Best retrieval accuracy: Voyage 3.5 — Voyage AI’s own published benchmark claims an 8.26% average retrieval-quality lift over OpenAI-v3-large
- Longest documents without chunking pain: Cohere embed-v4 — 128K-token context window vs OpenAI’s 8,191-token cap
- Safest default if you’re already on OpenAI infra: text-embedding-3-large — most battle-tested managed embedding model in production, per OpenAI’s own ecosystem documentation
What Actually Differs Between OpenAI, Voyage, and Cohere Embeddings?
The three models differ on four axes that matter operationally: native vector dimensions, price per 1M tokens, context window, and retrieval accuracy on domain-specific (not generic) text. OpenAI text-embedding-3-large ships at 3,072 dimensions natively but supports Matryoshka Representation Learning, so you can truncate down to 256 dimensions and trade a small accuracy hit for a much smaller pgvector index footprint. Voyage 3.5 goes further, offering four selectable output dimensions — 2048, 1024, 512, and 256 — plus five quantization modes including int8 and binary. Cohere embed-v4 doesn’t publish the same dimension flexibility but wins on raw context window: 128,000 tokens per input, enough to embed a full technical manual chapter without chunking it into fragments first.
Which Model Scores Highest on MTEB?
On the general MTEB leaderboard, Cohere embed-v4 posts roughly 65.2 average, edging out OpenAI text-embedding-3-large’s roughly 64.6. Voyage AI doesn’t compete head-to-head on the public MTEB leaderboard the same way — the company instead publishes its own RTEB retrieval benchmark, where voyage-3.5 claims an 8.26% average improvement over OpenAI-v3-large specifically on retrieval-focused tasks. That distinction matters: MTEB averages across classification, clustering, and retrieval, but a RAG pipeline only cares about retrieval. If your evaluation only reads the single averaged MTEB number, you’ll rank Voyage lower than it actually performs on the one task you’re building for.
How Much Does Each Model Actually Cost at Scale?
Cost separates fast once you’re past a demo. OpenAI text-embedding-3-large runs $0.13 per 1M tokens; text-embedding-3-small drops to $0.02 per 1M tokens but gives up meaningful retrieval accuracy for that discount. The Voyage 4 family spans a wider range — voyage-4-lite at $0.02/1M, voyage-4 at $0.06/1M, and voyage-4-large at $0.12/1M — so you’re choosing a price/accuracy tier within one vendor rather than switching vendors. Cohere embed-v4 undercuts all of them at $0.01 per 1M tokens, which Cohere frames as a roughly 50% reduction versus OpenAI’s small model, not just the large one.
Run the math on a realistic ingestion job: embedding a 10-million-token document corpus costs $1,300 on text-embedding-3-large, roughly $600 on voyage-4, and $100 on Cohere embed-v4. At that scale the vendor choice is a four-figure line item, not a rounding error.
What’s the Real Difference in Dimension Counts and Storage Cost?
Dimension count drives your vector database storage bill directly — more dimensions means more disk and slower index builds in pgvector, Pinecone, or Weaviate. Voyage’s own comparison shows voyage-3.5 running at int8 quantization and 2,048 dimensions against OpenAI-v3-large’s float32 at 3,072 dimensions, and claims an 83% reduction in vector database storage cost for a comparable or better retrieval result. That’s the practical payoff of quantization: you’re not paying for four bytes per dimension when one byte (int8) or even one bit (binary) gets you nearly the same recall.
| Model | Native Dimensions | Price / 1M Tokens | Context Window | Best For |
|---|---|---|---|---|
| OpenAI text-embedding-3-large | 3,072 (truncatable to 256) | $0.13 | 8,191 tokens | Existing OpenAI stacks, ecosystem maturity |
| OpenAI text-embedding-3-small | 1,536 | $0.02 | 8,191 tokens | Low-stakes, high-volume search |
| Voyage 3.5 | 2048 / 1024 / 512 / 256 | ~$0.06–0.12 | 32,000 tokens | Best retrieval accuracy, domain-specific corpora |
| Cohere embed-v4 | 1,536 (variable) | $0.01 | 128,000 tokens | Lowest cost, long documents, noisy real-world text |
Which Model Handles Noisy, Real-World Documents Best?
Cohere specifically trains embed-v4 for resilience against real-world document noise — scanned PDFs, inconsistent formatting, OCR artifacts — which matters more than a clean-benchmark MTEB score if your corpus is internal wikis, support tickets, or contracts rather than curated Wikipedia text. We tested this directly: feeding a batch of scanned, OCR’d product manuals (with the expected dropped characters and broken line breaks) through all three models, embed-v4’s retrieval held up noticeably better than text-embedding-3-small on the same corpus, though it still trailed Voyage 3.5 on the cleanest documents in the set.
What Breaks When You Switch Embedding Models Mid-Project?
The operator-grade failure mode nobody’s benchmark table warns you about: embeddings from different models are not interchangeable, and neither are embeddings at different dimension counts from the same model. Swap from text-embedding-3-large at 3,072 dimensions to voyage-3.5 at 1,024 dimensions without re-embedding your entire corpus, and you’ll get a dimension-mismatch error at query time — or worse, a silent wrong-length vector that pgvector either rejects outright or, in older client libraries, pads and returns meaningless nearest-neighbor results. Budget the full re-embedding cost (and the downtime) any time you change providers or change your truncated dimension count, even within the same OpenAI model family.
How Do You Actually Test Retrieval Accuracy on Your Own Corpus?
Set up a recall@10 test: take 50-100 real queries your users would actually type, manually mark which documents in your corpus should show up in the top 10 results for each, then run all three embedding models through the same pgvector or Pinecone index and count how many of the marked-correct documents land in the top 10. This is the only test that tells you anything about your specific data — MTEB and RTEB scores are averages across benchmark datasets that may look nothing like your support tickets or product manuals.
“Voyage models consistently achieve top scores on retrieval-focused benchmarks, with better handling of domain-specific content” — per Voyage AI’s published model documentation.
- Cohere embed-v4 is the cheapest ($0.01/1M tokens) and has the longest context window (128K tokens) of the three.
- Voyage 3.5 leads on retrieval-specific accuracy per its own RTEB benchmark, and cuts vector storage cost via int8/binary quantization.
- OpenAI text-embedding-3-large remains the most battle-tested option if you’re already deep in the OpenAI ecosystem.
- Never switch embedding models or dimension counts without budgeting a full corpus re-embed — dimension mismatches fail silently in some client libraries.
- Build your own recall@10 test on real queries; vendor benchmarks are directional, not predictive, for your specific corpus.
Frequently Asked Questions
Can I mix embedding models in the same vector database?
No — not in the same index. Different models produce vectors that aren’t comparable via cosine similarity or dot product, even if the dimension counts happen to match. Use separate indexes (or separate collections) per model, or fully re-embed when you switch.
Is a higher MTEB score always better for RAG?
No. MTEB averages classification, clustering, and retrieval tasks together. For RAG specifically, look at the retrieval-only subscore, or better, run your own recall@10 test — a model that wins on the blended average can still lose on the retrieval slice that actually matters for search.
Does reducing embedding dimensions hurt accuracy?
Slightly, but often less than expected. Models built with Matryoshka Representation Learning (OpenAI’s text-embedding-3 family, Voyage 3.5) are trained so that truncated lower-dimension outputs stay useful, trading a small accuracy loss for meaningfully smaller storage and faster index builds.
What’s the biggest hidden cost in switching embedding providers?
Re-embedding your entire existing corpus, plus any downtime or dual-write complexity while you migrate a live index. The per-token embedding price is the visible cost; the re-embedding job and migration window is the one teams underbudget.
Does context window size matter if I already chunk my documents?
Yes, indirectly — a larger context window (Cohere’s 128K vs OpenAI’s 8,191 tokens) means fewer, larger chunks, which reduces the total number of embedding calls and can improve retrieval by keeping more surrounding context in each vector.
Should a small project just default to OpenAI text-embedding-3-small?
For a low-stakes prototype, yes — it’s cheap and well-documented. For anything going to production with real users querying real documents, run the recall@10 test across at least two providers before locking in, since the cost difference compounds fast at scale.
Last updated: 2026-08-24
