MDER-DR: Multi-Hop Question Answering with Entity-Centric Summaries

The paper introduces MDER-DR, a novel Retrieval-Augmented Generation framework that combines a Map-Disambiguate-Enrich-Reduce indexing strategy with a Decompose-Resolve retrieval mechanism to significantly improve multi-hop question answering on Knowledge Graphs by preserving contextual nuance and enabling robust reasoning without explicit graph traversal.

The Gist

Imagine you are trying to solve a complex mystery, like figuring out who the wife of the King of Ithaca is. To do this, you need to connect several dots: Ithaca → King → Wife.

In the world of Artificial Intelligence, this is called Multi-Hop Question Answering. The AI has to "hop" from one fact to another to find the answer.

The paper you shared introduces a new system called MDER-DR that solves a major problem with how AI currently handles these mysteries. Here is the breakdown in simple terms:

The Problem: The "Lego Brick" Trap

Currently, when AI tries to learn from a huge library of books (a Knowledge Graph), it often breaks the stories down into tiny, rigid Lego bricks called "triples" (Subject-Predicate-Object).

• Example: "Ferrero" → "Introduced" → "Nutella".

The Issue: When you break a story into bricks, you lose the "glue." You lose the context.

• Real life: "Ferrero introduced Nutella in 1964, but they changed the recipe in 2015 to make it smoother."
• Broken Lego version: "Ferrero introduced Nutella" AND "Recipe changed in 2015."

If the AI only sees the bricks, it might get confused. To answer a question, it has to physically walk through the library, looking for every single brick and trying to snap them together in real-time. This is slow, and if a brick is missing or looks slightly different (like "EU" vs. "European Union"), the AI gets lost.

The Solution: MDER-DR

The authors propose a two-step magic trick to fix this.

Step 1: MDER (The "Smart Librarian")

Instead of just making a list of bricks, the AI acts like a super-smart librarian who reads the books before you even ask a question. It uses a process called Map-Disambiguate-Enrich-Reduce:

1. Map: It finds the facts (the bricks).
2. Disambiguate: It realizes that "EU" and "European Union" are the same person and gives them a single, clear ID card.
3. Enrich: This is the secret sauce. Instead of just writing "Ferrero introduced Nutella," the librarian writes a full sentence: "Ferrero introduced Nutella in 1964, and tweaked the recipe in 2015." It adds all the missing context back in.
4. Reduce: Finally, it creates a Summary Card for every main character (Entity).
   • Instead of a list of 50 separate bricks about "Marconi," the librarian writes one perfect paragraph: "Marconi was an engineer who sent the first radio signal across the ocean in 1901 and won a Nobel Prize in 1909."

The Result: The library is now organized by Summary Cards, not loose bricks. All the complex connections are already written down on the card.

Step 2: DR (The "Detective")

When you ask a question, the AI uses a process called Decompose-Resolve:

1. Decompose: It breaks your question into smaller parts.
   • Question: "Who was the wife of the King of Ithaca?"
   • Parts: 1. Who is the King of Ithaca? 2. Who is that King's wife?
2. Resolve: Instead of running around the library looking for bricks, the detective just picks up the Summary Card for "Ithaca."
   • The card says: "Ithaca's King is Odysseus."
   • The detective then picks up the Summary Card for "Odysseus."
   • The card says: "Odysseus's wife is Penelope."
   • Answer: Penelope.

Because the "hops" (the connections) were already written into the Summary Cards during Step 1, the detective doesn't need to do any heavy lifting or "graph walking" during the search. It's like having a map where the routes are already drawn, rather than having to find the path yourself every time.

Why is this a big deal?

1. It's Faster: The AI doesn't have to search for connections; they are already there.
2. It's Smarter: It keeps the "nuance" (the details, the dates, the conditions) that usually gets lost in simple data.
3. It Works in Any Language: The system translates everything into a standard format first, so it doesn't matter if you ask in English, Italian, or Spanish. It still finds the right Summary Card.

The Bottom Line

Think of traditional AI as a student trying to solve a math problem by looking up every single number in a dictionary and doing the math on the spot.

MDER-DR is like a student who has already studied the textbook, written perfect summary notes for every chapter, and memorized the connections. When the teacher asks a question, the student just reads the relevant summary note and gives the answer instantly.

The paper shows that this method is up to 66% better at answering complex questions than current standard methods, especially when the questions are tricky or the data is messy.

Technical Summary

Here is a detailed technical summary of the paper "MDER-DR: Multi-Hop Question Answering with Entity-Centric Summaries."

1. Problem Statement

The paper addresses a critical limitation in Retrieval-Augmented Generation (RAG) systems that rely on Knowledge Graphs (KGs).

• Context Loss: Conventional KG construction reduces unstructured text into atomic triples (Subject-Predicate-Object). This process is inherently lossy, discarding crucial contextual nuances such as assertion scopes, implicit relationships, qualifiers, and exceptions.
• Multi-Hop Complexity: Standard RAG approaches struggle with multi-hop Question Answering (QA), which requires composing answers from multiple entities and relations. Traditional methods often rely on explicit graph traversal (walking edges) at inference time, which is computationally expensive and prone to errors in sparse or incomplete graphs.
• Cross-Lingual Robustness: Existing solutions often fail to maintain performance when the query language differs from the indexing language, or they are restricted to specific domains.

2. Methodology: The MDER-DR Framework

The authors propose a domain-agnostic, two-stage framework that shifts the complexity of relational composition from the inference phase to the indexing phase.

A. Indexing Phase: Map-Disambiguate-Enrich-Reduce (MDER)

Instead of storing only raw triples, MDER generates entity-centric summaries that compress multi-hop evidence. The pipeline consists of four sequential steps:

1. Map: Preprocessed text chunks are passed through an LLM to extract subject-predicate-object triples. The prompt is designed to detect compound, nested, and implicit relations (temporal, causal, hierarchical) to make implicit meaning explicit.
2. Disambiguate: The system identifies and unifies fragmented or redundant entities (e.g., "EU" vs. "European Union"). It uses embedding similarity followed by LLM verification to assign canonical identifiers, ensuring a coherent entity set.
3. Enrich: This is the core innovation. Each extracted triple is augmented with a natural language description generated by an LLM. This description captures the original text's context, including scope, conditions, exceptions, and temporal boundaries, effectively re-introducing the nuance lost during triple extraction.
4. Reduce: The system consolidates all enriched triple descriptions associated with a specific entity into a single, condensed entity-centric summary. This summary acts as a "hop-free" representation of the entity's relational evidence, allowing downstream retrieval to access multi-hop information without traversing graph edges.

B. Retrieval Phase: Decompose-Resolve (DR)

The DR mechanism handles user queries without explicit graph traversal:

1. Preprocessing: Queries are translated into English to ensure linguistic consistency with the MDER-indexed data.
2. Decompose (Semantic Triple Decomposition): The user's natural language query is decomposed into a set of structured triples containing placeholders for unknown or intermediate entities (e.g., "Ithaca HAS KING X", "X HAS WIFE Y").
3. Resolve (Iterative Placeholder Resolution):
   • The system iteratively grounds placeholders into KG entities.
   • Known entities serve as retrieval anchors. The system performs embedding similarity searches against entity-level summaries (not raw triples).
   • Since the summaries already contain aggregated multi-hop context, the system can reason over the relationships directly.
   • An LLM analyzes the retrieved summaries to resolve the current placeholder, propagating the resolved value to subsequent triples.
4. Response Generation: Once all placeholders are resolved, the accumulated summaries are fed into a final LLM prompt to synthesize the answer, ensuring faithfulness to the retrieved evidence.

3. Key Contributions

• MDER Indexing Strategy: A novel approach that compresses multi-hop relational context into entity-centric summaries during KG construction, eliminating the need for explicit edge traversal during inference.
• DR Retrieval Mechanism: A structured, iterative reasoning process that decomposes compositional queries and resolves them using pre-computed summaries, decoupling relational complexity from inference-time traversal.
• Robustness: The framework demonstrates strong performance in cross-lingual scenarios (query language $\neq$ index language) and sparse data conditions, maintaining high precision where other methods degrade.
• Domain Agnosticism: The system is built on a generic RDF/OWL ontology, making it applicable across diverse domains without retraining.

4. Experimental Results

The framework was evaluated on WikiQA, HotpotQA, and a domain-specific energy dataset (BenchEE), across multiple languages (English, Italian, French, Spanish).

• Performance Gains: MDER-DR significantly outperformed standard baselines (Vector-based RAG, GraphRAG, and LLM-only).
  • On WikiQA, it achieved a 66% improvement over the best baseline (Vector-RAG) in LLM-as-a-Judge scores (0.790 vs. 0.477).
  • On HotpotQA, it maintained a consistent lead (e.g., +13% over Vector-RAG in mismatched language scenarios).
  • On BenchEE (expert domain), it achieved scores of ~0.83, significantly outperforming GraphRAG and Vector-RAG, especially in language-mismatched conditions.
• Cross-Lingual Robustness: Unlike other methods that suffer significant performance drops when the query language differs from the index language, MDER-DR showed minimal degradation (e.g., only a ~12% drop in WikiQA vs. larger drops in baselines). This is attributed to its translation-based preprocessing and language-agnostic representation.
• Human Evaluation: On the BenchEE dataset, human experts rated MDER-DR significantly higher (0.910) than all other architectures, confirming its ability to preserve technical accuracy and factual correctness.

5. Significance

• Paradigm Shift: The paper challenges the standard "query-time traversal" approach to multi-hop QA. By moving relational composition to the indexing phase, it transforms multi-hop QA into a structured retrieval problem over compressed, context-rich representations.
• Efficiency: While the indexing phase incurs higher upfront costs due to multiple LLM calls, the inference phase is highly efficient, avoiding expensive graph walks and offering predictable latency.
• Practical Applicability: The framework solves the "lossy" nature of KG extraction, making KG-based RAG viable for complex, real-world applications requiring high precision, nuance, and cross-lingual capabilities (e.g., legal compliance, scientific research).

In conclusion, MDER-DR represents a significant advancement in Knowledge Graph-based RAG, proving that entity-centric summarization is a superior strategy for handling multi-hop reasoning compared to traditional graph traversal or pure vector retrieval.