谷歌与Anthropic在检索架构上达成共识：独立服务化

Google and Anthropic agree on one thing about retrieval.

They both moved it out of the app and turned it into a standalone service that agents invoke.

• Anthropic's MCP exposes retrieval as a tool that an agent invokes. - Google ships it similarly, with its RAG Engine sitting under the Gemini agent platform next to MCP servers.

They did this because the old naive RAG setup was built as a one-time pipeline inside a single app, and it caused problems in two places:

• The first is stale embeddings. They reflect the source at indexing time, so the index drifts from the source when a doc or a row changes, and stays wrong until the pipeline is rerun.
• The second is coupled infrastructure. The retrieval logic sits inside one app, so another app duplicates the connectors, chunking, and embedding instead of reusing them.

Both failure modes are resolved by separating ingestion from query and running ingestion as a standing layer.

Ingestion runs continuously with content-hash sync, so only changed data is re-embedded, and the layer sits behind one API, so a chatbot and an agent hit the same index.

The agent then calls that layer as a tool inside a loop. It reasons, runs a search, reads the result, and issues a refined query, instead of retrieving once at the start.

The diagram below depicts all three stages, covering naive RAG, the standing layer, and the agent consuming it.

This helps, but it didn't solve all problems yet because across all three stages, the unit of retrieval is the same, i.e., a chunk of text.

And inherently, a chunk has no idea of a semantic boundary, version, or source info. The splitter cuts documents mostly on token count, so a single chunk can end mid-table or mid-argument.

Because of that, it can pull the top half of a table without the rows, or a conclusion without the reasoning that supports it.

Moving to a structured unit, embedding a question with its validated answer, addresses this.

My co-founder wrote a full breakdown on solving this. It replaces raw chunks with structured blocks that carry their own source and version.

The approach reduces corpus size 40x and improves vector relevance 2.3x.

Read it below.