G-Retriever GraphQA: Scalable Graph Retrieval

• G-Retriever GraphQA is a retrieval-augmented generation framework that integrates graph-centric retrieval with LLM prompting for explainable, multi-hop question answering.
• It employs embedding-based top-k retrieval, PCST-based subgraph extraction, and GAT-MLP projection to generate succinct, grounded textual summaries.
• Empirical results demonstrate improved accuracy, reduced hallucination, and scalable performance on benchmarks like ExplaGraphs, SceneGraphs, and WebQSP.

A G-Retriever GraphQA system is a retrieval-augmented generation (RAG) framework that enables LLMs to answer questions over large, real-world graphs with textual node and edge attributes by interleaving graph-centric information retrieval with parameter-efficient LLM prompting. Unlike prior approaches that focus on small or synthetic graphs, or that perform reasoning on flat representations prone to context truncation and hallucination, G-Retriever decomposes the pipeline into embedding-based top-k retrieval, subgraph construction via combinatorial optimization, and prompt-based answer generation. This architecture efficiently scales to graphs with thousands of nodes/edges, supports explainability via answer-supporting subgraphs, and empirically mitigates hallucination and information loss in multi-hop and long-context reasoning tasks (He et al., 2024).

1. Problem Formulation and Benchmark

G-Retriever addresses the problem of free-form question answering over “textual graphs,” formally defined as $G = (V, E, \{x_n\}_{n\in V}, \{x_e\}_{e\in E})$, where each node $n$ and edge $e$ has a text attribute ($x_n \in \mathbb{D}^{L_n}$, $x_e \in \mathbb{D}^{L_e}$). Given a natural language question $q$ about $G$, the system is tasked to output both an answer $Y$ and a highlighted subgraph $(V^*, E^*) \subseteq G$ that supports $Y$.

A key innovation is the GraphQA benchmark suite, comprising:

• ExplaGraphs: Commonsense stance (accuracy metric), avg. 5.17 nodes/4.25 edges.
• SceneGraphs: Open-ended scene QA, avg. 19.13 nodes/68.44 edges.
• WebQSP: Multi-hop knowledge QA subset from Freebase, avg. 1,370 nodes/4,252 edges (Hit@1 metric).

Benchmark evaluation focuses on accuracy (ExplaGraphs, SceneGraphs) and Hit@1 (WebQSP). Questions target multi-hop, scene, knowledge, and commonsense reasoning.

2. G-Retriever System Architecture

The G-Retriever pipeline interleaves retrieval and generation in a four-stage architecture:

1. Indexing: Compute LLM (LM) embeddings for all nodes and edges, storing outputs in an approximate nearest neighbor (ANN) index (e.g., Faiss).
2. Retrieval: Given a query $q$, encode it as $z_q$. Retrieve top-$k$ nodes $V_k$ and edges $E_k$ by cosine similarity in the embedding space.
3. Subgraph Construction (PCST): Formulate minimal subgraph extraction as the Prize-Collecting Steiner Tree (PCST) problem:

$$S^* = \underset{ S=(V_S,E_S)\ S\subseteq G,\,\text{connected} }{\arg\max} \left[\sum_{n\in V_S} p_n + \sum_{e\in E_S} p_e - |E_S| C_e\right]$$

where $p_n$, $p_e$ are retrieval-rank-based prizes and $C_e$ is an edge cost. A near-linear PCST solver produces a relevant, small, connected subgraph.

1. Generation:
   • Encode $S^*$ with a graph attention network (GAT) to compute a graph embedding $h_g$.
   • Project $h_g$ into the LLM embedding space via an MLP.
   • Linearize $S^*$ into a succinct textual summary.
   • Soft prompting: Concatenate projected $h_g$ and $[\,\text{textualized}\ S^*; q\,]$ as input to a frozen LLM (e.g., LLaMA-2-7B).
   • Backpropagate only through the GNN and projection layers (“graph prompt-tuning”).

All reasoning steps are thus grounded in a minimal, query-relevant, and context-constrained subgraph (He et al., 2024).

3. Formal Subgraph Optimization and RAG Mechanics

Subgraph selection is cast as PCST with the following properties:

• Each top-$k$ node/edge receives a nonnegative prize: $k, k-1, ..., 1$ (rest are zero).
• Edges have fixed cost $C_e$.
• Edge prizes can be mapped to nodes via “virtual nodes.”
• The optimal subgraph $S^*$ must be connected, guaranteeing that multi-hop paths relevant to the question are preserved.

RAG mechanics proceed as:

• Use a text encoder (e.g., Sentence-BERT) for embedding.
• ANN search retrieves top-$k$ nodes/edges.
• PCST produces $S^*$ for grounded context.
• GAT pooling and MLP projection produce the prompt embedding.
• Only GNN/MLP parameters are trained; the LLM is fixed.

4. Empirical Performance and Ablation Analysis

Quantitative results on the GraphQA benchmark demonstrate the system’s robustness and empirical superiority over baselines.

Dataset	Baseline (PT w/o retrieval)	G-Retriever	LoRA Baseline	G-Retriever+LoRA
ExplaGraphs	0.5876	0.8696	0.8741	0.8768
SceneGraphs	0.6851	0.8614	0.8594	0.9077
WebQSP (Hit@1)	0.4975	0.6732	0.6174	0.7011

Efficiency gains are pronounced, e.g., for WebQSP the token count after retrieval drops $100{,}627 \to 610$ ($-99\%$), and node count drops $1{,}371 \to 18$ ($-99\%$).

Ablations reveal the importance of each module: removing the graph encoder ($-$11.42\% Hit@1 on WebQSP), the projection layer ($-$2.32\%), the textual subgraph ($-$19.58\%), node retrieval ($-$1.10\%), or edge retrieval ($-$13.29\%) all degrade performance (He et al., 2024).

5. Hallucination Mitigation and Scalability

G-Retriever demonstrates strong hallucination resistance. On scene graphs, citation-validity (i.e., proportion of answers with fully valid grounding) climbs from 8\% (frozen LLM w/ prompt tuning) to 62\% (+54\%) with G-Retriever; node and edge citation validity also increase dramatically ($31\% \to 77\%$, $12\% \to 76\%$).

Scalability is ensured by (i) subgraph selection that fits within model context, (ii) connectivity constraints for multi-hop preservation, and (iii) parameter-efficient finetuning: only the GNN and projection require updates.

6. Algorithmic Design and Implementation

Pseudocode for G-Retriever GraphQA Core Loop:

def GRetrieverQA(G, q): # Indexing for n in nodes(G): z_n = TextEmbedder(x_n) for e in edges(G): z_e = TextEmbedder(x_e) build_KNN_index([z_n] + [z_e]) # Retrieval z_q = TextEmbedder(q) V_k = KNN_nodes(z_q, k) E_k = KNN_edges(z_q, k) # PCST assign_prizes(V_k, E_k) S_star = SolvePCST(G, prizes, cost) # Answer generation h_g = GAT(S_star) h_g_proj = MLP(h_g) txt_S = textualize(S_star) h_t = TextEmbedder(txt_S + q) Y = LLM.generate(input=concat(h_g_proj, h_t)) return Y, S_star

Gradients flow through the GAT and MLP, not the LLM.

7. Significance, Impact, and Future Directions

G-Retriever bridges the gap between graph-structured retrieval and scalable, faithful generative answer synthesis. Its design enables:

• Scalability: Efficient subgraph selection on graphs with thousands of nodes/edges.
• Faithfulness: All reasoning steps are grounded in retrieved graph elements, sharply reducing hallucinations.
• Parameter efficiency: Pure prompt tuning by freezing the LLM and updating only a small GNN head.

The approach forms the basis for subsequent research on combinatorial subgraph selection, prompt-based grounding of LLMs, and retrieval-augmented explainability in GraphQA. Empirical advances set new performance levels on multi-domain benchmarks and mark a shift towards explainable, scalable graph reasoning under tight context constraints (He et al., 2024).