Technical Summary: Reducing Hallucinations in Language Model-based SPARQL Query Generation Using Post-Generation Memory Retrieval

Problem Statement

Generating SPARQL queries from natural language questions is essential for retrieving structured data from Knowledge Graphs (KGs). While Large Language Models (LLMs) have been adopted for this task, they face significant reliability issues. Specifically, LLMs often hallucinate Uniform Resource Identifiers (URIs) when generating KG elements. Because modern KGs (e.g., Wikidata) utilize opaque, non-semantic identifiers (e.g., "Q937" for Albert Einstein) rather than semantic strings, LLMs must rely solely on their internal parametric memory to map concepts to these IDs. This reliance leads to the generation of plausible-looking but non-existent URIs, compromising the accuracy and safety of information retrieval systems.

Existing solutions like Retrieval-Augmented Generation (RAG) attempt to mitigate this by providing context before generation. However, RAG often fails to eliminate hallucinations because the LLM is not strictly constrained to the retrieved context and may still generate incorrect identifiers based on its internal knowledge. Furthermore, many existing SPARQL generation approaches require "tagged" training data (where URIs are pre-linked to questions), which is labor-intensive and impractical for real-world deployment.

Methodology: PGMR (Post-Generation Memory Retrieval)

The authors propose PGMR, a modular framework that decouples the generation of SPARQL query structure from the resolution of specific KG identifiers. The core innovation is the temporal repositioning of the retrieval phase: instead of retrieving context before generation (as in RAG), PGMR retrieves identifiers after the query structure is formed.

1. Intermediate Query Generation

The LLM is trained or prompted to generate an intermediate SPARQL-PGMR query. In this format:

• The syntactic structure of the SPARQL query is preserved.
• All specific URIs (entities and relations) are replaced with natural language placeholders.
• A mapping block accompanies the query, defining each placeholder with a canonical label and a disambiguating description (e.g., entity0 = [ENT] Hamburg [/ENT] city and state in the North of Germany).

This design allows the LLM to focus on syntactic correctness and logical structure without needing to recall specific opaque IDs from its parametric memory.

2. Post-Generation Retrieval

A non-parametric memory module, consisting of dictionaries for entities and relations, stores embeddings of URI labels and their descriptions paired with the actual URIs.

• Retrieval Process: After the LLM generates the intermediate query, a retriever (using BGE as the encoder and FAISS for similarity search) processes the natural language placeholders.
• Resolution: The retriever matches the placeholder's label and description against the memory to find the most similar URI.
• Final Output: The retrieved URIs replace the placeholders, resulting in a final, executable SPARQL query.

3. Safety Mechanism

PGMR incorporates a retrieval confidence threshold. If the similarity score of the top-ranked retrieved URI for any placeholder falls below a set threshold, the system is designed to refuse the query rather than hallucinate an incorrect ID. This mechanism allows the system to signal uncertainty when knowledge is missing.

Key Contributions

1. Novel Architecture: PGMR explicitly separates query syntax generation (LLM) from identifier grounding (non-parametric retriever), addressing the root cause of URI hallucinations.
2. Training Data Transformation: The authors introduce a systematic process to convert standard question-SPARQL pairs into the PGMR intermediate format, enabling training without the need for pre-tagged URI data in the input questions.
3. Near-Complete Hallucination Elimination: The framework achieves a near-zero rate of URI hallucinations across various models and datasets.
4. Robustness and Safety: The system demonstrates the ability to correctly refuse unanswerable queries via confidence thresholds and maintains performance even when the memory size is expanded with irrelevant, distracting entities.

Experimental Results

The authors evaluated PGMR on LCQUAD 2.0 (both original and "unknown URI" splits) and QALD-10, using models ranging from T5-Small to Llama 3.1 8B and GPT-4o.

• Query Correctness (SQM): PGMR consistently outperformed both direct generation and RAG baselines. On LCQUAD 2.0 (original split), it improved Semantic Query Match (SQM) by approximately 61% over direct generation and 16% over RAG on average.
• Hallucination Reduction: While direct generation hallucinated URIs in ~75% of cases and RAG reduced this to ~8.7%, PGMR achieved a near-complete elimination of URI hallucinations (0.0% to 0.01% across most configurations).
• Out-of-Distribution Robustness: In the "unknown URI" split (where test queries contain URIs unseen during training), PGMR maintained high performance, improving SQM by 73% over direct generation.
• Memory Scaling: When the entity memory was scaled up by 9x with irrelevant distractors, PGMR exhibited minimal performance degradation (only ~4% drop in SQM), demonstrating the retriever's resilience to noise.
• Refusal Accuracy: By adjusting the confidence threshold, the model could effectively refuse to answer queries lacking support in the memory, balancing the trade-off between refusal accuracy and answerability.

Significance and Claims

The paper claims that PGMR offers a robust solution to the reliability crisis in LLM-based KGQA. By deferring identifier grounding to a post-generation retrieval step, the framework ensures that all generated URIs are strictly aligned with existing knowledge graph elements.

The authors emphasize that this approach:

• Enhances Safety: The ability to refuse queries based on retrieval confidence prevents the system from fabricating answers in critical applications.
• Improves Generalization: It performs well even with untagged data and out-of-distribution URIs, making it more practical for real-world deployment than methods requiring extensive tagging.
• Maintains Efficiency: The computational overhead of the retrieval step is negligible compared to the base generation time, as the retrieval process is highly efficient.

The authors modestly note that while PGMR solves the URI hallucination problem, the overall performance is still bounded by the LLM's ability to construct accurate SPARQL query structures, particularly for highly complex queries found in datasets like QALD-10. They suggest that future work could involve combining PGMR with more powerful LLMs or integrating retrieval steps both before and after generation.