Skip to content

Architecture and migrationGuide

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

Cohere-embed-v3-english and Cohere-embed-v3-multilingual retire on Azure Foundry on 15 February 2027, and a new embedding model means a new vector space. This guide covers a shadow index, quality gates, a cost estimate and a cutover with a rollback window.

By INFRO Editorial

Published

10 min read

One application request entering a central AI gateway and branching to many model routes

In short

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 1.

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.

The dual-index plan

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

backfill.py
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.

CheckHowWhy it matters
Recall@k and nDCG@kScore both indexes on the judged queriesThe primary quality signal; gate on per-segment deltas, not the mean
Top-k overlapShare of v3's top-10 that v5 also returnsLow overlap is not bad by itself, but tells you how much downstream behaviour will move
Hard-case pass ratePass/fail on the known hard queriesCatches codes, numbers and mixed-language failures
Query-side comparisonPro queries vs Fast queries on the Pro indexDecides whether you can use the lower-latency tier for queries
Downstream answer checkRun the RAG answer step on a sample, with a graderRetrieval can improve while the answer gets worse if prompts relied on old ordering
Latency and error ratep50/p95 embed latency and 429 rate under shadow loadConfirms 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.

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)

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:

WindowStep
5–15 NovInventory every v3 deployment and index, freeze the evaluation set, create any extra v3 environment you need
15 Nov–15 DecDeploy v5, run the sample evaluation, choose the tier, size the new index, finish the cost estimate
15 Dec–8 JanDual-write on, backfill running, spot-check counts and deletions
8–22 JanShadow queries against both indexes, full quality gates, then 5%, 25% and 100% of live queries on the new index
22 JanCutover complete; v3 index kept read-only, v3 query path still working
After 15 FebStop 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 readers ask

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.

From the team that builds it

Where this shows up in INFRO

INFRO is a control plane in front of the provider accounts you already hold. The capabilities below are the parts of it this article touches, each with the documentation that defines its behaviour.

  • Embeddings

    Available with a plan

    POST /v1/embeddings in OpenAI's shape on your own OpenAI, Azure OpenAI, Mistral or OpenAI-compatible connection: routing that fails over only to the same model, budgets checked before the call, and the estimated provider cost of each request. Inputs follow your payload-logging setting; vectors are never stored.

INFRO accounts are self-serve. Provider usage is billed to you by your providers; INFRO charges a software subscription and takes 0% of model spend. See plans.

Sources

Numbered in order of first citation. Each was opened and checked against the claim on the date shown.

  1. 1.Model retirement schedule - Microsoft Foundry (opens in a new tab) — Microsoft Learn. Accessed Nov 5, 2026.
  2. 2.Foundry Models lifecycle and support policy (opens in a new tab) — Microsoft Learn. Accessed Nov 5, 2026.
  3. 3.Model migration: upgrade or switch models in Microsoft Foundry (opens in a new tab) — Microsoft Learn. Accessed Nov 5, 2026.
  4. 4.Introducing Embed 5: a new family of frontier embedding models (opens in a new tab) — Cohere. Accessed Nov 5, 2026.
  5. 5.Embeddings: API reference (opens in a new tab) — INFRO. Accessed Nov 5, 2026.

About this article

Read on 2026-11-05: Microsoft's Foundry retirement schedule (last updated 2026-09-23), its lifecycle policy and model-migration pages, Cohere's Embed 5 announcement, and INFRO's embeddings reference. Cohere's own-API v3 dates, Azure's per-token embedding rates and the v3 and v5 request contracts were not confirmed and are left out; the cost figures are illustrative.

Last checked against its sources on . The next review is due by . No separate named reviewer is recorded for this article.

How articles are written, sourced and corrected is set out in the editorial standards.