Migrating vector stores and caches
Moving vectors, metadata filters and embedding caches without silently degrading retrieval.
A retrieval stack has an unusual failure mode: it almost never stops working. Move an index to a different database and the queries still return ten rows. Swap the embedding model and the queries still return ten rows. Re-embed half a corpus and the queries still return ten rows. Nothing throws, nothing pages, and the only signal that anything is wrong arrives weeks later as a complaint that the answers have got vaguer.
These pages are about the checks that turn that silence into a signal — what a filter expression loses when it is translated, why an embedding cache keyed on text alone becomes a source of corruption the moment the model changes, and what a completeness audit has to compare before it can honestly say a re-embedding job finished. The migration steps are the easy half and are here too, but the checks are the part worth reading.
Migrating a RAG Pipeline From One Vector Database Client to Another
Rewriting a working pipeline's insert and query calls for a different vector database, including the parts of the query that have no counterpart.
10 min read
Why Metadata Filter Syntax Doesn't Transfer Between Vector Databases
The same filter intent written in five filter languages, and the four intents that cannot be expressed in all of them.
10 min read
Exporting Vectors and Metadata From One Vector Database to Another
The bulk export and re-insert pattern for moving stored vectors and their metadata without paying to recompute any embeddings.
10 min read
Migrating an Embedding Cache When You Change Models
Why a cache keyed on text alone serves vectors from the old model's space after a swap, how to confirm it, and what to do without discarding the cache.
9 min read
Keying an Embedding Cache So a Model Migration Can't Poison It
A cache key scheme built from every input that changes the vector, ordered so old and new model entries can coexist and be swept separately.
10 min read
What Changes in Semantic Search Quality After a Migration
Diagnosing a retrieval regression after an embedding change by comparing a fixed query set before and after, and separating a model effect from an incomplete re-index.
10 min read
Auditing Whether a Re-Embedding Migration Actually Finished
A completeness check that compares identifier sets, model tags and freshness rather than row counts, so a job that stopped partway cannot pass.
11 min read
Handling API Key Rotation During a Provider Migration
Sequencing a new provider's credentials alongside the old ones so there is no window where a running request has no valid key.
9 min read
Secrets Management When Running Two Providers at Once
Storing and selecting between several providers' credentials by environment, tenant and traffic share, without a request ever getting one provider's route and another's key.
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
- Re-embedding and model deprecation
- Cutting over between providers
- Parity gaps, shims and legacy endpoints
- Moving between model versions
- 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