# Embed v3 retires on Azure Feb 15: a dual-index re-embedding plan

URL: https://infro.io/blog/embed-v3-retires-on-azure-feb-15-a-dual-index-re-embedding-plan
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-05
Last modified: 2026-11-05
Last reviewed: 2026-11-05 (next review due 2026-12-05)
Topic: Architecture and migration
Format: Guide

> Build a second index with Embed 5, dual-write new content, backfill the old corpus, compare retrieval on a frozen query set, then cut queries over with the v3 index still readable for rollback. Azure lists both v3 models as retiring on 2027-02-15, so the cutover has to land weeks earlier [^azure-schedule].

Key takeaways:
- Azure Foundry lists Cohere-embed-v3-english and Cohere-embed-v3-multilingual as retiring on 2027-02-15, deprecated from 2026-11-15, with Embed 5 Fast and Pro as replacements.
- Treat Embed 5 vectors as a new space: build a second index, never mix models in one index, and never point a v5 query at a v3 index.
- Gate the cutover on your own frozen query set, per segment, not on Cohere's published benchmarks.
- Re-embed cost is corpus tokens times the per-million rate; storage and shadow queries during the overlap are the lines people forget.
- Rollback only exists until v3 stops answering, so schedule cutover in mid-January, not February.

## 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:

1. One index holds vectors from one model and one dimension. Tag every vector with the model that made it.
2. A query is embedded with the same model as the index it searches.
3. 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](https://infro.io/blog/can-an-llm-judge-be-trusted-calibrating-graders-against-humans).

## The dual-index plan

The mechanism is a shadow index that receives every write, plus a backfill for the existing corpus.

```python
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 before
```

Rules 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_version` and keep the higher.
- **Apply deletes to both.** A document deleted during the backfill must not reappear from the backfill's stale read. The `is_deleted` check 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](https://infro.io/blog/do-you-need-a-reranker-testing-cohere-rerank-5-pro-vs-fast) 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.

```text
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)
```

> **Example: Illustrative corpus**
> These figures are made up to show the method. Replace them with your own counts and your Foundry meter's rate.
> 
> - 40 million chunks averaging 400 tokens is 16,000 million tokens.
> - At Cohere's list rate of $0.12 per million tokens for Pro, that is 16,000 × 0.12 = $1,920. At $0.08 for Fast, it is $1,280.[4]
> - Shadow queries: 1 million queries a day at 30 tokens for 14 days is 420 million tokens, about $50 at the Pro rate.
> - Storage at 1,024 dimensions: float32 is about 4 KB a vector, so about 164 GB for 40 million vectors; int8 is about a quarter of that and binary about 5 GB. You hold the old and new indexes together until decommission.

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

## Questions

### Do I have to re-embed again if I later switch from Embed 5 Pro to Fast for queries?

Cohere says Pro and Fast share one embedding space, so you can index with Pro and query with either model without rebuilding the index [4]. Still run your frozen query set against the combination you ship, because quality and latency differ by tier.

### Does the 2027-02-15 date apply to Cohere's own API too?

The date above comes from Microsoft's Foundry schedule, which is the cloud's calendar for its own deployments [1]. I did not read a Cohere-API retirement date for v3, so confirm that separately if you call Cohere directly.

## Sources

1. Model retirement schedule - Microsoft Foundry — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-retirement-schedule (accessed 2026-11-05)
2. Foundry Models lifecycle and support policy — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-retirements (accessed 2026-11-05)
3. Model migration: upgrade or switch models in Microsoft Foundry — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/foundry-models/concepts/model-migration (accessed 2026-11-05)
4. Introducing Embed 5: a new family of frontier embedding models — Cohere. https://cohere.com/blog/embed-5 (accessed 2026-11-05)
5. Embeddings: API reference — INFRO. https://infro.io/docs/api/embeddings (accessed 2026-11-05)
