Re-embedding and model deprecation
What forces a full re-index, what a deprecation notice actually commits a vendor to, and how to plan around both.
Two things force a model change on you whether or not you wanted one. A better embedding model appears and the retrieval quality you could have is now visibly above the retrieval quality you have; or a generation model you already depend on gets a retirement date and the clock starts. Neither is a swap. The first is a consistency problem, because a corpus half converted to a new embedding model is not partly upgraded — it is broken, silently, for every query, until the last chunk lands. The second is a scheduling problem, because the date was published months in advance and the only way to be surprised by it is for nobody to own it.
These pages treat both as engineering work with a defined end state rather than as maintenance. They cover what invalidates a vector and what does not, how to derive the cost and the duration of a backfill from your own corpus and rate limits instead of guessing, how to keep a rollback available while the new index fills, what a deprecation notice commits a provider to and what it conspicuously omits, and how to run two providers side by side without letting the dual run become the permanent architecture.
Why You Have to Re-Embed When You Change Embedding Models
Two embedding models put the same text in different places, so a corpus half converted to a new model returns confident nonsense with no error anywhere.
9 min read
What Happens to Your Index When Embedding Dimensions Do Not Match
The insert error that stops a model swap on its first row, the two fixes that actually work, and why zero-padding silences it without solving anything.
9 min read
Estimating the Cost of Re-Embedding Everything Downstream
An arithmetic you can run against your own corpus, covering the derived artefacts a re-embed invalidates and the rate limit that decides how long it takes.
10 min read
A Rollback Plan for a Failed Re-Embedding Migration
Keep the old index live and dual-write to it during the backfill, so reverting a bad new embedding model is a config change rather than a second migration.
10 min read
Model Deprecation Notices: What They Actually Tell You
What a deprecation announcement commits a provider to, what the lifecycle words mean, and the five things the notice leaves for you to work out.
9 min read
A Version-Pinning Strategy for Production LLM Calls
Pin a dated snapshot in production and put the floating alias in staging, where you want to be broken early.
9 min read
Building a Model Deprecation Calendar for Your Stack
Join the model strings you actually call to the retirement dates your providers publish, in a checked-in file that fails CI when it goes stale.
10 min read
Dual-Running Two Providers During a Cutover
Shadow the new provider first to catch structural failures, then split live traffic by a stable key, with the tool-execution trap handled before either.
10 min read
Comparing Outputs From Two Providers During a Migration
A three-layer harness: deterministic structural checks, embedding similarity used only for ranking, and a judge model spent only on what the first two flagged.
10 min read
When to Stop Dual-Running and Cut Over Fully
Replace a duration with an exit condition, derived from the sample size your own error rates require rather than from how long feels prudent.
10 min read
Other topics
- LLM fundamentals & architecture
- Tokens, tokenization & context windows
- Prompt engineering
- Reasoning models & test-time compute
- Multimodal AI: vision, audio, video
- RAG & retrieval
- Embeddings & vector search
- AI agents & tool use
- Structured output & function calling
- Fine-tuning & post-training
- Local inference errors, string by string
- Running local models day to day
- Testing code that calls an LLM
- Snapshot and property testing for model output
- Regression suites for prompts
- Eval gates in CI
- Flaky tests against a model
- Determinism and the cost of testing
- Contract and streaming tests
- Testing tool calls and retrieval
- Inference, serving & latency
- Rolling out a prompt change
- Testing AI systems in practice
- Forecasting a time series
- Machine learning on tabular data
- Geospatial data and models
- Understanding audio that is not speech
- Understanding video
- Core computer vision tasks
- Machine learning on graphs
- Point clouds and 3D
- Evaluation, benchmarks & LLM-as-judge
- Sensor and IoT data
- Logs and event streams
- Models over biological sequences
- Machine learning on molecules
- Embedding and searching code
- Extracting invoices and purchase orders
- Receipts, statements and tax forms
- Insurance policies and contracts
- Deeds, court filings and patents
- Extracting from medical records
- Observability & LLMOps
- CVs, certificates and identity documents
- Shipping, customs and technical documents
- Meetings, email, chat and filled-in forms
- Building an extraction pipeline
- Business, property and inspection documents
- Contract clauses and insurance claims
- Regulated and compliance documents
- Consumer, travel and closing documents
- Mapping one chat API onto another
- SDK and framework migrations
- Hallucination & failure modes
- Cutting over between providers
- Parity gaps, shims and legacy endpoints
- Moving between model versions
- Migrating vector stores and caches
- Mapping capabilities and parameters
- Migrating pipelines and agents
- Contracts, runbooks and rollback
- Auditing a codebase before a cutover
- Compliance and fine-tune migration
- LLM cost engineering
- Routing, cost tracking and multi-tenancy
- What a migration does to your prompts
- AI security & prompt injection
- Privacy, compliance & data residency
- AI governance, policy & society
- Building reliable AI applications
- AI hardware, GPUs & compute
- Open-weight models & local inference
- AI for developers & coding agents
- AI in industry: vertical playbooks
- AGI, superintelligence, alignment & the long future
- Machine learning foundations
- NLP fundamentals & classical tasks
- Data engineering for AI
- Synthetic data & dataset curation
- AI product design & UX
- Search, ranking & recommendation
- Enterprise adoption & change management
- AI careers, skills & teams
- Reading AI research
- AI in science & discovery
- Robotics & embodied AI
- AI economics, markets & business models
- AI myths, hype & media literacy
- Context engineering
- Shipping AI features: patterns & anti-patterns
- Build it: end-to-end AI tutorials
- Python for AI: hands-on recipes
- TypeScript, React and the web
- Frameworks and SDKs
- Errors and troubleshooting
- AI facts, numbers and statistics
- The history of AI
- The maths behind AI
- Architectures beyond the transformer
- Reinforcement learning
- Diffusion and generative media
- Speech, audio and voice engineering
- Benchmarks, one at a time
- AI search visibility
- Infrastructure and operations
- Databases and storage for AI
- Knowledge graphs and structured knowledge
- Classical ML in production
- Regulation, jurisdiction by jurisdiction
- Prompt recipes and pattern library
- AI for people who do not write code
- Writing, media and creative work
- Edge and on-device AI
- Interpretability and model internals
- Field notes
- OpenAI model behaviour
- Claude model behaviour
- Gemini model behaviour
- Llama model behaviour
- Mistral model behaviour
- Qwen model behaviour
- DeepSeek model behaviour
- Cohere model behaviour
- Grok model behaviour
- Small model behaviour
- Hybrid model architectures
- Token cost by language and script
- Transliteration, romanization and script handling
- Locale-correct output
- Multilingual generation quality
- Multilingual pipelines
- The EU AI Act, article by article
- AI under the GDPR and EU data law
- US AI regulation, state and sector
- International AI governance and standards
- AI litigation and enforcement
- Running AI workloads on AWS
- Running AI workloads on Google Cloud
- Running AI workloads on Azure
- AI at the edge: Workers, Vercel and Netlify
- Serving models on Kubernetes
- Operating AI infrastructure
- Quantization formats and what they cost
- llama.cpp, flag by flag
- Ollama and the desktop local-model runtimes
- Local models on Apple Silicon
- Hardware for local inference
- Running speech and embedding models locally
- Model files, adapters and conversion
- VRAM arithmetic for local models