Why do semantic similarity and task relevance diverge in vector search results?
This explores why the passages an embedding model scores as 'closest' to a query are often not the ones that actually answer it — and what the corpus says is going wrong underneath.
This explores why the passages an embedding model scores as 'closest' to a query are often not the ones that actually answer it. The corpus has a clear root cause: vector embeddings encode *co-occurrence and topical association*, not the role a passage plays in a task. Words that show up in similar contexts land near each other in the vector space, so a query and a 'wrong-but-associated' candidate can look nearly identical to the math while being useless to the user Do vector embeddings actually measure task relevance?. This is why the trick works in clean demos and collapses in production, where underspecified queries are surrounded by many semantically-close decoys.
The sharpest illustration is causal divergence. When a student asks about 'projection' after a specific lecture statement, the *closest* passage is the one that talks most about projection matrices — but the passage that actually *caused* the question is somewhere else entirely. Finding what prompted a query is a different operation from finding what resembles it, and the two pull apart most in conversational and lecture settings Why do queries and their causes seem semantically different?. Relevance, in other words, is sometimes about *why this question exists*, which surface similarity is blind to.
There's a deeper, almost mechanical reason this keeps happening: the models lean on statistical mass rather than meaning. LLMs systematically prefer higher-frequency phrasings of the same idea across math, translation, and reasoning — they track what was common in pretraining, not what's equivalent in meaning Do language models really understand meaning or just surface frequency?. Embeddings inherit the same bias, so a frequent-but-irrelevant phrasing can outrank a rare-but-exact one. The divergence isn't a bug to tune away; it's baked into how the representation is built.
The corpus frames this as architectural, not incremental. RAG fails at structural seams — when to retrieve, the semantic-vs-task mismatch itself, and hard mathematical limits on what a fixed embedding dimension can even represent Where do retrieval systems fail and why?. So the fixes are not 'better similarity' but *different operations*: route the query to the knowledge structure its task actually demands instead of retrieving uniformly Can routing queries to task-matched structures improve RAG reasoning?, or add a second verification stage that judges full token-to-token interaction patterns and rejects the 'structural near-misses' that pooled-vector similarity waves through Can verification separate structural near-misses from topical matches?.
The thing you might not expect: sometimes the cure is to *leave the vector space entirely*. Describing an image in natural language and then retrieving against text descriptions bridges a gap that direct embedding similarity can't Can describing images in text improve zero-shot recognition?. The lesson running through all of these is the same — semantic closeness is a proxy, and the moment a task asks 'which one is *correct*' rather than 'which one is *similar*,' the proxy starts lying, and you need a separate signal to catch it.
Sources 7 notes
Embeddings encode co-occurrence patterns, making semantically close but role-distinct concepts highly similar. This works in simple demos but fails in production where underspecified queries have many wrong-but-associated candidates.
Backtracing—finding what caused a query—diverges from semantic similarity especially in conversation and lecture domains. Students ask about projection after hearing a specific statement, but the semantically closest passage discusses projection matrices instead, showing that surface similarity misses the actual cause.
LLMs show consistent preference for higher-frequency surface forms over semantically equivalent rare paraphrases across math, machine translation, commonsense reasoning, and tool calling. This suggests models track statistical mass from pretraining rather than meaning-recognition as their primary mechanism.
RAG systems fail at three structural levels: adaptive triggering (fixed intervals waste context), semantic-task mismatch (embeddings measure association, not relevance), and mathematical limits (embedding dimension constrains representable document sets). These require fundamentally different retrieval approaches, not tuning.
StructRAG demonstrates that selecting knowledge structure type based on query demands—via DPO-trained router choosing among tables, graphs, algorithms, catalogues, and chunks—improves knowledge-intensive reasoning over standard retrieval. The approach grounds this in cognitive load and cognitive fit theory from cognitive science.
A two-stage pipeline—pooled-cosine recall followed by a small Transformer verifier operating on token-token similarity maps—reliably rejects structural near-misses that MaxSim-style late interaction cannot. The verifier succeeds because it operates on full token interaction patterns rather than compressed vectors.
SignRAG demonstrates that describing an unknown image via vision-language model, then retrieving known designs from a text-indexed database, eliminates the need for recognition model training. Natural-language description bridges the visual-reference gap better than direct embedding similarity.