"I spent 4 months building something the entire ML community said was already solved. Turns out, it wasn't."
I need to tell you something uncomfortable about every RAG system running in production today.
They're all broken in the same way. And almost nobody is talking about it.
I'm not saying they don't work. They do — most of the time. But there are two silent failure modes that cause them to hallucinate even when they retrieve the correct document. After months of banging my head against this problem, I built VORTEXRAG to fix both of them. This is that story.
The Day I Realized Something Was Deeply Wrong
I was building a financial Q&A system. Simple enough — index a corpus of SEC filings, answer questions about why companies performed the way they did.
The query: "Why did Company X's revenue drop in Q3?"
My RAG pipeline retrieved the right document. I could see it in the logs — the actual earnings call transcript where the CEO explained the supply chain disruption. Cosine similarity: 0.91. Perfect.
But the LLM's answer was completely wrong. It talked about macroeconomic conditions, interest rate sensitivity, sector-wide headwinds. All factually true things — about the industry. None of them the actual cause.
I dug into the context window. The correct chunk was there. But it was surrounded by 7 other chunks:
- The company's 10-K risk factors (similarity: 0.87)
- An analyst report on sector performance (similarity: 0.84)
- Fed reserve commentary on the quarter (similarity: 0.82)
- Three more topically-related but causally-irrelevant passages
The LLM saw all of them. It averaged them. It hallucinated a narrative that sounded exactly right but was factually wrong about this specific company.
I had discovered Context Window Poisoning — and I'd been unknowingly fighting it for months.
The Two Problems Nobody Fully Solves
After that moment, I went deep. I read every RAG paper published in the last 3 years. Self-RAG, CRAG, RAG-Fusion, FiD, REALM, Atlas, Toolformer — all of them. Great papers. Smart people. Significant advances.
But none of them fully addressed what I was seeing. Here's why:
Problem 1: Semantic Drift 🎯
Every RAG system today retrieves by cosine similarity. This works great for finding topically related content. But it fundamentally cannot distinguish between:
- A chunk that caused something
- A chunk that is merely associated with it
Ask "Why did Lehman Brothers collapse?"
Standard RAG returns:
| Chunk | Similarity | Causal? |
|-------|-----------|---------|
| Dodd-Frank Act provisions | 0.87 | ❌ Response to collapse |
| CDS mispricing mechanism | 0.91 | ✅ Actual cause |
| Systemic risk reports | 0.85 | ❌ Consequences |
| Bear Stearns comparison | 0.83 | ❌ Parallel event |
The LLM gets all four. It produces a response about regulatory failure and systemic risk. It never mentions CDSs. The answer is 100% hallucination — constructed from real documents, assembled into a false causal chain.
This is Semantic Drift: the retrieved context drifts from causal relevance toward topical association.
Problem 2: Context Window Poisoning ☠️
Even when you retrieve the right chunk, if 7 wrong chunks surround it, the LLM's attention gets diluted. This isn't speculation — it's backed by the "Lost in the Middle" paper (Liu et al., 2023): LLMs have a U-shaped recall curve. They remember the beginning and end of context best, and systematically lose information in the middle.
So even if your correct chunk is in the context window, if it lands at position 4 of 8 chunks, the LLM may functionally ignore it.
This is Context Window Poisoning: the noise-to-signal ratio in the context window destroys the LLM's ability to use the correct information.
Building VORTEXRAG: 4 Months, 7 Layers, One Obsession
I started with a simple question: What would it take to fix both problems simultaneously?
The answer turned out to be a 7-layer pipeline. Each layer solves a specific failure mode. Let me walk you through each one — not just what it does, but why I built it.
Layer 1: TVE — Tri-Vector Encoding 🔺
The insight: If similarity retrieval can't capture causality, we need to encode causality directly.
Standard RAG embeds text into a single semantic vector (usually 768 dimensions). VORTEXRAG encodes every chunk into a 864-dimensional tri-vector:
TVE score = α·cos_sem + β·cos_syn + γ·cos_cau
Where:
sem = 768d SBERT all-mpnet-base-v2 (semantic meaning)
syn = 64d spaCy dependency parse (syntactic structure)
cau = 32d PropBank SRL events (causal relationships)
The causal arm (32 dimensions) encodes the PropBank-style semantic role labels: ARG0 (agent), ARG1 (patient), ARGM-CAU (cause), ARGM-EFF (effect). A chunk about "CDSs caused Lehman's collapse" has a very different causal vector than a chunk about "Dodd-Frank responded to the collapse" — even if they have identical semantic similarity to the query.
This is the foundation everything else builds on.
Layer 2: VRC — Vortex Retrieval Cone 🌀
The insight: Retrieval isn't a list — it's a geometry.
Traditional top-k retrieval treats candidates as a ranked list. VORTEXRAG models retrieval as a spiral probability surface in causal vector space:
spiral_rank = TVE · e^(−λr) · cos(nθ)
Where:
θ = angle between query's causal vector and chunk's causal vector
r = rank position in initial retrieval
λ = 0.5 (radial decay, adaptive with corpus size)
n = 2 (angular frequency)
The key term is cos(nθ). Chunks whose causal direction is more than π/4 (45°) from the query's causal direction get geometrically suppressed — their spiral rank drops toward zero regardless of semantic similarity. The "vortex" shape comes from combining the radial decay with the angular suppression: retrieved chunks form a cone, not a list.
Layer 3: SDC — Semantic Drift Corrector 🛡️
The insight: Measure the drift explicitly. Filter on it.
For each candidate chunk, SDC computes a Semantic Drift Score:
D = v_cau(query) − v_cau(chunk) ← causal drift vector
SDS = 1 − tanh(‖D‖ / τ) ← drift score ∈ [0, 1]
Accept chunk if SDS ≥ 0.72
The higher the ‖D‖, the more the chunk's causal structure has drifted from the query's. τ controls the sensitivity — and this is where the 11 domain presets come in:
| Domain | τ | Why |
|---|---|---|
| Scientific | 0.30 | Strict: cause-effect chains must be tight |
| Medical | 0.35 | Strict: diagnosis → treatment causality |
| Legal | 0.40 | Strict: precedent → ruling chains |
| Financial | 0.50 | Moderate: multi-factor causation |
| General | 0.80 | Default: relaxed filtering |
| Creative | 1.20 | Lenient: loose associations acceptable |
Layer 4: CPG — Context Poison Guard ⚗️
The insight: The entire window must be healthy, not just individual chunks.
Even if each chunk individually passes SDC, the combination of chunks can still poison the context. CPG measures the Effective Signal Ratio of the entire window:
ESR = Σ(SDS_i · w_i) / (P + ε)
Where:
P = 1/k normalization penalty (penalizes large windows)
ε = smoothing constant
If ESR < 3.5, CPG runs a greedy purge: remove the chunk with the lowest SDS score. Recompute ESR. Repeat until ESR ≥ 3.5.
Theorem 5.1 (proved in the paper): Removing the minimum-SDS chunk maximizes ESR improvement per step. The greedy algorithm is provably optimal — no other single-step removal produces a better ESR increase.
This theorem is what separates CPG from heuristic approaches. It's not "try to remove bad chunks." It's a mathematical guarantee that the greedy approach is the best possible approach.
Layer 5: RFG — Rank Fusion Gate 🔀
The insight: Additive fusion lets weak links through. Multiplication doesn't.
Most multi-signal retrieval systems use additive fusion:
score = w1·signal1 + w2·signal2 + w3·signal3
The problem: a chunk with (0.9, 0.9, 0.1) scores the same as one with (0.63, 0.63, 0.63). But the first chunk is clearly wrong — one signal is terrible.
VORTEXRAG uses multiplicative fusion:
Φ = TVE^α × SDS^β × ESR_contrib^γ
Now (0.9 × 0.9 × 0.1)^(1/3) = 0.45 vs (0.63 × 0.63 × 0.63)^(1/3) = 0.63. The chunk with one bad signal scores lower, as it should. No weak link can be compensated by strong links in other dimensions.
Layer 6: CCB — Causal Context Builder 🏗️
The insight: Where you put information in the context window matters enormously.
From "Lost in the Middle": LLMs recall information best at position 0 and near the end of context. The middle is a graveyard for information.
CCB builds a causal dependency graph and assigns positions:
pos = rank(Φ+) × causal_depth
depth-0 root-cause chunks → always placed at pos = 0
The chunk that is the causal root — the one that explains why — always goes first. Supporting evidence follows in causal order. The LLM gets the most important information exactly where it's best at attending to it.
Layer 7: FV — Faithfulness Verifier ✅
The insight: Don't trust the LLM. Measure it.
After generation, FV computes:
ΔR = 1 − ROUGE-L(answer, context) × NLI_score(answer, context)
Accept if ΔR ≤ 0.15
If ΔR > 0.15 (more than 15% of the answer isn't grounded in the context), FV rejects the response, reranks the context, and retries — up to 3 times. Uses DeBERTa-v3-small CrossEncoder for NLI.
This is the final catch. Even if all 6 previous layers work perfectly, the LLM can still hallucinate. FV makes hallucination measurable and catchable.
The Results — After 229 Tests and 6 Benchmarks
I tested VORTEXRAG on the standard QA benchmark suite: NQ, TriviaQA, WebQ, PopQA, HotpotQA, and 2WikiMultiHopQA.
Overall Performance
| System | EM | F1 | Faithfulness | Semantic Drift | Context Poisoning | Latency |
|---|---|---|---|---|---|---|
| VORTEXRAG | 74.8 | 82.6 | 0.94 | 14% | 7% | 185ms |
| Self-RAG | 68.4 | 77.1 | 0.81 | 28% | 19% | 410ms |
| CRAG | 66.9 | 75.8 | 0.79 | 31% | 22% | 320ms |
| RAG-Fusion | 62.8 | 71.9 | 0.73 | 33% | 21% | 280ms |
| Naive RAG | 61.2 | 69.4 | 0.71 | 36% | 24% | 95ms |
+13.6 EM over Naive RAG. +6.4 EM over Self-RAG. 2.2× faster than Self-RAG.
Per-Dataset Breakdown
| Dataset | VORTEXRAG | Self-RAG | Δ | Why VORTEXRAG wins here |
|---|---|---|---|---|
| NQ | 74.1 | 67.2 | +6.9 | Single-hop causal queries |
| TriviaQA | 81.3 | 77.8 | +3.5 | Fact retrieval, less causal |
| WebQ | 68.4 | 61.9 | +6.5 | Entity-centric causal chains |
| PopQA | 71.2 | 63.4 | +7.8 | Long-tail causal knowledge |
| HotpotQA | 67.9 | 61.1 | +6.8 | Multi-hop: biggest gains |
| 2WikiMH | 69.8 | 62.3 | +7.5 | Multi-hop: biggest gains |
The biggest gains are on multi-hop datasets — exactly where causal reasoning matters most. This is the validation I was hoping for.
Ablation: Every Layer Earns Its Place
One of my proudest moments was running the ablation study. I was terrified some layers would show no contribution. They all did.
| Configuration | EM | F1 | Faithfulness | +EM |
|---|---|---|---|---|
| A: Naive RAG baseline | 61.2 | 69.4 | 0.71 | — |
| B: +TVE | 65.3 | 72.8 | 0.74 | +4.1 |
| C: +VRC | 67.8 | 75.1 | 0.76 | +2.5 |
| D: +SDC | 70.4 | 78.3 | 0.80 | +2.6 |
| E: +CPG | 72.1 | 80.2 | 0.85 | +1.7 |
| F: +RFG | 73.4 | 81.4 | 0.89 | +1.3 |
| G: +CCB | 73.9 | 81.9 | 0.91 | +0.5 |
| H: +FV (full VORTEXRAG) | 74.8 | 82.6 | 0.94 | +0.9 |
Every single layer contributes. There's no dead weight.
Human Evaluation — The Number That Matters Most
Automatic metrics only go so far. I had 3 domain experts (an NLP researcher, a practicing lawyer, and a biomedical scientist) evaluate 150 responses each on 4 dimensions using 5-point Likert scales.
| Dimension | VORTEXRAG | Self-RAG | Naive RAG |
|---|---|---|---|
| Factual Accuracy | 4.5/5 | 3.9/5 | 3.2/5 |
| Causal Coherence | 4.3/5 | 3.4/5 | 2.8/5 |
| Completeness | 4.2/5 | 3.8/5 | 3.5/5 |
| Conciseness | 4.1/5 | 4.2/5 | 4.0/5 |
The +0.9 on Causal Coherence vs Self-RAG is the one I'm most proud of. It means real humans, in real domains, found the causal reasoning in VORTEXRAG's answers to be significantly better. No automatic metric fully captures this.
Try It Right Now
5-Minute Quickstart
git clone https://github.com/vignesh2027/VORTEXRAG
cd VORTEXRAG
pip install -r requirements.txt
python examples/basic_usage.py
Your First Causal Query
from vortexrag import VortexRAG
# Pick your domain — parameters auto-calibrate
rag = VortexRAG(domain="medical")
result = rag.query(
query="Why do SSRIs take 2-4 weeks to work?",
chunks=my_medical_chunks
)
print(result.answer) # Causally grounded answer
print(result.sds_score) # Drift score: should be >= 0.72
print(result.faithfulness) # Hallucination delta: <= 0.15
print(result.layer_trace) # Full 7-layer trace for debugging
Layer-by-Layer Trace (What You Actually See)
Layer 1 [TVE]: Encoded 847 chunks as 864-dim tri-vectors (8.2ms)
Layer 2 [VRC]: Spiral-ranked top-50 candidates (2.1ms)
Angular suppression: 12 chunks suppressed (θ > π/4)
Layer 3 [SDC]: Drift filtering with τ=0.35 (medical preset)
Accepted: 31/50 chunks (SDS range: 0.72-0.97)
Layer 4 [CPG]: Initial ESR: 2.84 (below threshold 3.5)
Purging: removed 4 low-signal chunks
Final ESR: 4.12 ✓
Layer 5 [RFG]: Multiplicative Φ-scores computed (1.8ms)
Top-5 selected: Φ ∈ [0.71, 0.89]
Layer 6 [CCB]: Causal graph built (3 root-cause chunks at pos=0)
Context ordered by causal depth
Layer 7 [FV]: Generated answer, ΔR = 0.09 ✓ (< 0.15 threshold)
Faithfulness verified on first attempt
Total: 183ms
What I Learned Building This
1. Cosine similarity is a local optima. The entire field optimized around it so heavily that we forgot it was a proxy, not the thing itself. Causal relevance is the thing itself.
2. Every layer needs a mathematical reason to exist. I threw out 3 layers during development because I couldn't prove they were optimal or even justified. Theorem 5.1 (CPG optimality) took me 3 weeks to prove. Worth it.
3. Latency is a feature. At 185ms, VORTEXRAG is 2.2× faster than Self-RAG despite doing far more work. Why? Because Self-RAG generates multiple draft responses and selects. VORTEXRAG's pre-generation filtering means the LLM sees a clean, small context and generates once. Less is more.
4. Human evaluation is irreplaceable. My biomedical expert caught failure modes on multi-step enzyme pathway questions that EM, F1, and faithfulness all missed. Automatic metrics are necessary but not sufficient.
The Part I Almost Didn't Share
I'm a student at Takshashila University. This wasn't done in a research lab with 40 GPUs and a team of PhD students. This was done on my laptop, in my room, across 4 months of evenings and weekends, after getting frustrated with every RAG system I used giving me wrong causal answers.
I don't have institutional affiliation. I don't have a PhD supervisor. I just had a problem that bothered me and enough stubbornness to not stop until I could prove I'd solved it.
If you're a student or independent researcher reading this: the problems worth solving are the ones that bother you personally. Not the ones that are impressive on a CV. The ones that make you think "this is broken and nobody seems to notice."
That's what VORTEXRAG was for me. I hope it's useful for you.
Links & Citation
🌀 Live Demo: https://huggingface.co/spaces/vigneshwar234/VORTEXRAG
💻 Code (MIT, 229 tests): https://github.com/vignesh2027/VORTEXRAG
📄 Paper (Zenodo v3.0): https://doi.org/10.5281/zenodo.20579702
🔬 ORCID: https://orcid.org/0009-0004-9777-7592
@article{vignesh2026vortexrag,
title = {VORTEXRAG: Vector Orthogonal Resonance-Tuned EXtraction
Retrieval-Augmented Generation — A 7-Layer Framework for
Simultaneous Elimination of Semantic Drift and Context
Window Poisoning},
author = {Vignesh, L},
year = {2026},
doi = {10.5281/zenodo.20579702},
url = {https://doi.org/10.5281/zenodo.20579702}
}
If this helped you, or if you tried VORTEXRAG and have feedback, drop a comment below. Every reaction, unicorn, and share genuinely helps this reach more people. Thank you for reading.
Tags: #machinelearning #python #rag #nlp #ai #deeplearning #opensource #research
Top comments (0)