Retrieval-Augmented Generation (RAG) does not fail on evolving documents because the language model is weak. It fails because vector similarity has no concept of time. An embedding of an API parameter description looks nearly identical whether it came from version 1.4 or version 2.0, so a retriever asked “what is the default timeout?” will happily return a semantically close passage that is factually obsolete. Two research systems published on arXiv — VersionRAG and LiveVectorLake — attack this problem from different directions and report large gains over naive retrieval, while also exposing the tradeoffs a production team must accept.
Why freshness is an architectural problem
Most RAG pipelines are built around a single assumption: the corpus is roughly static. Indexing is a batch job, the vector store is a snapshot, and updates mean deleting old vectors and re-embedding everything. That assumption breaks in three common situations:
- Continuous updates. Documentation, policies, and product catalogues change daily, so the index is perpetually behind.
- Compliance and audit. A regulator or customer asks what the system would have answered on a specific date, and the snapshot no longer exists.
- Version-sensitive questions. Users ask about behaviour that differs between releases, and the retriever must know which release the question refers to.
Prompt engineering cannot repair any of these. The information needed to answer correctly — which version, as of when — has to be present in the index and available to the retrieval step.
Two distinct failure modes
It helps to separate two problems that are often conflated.
Staleness is the simpler one: the index contains content that is no longer current. The fix is a synchronisation policy — detect what changed and update only that.
Version confusion is harder: the index contains several versions of the same passage, all semantically similar, and the retriever has no basis for choosing among them. The fix is structural — the index must encode version relationships and the query must be routed or filtered by them.
VersionRAG, from researchers at the Zurich University of Applied Sciences, frames this as a distinct task. Its authors report that existing approaches reach only 58–64% accuracy on version-sensitive questions, retrieving semantically similar content without temporal validity checks. Their framework explicitly models document evolution through a hierarchical graph capturing version sequences, content boundaries, and the changes between document states, and routes queries through specialised paths based on intent classification. On their VersionQA benchmark — 100 manually curated questions across 34 versioned technical documents — VersionRAG reports 90% accuracy, against 58% for naive RAG and 64% for GraphRAG (arXiv:2510.08109v1).
That gap is the clearest available evidence that version structure, not embedding quality, is the limiting factor on this class of question.
Strategy 1: detect change at the chunk level
The cheapest freshness win is to stop re-indexing whole documents. LiveVectorLake introduces content-addressable chunk-level synchronisation using SHA-256 hashing, which makes change detection deterministic without maintaining external state: hash each chunk, compare against the stored hash, and re-embed only the chunks whose hash changed.
The reported effect is substantial. On a 100-document corpus versioned across five time points, the authors measure 10–15% re-processing of content during updates, compared with 100% for full re-indexing (arXiv:2601.05270). The saving is not just cost; it also shortens the window during which the index is inconsistent with the source.
The practical requirement is that chunking must be stable. If your splitter produces different boundaries on each run — because it depends on document length, random seeds, or a moving token budget — hashes will differ for unchanged text and the optimisation collapses. Pin the chunker, pin the embedding model, and version both alongside the index.
Strategy 2: separate the hot query tier from the cold version tier
LiveVectorLake’s central architectural claim is that query latency and version history are best optimised independently. The system uses a dual-tier design: a hot tier of vector indices (Milvus with HNSW) holding only current chunks, and a cold tier of columnar versioning (Delta Lake with Parquet) holding the full history. Temporal query routing then reconstructs point-in-time knowledge from delta versions, with ACID consistency across the two tiers.
The reported latencies are sub-100ms for retrieval on current knowledge and sub-2s for temporal queries across version history. The authors also frame the tiering as a storage-cost optimisation, since only current chunks occupy the comparatively expensive vector index.
This is a design pattern rather than a product. You can approximate it with any vector store for the hot tier and any append-only, time-stamped store — object storage with Parquet files, a relational table, or a log-structured store — for the cold tier. What matters is that the cold tier is authoritative for history and the hot tier is disposable and rebuildable.
Strategy 3: model version relationships explicitly
Where LiveVectorLake optimises storage and latency, VersionRAG optimises retrieval reasoning. Its hierarchical graph stores version sequences and change boundaries, so the retriever can filter by version before ranking by similarity. The authors also report 60% accuracy on implicit change detection — cases where a document was modified without an explicit changelog — where they state baselines score 0–10%.
They further report that VersionRAG requires 97% fewer tokens during indexing than GraphRAG, which matters if your graph construction is LLM-driven and therefore billed per token.
The tradeoff is construction complexity. A version graph requires either reliable version metadata from the source system or an extraction step that infers changes. Technical documentation with clear release tags is a good fit; a shared drive full of files named final_v3_edited.docx is not.
What the reported numbers do and do not show
Both systems report results on modest, purpose-built evaluations: 100 documents across five time points for LiveVectorLake, and 100 curated questions across 34 documents for VersionRAG. These are useful signals, not universal benchmarks. Neither source reports results on a large multi-tenant corpus, and neither reports long-run operational behaviour such as index compaction cost or cold-tier growth over years. Treat the accuracy and latency figures as evidence that the approach works in principle, and validate them against your own corpus before committing to a migration.
An illustrative pipeline
The following is a proposed design, not a deployed or measured system. It combines the three strategies above and is meant as a starting sketch.
- Ingest with stable chunking. Split each document with a pinned, deterministic splitter. Store the chunk text, its SHA-256 hash, the source document ID, the version identifier, and a validity timestamp.
- Diff before embedding. Compare incoming hashes against the current hot-tier set. Embed only new or changed chunks; mark removed chunks as superseded rather than deleting them.
- Write history to the cold tier. Append every chunk version with its validity interval to a columnar or relational store. This is the audit trail and the source for point-in-time reconstruction.
- Tag queries with intent. Classify each incoming query as current-state, version-specific, or change-tracking. Route current-state queries to the hot index; route the others through a version filter or a version graph.
- Verify with a regression set. Maintain a small set of questions whose correct answers differ between versions. If the pipeline cannot answer them correctly, the version metadata is not reaching retrieval.
WordPress and local-first considerations
Teams running WordPress as a content source have a versioning substrate already: WordPress stores each saved revision as a separate row in the posts table with post_type set to revision, linked to the parent post and carrying its own date. The wp_get_post_revisions() function and the REST API expose these revisions, which makes them a usable cold tier for point-in-time retrieval without building a separate history store.
The caveat is that revisions are pruned by default and are not a compliance-grade archive. If auditability is a requirement, export revisions to durable storage rather than relying on the database.
For local deployments, the economics of re-indexing differ from API-billed pipelines. When embeddings run on your own hardware, a full re-index costs wall-clock time and electricity rather than per-token spend, which can make aggressive re-indexing acceptable and chunk-level diffing less urgent. The exception is large corpora, where embedding time becomes the bottleneck and the 10–15% re-processing figure reported by LiveVectorLake becomes the difference between a nightly job and a continuous one.
Tradeoffs and open questions
Versioning adds storage, complexity, and a new class of bug: stale version metadata is harder to notice than a stale document, because the system will confidently return a well-formed answer from the wrong release. A few practical constraints are worth stating plainly.
- Deletion semantics. Neither source’s approach removes history. If your obligations include the right to erasure, you need a separate purge path that reaches both tiers.
- Cold-tier growth. Full history grows without bound. Retention windows and compaction policies must be designed, not assumed.
- Chunker stability. Any change to the splitter invalidates all hashes and forces a full re-embed. Version the splitter configuration.
- Evaluation cost. Version-sensitive benchmarks must be curated by hand; the VersionQA set of 100 questions across 34 documents illustrates the scale of effort involved.
What to do next
Start with the cheapest change: add stable chunk hashes and version identifiers to your existing index, and measure how much of a typical update actually needs re-embedding. If that number is small, you have already recovered most of the freshness benefit. Add a version filter to retrieval only when you can demonstrate, with a small hand-built question set, that version confusion is causing real errors. Reserve the full dual-tier or graph architecture for corpora where auditability or version-sensitive questions are a genuine requirement rather than a hypothetical one.
If you are running this against a WordPress site, a local embedding stack, or both, the community is a good place to compare chunking configurations, hash-stability problems, and revision-export approaches. Share your corpus shape, your chunker settings, and what your update diff actually measured.
FAQ
Does a standard RAG pipeline automatically retrieve the newest version of a document?
No. Vector similarity ranks by semantic closeness, not by date or version. If several versions of a passage are indexed, the retriever has no inherent basis for preferring the current one unless you add version metadata and filter on it.
How often should a RAG index be refreshed?
It depends on how fast the corpus changes and how much staleness the use case tolerates. Chunk-level hashing makes frequent updates cheaper, since only changed chunks are re-embedded — LiveVectorLake reports 10–15% re-processing versus 100% for full re-indexing.
Can RAG support compliance-grade point-in-time retrieval?
LiveVectorLake demonstrates the pattern: keep current chunks in a fast vector tier and full history in a columnar version store, then reconstruct past states via delta versioning with ACID consistency across tiers. Its temporal query latency is reported as sub-2s.
Can versioning help when documents change without a changelog?
VersionRAG reports 60% accuracy on implicit change detection, where the authors state baselines score 0–10%. This requires a version graph that captures content boundaries, not just release tags.