Don't Worry About Quality: Robust Multi-Hop Retrieval despite Issues in Knowledge Graphs

arXiv:2603.14828 · cs.IR · Submitted 2026-03-16 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.

Tom: We're looking at the paper: "Don't Worry About Quality".

Jane: Here's the gist of the paper. Graph Retrieval-Augmented Generation (GraphRAG) has become a common approach for multi-hop reasoning by using knowledge graphs (KGs) as structured retrieval indexes However, most existing GraphRAG methods implicitly assume that LLM-constructed KGs provide structural support for evidence chaining This paper shows that this assumption does not always hold in practice through an empirical analysis and identifies two recurring KG issue modes often overlooked by current retrievers: spurious noise and incomplete information.

Tom: Identifying KG Deficiencies The authors empirically show that the common reliable-KG assumption in GraphRAG does not always hold, revealing that query-relevant incorrect tuples concentrate around recurring extraction patterns summarized into two issue modes: spurious noise and incomplete information.

Jane: Spurious noise includes over-generalized relations, mis-bound relations, and semantic flips which preserve plausible graph connectivity but corrupt hop semantics.

Tom: Incomplete information involves missing bridge edges or dropped qualifiers which remove structural support for multi-hop evidence chaining.

Title and authors: Tom: So, we're looking at this paper, "Don't Worry About Quality: Robust Multi-Hop Retrieval despite Issues in Knowledge Graphs," and it tackles a problem that comes up all the time when we use knowledge graphs for complex reasoning.

Jane: It sounds like they are saying that just having a knowledge graph structure isn't enough; if the graph itself has errors, our retrieval system can fail spectacularly on multi-hop questions.

Lu: Exactly, the core assumption in Graph Retrieval-Augmented Generation, or GraphRAG, is that the knowledge graph we build is actually reliable enough to provide solid evidence chains for reasoning across multiple steps.

Meng: But this paper shows that assumption doesn't always hold in practice; they found specific ways these imperfect knowledge graphs mess up the retrieval process.

Tom: They identify two main issues: spurious noise and incomplete information, which are recurring patterns in incorrect data extraction that current retrievers often miss.

Jane: Spurious noise sounds like things where the connection looks plausible—like a wrong relation or a semantic flip—but it actually corrupts the meaning of each hop we're trying to take.

Lu: And incomplete information is different; that's when crucial bridge edges are missing, or qualifiers get dropped, which just means the evidence chain can't be structurally supported at all.

Meng: So what they propose is a new framework called CS-RAG that tries to handle these flaws during the retrieval phase instead of just trying to repair the knowledge graph itself.

Tom: CS-RAG plans each query as an ordered sequence of atomic constraints, which means it breaks down the big question into smaller, executable pieces with explicit intermediate variables.

Jane: That sounds like they are trying to constrain where the retrieval system looks for evidence, instead of just letting it wander based on a general graph search.

Lu: Right; they use this planning scheme to ensure that when we look for the first piece of evidence, it's specifically tailored to that step in the reasoning process.

Title and authors: Tom: They also introduce a sufficiency check during hop-wise propagation to decide if the retrieved evidence is actually good enough to safely continue into the next step.

Jane: That sounds like they are trying to stop the model from propagating a bad structural connection just because it looks plausible on paper.

Lu: They use something called an effective number of candidates, Neff, and a threshold gamma, which helps them decide if a constraint is sufficiently grounded by the available structural evidence.

Meng: From an engineering standpoint, that sufficiency check is smart because it gives us a principled way to block ambiguous bindings before they turn into hallucinations down the line.

Tom: The experimental validation shows that CS-RAG maintains strong performance even when we inject errors into the knowledge graph structure, which is a big deal for real-world deployment.

Jane: They tested this on three different multi-hop question benchmarks, and it seems to handle issues caused by different knowledge graph builders pretty well.

Lu: And they found that CS-RAG is less affected by variations across different knowledge graph builders than the existing methods we've seen.

Meng: That robustness across those builders is key; it suggests that the framework isn't just tuned to one specific way of building a graph, but handles general quality degradation.

Tom: And the ablation studies confirm that both the constraint-based retrieval and that sufficiency checking module are absolutely necessary for this performance boost.

Jane: So if you remove those parts, CS-RAG’s performance drops significantly, which tells us exactly where its power is coming from.

Lu: It really highlights that having a good planner and a smart way to check evidence quality are critical ingredients for building reliable GraphRAG systems over imperfect KGs.

Meng: What I like is that the analysis of hyperparameter sensitivity suggests we should keep the budgets for structural propagation and textual recovery moderate to keep accuracy and efficiency balanced.

Tom: That makes sense because pushing those budgets too far just introduces more risk of error, whether it's structural drift or hallucination.

Title and authors: Jane: So, what this means for us is that when we use these tools, we need to be careful about tuning those settings to find the sweet spot between being accurate and being fast.

Lu: It points toward a more principled approach where the system decides whether to trust the structure or fall back on reading text when things get fuzzy.

Meng: If you look at Controlled KG Issue Injection, they show that CS-RAG handles both spurious noise and incomplete information much better than the baselines we were testing against.

Tom: That controlled injection really proves that CS-RAG is designed specifically to mitigate those two failure modes we discussed earlier.

Jane: So, to summarize, this paper proposes CS-RAG to reduce retrieval drift from spurious noise and hallucination from incomplete information by using atomic constraint planning and a sufficiency check.

Lu: It grounds each hop in fine-grained anchor and relation constraints, which fights the drift toward structurally plausible but unsupported evidence.

Meng: And the sufficiency check, guided by Neff, stops those ambiguous bindings from propagating into false chains by triggering textual recovery when structural support is weak.

Tom: The results on those three multi-hop QA benchmarks show that CS-RAG has stronger robustness across both cross-builder evaluations and controlled injection scenarios.

Jane: It seems like a solid improvement because it doesn't just fix one type of error; it tackles the fundamental structural weaknesses in how we retrieve from messy graphs.

Lu: The implication is that for building reliable multi-hop reasoners on top of LLM-constructed KGs, focusing on constraint planning and evidence sufficiency is a much more robust strategy than relying solely on the graph structure itself.

Meng: For production, that means we can deploy GraphRAG systems with less fear of catastrophic failure when the underlying knowledge base isn't perfectly curated.

Tom: It’s about making the retrieval process resilient so that even if the graph is noisy, our final answer generation stays grounded in solid evidence.

Jane: So, this paper gives us a more practical toolkit for dealing with the messy reality of building and using large knowledge graphs for complex AI tasks.

The paper's summary: Tom: So, we're looking at this paper, "Don't Worry About Quality: Robust Multi-Hop Retrieval despite Issues in Knowledge Graphs." Essentially, they’re saying that when you use knowledge graphs for multi-step reasoning across different steps—multi-hop—your system can still fail badly if the graph itself is a mess.

Jane: That's exactly right. The paper points out that the big assumption we make in GraphRAG is wrong: we assume the knowledge graph structure reliably supports evidence chaining, and they show it doesn't always do that in practice.

Lu: They identify two ways the graph gets broken during retrieval: spurious noise, where relations look plausible but are actually wrong, like a semantic flip; and incomplete information, which is when crucial bridge edges or qualifiers get dropped entirely.

Meng: Spurious noise messes up the hop semantics—it keeps the graph connected but gives you bad evidence for that specific step. And incomplete information just means there's no structural support at all for the next piece of evidence you need.

Tom: So, instead of trying to fix every single error in the knowledge graph, they propose a framework called CS-RAG that tries to handle these problems right during retrieval.

Jane: The core idea is that CS-RAG plans the query as a sequence of strict, atomic constraints—like small, executable rules—and uses those rules to guide the search for evidence.

Lu: They introduce a planning scheme where they create explicit intermediate variables and relation variants in their plan, like saying "Apollo thirteen has nominated for award," to make sure the retrieval targets are exactly what you need for that hop.

Tom: And then there's this sufficiency check during propagation—it decides if the evidence retrieved is actually good enough to safely carry over into the next step without hallucinating a connection.

Jane: It uses something called an effective number of candidates and a threshold, which acts like a quality gate, telling the system when structural support is weak and it should stop propagating that bad binding.

Meng: That’s interesting for me from a deployment standpoint; it sounds like you're building in a safety net to stop the model from spreading its errors across multiple reasoning steps.

Tom: And the experiments back this up; they show that CS-RAG stays very stable even when they intentionally inject errors into the knowledge graph, unlike other methods which degrade quickly.

Jane: It’s not just about handling one type of error; it shows robustness whether the graph builder is good or bad, suggesting this approach works for a wider range of real-world knowledge bases.

Lu: The ablation studies confirm that both the constraint planner and that sufficiency check are absolutely necessary components; removing them makes the performance drop off significantly.

Tom: So, to put it plainly, CS-RAG grounds each reasoning hop in specific constraints to fight drift from noisy data, and then uses a sufficiency check to stop incomplete information from leading to hallucinations down the line.

Jane: The implication for us is that when we build these complex AI systems on top of knowledge graphs, focusing on precise constraint planning and checking evidence quality is a much more reliable strategy than just building the graph itself perfectly.

Lu: It means we can deploy GraphRAG systems with less fear of catastrophic failure when the underlying data isn't perfectly curated or complete.

The paper's improvements: Tom: So, we're talking about how they actually fix these issues, not just identify them. The paper suggests several concrete improvements to make CS-RAG even tougher against those noisy knowledge graphs and incomplete information.

Jane: It sounds like they are adding layers of guardrails to the retrieval process itself instead of relying on a heavy repair mechanism for the graph structure.

Lu: One big improvement is that they're using constraint-based retrieval, which means they plan the query as an ordered sequence of executable atomic constraints with explicit intermediate variables.

Tom: So instead of just searching broadly, the system is constrained to find evidence specifically tailored to that exact step in the reasoning process, cutting down on irrelevant matches.

Jane: That’s smart because it prevents retrieval drift where you pick something that looks related but doesn't actually help complete your specific multi-hop path.

Meng: And they aren't just stopping there; they added cross-encoder reranking during this retrieval phase to ensure the top candidates are not just semantically similar, but actually aligned with that specific atomic constraint.

Tom: That means you’re keeping the most relevant context while making sure it fits the structure of your current reasoning step.

Jane: Then they introduced a hop-wise sufficiency check, which is basically a principled way to decide if the retrieved evidence can safely induce variable bindings for the next step without risking hallucinated chains.

Lu: They use this check with something called an effective number of candidates and a threshold gamma, which helps them decide if the structural evidence is sufficiently grounded before propagating any changes.

Tom: And they tuned that threshold gamma dataset by dataset, finding that as it goes up, the rate of successfully resolving hops increases while keeping online retrieval time and inference tokens down.

Jane: That sounds like a great trade-off for us; it gives you a tunable knob to balance how much structural propagation you trust against when you should switch over to reading text instead.

Meng: It’s good that they found a way to keep the budget for textual recovery moderate; if it gets too high, you just end up spending all your time reading text instead of getting the structure right.

Lu: And they showed this robustness across different knowledge graph builders, meaning the system doesn't break just because the underlying data was constructed in a different way.

Tom: I like that they didn't try to solve everything by fixing the graph; they focused on making sure their retrieval process is resilient enough to survive imperfect input.

Jane: The implication here is that for building these complex AI systems, we need to prioritize planning and checking evidence sufficiency over just hoping the knowledge graph structure is perfect.

Conclusion: Tom: So, we're wrapping up on "Don't Worry About Quality: Robust Multi-Hop Retrieval despite Issues in Knowledge Graphs." In short, this paper shows that you can make your AI reasoning much more resilient to messy knowledge graphs by focusing on strict planning and evidence sufficiency.

Jane: It’s about moving away from just assuming the graph is good, and instead building a system that actively checks the quality of its evidence at every single step of a multi-hop query.

Lu: The main contribution here is showing how to mitigate both spurious noise and incomplete information without having to rewrite the entire knowledge graph.

Tom: I mean, I’m always interested in the mechanics, and this paper gives us solid numbers on how much better CS-RAG performs compared to baselines when we inject errors into those graphs.

Meng: For me, it matters because it suggests a more reliable way to deploy these systems at scale; if you can't guarantee perfect data quality, you need a retrieval system that’s fundamentally built to handle the mess.

Lalam: I think what this means for us is that the AI doesn't have to just guess the next hop when it finds a structural gap; it has a mechanism to decide whether to trust its structure or switch over and read text instead.

Jane: Exactly, so we’re getting better control over where the AI gets its information from during reasoning.

Tom: So, we’ve seen how they plan those atomic constraints and how they tune that sufficiency check gamma for the best balance between structural propagation and textual recovery.

Lu: The future work mentioned is looking at how to make this planning scheme even more flexible when dealing with the sheer variety of knowledge graph formats out there.

Meng: I wonder if we can apply these same constraint-based retrieval ideas to other areas where we rely on structured data but that data might be incomplete or noisy, like in complex simulation environments.

Jane: It’s definitely a strong direction because it shows that for multi-hop reasoning, the quality of the retrieval mechanism is just as important as the initial structure of the knowledge graph itself.

Yizhuo Ma, Jinchuan Xu, Tao Wen Qizhi Chen, Jiakai Li, Rongzheng Wang, Muquan Li, Shuang Liang Ke Qin

University of Electronic Science and Technology of China

cs.IR

Submitted: 2026-03-16

Updated: 2026-10-31

Code: https://github.com/myz12138/CS-RAG

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 88/100

The gist: Graph Retrieval-Augmented Generation (GraphRAG) has become a common approach for multi-hop reasoning by using knowledge graphs (KGs) as structured retrieval indexes However…

Key concepts

Spurious Noise
This occurs when the knowledge graph contains relations that look plausible but are incorrect or over-generalized. These errors corrupt the meaning of a hop, causing retrieval to pull evidence that is structurally connected but semantically wrong, thus leading to retrieval drift.
Incomplete Information
This refers to missing structural links in the KG, such as bridge edges or necessary qualifiers. When these are absent, the system loses the necessary support for chaining multiple steps together in a multi-hop query, making it impossible to find complete evidence paths.
Atomic Constraint Planning
Instead of searching broadly, this method plans a complex query into a sequence of small, executable constraints with specific intermediate variables. This ensures that every piece of retrieved evidence is tightly focused on the exact structural requirement for the next step in the reasoning process.

Terminology

Summary

Graph Retrieval-Augmented Generation (GraphRAG) has become a common approach for multi-hop reasoning by using knowledge graphs (KGs) as structured retrieval indexes However, most existing GraphRAG methods implicitly assume that LLM-constructed KGs provide structural support for evidence chaining This paper shows that this assumption does not always hold in practice through an empirical analysis and identifies two recurring KG issue modes often overlooked by current retrievers: spurious noise and incomplete information. p. 0

Where the paper says it

However, most existing GraphRAG methods implicitly assume that LLM-constructed KGs provide structural support for evidence chaining. In this paper, we show that this assumption does not always hold in practice through an empirical analysis, and identify two recurring KG issue modes often overlooked by current retrievers: spurious noise and incomplete information.

Identifying KG Deficiencies

The authors empirically show that the common reliable-KG assumption in GraphRAG does not always hold, revealing that query-relevant incorrect tuples concentrate around recurring extraction patterns summarized into two issue modes: spurious noise and incomplete information. Spurious noise includes over-generalized relations, mis-bound relations, and semantic flips which preserve plausible graph connectivity but corrupt hop semantics. p. 1

Where the paper says it

) Based on their effects on downstream retrieval, we summarize these patterns into two broader issue modes: (1) spurious noise, including over-generalized relations, mis-bound relations, and semantic flips, and (2) incomplete information, including missing bridge edges and dropped qualifiers. The former preserves plausible graph connectivity but corrupts hop semantics, as finegrained relations may be weakened into vague associations, attached to unsupported co-mentioned entities, or flipped in direction.

Incomplete information involves missing bridge edges or dropped qualifiers which remove structural support for multi-hop evidence chaining. p. 1
Where the paper says it

The former preserves plausible graph connectivity but corrupts hop semantics, as finegrained relations may be weakened into vague associations, attached to unsupported co-mentioned entities, or flipped in direction. The latter removes bridge edges or drops qualifiers such as time, location, and conditions, leaving the graph with incomplete structural support for multi-hop evidence chaining.

Proposed Robust Framework

To address these challenges, the paper proposes CS-RAG, a robust GraphRAG framework that mitigates the impact of imperfect KGs during retrieval rather than relying on KG repair. CS-RAG first plans each query as an ordered sequence of executable atomic constraints and performs fine-grained anchor- and relation-aware retrieval to constrain evidence acquisition around the intended hop semantics. p. 0

Where the paper says it

To address these challenges, we propose CS-RAG, a robust GraphRAG framework that mitigates the impact of imperfect KGs during retrieval rather than relying on KG repair. CS-RAG first plans each query as an ordered sequence of executable atomic constraints and performs fine-grained anchor- and relation-aware retrieval to constrain evidence acquisition around the intended hop semantics.

It then applies a sufficiency check to decide whether the retrieved evidence can safely induce variable bindings for subsequent propagation and activates textual recovery when structural support is insufficient. p. 0
Where the paper says it

CS-RAG first plans each query as an ordered sequence of executable atomic constraints and performs fine-grained anchor- and relation-aware retrieval to constrain evidence acquisition around the intended hop semantics. It then applies a sufficiency check to decide whether the retrieved evidence can safely induce variable bindings for subsequent propagation and activates textual recovery when structural support is insufficient, thereby reducing hallucinated structural continuation.

Mechanism of Robustness

CS-RAG introduces an atomic-constraint planning scheme that maps a complex query into atomic constraints with explicit intermediate variables and relation variants to constrain evidence acquisition against retrieval drift. It also introduces a hop-wise sufficiency criterion to decide whether to propagate structural bindings or trigger textual recovery, which provides a principled way to block ambiguous bindings before they propagate into hallucinated chains. p. 1

Where the paper says it

Second, We introduce a hop-wise sufficiency criterion into multi-hop retrieval for the first time, and prove that it yields a lower bound on the top-candidate probability, thereby providing a principled way to block ambiguous bindings before they propagate into hallucinated chains. Specifically, CS-RAG performs a distribution-based check to decide whether the retrieved candidates provide reliable support for structural binding or whether textual recovery should instead be triggered.

The sufficiency check uses an effective number of candidates Neff(τi) and a threshold γ to determine if a constraint is sufficiently grounded by structural evidence. p. 4
Where the paper says it

(2) A smaller Neff(τi) indicates a concentrated distribution and a more sufficient match, while a larger value indicates ambiguity. We use a threshold γ to determine whether τi is sufficiently grounded by structural evidence.

Experimental Validation

Experiments on three multi-hop QA benchmarks show that CS-RAG achieves stronger robustness under both cross-builder evaluation and controlled KG issue injection. The results demonstrate that CS-RAG maintains nearly stable F1 as the issue ratio ρ increases under query-centric injection, while baselines show clear performance degradation. p. 7

Where the paper says it

Query-Centric Issue Injection Figure 3 (a)–(b) reports the results under query-centric injection. Across all three datasets, CS-RAG maintains nearly stable F1 as ρ increases, while the baselines show clear performance degradation.

Furthermore, CS-RAG remains nearly stable across whole-KG issue injection, indicating its robustness extends to globally distributed KG quality degradation. p. 7
Where the paper says it

CS-RAG remains nearly stable across issue ratios, indicating that constraint-based retrieval and sufficiency checking are still effective when KG issues are distributed broadly over the graph. These results show that the robustness of CS-RAG is not limited to local issue concentration, but also extends to whole-KG quality degradation.

Ablation and Analysis

Ablation studies confirm that components like constraint-based retrieval and sufficiency checking are critical, showing that removing the planner or the sufficiency check leads to performance drops, illustrating the necessity of these modules. The analysis of hyperparameter sensitivity shows that structural propagation and textual recovery budgets should be set to moderate values to balance accuracy-efficiency trade-offs across different datasets. p. 8

Where the paper says it

Table 3 shows that γ controls a dataset-dependent balance between structural propagation and textual recovery. Table 3: Effect of the representative γ-values from the searched range across datasets.

The failure analysis highlights that planner errors, such as omitting intermediate bridge variables, are a key source of error in the planning stage. p. 8
Where the paper says it

7, corresponding to planner errors and insufficient evidence. In the first case, the planner omits an intermediate bridge variable, causing the generated constraints to retrieve evidence around the wrong entity.

Conclusion

In conclusion, CS-RAG mitigates two issue-induced retrieval failures: retrieval drift caused by spurious noise and retrieval hallucination caused by incomplete information. The framework successfully grounds each hop in fine-grained anchor and relation constraints to reduce drift toward structurally plausible but unsupported evidence, while sufficiency-guided propagation and textual recovery reduce the chance that incomplete KGs force hallucinated structural continuations. p. 8

Where the paper says it

CS-RAG mitigates two issue-induced retrieval failures: retrieval drift caused by spurious noise, and retrieval hallucination caused by incomplete information. Specifically, constraint-based retrieval grounds each hop in fine-grained anchor and relation constraints to reduce drift toward structurally plausible but unsupported evidence, while sufficiency-guided propagation and textual recovery reduce the chance that incomplete KGs force hallucinated structural continuations.

Experiments on three multi-hop QA benchmarks show that CS-RAG achieves stronger robustness across different KG builders and under controlled KG issue injection. p. 9
Where the paper says it

multi-hop QA benchmarks show that CS-RAG achieves stronger robustness across different KG builders and under controlled KG issue injection. References [1] Bilal Abu-Salih.

The results show that CS-RAG is less affected by builder-induced KG variations and achieves stronger robustness. p. 6
Where the paper says it

The results show that CS-RAG achieves the highest cross-builder averages across all datasets and metrics, while maintaining consistently low standard deviations. This indicates that CS-RAG is less affected by builder-induced KG variations and achieves stronger robustness.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Constraint-based Retrieval for better evidence acquisition by using an ordered sequence of executable atomic constraints to constrain evidence acquisition around intended hop semantics, reducing coarse query matching.

  2. Sufficiency-Guided Propagation and Recovery to decide whether retrieved evidence can safely induce variable bindings for subsequent propagation, thereby reducing hallucinated structural continuation by activating textual recovery when structural support is insufficient.

  3. Atomic Constraint Planning using an LLM-based planner to produce a structured plan P with explicit intermediate variables and relation variants (e.g., Apollo 13 – has nominated for – ?award), ensuring the retrieval targets are aligned with intended hop semantics rather than just coarse query matching.

  4. Distribution-based Sufficiency Check, which computes an effective number of candidates Neff(tau i) = 1/P c in Ctop i p squared, to provide a principled way to block ambiguous bindings before they propagate into hallucinated chains by checking if the retrieved candidates provide reliable support for structural binding.

  5. Incorporating Cross-Encoder Reranking for relation alignment and contextual scoring during constraint-based retrieval to retain the top-Ks candidates that are aligned with the current atomic constraint, avoiding selections that are merely semantically related but violate the intended relation.

  6. Implementing a sufficiency check threshold gamma (γ) tuned dataset by dataset, where As γ increases, the resolved-hop rate rises and both online retrieval time and inference tokens decrease, to balance structural propagation against textual recovery based on specific QA trends.

  7. Robustness across KG builders by showing that CS-RAG achieves the highest cross-builder averages across all datasets and metrics, while maintaining consistently low standard deviations, indicating it is less affected by builder-induced KG variations.

  8. Controlled KG Issue Injection to evaluate robustness under spurious noise (inducing retrieval drift) and incomplete information (leading to retrieval hallucination), demonstrating that CS-RAG remains much less affected because sufficiency checking and textual recovery reduce forced structural continuation.

Abstract

Graph Retrieval-Augmented Generation (GraphRAG) has made substantial progress in multi-hop reasoning, but typically assumes that constructed knowledge graphs (KGs) provide sufficient structural support. In practice, cost and computing constraints often leave constructed KGs imperfect, raising the key challenge of achieving robust multi-hop retrieval. To address this challenge, we empirically analyze KG extraction across builders and find similar error patterns despite differences in error proportions, motivating a retrieval strategy targeted at these shared errors. We further summarize these patterns into two issue modes, spurious noise and incomplete information, which induce retrieval drift and retrieval hallucination by misleading evidence selection and weakening evidential support, respectively. Based on this, we propose CS-RAG, a robust GraphRAG framework that mitigates the impact of imperfect KGs during retrieval. CS-RAG first plans each query as an ordered sequence of executable atomic constraints and performs fine-grained anchor- and relation-aware retrieval to constrain evidence acquisition around the intended hop semantics. It then applies a sufficiency check to decide whether retrieved entities should serve as anchors for subsequent retrieval hops and activates textual recovery for unresolved constraints, thereby reducing hallucinated structural continuation. Experiments on three multi-hop QA benchmarks show that CS-RAG is less sensitive to builder choice and remains stable under controlled KG issue injection. Code is available at https://github.com/myz12138/CS-RAG.

Sources

Related papers