💻 computer science

Topology-Aware Hybrid Retrieval for Enterprise Knowledge Systems

This paper presents a topology-aware hybrid retrieval engine that unifies dense, sparse, and file-system search with a multi-tier controller to automatically traverse document hierarchies and hyperlinks, significantly improving recall, ranking quality, and latency for enterprise knowledge systems while avoiding the overhead of language-model-driven query decomposition.

Original authors: Shubhay Joshua

Published 2026-07-31

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Shubhay Joshua

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to find a specific fact in a massive, chaotic library. In the world of artificial intelligence, this library is the internet or a company's internal documents, and the librarian is a "Retrieval-Augmented Generation" (RAG) system. Think of RAG as a super-smart robot that doesn't just memorize answers but goes to the library to look them up before it speaks. This prevents the robot from making things up (hallucinations) and lets it learn new things instantly.

However, traditional librarians have a few quirks. Some only care about the exact words you use (if you say "car," they won't find "automobile"), while others only care about the general vibe of the sentence (if you say "fast vehicle," they might bring you a race car even if you asked about a truck). Furthermore, these librarians often treat every book as a pile of loose, disconnected pages, missing the fact that one page might have a note saying, "See also page 42," or a hyperlink to a different book entirely. When the robot tries to piece together a complex story that requires reading multiple connected pages, it often gets lost, confused, or takes too long to figure out which pages to read next.

This is where a new approach comes in, designed to make the librarian faster, smarter, and more connected.

The Super-Connected Librarian: A New Way to Find Answers

Imagine you are a detective trying to solve a mystery. In the old way of doing things, you might ask a single friend for a clue. If your friend only knows about "red cars," they won't tell you about a "crimson sedan," even if it's the same thing. Or, if you ask a friend who only knows the "feeling" of a crime scene, they might bring you a story about a robbery when you were actually looking for a burglary.

This paper introduces a new kind of detective team called Topology-Aware Hybrid Retrieval. Instead of relying on just one friend, this team sends four different scouts out at the same time to find clues, then combines their reports into one perfect list.

The Four Scouts
The system sends the same question to four different "scouts" simultaneously:

The Semantic Scout (Dense Search): This scout understands the meaning of words. If you ask about "fast vehicles," they find documents about speed, even if the word "fast" isn't there.
The Keyword Scout (Sparse/BM25 Search): This scout is a stickler for exact matches. If you ask for a specific serial number or error code, this scout finds it instantly, ignoring the general meaning.
The Frequency Scout (TF-IDF Search): This scout looks at how rare a word is across the whole library. If a word is very common, they ignore it; if it's unique, they pay attention.
The File-System Scout (Native DFS): This scout doesn't even look at the text inside the books. Instead, they look at the file folders, the file names, and the ownership tags on the shelves to find the right documents based on where they are stored.

The Great Mixing Pot
Here is the tricky part: The Semantic Scout gives scores like "0.95" (very close), while the Keyword Scout gives scores like "150" (based on how many times a word appears). If you just added these numbers together, the Keyword Scout would win every time, and the Semantic Scout's smart insights would be ignored.

To fix this, the system uses a clever "Over-Fetching" strategy. Instead of asking each scout to bring back only the top 5 results, it asks them to bring back a huge pile (say, 100 results each). Then, it uses a mathematical "translator" to normalize all the scores, putting them on the same scale. Finally, it mixes them together using a customizable recipe. You can tell the system, "I want 70% meaning and 30% exact words," or "Just give me the highest score from any scout." This ensures that the final list of documents is the best of all worlds.

The "Hyperlink" Superpower
The real magic, however, happens after the first list is made. In a normal library, if you find a page that says, "See also: The Secret Recipe," a human might have to stop, think, and ask the librarian to go find that second page. This takes time and can lead to mistakes.

This new system has a Topologically-Aware Multi-Tier Controller. Think of this as a robot that can instantly see the invisible threads connecting the pages.

Primary Pass: It finds the best initial documents using the four scouts.
The Link Jump: It immediately scans those documents for any "hyperlinks" or references to other documents.
The Secondary Pass: Instead of asking a slow, thinking AI to figure out what to search for next, the robot programmatically jumps to those linked documents and fetches them instantly.
The Safety Net: To make sure it doesn't get stuck in an infinite loop (like a dog chasing its own tail), the system keeps a "visited list." If it sees a document it has already checked, it skips it. It also checks if the new document actually fits the context of the original link, filtering out irrelevant junk.

Why This Matters: Speed and Smarts
The authors tested this system and found some impressive results.

Better Answers: The system improved the "recall" (how many correct answers it found) by 20.0%, reaching a perfect score of 1.0000 Recall@100 on certain tests. It also improved the ranking quality (how well the best answers are at the top) by 13.2%.
Blazing Fast: The biggest win is speed. Old methods that used a thinking AI to figure out the next step took seconds (around 3,700 milliseconds). This new system does the same job in less than a millisecond (0.87 ms). That is a 95% reduction in waiting time.
Less Waste: By only fetching the specific linked documents needed, the system reduced the amount of extra text (tokens) it had to process by 25.8% to 43.3%.

What It's Not
It is important to note what this paper doesn't do. It doesn't replace the big AI that writes the final answer; it just makes the "looking up" part much better. It also argues against the idea of using slow, looping AI agents to figure out what to search for next, showing that a direct, programmed jump to linked documents is faster and more reliable.

In short, this paper suggests that by combining four different search styles, mathematically blending their results, and using the document's own internal map to jump to related pages, we can build an enterprise search system that is not only smarter but also fast enough to keep up with real-time conversations. It turns a chaotic library into a perfectly organized, hyper-connected web of knowledge.

Technical Summary: Topology-Aware Hybrid Retrieval for Enterprise Knowledge Systems

Problem Statement

Traditional Retrieval-Augmented Generation (RAG) pipelines face significant limitations in enterprise environments due to their reliance on partitioning corpora into isolated, flat text segments. This approach omits structural document hierarchies and fails to resolve relational hyperlink topologies, leading to three primary failure modes:

Boundary Fragmentation: Critical contextual connections are severed when documents are split into independent chunks.
Vocabulary Mismatch: Purely dense retrieval models suffer from "vocabulary blindness," failing to retrieve exact matches for specific identifiers (e.g., product SKUs, serial numbers) or technical configurations. Conversely, sparse lexical methods (like BM25) struggle with conceptually identical documents phrased in different terminology.
Latency and Error Propagation: Current multi-hop query resolution often relies on LLM-driven iterative query rewriting or agentic self-questioning loops. These methods introduce substantial latency (often seconds) and are prone to error propagation, making them unsuitable for real-time conversational interfaces.

Additionally, existing architectures often suffer from mathematical bias when fusing disparate scoring spaces (unbounded lexical scores vs. bounded dense vector similarities) and lack direct integration with the underlying physical storage layer, introducing database wrapper bottlenecks.

Methodology

The paper proposes a high-performance, unified retrieval engine that integrates four parallel pathways and a deterministic topological expansion controller.

1. Distributed Ingestion and File-System Integration

The system utilizes a zero-copy ingestion pipeline that integrates directly with a native distributed file system (DFS), bypassing external database abstraction layers.

Preprocessing: Incoming streams undergo Unicode Normalization Form C (NFC) and whitespace standardization.
Chunking: A sentence-aware sliding window algorithm partitions text while preserving a configurable overlap (typically 20%).
Graph Construction: Crucially, the parser extracts structural hyperlinks and cross-document anchors during chunking, mapping them as directed edges in a local document graph metadata schema.

2. Multi-Path Parallel Retrieval Engine

Upon query initialization, the system broadcasts the input to four simultaneous sub-systems:

Dense Vector Search: Uses a local transformer model to generate embeddings, retrieved via an in-memory Hierarchical Navigable Small World (HNSW) graph for semantic proximity.
Sparse Lexical Search: Employs the Okapi BM25 algorithm via a high-performance inverted index for exact keyword and identifier matching.
Classical TF-IDF Search: Provides a global baseline relevance score to prevent penalization of high-frequency matches by BM25's length normalization.
Native DFS Lookup: Executes direct, zero-copy lookups on storage partitions to resolve file ownership tags, directory clustering, and system attributes with minimal CPU overhead.

3. Over-Fetching and Score Fusion

To address the scale mismatch between scoring spaces and avoid truncation errors, the engine employs an Over-Fetching Protocol:

Over-Fetching: Retrieves a large candidate set ( $K_{over}$ ) from each index before fusion, ensuring a dense candidate pool with high overlap.
Normalization: Scores are standardized using Min-Max, L2, or Z-Score normalization to map divergent distributions to a uniform scale.
Hybrid Fusion: Candidates are combined using configurable weighting and combination modes (Sum, Max, Mean) or Reciprocal Rank Fusion (RRF) to aggregate ordinal rankings.

4. Topologically-Aware Multi-Tier Expansion Controller

This component replaces LLM-driven query decomposition with a deterministic, two-pass retrieval strategy:

Primary Pass: Retrieves top candidates using the hybrid fusion matrix.
Secondary Pass: The system programmatically parses primary candidates to identify embedded hyperlinks. It executes a direct lookup of the target chunks corresponding to these links via the native DFS index.
Context-Aware Reranking: Supporting chunks are validated using local context-aware cosine similarity against the anchor text in the parent document.
Cycle Avoidance: A Depth-First Search (DFS) traversal with a global state registry prevents infinite loops and redundant text duplication, ensuring each cross-referenced node is integrated exactly once.

Key Contributions

Unified Hybrid Architecture: The integration of dense, sparse (BM25), classical (TF-IDF), and native file-system retrieval into a single pipeline, resolving the isolation of storage and search layers.
Deterministic Topological Expansion: A novel controller that programmatically resolves multi-hop relationships via document hyperlinks, eliminating the latency and error risks associated with LLM-based query rewriting.
Mathematical Rigor in Fusion: A formalized framework for score normalization and configurable hybrid weighting that prevents any single modality from dominating the ranking due to scale differences.
Zero-Copy Storage Integration: Direct file-system access that bypasses database bottlenecks, enabling high-throughput candidate lookups.

Results

Systematic evaluations using open-source benchmarks (BEIR SciFact and HotpotQA Linked Corpus) demonstrate the following improvements:

Recall Improvement: The unified pipeline achieved a 20.0% absolute improvement in recall, reaching 1.0000 Recall@100 on multi-hop benchmarks, compared to a baseline of 0.8333 for flat hybrid retrieval.
Ranking Quality: Normalized Discounted Cumulative Gain (NDCG@10) increased from 0.7654 to 0.8664 (+13.2% gain).
Latency Reduction: The topological anchor reranking process operates in 0.87 ms, representing a >95% reduction in context-processing latency compared to typical LLM query decomposition loops (approx. 3,700 ms).
Token Efficiency: By selectively retrieving only targeted, hyperlinked supporting chunks rather than static parent windows, the system reduced context token overhead by 25.8% to 43.3%.

Significance and Claims

The paper claims to establish a scalable paradigm for real-time enterprise information extraction. By preserving structural semantic continuity without incurring the high computational overhead of language-model-driven query decomposition, the system enables:

Real-Time Responsiveness: The sub-millisecond latency of the topological expansion makes the pipeline suitable for voice-enabled AI agents and conversational interfaces where strict sub-200ms latency budgets are required.
Structural Integrity: The system successfully captures multi-hop relationships inherent in naturally structured documentation, addressing the "flat" limitation of standard RAG.
Robustness: The hybrid approach mitigates the specific failure modes of both dense (vocabulary blindness) and sparse (conceptual mismatch) retrieval, ensuring high precision for technical identifiers and high recall for semantic concepts.

The authors position this work as a foundational step toward more efficient, structurally aware retrieval systems, with future work planned for integrating neural-sparse representations (e.g., SPLADE) and dynamic query-intent classification.