Vertex AI is retiring text-embedding-005 and three other embedding models: how to re-embed before search breaks
text-embedding-005, text-embedding-004, the multilingual model and multimodalembedding@001 stop on 1 April 2027. Swapping the name won't fix it, because every stored vector has to be made again. Here's how to plan it.
part 12 of 25 · Platform releases, explained from scratchthe ideaRe-embed into a fresh index first. Switch both sides once it tests well.
after reading, you can- Find every feature still embedding with a retiring model, before your users find it for you
- Pick the new model and vector size on purpose, so your tables and indexes don't break on the switch
- Re-embed into a fresh index and prove relevance held before you switch over
If your search box, document chatbot or recommendations run on Vertex AI's older embedding models, they stop working on 1 April 2027. Google is retiring text-embedding-005, text-embedding-004, text-multilingual-embedding-002 and multimodalembedding@001 that day. You can't fix it by swapping a model name, because every vectordefinitionThe list of numbers you get back for one item. How long it is, 768 or 3,072 for example, is the vector size, and your database has to be set up for it. you've stored was made by the old model and has to be made again.
Your search runs on one embedding model. Once Google retires it, everything it filed has to be redone.
Most AI search features run on an embedding model behind the scenes. It reads each of your documents once and files it as a long list of numbers. When someone types a question, the question gets the same treatment and the app looks for the closest numbers. Google switches four of these models off on 1 April 2027, and from that day questions can't be converted, so search breaks. A newer model can't read the old numbers either. Someone has to run every document through again, and that takes planning.
Think of a library that filed every book under a numbering system one cataloguer invented. The cataloguer is retiring and nobody else can read the system. You can hire a new cataloguer, but they have to re-file the whole library in their own system before anyone can find a book again.
- Teams with RAG chatbots on Vertex AI
- Anyone using RAG Engine with default settings
- Product search and recommendation owners
- BigQuery and AlloyDB users generating embeddings
- Teams that tuned text-embedding-004 or 005
Why it matters to you
When the model behind a search feature retires, the failure isn't gradual. Each search has to embed the user's question with the same model that embedded your documents. Once that model stops answering, the question can't be embedded and the search step errors out. A chatbot built on retrieval then either fails outright or answers without your documents, which is worse, because it sounds confident and nobody notices.
The real cost is the re-embedding. Every document, product, image or ticket you've indexed has to go through the new model again, and that's where the time goes. A small help centre is a quick job. A product catalogue with millions of images, or years of support tickets, is a project with its own budget and test plan, and it needs to start well before spring.
Google's retirement table leaves the replacement column blank for all four. Still, its text embeddings page says gemini-embedding-001 covers what text-embedding-005 and the multilingual model used to do, and the Gecko models retired last year pointed there too. So we'd expect most text work to end up on gemini-embedding-001, though gemini-embedding-2 takes text too. For images and video, the one multimodal model left is gemini-embedding-2. Neither behaves quite like the model it replaces, so test before you commit.
-
01 Documents were embedded once
Someone ran every document through text-embedding-005 back when the feature was built. Those vectors still sit in your index.
-
02 Each question gets embedded
Every search goes through that same model first. The app turns the question into numbers, then hunts for the stored vectors sitting nearest.
-
03 The model is retired
Once the model is retired, that call fails. Search throws an error, or worse, the bot carries on and replies without any of your documents behind it.
-
04 Someone swaps the model name
Questions now go to a newer model, but the saved vectors came from the old one. Results come back as errors or as junk.
-
05 Re-embed, then switch both sides
Run every document through the new model into a fresh index, test it, then move questions and documents over together.
For engineers: Google says outright that gemini-embedding-001 and gemini-embedding-2 vectors can't be compared, and that moving between them means re-embedding everything. RAGdefinitionShort for retrieval-augmented generation. The app pulls the most relevant passages from your documents and hands them to a chat model, which answers from them. Engine goes further and ties each corpus to one embedding modeldefinitionA model that reads a piece of content and turns it into a long list of numbers. Two things that mean the same get similar numbers, and that's what lets search work by meaning. for its whole life. Treat any model change the same way. If the new model's vectors are a different size, you'll get dimension errors. If you've trimmed them to the old size, you get no error at all, just bad results, and that's the version that slips through testing.
What's retiring, and where each one goes
The four models on the list, and the two that stay
RAG Engine picks this one unless someone chose otherwise, so it's often running where nobody expects it. It handles English and code. Plan to move it to gemini-embedding-001 before 1 April 2027.
The older English model, still behind plenty of tutorials and early prototypes. Same date. If you find it in code, it's probably been running untouched since 2024.
Anyone serving several languages is probably on this one. It goes the same day. gemini-embedding-001 covers multilingual text too, so teams running both older models can drop to one.
Image, text and video embeddings in one shared space, used for image search and catalogue matching. Retires the same day. gemini-embedding-2 is the multimodal model left.
We expect most text work to land here. It gives up to 3,072 dimensions, and Google says it won't retire before 20 May 2028, so moving now buys you at least a year of quiet.
It went GA in April 2026 and reads far more than plain text, PDFs and video among them, with inputs up to 8,192 tokens. Google's table has no retirement date for it yet.
| Model | Released | Retires | Vector size | Max input | Can you tune it? |
|---|---|---|---|---|---|
| text-embedding-005 | 18 Nov 2024 | 1 Apr 2027 | up to 768 | 2,048 tokens | Yes |
| text-embedding-004 | 14 May 2024 | 1 Apr 2027 | up to 768 | Not listed | Yes |
| text-multilingual-embedding-002 | 14 May 2024 | 1 Apr 2027 | up to 768 | 2,048 tokens | Yes |
| multimodalembedding@001 | 12 Feb 2024 | 1 Apr 2027 | 128 to 1,408 | 32 tokens of text | Not listed |
| gemini-embedding-001 | 20 May 2025 | Not before 20 May 2028 | up to 3,072 | 2,048 tokens | Not listed |
| gemini-embedding-2 | 22 Apr 2026 | No date yet | up to 3,072 | 8,192 tokens | Not listed |
The vector size is the column that causes the most work. The old text models give you 768 numbers per item and gemini-embedding-001 gives 3,072 by default. Every table column, index setting and storage estimate built around 768 has to change, unless you ask the new model for 768 using output_dimensionalitydefinitionA setting you pass to a Gemini embedding model to get shorter vectors, say 768 numbers in place of 3,072. You save storage, and Google says the quality loss is small.. If you do shrink it, normalise the vectors yourself: Google's docs say gemini-embedding-001 only normalises the full 3,072, while gemini-embedding-2 handles it for you.
Tuned models are the awkward case. Google's tuning page lists only text-embedding-004, text-embedding-005 and text-multilingual-embedding-002 as tunable, so all three tunable models are on the retirement list. If you tuned one on your own data, there's no tunable successor listed to retrain on. RAG Engine's docs do say a tuned model you deployed yourself keeps working after the publisher model is discontinued. Even so, plan to test the stock gemini-embedding-001 against your tuned model on your own queries, and keep whichever one wins.
Retirements you'll hit on the way to the embedding cutoff
- 19 Nov 2026gemini-3.6-flash retires
If your RAG app writes its answers with gemini-3.6-flash, that part breaks first. Google says to move it to gemini-3.8-flash, and you'll want that done before the embedding work starts.
- 13 Dec 2026Live audio model retires
Voice agents on gemini-live-2.5-flash-native-audio have to move to gemini-3.8-live. If nobody owns the voice bot, find someone now.
- 28 Jan 2027gemini-3.7-flash retires
Google only promised this one a short life, and it goes to gemini-3.8-flash as well. Anyone who jumped to it in August has to move again.
- 15 Mar 2027gemini-2.5-flash-image retires
Anything that generates images moves to gemini-3.1-flash-lite-image. Google has already pushed this date back once, from October 2026, but don't plan around it slipping again.
- 1 Apr 2027Four embedding models retire
text-embedding-005, text-embedding-004, text-multilingual-embedding-002 and multimodalembedding@001 stop. Searches that still embed with them fail.
- 20 May 2028Earliest end for gemini-embedding-001
Google's wording is no sooner than this date. Build so the next model change is a planned job, not another scramble.
Your options, side by side
Unless you keep a tuned model you host yourself, every path below ends in a full re-embeddefinitionRunning every stored item through a new embedding model again, because vectors from different models can't be compared., because the old models simply stop. What differs is the model you land on and how big the vectors get. Pick by what you search over and what your database can index.
| Option | When it fits | Effort | Main risk |
|---|---|---|---|
| gemini-embedding-001 at 768 dimensions | Text search or RAG where you'd rather keep table and index sizes as they are | Re-embed everything, plus normalising code | Quiet relevance changes, since the schema matches and nothing errors |
| gemini-embedding-001 at 1,536 or 3,072 | Text retrieval where quality matters more than storage | Re-embed, resize columns and indexes, re-plan storage | pgvector index limits, and bigger memory and storage bills |
| gemini-embedding-2 | Images, video, PDFs or mixed content, or long inputs up to 8,192 tokens | Re-embed, rewrite task hints into the text, change region to global, us or eu | Behaviour differences with multiple inputs, and data residency rules |
| Keep a self-deployed tuned or open model | A tuned model clearly beats the stock ones on your queries | Run and pay for your own endpoint, and own its upkeep | You're now running model serving, with no newer tunable Google model to move to |
| Another provider's embedding model | You're consolidating on another cloud or vector platform anyway | Re-embed, plus new auth, networking and contracts | Two migrations stacked on one deadline |
Price matters at scale. On Google's pricing page, Gemini Embedding costs $0.00015 per 1,000 units online against $0.000025 for the older text models, six times as much, and batch is a little cheaper for both. For a help centre that's pocket change. For a team embedding every product description and support ticket daily, run the numbers before choosing 3,072 dimensions, since bigger vectors cost more to store and search as well.
Expect quota trouble during the bulk load. Developers on Google's AI developer forum have reported 429 errors from gemini-embedding-001 through the Gemini API, one of them at about 5% of quota. In that September case the error named a Vertex AI quota, and Google staff put it down to an intermittent issue. For a big re-embed, batch jobs are the safer route. They take up to a million rows each and can sit in the queue for 72 hours, so give yourself slack.
What to do before 1 April
What to do, by who you are
- Ask your tech lead which features search by meaning, recommend things or answer from your documents, and which model each uses.
- Ask vendors whose products run on Google Cloud whether they use any of the four models, and when they'll move.
- Budget the re-embed as a small project with testing, and put 1 April 2027 on the risk register with an owner.
- Search code, config, notebooks and Terraform for text-embedding-005, text-embedding-004, text-multilingual-embedding-002, multimodalembedding and textembedding-gecko.
- List your RAG Engine corpora and check each one's embedding model. Anyone who took the defaults ended up on text-embedding-005, often without knowing it.
- Pick a model and vector size per use, and normalise gemini-embedding-001 vectors if you trim them below 3,072.
- Move task hints into the input text for gemini-embedding-2, since it ignores task_type.
- Find BigQuery remote models with ENDPOINT set to a retiring model, and every table they write vectors into.
- Check AlloyDB and Cloud SQL calls to google_ml embedding functions, plus each vector column's size and index type.
- Size storage, memory and batch jobs for the new vectors, and ask for quota headroom before the bulk load.
- Collect 50 to 200 questions people really ask, and for each one note the documents a good answer can't do without. You'll grade every model against this list.
- Agree what counts as good enough, for example the right document in the top five, before anyone compares models.
The inventory is the slow part, because embedding calls hide in places a model-name search misses. RAG Engine corpora don't name the model in your code. BigQuery remote models keep it in SQL DDL, and AlloyDB keeps it in a registered model endpoint. Ask every team that owns a Google Cloud project to run the same search, since the callers nobody wrote down usually sit outside the main repo. Then match each one to an owner.
A migration order that holds up
- 01Inventory callers and stores
List every service that calls a retiring model and every index, table or corpus holding its vectors. Give each an owner.
- 02Pick model and size per use
gemini-embedding-001 or gemini-embedding-2 for text, and gemini-embedding-2 for images and video. Decide the vector size up front, because changing it later means re-embedding again.
- 03Build a relevance test
Use real queries with known right answers. Record how the old model scores today, so you have something to beat.
- 04Re-embed into a new index
Write new vectors to a fresh index or table next to the old one. Use batch jobs for large sets and keep a key on every row so outputs map back.
- 05Test before switching
Run the relevance set on the new index. Check the question and document task types are set the right way round, then compare against the old scores.
- 06Switch both sides together
Move question and document embedding to the new model in one change, behind a flag. Until 1 April the old index is your rollback.
- 07Clean up and record
Retire the old index after the switch. Log the model, version and vector size for each index so the next retirement is a plan, not a hunt.
Make the next model change cheaper
This won't be the last time. Google already retired the Gecko embedding models, and now these four are going. Most of the pain comes from vectors nobody tagged with the model that made them, and model names copied into a dozen services. You're re-embedding anyway, so fix that now.
Before: model names everywhere, one index, no record
Each service calls the embedding model directly. Nobody can say which model made which vectors.
After: one embedding service, versioned indexes
Apps ask your own embedding service instead of calling Google directly. Each index carries its model and size in its name, and nobody switches until the relevance test passes.
Habits worth keeping after the move
- 01Store the model with the vectors
Put the model ID, version and vector size in the index name or metadata. Mixing two models in one index is the silent failure to guard against.
- 02Keep one place that picks the model
Route embedding calls through one small service or shared library, so the next change happens in one config file.
- 03Keep the source text
Re-embedding needs the original text and images. If your pipeline threw them away after embedding, fix that first.
- 04Re-run the relevance test on a schedule
Score it monthly and on every model change, so a drop shows up in a report before a user complains.
- 05Watch the retirement table
Have someone check Google's model versions page each quarter. Google promises at least 45 days' notice for shorter-lived models, which isn't much for a large re-embed.
If it goes wrong
If search breaks after the switch, or on 1 April
Before 1 April the old model and index are your rollback, so use them. After that date there's nothing to roll back to, and the plan is to fix forward fast.
- 01Spot itfirst hour
- Look for model-not-found errors from the embedding call, and for dimension mismatch errors from the vector store.
- Check what the chatbot is answering from. A RAG bot that suddenly cites nothing has usually lost its retrieval step.
- 02Stop the damagefirst hour
- If it's still before the cutoff, flip queries back to the old model and old index. Then work out what went wrong without users watching.
- Past the cutoff there's nothing to roll back to. Fall back to keyword search, or show a plain 'search unavailable' message, so the bot doesn't answer blind.
- 03Check the resultsfirst day
- Run the relevance test against the new index and spot-check live queries by hand.
- Make sure nobody mixed up the task types, so questions go in as queries and documents as documents. Then check that trimmed gemini-embedding-001 vectors got normalised, since that step is easy to skip.
- 04Fix it properlyfirst week
- Re-embed anything the batch job missed. Match outputs to inputs by key and count rows on both sides.
- If quality dropped, try a bigger vector size or the other Gemini model on the test set before reaching for tuning.
- 05Learn from itafter
- Write down which caller or index slipped through and why. Add it to the inventory so the next migration doesn't miss it too.
- Tell the people who rely on the feature what happened and what changed, in plain words.
What this could look like: three typical setups
Three typical setups facing the April deadline
- the setup
- A developer built the support bot last year with RAG Engine, accepted the defaults and imported about two thousand help articles. Nobody has touched the corpus since.
- what happens
- Nobody picked a model, so RAG Engine used its default, text-embedding-005, and that choice is fixed for the life of the corpus. Google says a retired publisher model can't serve even an older corpus. On 1 April the bot keeps talking but stops finding the help articles.
- what to do
- Check RAG Engine's supported list first, because every Google model on it today is one of the retiring ones. Google's documented ways out are a tuned model or an open model you deploy yourself, so build the new corpus on one of those, re-import the articles and test common questions before you repoint the bot.
- the setup
- A retailer ran its product photos through multimodalembedding@001 at 1,408 dimensions and keeps them in Vector Search. Shoppers search by typing or by uploading a photo, and the jobs all run in us-central1.
- what happens
- That model is gone on 1 April. The multimodal model left, gemini-embedding-2, only runs on the global, us and eu endpoints. It also merges several inputs passed directly in one request into a single vector unless each is wrapped separately, so batching code written for the old model needs checking.
- what to do
- Re-embed the catalogue with batch jobs on the us endpoint, one image per request, into a new index at a size you choose. Then test text-to-image queries before switching.
- the setup
- Analysts built a BigQuery remote model with ENDPOINT set to text-embedding-005 to embed support tickets nightly. A separate app stores 768-dimension vectors in AlloyDB with a pgvector HNSW index, and one team tuned text-embedding-005 on internal documents.
- what happens
- If someone just swaps the endpoint, BigQuery's default output jumps from 768 to 3,072 dimensions, so new rows no longer match the old ones in the same column or vector index. On the AlloyDB side, pgvector can't index a plain vector column that big. The tuned model has no tunable successor listed.
- what to do
- Set output_dimensionality on purpose, re-embed into new columns or tables, and rebuild indexes. Then test the stock gemini-embedding-001 against the tuned model on the same queries.
These three are made-up examples, so don't read them as client stories. What the models do in each one is taken from Google's documentation.
We do this work as part of our Vertex AI and Gemini Enterprise Agent Platform engagements. We find every caller and vector store, build the relevance test from your real queries, run the re-embed and switch over behind a flag. If you need engineers to do the work with your team, see who we can staff. If you'd rather start by sizing it, our assessment gives you an inventory and an order of work.
What to take from this
- 01
The four older models stop answering on 1 April 2027. Anything still calling them breaks that day, so start with the inventory.
- 02
Changing the model means re-embedding everything you've stored. Old and new vectors can't be mixed in one index.
- 03
Google's retirement table names no replacement. We expect most text work to go to gemini-embedding-001, with gemini-embedding-2 for images and video and as a second text option.
- 04
Decide the vector size on purpose. The 768 to 3,072 jump breaks tables, indexes and pgvector limits.
- 05
RAG Engine corpora on default settings need a new corpus and a fresh import. Check its supported list first, since every Google model on it today is retiring.
- 06
Build a relevance test from real queries before you compare models, and keep the old index as rollback until cutover.
01Our search runs on text-embedding-005. Is that one of the models going away?
It is. Google is retiring it along with text-embedding-004, the multilingual text model and multimodalembedding@001, and all four stop on the same day in April 2027. gemini-embedding-001 and gemini-embedding-2 aren't on the list, so those are the ones you'd move to.
02What should replace text-embedding-005?
Google's retirement table doesn't name one. Its docs describe gemini-embedding-001 as covering what text-embedding-005 and the multilingual model did, so we expect most text workloads to go there. gemini-embedding-2 takes text too, and Google's separate Gemini API already points text-embedding-004 users to it, so test both on your own queries.
03Do I have to re-embed all my documents?
Yes. Vectors from one embedding model can't be compared with another's, and Google says so for its own models. Plan to run every stored item through the new model into a new index, then switch.
04Can we keep our 768-dimension tables if we move to gemini-embedding-001?
Yes, set output_dimensionality to 768. Your column and index sizes stay the same, but you still re-embed everything, and you need to normalise the trimmed vectors yourself.
05Does this affect RAG Engine?
It does if a corpus uses one of the retiring models, and since text-embedding-005 is the default, plenty will. A corpus can't switch models, so you create a new one and import the data again. Every Google model on RAG Engine's list today is retiring, so the documented routes are a tuned model or an open model you deploy yourself.
06We tuned text-embedding-005 on our own data. What happens to that model?
Google lists only the three retiring text models as tunable. RAG Engine's docs say a tuned model you deployed keeps working after the publisher model goes. Test stock gemini-embedding-001 against it before deciding.
07Is Gemini 3.6 Flash retiring too?
Yes. It retires on 19 November 2026, and Google says to move to gemini-3.8-flash. That's a separate job from the embeddings, but if your RAG app writes its answers with it, do it first.
Three questions, about a minute
Pick an answer and we'll tell you if it's right, and why it is or isn't. The score stays in this browser.
-
Q1Your team switches the query side of a help-centre search to gemini-embedding-001 at 768 dimensions but leaves the stored vectors alone. What happens?
show the answer
C. Results come back with no error but match poorly, because the stored vectors came from another model The sizes match, so nothing complains, but vectors from two models live in different spaces. Re-embed the documents with the same model before switching.
-
Q2Your support bot was set up on RAG Engine and nobody changed the defaults. What do you do before the old model goes?
show the answer
A. Build a new corpus on a model RAG Engine still supports, then load every article back in A corpus stays on its embedding model for life, and RAG Engine's default is text-embedding-005. Google says a retired model can't serve even an older corpus, so the only way out is a new corpus and a fresh import.
-
Q3Your AlloyDB app has 768-dimension vectors under a pgvector HNSW index. Someone switches to gemini-embedding-001 without setting the size. What breaks?
show the answer
B. The vectors come back at 3,072, too big for the column and over pgvector's 2,000-dimension index limit for plain vectors gemini-embedding-001 returns 3,072 dimensions by default. Pick the size on purpose, then re-embed and rebuild the index around it.