What retires, and when
Microsoft's Foundry schedule lists Cohere-embed-v3-english and Cohere-embed-v3-multilingual as GA with a retirement date of 2027-02-15, and names Cohere-embed-v5-fast and Cohere-embed-v5-pro as the replacements. A note on the same page says both v3 models are deprecated on 15 November 2026.1 Today is 5 November, so there are 102 days to the retirement date and 10 to the deprecation.
Three consequences follow from Microsoft's lifecycle policy:
- Deprecated means existing customers can keep creating and managing deployments, but new customers cannot. "Existing customer" is decided per subscription: a subscription that has never deployed the v3 version cannot start now, and a new subscription under the same tenant does not inherit access.2 If you want a fresh staging subscription with a v3 deployment as your baseline, create it before 15 November.
- Retired means every inference request returns
410 Gone.2 - Retirement dates are not extendable, and there is no exception process.3
The policy page describes automatic upgrades for Global Standard, Data Zone Standard and Standard deployments when a version retires, and says provisioned deployments are not upgraded.2 It does not say how that works for a partner embedding model, and the v3 rows list two replacements, not one. For an embedding model that matters: a silent swap would make your query vectors come from a model your index has never seen, and recall would drop without an error. Check each deployment's upgrade setting (the migration page names versionUpgradeOption, with NoAutoUpgrade meaning the deployment stops working at retirement)3 and decide on purpose.
One more date to avoid: the same schedule lists embed-v-4-0 retiring 2027-06-01, also with the v5 models as replacements.1 Moving to v4 as a stopgap buys four months and a second re-embed. Go to v5 once.
Why this is a re-index, not a model swap
Cohere documents one compatibility guarantee for Embed 5: Pro and Fast share a single embedding space, so you can index with Pro and query with either tier without rebuilding the index.4 Nothing I read says v3 vectors share a space with v5. INFRO's embeddings reference makes the general point: vectors from two embedding models live in unrelated spaces.5 Treat v3 and v5 as incompatible, and verify with the test below if you doubt it.
That gives three rules:
- One index holds vectors from one model and one dimension. Tag every vector with the model that made it.
- A query is embedded with the same model as the index it searches.
- The old index must keep a working v3 query path until you no longer need rollback.
Embed 5 also changes things you set at index creation. Cohere lists output dimensions of 2048, 1536, 1024, 768, 512 and 256, and float, int8 and binary formats, for both tiers.4 Your v3 index has its own dimension and format, so the new index is a new collection with new parameters, not a column you alter.
Pick the target: Pro, Fast, or Pro to index and Fast to query
Cohere positions Pro for maximum retrieval quality and offline indexing, and Fast for interactive search and high-volume RAG. Both take 128K tokens of context and 100+ languages.4 Its list rates are $0.12 per million text tokens for Pro and $0.08 for Fast.4 Check what your Foundry meter and contract actually charge before you plan around those figures.
The shared space gives you an option worth testing: index the whole corpus with Pro once, then compare Pro queries against Fast queries on the same index. If Fast queries hold your quality gate, you get lower query latency and a lower query rate without a second index. If you start with Fast for both and later want Pro, the index has to be rebuilt only if you change the index side, so the safer default for a corpus you rarely re-embed is Pro on the index side.
Cohere's published benchmark numbers are Cohere's, on its chosen datasets. Microsoft's guidance is the same in spirit: treat public leaderboards as a filter, not the finish line, and confirm the shortlist against your own workload.3 The next sections do that.
Build the evaluation set before you touch the index
Microsoft's migration guide gives two rules that apply directly. Freeze the dataset (inputs, ground truth and success criteria) for the whole migration, or source and target results are no longer comparable. And capture is opt-in and never retroactive, so you cannot evaluate traffic you did not record.3
For retrieval, the frozen set has four parts:
- Queries: a sample of real production queries, stratified by language, tenant or product area, and query length. Strip or redact anything your logging policy does not allow you to keep.
- Judgments: for each query, the documents or chunk ids that should be retrieved. Use click or answer-citation data where you have it, and label a smaller sample by hand for the queries that matter most.
- Known hard cases: acronyms, product codes, numeric lookups, mixed-language queries, long pasted error messages. These are where a model change shows first.
- Corpus snapshot: the chunk ids and text as of a fixed date, so both indexes are scored against the same documents while the live corpus keeps changing.
If you use an LLM to produce or grade judgments, calibrate it against human labels first; see can an LLM judge be trusted.
The dual-index plan
The mechanism is a shadow index that receives every write, plus a backfill for the existing corpus.
def backfill(source, embed_v5, new_index, state, batch_size):
"""Re-embed the corpus into the shadow index. Safe to stop and restart."""
for batch in source.scan(after=state.cursor(), size=batch_size):
live = [c for c in batch if not source.is_deleted(c.id)]
vectors = embed_v5([c.text for c in live]) # your Foundry v5 deployment
new_index.upsert_if_newer([
{
"id": c.id,
"vector": v,
"doc_version": c.version,
"embed_model": "cohere-embed-v5-pro",
}
for c, v in zip(live, vectors)
])
state.commit(batch[-1].id) # checkpoint after the write, not beforeRules that keep this correct while the corpus changes underneath it:
- Dual-write first. Turn on writes to both indexes before the backfill starts, so nothing created during the backfill is missed. Both writers use the same chunk id.
- Upsert only if newer. The backfill reads an old snapshot of a chunk while the ingestion path may already have written a newer one. Compare
doc_versionand keep the higher. - Apply deletes to both. A document deleted during the backfill must not reappear from the backfill's stale read. The
is_deletedcheck above is the minimum; a tombstone table is better. - Checkpoint per batch and make writes idempotent. Rate limits and transient errors will interrupt a long job. Restarting should repeat at most one batch.
- Throttle to the deployment's quota. The backfill shares the deployment with live query embedding if you use one deployment. Use a separate deployment, or cap backfill throughput, so retrieval latency does not move.
- Chunk the same way. Keep chunking and metadata identical for both indexes while comparing, or you cannot tell a model effect from a chunking effect. Change chunking in a later project.
Quality gates
Run the frozen query set against both indexes and compare. Report each metric overall and per segment, because an average hides a language or document type that got worse.
| Check | How | Why it matters |
|---|---|---|
| Recall@k and nDCG@k | Score both indexes on the judged queries | The primary quality signal; gate on per-segment deltas, not the mean |
| Top-k overlap | Share of v3's top-10 that v5 also returns | Low overlap is not bad by itself, but tells you how much downstream behaviour will move |
| Hard-case pass rate | Pass/fail on the known hard queries | Catches codes, numbers and mixed-language failures |
| Query-side comparison | Pro queries vs Fast queries on the Pro index | Decides whether you can use the lower-latency tier for queries |
| Downstream answer check | Run the RAG answer step on a sample, with a grader | Retrieval can improve while the answer gets worse if prompts relied on old ordering |
| Latency and error rate | p50/p95 embed latency and 429 rate under shadow load | Confirms the new deployment's quota and speed before real traffic |
Set the thresholds from your own v3 baseline before you look at v5 results: for example, "no segment more than a margin you choose below v3, and no regression on the hard cases." Writing the gate first stops the result from choosing the gate.
If you rerank after retrieval, keep that stage constant while comparing, and note it has its own lifecycle; the schedule lists Cohere's rerank 4.0 models retiring 2027-09-13.1 See do you need a reranker for that test.
A quick sanity test of the incompatibility assumption is cheap: embed the same 200 chunk texts with v3 and v5, then check that v3 queries against v5 vectors perform no better than chance on your judged set. Do not ship a mixed arrangement even if it appears to work.
Estimate the cost
The core is arithmetic: corpus tokens times the per-million rate, plus the overlap costs people forget.
backfill = corpus_tokens / 1e6 * rate_per_million
shadow = daily_query_tokens * shadow_days / 1e6 * rate_per_million
storage = vectors * bytes_per_vector, for both indexes during the overlap
re-runs = backfill * expected_reruns (a chunking fix or a failed gate means another pass)Count tokens with the tokenizer that matches the billed model, not a character estimate; the billing meter, not your chunker, decides the figure. Sample 1,000 chunks, embed them, read the reported usage, and scale. Budget for at least one re-run.
Two levers change the bill: int8 or binary output formats and fewer dimensions shrink storage and search cost, which Cohere states as the point of its Matryoshka representations and lower-precision outputs,4 but each is a quality trade-off, so run it through the same gates as a separate variant rather than combining it with the model change.
Cutover and rollback
Work backwards from 15 February. Microsoft's own advice is to treat the retirement date minus your validation and rollout time as the real deadline.3 Here is one schedule, with dates that are suggestions, not Azure facts:
| Window | Step |
|---|---|
| 5–15 Nov | Inventory every v3 deployment and index, freeze the evaluation set, create any extra v3 environment you need |
| 15 Nov–15 Dec | Deploy v5, run the sample evaluation, choose the tier, size the new index, finish the cost estimate |
| 15 Dec–8 Jan | Dual-write on, backfill running, spot-check counts and deletions |
| 8–22 Jan | Shadow queries against both indexes, full quality gates, then 5%, 25% and 100% of live queries on the new index |
| 22 Jan | Cutover complete; v3 index kept read-only, v3 query path still working |
| After 15 Feb | Stop dual-write, delete the v3 index and deployment, record the result |
Rollback is a routing flag that sends queries back to the v3 index and v3 query embedding. It works only while v3 still answers. After 15 February the old index cannot be searched with new queries at all, so the real rollback window closes on the retirement date, and the useful one closes sooner because a fix needs time. That is why cutover sits in mid-January.
During the staged ramp, watch zero-result rate, click-through or citation rate, answer-grader scores and embed latency, split by the same segments as the offline test.
Where a gateway fits
INFRO's /v1/embeddings takes OpenAI's request shape on your own OpenAI, Azure OpenAI, Mistral or OpenAI-compatible connection, fails over only to the same model, checks budgets before the call and records estimated provider cost per request; it stores no vectors and runs no retrieval.5 The model ids its reference lists are OpenAI and Mistral embedding models, plus openai-compatible/<model id>, so a Cohere Embed model on Foundry is not on the list I read. Do not plan this migration through it unless you confirm that path. Where it can help is the surrounding discipline: one record per request of model and cost, and a rule that a route never fails over from one embedding model to another, which is the same rule this plan applies to indexes.
Checklist
- Every v3 deployment, index and owner listed, with deployment type and upgrade setting
- Decision made on each deployment: stop at retirement, or auto-upgrade, knowingly
- Any extra v3 subscription created before 15 November
- Evaluation set frozen: queries, judgments, hard cases, corpus snapshot
- Gate thresholds written down before v5 results exist
- Shadow index created with the new dimension and format; vectors tagged with the model
- Dual-write live; backfill checkpointed, throttled, delete-safe
- Cost estimate from sampled billed usage, with a re-run allowance
- Cutover rehearsed with a tested rollback flag, completed by late January
- v3 index and deployment deleted only after 15 February
