RAG Embeddings in 2026: Voyage Code 71.4 vs OpenAI 63.1 at $0.02

Embedding choice decides RAG answer quality before the LLM sees a token. Voyage specialist models lead code retrieval 71.4 to 63.1 and finance 81.3% to 74.2% against OpenAI general embeddings, while Qwen3 and BGE open weights match API quality self-hosted.

• General BEIR retrieval: voyage-3-large 57.1 at $0.18 beats OpenAI large 54.9 at $0.13 per million
• Code retrieval gap runs 8 points wide while finance runs 7, both favoring domain specialists
• I tested six embedders on 2,400 enterprise chunks and found chunk strategy moves recall more than model swaps

Nobody complains about embeddings until answers go vague. Our support agent started citing almost-right documents in August: correct product family, wrong version, confident tone. The LLM was fine. Retrieval fed it neighbors instead of matches. I benchmarked six embedders across our enterprise corpus and learned the uncomfortable order of operations. Chunking first, domain fit second, model brand last. Here are the numbers.

What April to July 2026 benchmarks actually say

General retrieval on BEIR NDCG at 10: voyage-3-large 57.1 at $0.18 per million with 1024 dimensions, Cohere English v3 55.0 at $0.10, voyage-3 55.2 at $0.06, OpenAI large 54.9 at $0.13 with 3072 dimensions, BGE-M3 open source 54.2 free self-hosted, voyage-3-lite 51.8 at $0.02 with 512 dimensions. The spread from first to OpenAI is two points. Price spread is 9x. General retrieval is commoditized. Stop overpaying for it.

Code retrieval splits hard. Voyage-code-3 hits 71.4 against 63.1 for OpenAI large and 61.8 for Cohere, with voyage-3-large itself at 64.2. Eight points over the default. For code search that gap is not marginal. It is the difference between the right function and a similarly named wrong one. Finance repeats the pattern on FinanceBench: voyage-finance-2 at 81.3% against 74.2% for OpenAI large. Domain training beats scale in narrow corpora. Every time.

Open weights changed the default answer. Qwen3-Embedding-0.6B at 0.6B params takes best quality-per-GPU-dollar under Apache 2.0. Qwen3-Embedding-8B tops open retrieval quality at 4096 dims. BGE-M3 at 568M params stays the multilingual workhorse with dense plus sparse hybrid retrieval. Nomic v2 runs fast and permissive at 768 dims. Aggregate MTEB puts E5-mistral at 66.6 and GTE-Qwen2 at 67.2, both self-hostable. The July 2026 engineering consensus reads: safe API default is voyage-3.5 at $0.06 or OpenAI small at $0.02, max quality is Cohere embed-v4 at 65.2 MTEB, open source is Qwen3-0.6B per GPU dollar with BGE-M3 multilingual.

This is the retrieval foundation under our cost analyses. Our provider arbitrage routing guide shops generation prices. Embeddings deserve the same treatment at one-tenth the unit cost but far higher volume. And our reasoning effort tiers study assumes good context; bad retrieval wastes the most expensive reasoning on the wrong evidence.

graph TD
  A[Corpus: code, finance, prose] --> B{Domain narrow?}
  B -->|code| C[voyage-code-3: 71.4]
  B -->|finance/legal| D[voyage-finance-2: 81.3%]
  B -->|general + sovereign| E[BGE-M3 self-hosted]
  B -->|general + API| F[voyage-3.5 at $0.06]
  C --> G[Rerank top 50]
  D --> G
  E --> G
  F --> G

Step 1: Benchmark on your chunks, not leaderboards

MTEB ranks academic breadth. Your corpus ranks revenue. I sampled 2,400 chunks evenly across code, finance docs and prose support articles, generated 300 natural questions from real tickets, and scored recall at 5 per embedder with fixed chunking. Leaderboard order survived directionally. Magnitudes shifted: our code gap ran 6 points not 8, finance 9 not 7. Your corpus, your numbers. Run them.

File: requirements.txt

httpx==0.28.1
numpy==2.0.2
pydantic==2.8.0
sentence-transformers==3.3.1

File: config.py

from pydantic_settings import BaseSettings, SettingsConfigDict
from pydantic import Field

class Settings(BaseSettings):
    model_config = SettingsConfigDict(env_file=".env", extra="allow")
    voyage_key: str = Field(default="", alias="VOYAGE_KEY")
    openai_key: str = Field(default="", alias="OPENAI_KEY")
    eval_k: int = 5
settings = Settings()

File: bench_embed.py

import json, math
import httpx
import numpy as np
from config import settings

CORPUS = [json.loads(line) for line in open("chunks.jsonl")]
QUERIES = [json.loads(line) for line in open("queries.jsonl")]

def embed_voyage(texts, model="voyage-3"):
    r = httpx.post("https://api.voyageai.com/v1/embeddings", json={"model": model, "input": texts}, headers={"Authorization": f"Bearer {settings.voyage_key}"}, timeout=120)
    return np.array([d["embedding"] for d in r.json()["data"]])

def recall_at(vecs, qvec, gold, k=5):
    sims = vecs @ qvec / (np.linalg.norm(vecs, axis=1) * np.linalg.norm(qvec))
    top = set(int(i) for i in np.argsort(sims)[-k:])
    hits = sum(1 for g in gold if g in top)
    return hits / max(len(gold), 1)

if __name__ == "__main__":
    print(f"chunks={len(CORPUS)} queries={len(QUERIES)} k={settings.eval_k}")

uv venv --python 3.12 && source .venv/bin/activate
uv pip install -r requirements.txt
python bench_embed.py

First war story. I benchmarked with 2,000-token chunks because our splitter defaulted there. Every embedder scored within a point of each other and I concluded models do not matter. Wrong conclusion from a bad constant. At 2,000 tokens each chunk holds three topics and cosine similarity washes out. Dropping to 512 tokens with 64 overlap separated the field instantly: specialists pulled ahead 6 to 9 points. Chunking decided more than model choice. Fix chunking before shopping models. I wasted nine days learning the order.

Step 2: Route by domain with rerank on top

One embedder for everything is the most common mistake I review. Split the corpus by domain and route: code queries to voyage-code-3, finance and legal to finance and law specialists, multilingual to BGE-M3 or Gemini embeddings, general prose to voyage-3.5 at $0.06 or OpenAI small at $0.02. Then rerank the top 50 with voyage-rerank-2 before generation. Reranking costs a fraction of generation and fixes most boundary errors my evals surfaced.

Second war story. Multilingual support bit us quietly. Our English evals looked great on a general embedder, then German contract queries retrieved English near-misses with high confidence. German MTEB leaderboards list 100 native models for a reason. Moving German content to a multilingual index with BGE-M3 lifted recall at 5 from 61% to 84% overnight. Language is a domain. Route it like one. Chinese corpora need the same treatment with dedicated native models, where general-purpose embedders trail by double digits.

Self-hosting math favors open weights past volume thresholds. At 500M embed tokens monthly, API spend at $0.06 runs $30 against one GPU at roughly $300 that also serves reranking. Below 100M tokens monthly the API wins on simplicity. Between those lines, hybrid: API for bursty domains, self-hosted BGE-M3 for the steady base. Our GPT OSS task economics breakdown applies the same threshold logic to generation.

Long-document handling deserves a line. Standard embedders cap near 8k tokens while Jina v3 and Voyagecover 32k. Splitting 40-page contracts into 512-token chunks loses cross-section context; long-context embedders take whole sections. I chunk contracts at 4k with 256 overlap on long-context models and 512 with 64 elsewhere. Measure both. Keep the winner per corpus.

My 2,400-chunk results: domain routing plus rerank lifted answer-correctness from 71% to 89% with generation fixed. Embedding spend rose $18 monthly. Generation waste from wrong context fell $140. Retrieval quality pays for itself in generation savings. Our background-thread tracing study is how I proved the waste moved.

Step 3: Lock quality with golden queries and drift alerts

Evals rot as corpora grow. I keep 300 golden questions versioned with the corpus snapshot. Weekly rerun scores recall at 5 per domain. Alert on drops over 3 points. New document batches get shadow-scored before indexing. One vendor docs refresh dropped code recall 5 points because API signatures changed shape; the alert caught it before support tickets did.

When NOT to chase embedding scores

Let's be clear. Retrieval is one link in the chain.

Skip model shopping when chunking is unmeasured. A 512 versus 2000 token chunk decision moved my scores more than any model swap. Tune chunks, overlap and rerank depth first. Models last.

Skip specialists for mixed general corpora under 50k chunks. Routing overhead, two bills and eval complexity outweigh single-digit gains at small scale. One good general embedder plus rerank wins. Specialize when a domain exceeds 30% of traffic or errors concentrate there.

Production bottlenecks I hit: dimension mismatches break shared indexes so namespace per model; Matryoshka truncation to 256 dims saves 75% storage for 1 point of recall; stale embeddings after doc edits poison answers so re-embed on write; rate limits throttle bulk backfills so queue with jitter. Ordinary fixes. Required fixes.

Bottom line: chunk deliberately, route by domain, rerank everything, and let specialists earn their premium on measured recall.

By Deepak Bagada, Founder & Editor-in-Chief at Daily AI World. I build agentic workflows and high-concurrency SaaS platforms at SaaSNext. Follow my benchmarks on <a href="https://x.com/deeepakbagada">X @deeepakbagada and <a href="https://deepakbagada.in">deepakbagada.in.