Mitigating Hallucinations in Knowledge Graph Completion via Embedding-Guided Instruction Tuning

Abstract

Real-world Knowledge Graphs (KGs) are inherently incomplete, which hinders effective downstream reasoning. While Large Language Models (LLMs) possess powerful semantic capabilities, directly applying them to Knowledge Graph Completion (KGC) often leads to hallucinations and a lack of structural awareness. To address these challenges, we propose Embedding-Guided Instruction Tuning (EGIT), a novel framework that synergizes the structural precision of embedding models with the semantic reasoning of LLMs. Our approach operates in three key stages: (1) utilizing pre-trained embedding models to automatically synthesize high-quality, annotation-free instruction data; (2) fine-tuning the LLM with these structure-aware instructions to adapt it to the KGC task; and (3) employing a joint inference mechanism where the embedding model retrieves candidates and the fine-tuned LLM performs the final selection, thereby significantly reducing hallucinations. In extensive experiments, the best variant of EGIT achieves 7.0% and 2.5% improvements in Hits@1 on the FB15k-237 and WN18RR datasets, respectively.

1. Introduction

In the era of data-driven intelligence, Knowledge Graphs (KGs) have established themselves as the backbone of structured knowledge representation and management by addressing limitations of traditional unstructured data processing (e.g., weak knowledge association, low reasoning interpretability). Their ability to model complex relationships between real-world entities enables support for a wide range of mission-critical applications across domains. For instance, in Question Answering (QA), KGs provide precise logical chains to answer complex natural language queries, significantly improving the accuracy and interpretability of QA systems [1]. In Recommender Systems, rich side information is used to alleviate the cold-start problem, enabling personalized recommendations even with sparse user-item interactions [2]. Furthermore, in scientific domains like Drug Discovery, KGs model intricate interactions between proteins and molecules, accelerating the identification of potential therapeutic targets [3,4].

Despite their immense utility, real-world KGs are notoriously incomplete. For example, over 70% of person nodes in Freebase [5] lack a birthplace relation, and the density of long-tail entities in open-source graphs is often insufficient. This sparsity severely hinders the reasoning capability of downstream models, making Knowledge Graph Completion (KGC)—the task of inferring missing links based on existing facts—a pivotal research focus [6,7].

For the past decade, the dominant paradigm for KGC has been Knowledge Graph Embedding (KGE). Traditional methods map entities and relations into low-dimensional vector spaces, scoring triples based on geometric distances or tensor factorization. While these models excel at capturing local structural patterns, they suffer from a fundamental “semantic gap.” They typically treat entities as discrete, independent identifiers (IDs), discarding the rich semantic information embedded in textual descriptions, which limits their generalization ability in inductive settings [8].

Recently, Large Language Models (LLMs) have revolutionized this landscape. By linearizing triples into natural-language sequences, LLMs can leverage their vast pre-trained knowledge to predict missing links, theoretically overcoming the semantic limitations of KGEs [9]. However, applying generative LLMs to the rigid task of link prediction introduces a new, critical challenge: Hallucination [10]. The core conflict lies in the objective mismatch: LLMs are designed for open-ended probabilistic generation, whereas KGC requires precise closed-set discrimination. Without strict constraints, an LLM might confidently generate a plausible-sounding but non-existent entity, leading to factually incorrect predictions [11]. This issue is exacerbated when the LLM’s internal knowledge conflicts with the specific schema of the target KG [12].

In the context of knowledge graph completion, hallucination refers to model predictions that violate the structural constraints of the target knowledge graph under the closed-world assumption. Specifically, this includes: (1) generating entities or relations that do not belong to the predefined entity or relation set of the graph; and (2) selecting structurally implausible entities that appear semantically plausible due to over-reliance on the language model’s parametric knowledge rather than graph evidence. Unlike hallucination in open-ended natural language generation, hallucination in KGC is fundamentally a structure violation problem rather than a linguistic inconsistency problem.

Existing attempts to bridge this gap generally fall into two categories: In-Context Learning (ICL) and Adapter-based tuning. Methods like KICGPT [13] retrieve relevant triples as few-shot demonstrations to prompt the LLM. While cost-effective, ICL is highly sensitive to prompt selection and limited by the context window size [14]. Adapter-based methods, such as KoPA [15], inject structural embeddings via soft prompts. However, these methods primarily focus on feature alignment rather than enabling the model to effectively discriminate between true facts and “hard negatives”.

To address these limitations, we propose a novel hybrid framework: Embedding-Guided Instruction Tuning (EGIT). Our core insight is to utilize the lightweight KGE model as a “structural anchor” to guide the semantic reasoning of the LLM. Specifically, we design an automated instruction generation pipeline. Before fine-tuning, a pre-trained KGE model is employed to retrieve a candidate list containing both the ground truth and “hard negatives.” These candidates are then incorporated into a multiple-choice instruction template. This strategy transforms the unconstrained generation task into a constrained discrimination task, enabling the LLM to better discern the subtle distinctions between valid facts and structural noise. We further employ Low-Rank Adaptation (LoRA) [16] to efficiently adapt the LLM to this structure-aware task. During inference, we adopt a “Retrieve-then-Rerank” pipeline: the KGE model acts as a high-recall retriever to narrow the search space, and the fine-tuned LLM acts as a high-precision reranker to make the final prediction [17].

EGIT differs from existing instruction-tuning or retrieval-augmented approaches in three fundamental aspects. First, unlike RAG, which only injects retrieved knowledge at inference, EGIT uses embedding-based retrieval to construct hard-negative-aware instructions during training, thereby transforming KGC into a structure-constrained discrimination task. Second, we introduce a structure-guided attention bias that explicitly alters the attention distribution inside the Transformer, rather than treating structural signals as passive context. Third, EGIT enforces training–inference alignment, where the candidate set mechanism used during fine-tuning is identical to that used at inference, reducing distribution mismatch and hallucination risk.

Although EGIT adopts a retrieval-and-reranking style pipeline at inference, it is fundamentally different from existing retrieve-and-rerank or instruction-tuning approaches in its training paradigm. Conventional methods typically apply retrieval only at inference time to narrow the candidate space, while the language model itself is trained with open-ended or weakly structured supervision. In contrast, EGIT leverages embedding-based retrieval to construct hard-negative-aware instruction data during training, thereby converting knowledge graph completion into a structure-constrained discrimination task. As a result, the LLM is explicitly trained to reason over structurally plausible candidates rather than generate free-form answers, which significantly reduces hallucination risk and improves alignment with the closed-world assumption of knowledge graphs.

The main contributions of this work are summarized as follows:

• We propose a novel instruction generation strategy that utilizes pre-trained KGE models to automatically synthesize high-quality, structure-aware fine-tuning data, effectively eliminating the need for manual annotation.
• We develop a specialized instruction-tuning protocol that adapts LLMs to the structural constraints of KGC tasks, significantly enhancing their discriminative capabilities while mitigating generative hallucinations.
• We introduce a joint prediction pipeline that synergizes the high-recall retrieval of KGE models with the high-precision reasoning of fine-tuned LLMs to ensure robust and accurate link prediction.
• We demonstrate through empirical validation on standard benchmarks that our approach outperforms state-of-the-art baselines, achieving absolute Hits@1 improvements of 7.0% on FB15k-237 and 2.5% on WN18RR compared to the baseline.

2. Related Work

2.1. Geometric and Factorization-Based KGE

Knowledge Graph Embedding (KGE) aims to map entities and relations to continuous low-dimensional vector spaces while preserving the inherent structural information of the graph. These methods can be broadly classified into translational distance models and semantic matching models.

Translational Distance Models. The representative model, TransE [18], interprets a relation as a translation vector connecting head and tail entities, assuming $\mathbf{h}+\mathbf{r}\approx \mathbf{t}$. While computationally efficient, TransE struggles with complex relational patterns such as 1-to-N, N-to-1, and symmetric relations. To overcome these limitations, TransH [19] projects entities onto relation-specific hyperplanes, allowing an entity to have distinct representations under different relations. TransR [20] further extends this by modeling entities and relations in separate spaces, using projection matrices to map entities from the entity space to the relation space. More recently, RotatE [21] defines relations as rotations in a complex vector space. By leveraging Euler’s identity, it theoretically proves its ability to model symmetry, antisymmetry, inversion, and composition patterns. HAKE [22] introduces a hierarchy-aware knowledge graph embedding model that maps entities into polar coordinates to better capture semantic hierarchies in taxonomy graphs.

Semantic Matching Models. These models calculate plausibility scores using similarity-based functions. DistMult [23] employs a bilinear diagonal model, capturing interactions through element-wise products. However, its symmetric scoring function restricts it from modeling asymmetric relations. ComplEx [24] solves this by introducing complex-valued embeddings and utilizing the Hermitian product to handle asymmetry. TuckER [25] proposes a more generalized framework based on Tucker decomposition, which learns a core tensor to model interactions between entity and relation embeddings, subsuming DistMult and ComplEx as special cases. SimplE [26] provides another fully expressive model based on Canonical Polyadic decomposition, allowing for independent embeddings for head and tail roles.

While these embedding-based methods are effective at modeling structural patterns, they lack rich semantic knowledge and struggle with long-tail entities and complex reasoning, often resulting in suboptimal performance in open-domain scenarios.

2.2. Neural and Graph-Based Architectures

Beyond shallow linear models, deep neural architectures have been introduced to capture non-linear interactions and graph topology.

CNN-based Models. ConvE [27] is the first model to use 2D convolutional neural networks for KGC. It reshapes head and relation embeddings into 2D images and applies convolution filters to extract local interaction features, significantly improving performance on link prediction. ConvKB [28] adopts 1D convolution to capture global relationships among entities and relations, treating triples as sequence data.

GNN-based Models. Graph Neural Networks (GNNs) explicitly leverage the graph connectivity. R-GCN [29] generalizes graph convolutions to multi-relational data, aggregating neighborhood information to update entity representations. CompGCN [30] integrates composition operations (e.g., subtraction, multiplication) into GCNs to handle multi-relational data effectively. NBFNet [31] parameterizes the Bellman-Ford algorithm with neural networks, capturing path-based reasoning and offering interpretability. Furthermore, RED-GNN [32] utilizes subgraph reasoning to improve inductive performance, demonstrating the power of topological awareness in KGC. Despite their efficiency, these structure-based methods treat entities as opaque IDs, failing to leverage the rich semantic information contained in textual names and descriptions [33].

2.3. Pre-Trained Language Models

With the advent of Pre-trained Language Models (PLMs) like BERT, researchers have started to integrate textual semantics into KGC.

Cross-Encoder Paradigm. KG-BERT [34] treats triples as text sequences and employs BERT to classify their plausibility. StAR [35] adopts a two-tower architecture to encode structural and textual information separately, interacting them via complex matching networks to reduce computational overhead. Structure-BERT [36] extends BERT pre-training tasks to include entity alignment and triple classification, further aligning language representations with KG structures. These methods achieve high accuracy but suffer from high computational costs during inference, as every candidate triple must be fed into the heavy PLM.

Bi-Encoder Paradigm. To improve efficiency, SimKGC [37] utilizes a bi-encoder architecture with contrastive learning. It encodes the query (head, relation) and the candidate (tail) independently, allowing for fast retrieval via Maximum Inner Product Search (MIPS). KGT5 [38] proposes a sequence-to-sequence framework that unifies KGC and QA, significantly reducing model size while maintaining competitive accuracy. Despite their semantic awareness, these PLM-based methods operate in a discriminative manner—ranking a fixed set of candidates—and lack the flexibility to generate answers for open-ended queries or explain their reasoning.

2.4. Generative LLMs and Hallucination Mitigation

The emergence of Large Language Models (LLMs) has shifted the focus from discrimination to generation. Generative KGC aims to directly output the target entity given a query.

Generative KGC. GenKGC [39] explores prompting generative models for link prediction using schema-aware prompts. AutoKG [40] employs autonomous agents to construct and complete KGs. InstructKGC [41] demonstrates that instruction tuning can unlock the few-shot capabilities of LLMs for KGC tasks, aligning LLMs with the format of triple completion.

The Hallucination Challenge. A critical bottleneck for generative KGC is “hallucination”, where LLMs generate plausible but factually incorrect entities [10]. This stems from the mismatch between the LLM’s open-world pre-training and the KGC task’s closed-world constraints [11]. Recent works attempt to mitigate this via retrieval-augmented generation (RAG) [42] or post-hoc verification. KICGPT [13] employs In-Context Learning (ICL) by retrieving relevant triples as few-shot demonstrations. KoPA [15] injects structural embeddings via prefix adapters. However, ICL is limited by context window size, and adapters often fail to fully constrain the generation space. Ultra [43] introduces a foundation model for reasoning on graphs to improve generalization. In contrast, our work proposes an Embedding-Guided Instruction Tuning strategy. By constructing “hard-negative aware” instructions derived from lightweight KGE models, we explicitly enable the LLM to adhere to structural constraints during the fine-tuning stage [17,44].

Existing LLM-based KGC methods can be broadly categorized into retrieval-augmented generation, in-context learning, and instruction-tuning paradigms. Retrieval-augmented or retrieve-and-rerank methods primarily rely on external retrieval modules at inference time, while the LLM remains largely unconstrained during training. Instruction-tuning approaches adapt LLMs to KGC formats but typically lack explicit structural grounding derived from the graph topology. In contrast, EGIT introduces embedding-guided retrieval during instruction construction, embedding hard negatives directly into the training data. This design enforces structural constraints throughout both training and inference, distinguishing EGIT from prior approaches that combine retrieval and LLM reasoning in a decoupled manner.

3. Preliminaries

3.1. Notation Definitions

Let $\mathcal{G}=(\mathcal{E},\mathcal{R},\mathcal{T})$ denote a knowledge graph, where $\mathcal{E}=\{e_1,e_2,\dots ,e_N\}$ is the set of entities, $\mathcal{R}=\{r_1,r_2,\dots ,r_M\}$ is the set of relations, and $\mathcal{T}=\left\{\right(h,r,t\left)\right\}$ is the set of triples with $h\in \mathcal{E}$ (head entity), $r\in \mathcal{R}$ (relation), and $t\in \mathcal{E}$ (tail entity). For the knowledge graph completion task, an incomplete triple is defined as $\tau =(h,r,?)$ (missing tail entity) or $\tau =(?,r,t)$ (missing head entity).

Let ${\mathcal{M}}_{EMB}$ be a knowledge graph embedding model that maps entities and relations into a low-dimensional vector space, i.e., $\mathit{h},\mathit{t}\in {\mathbb{R}}^d$ and $\mathit{r}\in {\mathbb{R}}^d$, where d is the embedding dimension. ${\mathcal{M}}_{LLM}$ represents a pre-trained large language model, and ${\mathcal{M}}_{LLM}^{FT}$ denotes the model after instruction tuning; ${\mathcal{D}}_{FT}$ is the instruction tuning dataset; $\mathcal{C}(h,r,?)$ is the candidate entity list corresponding to the incomplete triple $(h,r,?)$ with length K.

3.2. Definition of Knowledge Graph Completion Task

The goal of knowledge graph completion is to predict the missing components of incomplete triples, which can be divided into three subtasks:

1.

Prediction of tail entity: Given the head entity h and the relation r, predict the tail entity $t^{\ast }$ that satisfies $(h,r,t^{\ast })\in \mathcal{T}$. Its mathematical expression is as follows:

$$t^{\ast }=\arg \underset{t\in \mathcal{E}}{\max }P\left(t\right|h,r;{\Theta }_{EMB}),$$

(1)

where ${\Theta }_{EMB}$ is the set of parameters of the embedding model, and $P\left(t\right|h,r;{\Theta }_{EMB})$ is the probability that the entity t is the correct tail entity.

2.

Prediction of the head entity: Given the relation r and the tail entity t, predict the head entity $h^{\ast }$ that satisfies $(h^{\ast },r,t)\in \mathcal{T}$. The expression is as follows:

$$h^{\ast }=\arg \underset{h\in \mathcal{E}}{\max }P\left(h\right|r,t;{\Theta }_{EMB}).$$

(2)

3.

Prediction of relationships: Given the head entity h and the tail entity t, predict the relation $r^{\ast }$ that satisfies $(h,r^{\ast },t)\in \mathcal{T}$. The expression is as follows:

$$r^{\ast }=\arg \underset{r\in \mathcal{R}}{\max }P\left(r\right|h,t;{\Theta }_{EMB}).$$

(3)

In the closed-domain knowledge graph completion task, the predicted entities or relations must belong to the original entity set $\mathcal{E}$ or the relation set $\mathcal{R}$; in the open-domain scenario, the model can predict entities or relations outside the original sets.

3.3. Knowledge Graph Embedding

The core idea of knowledge graph embedding is to project entities and relations into a continuous vector space and measure the rationality of triples through a scoring function. For example, in the classic TransE model, the scoring function is as follows.

$$f(h,r,t)={\parallel \mathit{h}+\mathit{r}-\mathit{t}\parallel }_2^2.$$

(4)

A smaller score indicates higher rationality of the triple. The model is trained by minimizing the margin-based ranking loss, and the loss function is as follows:

$${\mathcal{L}}_{EMB}=\sum _{(h,r,t)\in \mathcal{T}}\sum _{(h^{\prime },r^{\prime },t^{\prime })\in {\mathcal{T}}_{neg}}\max (0,\gamma +f(h,r,t)-f(h^{\prime },r^{\prime },t^{\prime })),$$

(5)

where ${\mathcal{T}}_{neg}$ is the set of negative triples, and $\gamma$ is the margin hyperparameter.

3.4. Instruction Tuning of Large Language Models

Instruction tuning adapts pre-trained LLMs to specific tasks through supervised learning on instruction datasets containing natural language prompts and reference responses. For KGC, instructions describe completion tasks, and the model learns to output correct entities or relations by minimizing cross-entropy loss:

$${\mathcal{L}}_{FT}=-\sum _{(q,a)\in {\mathcal{D}}_{FT}}\log P\left(a\right|q;{\Theta }_{FT}),$$

(6)

where q is the instruction (including incomplete triples and candidate lists), a is the correct answer, and ${\Theta }_{FT}$ is the fine-tuning parameter set (We employ Low-Rank Adaptation (LoRA) [16] for parameter-efficient fine-tuning, freezing the pre-trained LLM parameters and training only low-rank update matrices $\Delta \mathit{W}=\mathit{B}\mathit{A}$, where $\mathit{B}\in {\mathbb{R}}^{d\times r}$, $\mathit{A}\in {\mathbb{R}}^{r\times k}$ and $r\ll \min (d,k)$.

4. Method

4.1. Overview

The overall framework of Embedding-Guided Instruction Tuning (EGIT) is illustrated in Figure 1. To effectively bridge the gap between structural embeddings and semantic reasoning, EGIT operates through a coherent three-stage pipeline, transforming the KGC task from open-ended generation into structure-constrained discrimination.

Stage 1: Embedding-Guided Data Synthesis. First, we train a lightweight Knowledge Graph Embedding (KGE) model (e.g., TransE, SimKGC) to capture the global structural patterns of the graph. We employ similarity-based retrieval and ranking, which are well-established techniques for KGE models, to predict candidate lists for missing triples. This model serves as a structural prior to identify both ground truth and hard negatives. These candidates are then populated into designed templates to automatically synthesize high-quality, structure-aware instruction datasets, bypassing the need for manual annotation.

Stage 2: Structure-Aware Instruction Tuning. Next, we employ the synthesized data to fine-tune a Large Language Model (LLM). We build upon instruction tuning and QLoRA, and unlike standard instruction tuning, our novel protocol specifically adapts the LLM to the closed-world constraints of KGC. By learning to select the correct entity from the provided candidate list, the LLM aligns its semantic reasoning capabilities with the structural logic of the knowledge graph.

Stage 3: Joint Inference Mechanism. Finally, we implement a “Retrieve-then-Rerank” joint prediction strategy, adopting the two-stage inference architecture. During inference, the KGE model acts as a high-recall retriever, leveraging its strength in entity matching to narrow the search space to a top-K candidate set and filter out massive amounts of irrelevant noise. The fine-tuned LLM then acts as a high-precision reranker, leveraging its semantic knowledge to identify the optimal completion. This collaborative mechanism effectively combines the structural reliability of KGEs with the reasoning power of LLMs, significantly mitigating hallucinations.

4.2. Embedding-Guided Instruction Generation

To efficiently synthesize high-quality training corpora and enforce structural consistency, we design an automated instruction generation pipeline. This module leverages the global structural patterns captured by KGE models to construct annotation-free fine-tuning data.

4.2.1. Instruction Template Design

We first design a structured instruction template to align the KGC task with the generative paradigm of LLMs. As shown in Figure 2a, each instruction consists of four components, and a concrete instance of such a fine-tuning instruction is shown in Figure 2b.

• Query: Describes the task (e.g., tail entity prediction) and provides the incomplete triple $(h,r,?)$ with a natural language prompt.
• Entities: A candidate entity list retrieved by the KGE model using similarity-based ranking, which is a well-established technique. This list serves as the “options” for the LLM, transforming the open-ended generation into a multiple-choice-like discrimination task.
• Info: Contextual information to aid reasoning. In this work, we utilize the textual descriptions of entities provided by the dataset. To filter out irrelevant noise, we select descriptions based on TF-IDF similarity with the query.
• Answer: The ground truth entity, used as the supervision signal for fine-tuning.

To help the LLM parse the structure, we introduce special marker tokens (e.g., [QUERY], [ENTITY]) into the vocabulary.

4.2.2. Automated Data Synthesis

The core of our approach is to utilize a pre-trained KGE model to populate the Entities field in the template. The process involves three steps:

Structural Prior Learning. We first train a lightweight KGE model (e.g., TransE, SimKGC) on the training set ${\mathcal{T}}_{train}$ to learn the vector representations of entities and relations. The training objective is to minimize the margin-based ranking loss or cross-entropy loss, ensuring that the model captures the global topology of the graph.

Candidate Retrieval and Scoring. For each incomplete triple $(h,r,?)$ in the training set, we use the trained KGE model to compute the plausibility score for all entities in the entity set $\mathcal{E}$. This employs similarity-based retrieval and ranking, which are well-established techniques in KGE. The scoring function $f(h,r,t)$ depends on the specific KGE architecture (e.g., distance-based for TransE or semantic matching for ComplEx). To quantify the relevance, we normalize the scores into a probability distribution. For a candidate entity $t_c$, its probability is calculated as follows:

$$P\left(t_c\right|h,r;{\Theta }_{\mathrm{EMB}})={\displaystyle \frac{\exp (f(h,r,t_c)/\tau )}{{\sum }_{t^{\prime }\in \mathcal{E}}\exp (f(h,r,t^{\prime })/\tau )}}$$

(7)

where $\tau$ is a temperature hyperparameter. Alternatively, for distance-based models, similarity can be directly measured via cosine similarity between the query embedding $(h+r)$ and candidate embedding $t_c$:

$$\mathrm{sim}(h,r,t_c)={\displaystyle \frac{{(\mathbf{h}+\mathbf{r})}^{\top }{\mathbf{t}}_c}{{\parallel \mathbf{h}+\mathbf{r}\parallel }_2·{\parallel {\mathbf{t}}_c\parallel }_2}}$$

(8)

Filtering and Synthesis. To construct the final instruction, we sort all entities based on their scores (or probabilities) in descending order. We retain the top-K entities to form the candidate list ${\mathcal{C}}_{cand}$. This truncation strategy serves two purposes: it ensures the inclusion of ground truth and hard negatives (high-ranking but incorrect entities), while filtering out massive amounts of irrelevant noise that might confuse the LLM. Finally, the triplet, the top-K candidate list, the retrieved description (Info), and the ground truth are filled into the template to generate a complete instruction sample. This process is repeated for all triples in ${\mathcal{T}}_{train}$, yielding a large-scale dataset ${\mathcal{D}}_{FT}$ without manual annotation. The overall procedure of this synthesis phase is summarized in Algorithm 1.

Algorithm 1: Fine-tuning Instruction Generation Algorithm Based on Knowledge Graph Embedding Model

4.3. Structure-Aware Instruction Tuning

After synthesizing the instruction dataset, the critical challenge is to adapt the LLM to the strict constraints of the KGC task. Standard LLMs, trained on open-ended text, are prone to hallucinations—generating plausible but non-existent entities. To mitigate this, we propose a novel Structure-Aware Instruction Tuning protocol that explicitly grounds the model’s generation in the provided structural candidates. While we build upon instruction tuning and QLoRA as foundational adaptation techniques, our protocol introduces two key innovations specifically designed for KGC tasks: (1) structural token initialization and (2) attention-enhanced QLoRA, which enable the LLM to better internalize the closed-domain constraints and suppress hallucinations from within the model.

4.3.1. Structural Token Initialization

Standard LLMs treat structural markers (e.g., [ENTITY]) as random new tokens, lacking semantic grounding. This ambiguity often confuses the model, leading to unconstrained generation. To address this, we propose a novel semantic-aware initialization strategy. For a marker m, its embedding ${\mathbf{e}}_m$ is initialized as the centroid of its semantic class:

$${\mathbf{e}}_m={\displaystyle \frac{1}{|{\mathcal{S}}_m|}}\sum _{w\in {\mathcal{S}}_m}{\mathbf{e}}_w$$

(9)

where ${\mathcal{S}}_m$ denotes task-relevant words (e.g., {“entity”, “object”}). This initialization mechanism represents a key methodological innovation in our work. By providing an explicit semantic anchor, it helps the model strictly distinguish between “instructional markers” and “content,” reducing the likelihood of the model misinterpreting the task instruction and drifting into hallucination. Consider an LLM reading: “Predict the missing entity: [Steve Jobs] was the CEO of [ENTITY] Apple.” Without proper initialization, the model might misunderstand [ENTITY] as part of the answer (e.g., “[ENTITY] Steve Ballmer”). By initializing [ENTITY] with the semantic meaning of “entity marker,” the model learns to treat it as a placeholder tag indicating “the answer goes here” rather than actual content.

4.3.2. Attention-Enhanced QLoRA

We adopt QLoRA [45] as our foundational fine-tuning strategy, which is an existing technique that enables efficient model adaptation by freezing the 4-bit quantized LLM backbone and optimizing only a small set of low-rank adapter parameters.

Limitation of Vanilla QLoRA: While efficient, standard QLoRA inherits the vanilla self-attention mechanism of Transformers, which computes attention scores based solely on semantic correlations. This treats all tokens with equal potential importance. However, in KGC tasks, specific structural tokens (i.e., the retrieved candidate entities in ${\mathcal{C}}_{cand}$) carry the critical evidence required for correct discrimination, whereas other context tokens are often mere syntactic noise.

Consider the instruction: “Given (Steve Jobs, CEO, ?), select from: [ENTITY] Tim Cook, [ENTITY] Satya Nadella, [ENTITY] Elon Musk.” Vanilla QLoRA might pay equal attention to words like “Given,” “from,” and the entity names, diluting the signal. Our attention bias tells the model: “Focus more heavily on the actual candidate entities (Tim Cook, Satya Nadella, Elon Musk) since these contain the answer, and pay less attention to the generic template words.”

To address this limitation, we propose Attention-Enhanced QLoRA. This is a core methodological innovation that enhances QLoRA with structure-guided attention mechanisms. Specifically, we introduce a Structure-Guided Attention Bias to explicitly recalibrate the model’s focus. During the fine-tuning phase, we modulate the attention weights to enforce structural awareness. The enhanced attention score ${\widehat{\alpha }}_{i,j}$ is defined as

$${\widehat{\alpha }}_{i,j}=\mathrm{Softmax}\left({\displaystyle \frac{{\mathbf{q}}_i{\mathbf{k}}_j^{\top }}{\sqrt{d}}}+{\mathbf{B}}_{i,j}^{struct}\right)$$

(10)

where ${\mathbf{B}}_{i,j}^{struct}$ is the structural bias term:

$${\mathbf{B}}_{i,j}^{struct}=\left\{\begin{array}{cc}\gamma ,\hfill & \mathrm{if}{w}_j\in {\mathcal{C}}_{cand}\hfill \\ 0,\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(11)

where ${\mathcal{C}}_{cand}$ represents the set of tokens belonging to the candidate entities provided by the KGE model, and $\gamma$ is a learnable or fixed scalar (e.g., $\gamma =0.3$) that amplifies the attention signal. By boosting attention weights specifically for candidate entity tokens, the model is forced to focus its reasoning on the actual valid options provided by the KGE model rather than on irrelevant context words or distractors.

Anti-Hallucination Discussion: This mechanism acts as a “soft structural constraint.” By artificially boosting the attention weights of valid candidates, AEQLoRA effectively suppresses the noise from the LLM’s internal parametric memory. This ensures that the model’s reasoning is grounded in the explicitly retrieved context rather than open-world hallucinations. The attention-enhanced mechanism enables the LLM to better internalize KGC task constraints and suppress hallucinations from within the model.

4.3.3. Optimization Objective

Finally, we optimize the model to minimize the negative log-likelihood of the ground truth entity a given the structure-constrained context q:

$${\mathcal{L}}_{FT}=-\sum _{(q,a)\in {\mathcal{D}}_{FT}}\log P\left(a\right|q;{\Theta }_{LoRA},{\Theta }_{bias})$$

(12)

This loss function forces the LLM to learn that “my answer must come from the constrained candidate set provided by the KGE model,” effectively transforming it from a stochastic generator into a discriminative reasoner and aligning its output space with the closed-world knowledge graph.

4.4. Joint Inference Mechanism

In the link prediction phase, we define a novel collaborative relationship and division of labor between the KGE model and the LLM. We adopt the well-established “retrieve-then-rerank” two-stage inference architecture, but our innovation lies in how KGE and the LLM collaborate specifically for KGC tasks: KGE serves as a high-recall retriever, leveraging its strength in entity matching, while the fine-tuned LLM acts as a high-precision reranker, utilizing its vast pre-trained semantic knowledge. This collaborative paradigm enables complementary advantages and provides a systematic solution for mitigating hallucinations through collaborative reasoning.

For the input incomplete triple, the trained knowledge graph embedding model is first used to generate a predicted candidate entity list. The candidate selection is based on the embedding model’s ranking score:

$$\mathrm{Rank}\left(t_c\right)=\sum _{t^{\prime }\in \mathcal{E},f(h,r,t^{\prime })<f(h,r,t_c)}1,$$

(13)

where $\mathrm{Rank}\left(t_c\right)$ is the rank of candidate $t_c$ (smaller rank indicates higher relevance), and only candidates with $\mathrm{Rank}\left(t_c\right)\le K$ are retained. The candidate list is then filled into the discriminant instruction template and input to the fine-tuned large model. The large model outputs the entity with the highest predicted probability, where the probability of candidate $t_c$ being the correct answer is:

$$P\left(t_c\right|q;{\mathcal{M}}_{LLM}^{FT})={\displaystyle \frac{\exp \left(\mathrm{score}\left(t_c\right)\right)}{{\sum }_{t^{\prime }\in \mathcal{C}(h,r,?)}\exp \left(\mathrm{score}\left(t^{\prime }\right)\right)}}$$

(14)

where $\mathrm{score}\left(t_c\right)$ is the model’s output logit for the token sequence corresponding to $t_c$. The prediction result is ensured to belong to the entity space of the knowledge graph through structured constraints: $t^{\ast }\in \mathcal{E}$.

From a hallucination perspective, EGIT explicitly constrains the output space of the large language model during inference. Since the LLM is required to select an answer from the candidate entity set retrieved by the embedding model, all predicted entities are guaranteed to belong to the entity vocabulary of the target knowledge graph. As a result, out-of-graph or schema-violating hallucinations are structurally impossible in EGIT. This design contrasts with unconstrained generative KGC approaches, where the model may produce entities outside the graph schema due to open-ended decoding.

After completing instruction tuning, we evaluate the fine-tuned large model on the structured link prediction task. For test set triples, the trained KGE model generates candidate entity lists sorted by Equation (7) descending, retaining only top-K entities. This information fills the discriminant instruction template, which lacks the correct answer (unlike fine-tuning instructions). The large model outputs an entity from the candidate entities as the prediction. Prediction confidence is defined as

$$\mathrm{Conf}\left(t^{\ast }\right)=P\left(t^{\ast }\right|q;{\mathcal{M}}_{LLM}^{FT})-\underset{t_c\ne t^{\ast }}{\max }P\left(t_c\right|q;{\mathcal{M}}_{LLM}^{FT}),$$

(15)

where a higher $\mathrm{Conf}\left(t^{\ast }\right)$ indicates a more reliable prediction.

By comparing the model prediction results with the correct answers of the test set, various performance indicators of the model can be calculated, including Mean Reciprocal Rank (MRR) and Hits@K:

$$\begin{array}{cc}\hfill \mathrm{MRR}& ={\displaystyle \frac{1}{N_{\mathrm{test}}}}\sum _{i=1}^{N_{\mathrm{test}}}{\displaystyle \frac{1}{\mathrm{Rank}\left(t_i^{\ast }\right)}},\hfill \\ \hfill \mathrm{Hits}@\mathrm{K}& ={\displaystyle \frac{1}{N_{\mathrm{test}}}}\sum _{i=1}^{N_{\mathrm{test}}}\mathbb{I}(\mathrm{Rank}\left(t_i^{\ast }\right)\le K),\hfill \end{array}$$

(16)

where $N_{\mathrm{test}}$ is the number of incomplete triples in the test set, and $t_i^{\ast }$ is the correct answer for the i-th test triple. This combination of the embedding model and the large language model can effectively avoid the hallucination problem that may occur when using the large language model directly for completion, while fully leveraging the embedding model’s advantages in entity matching and the large model’s massive pre-trained knowledge. The pseudocode of the algorithm is shown in Algorithm 2.

Algorithm 2: Link Prediction Algorithm Combining Embedding Model and Large Language Model

5. Experiments

5.1. Datasets

To evaluate the proposed method, we conduct experiments on two widely used benchmark datasets for knowledge graph completion: FB15k-237 [18] and WN18RR [27]. The FB15k-237 dataset is derived from FB15k by removing inverse relations and contains 14,541 entities, 237 relations, and 310,116 triplets. The WN18RR dataset contains 40,943 entities, 11 relations, and 93,003 triplets. Both datasets are split into training, validation, and test sets. The detailed statistics are shown in

Table 1. Statistics of the datasets used in the experiments.

Dataset	#Entities	#Relations	#Triplets	#Train	#Valid	#Test
FB15k-237	14,541	237	310,116	272,115	17,535	20,466
WN18RR	40,943	11	93,003	86,835	3034	3134

.

5.2. Evaluation Metrics

We adopt standard evaluation metrics for knowledge graph completion: Hits@1, Hits@3, Hits@10, and Mean Reciprocal Rank (MRR). Hits@k measures the proportion of correct entities ranked in the top-k predictions. MRR computes the average reciprocal rank of the correct entity across all test triplets. Higher values indicate better performance.

5.3. Experimental Setup

We compare EGIT with several baseline models, categorized into three groups: (1) Traditional triple-based knowledge graph embedding models (TransE [18], ConvE [27], SimKGC [37], RESCAL [46], ComplEx [24]); (2) GNN-based methods (CompGCN [30], NBFNet [31]); and (3) LLM-based methods (KICGPT [13]).

For our EGIT framework, we use three knowledge graph embedding models (TransE, SimKGC, ComplEx) to generate candidate lists, and two large language models (Llama-3-8B-Instruct, Llama-3.1-8B-Instruct) for fine-tuning and prediction. The hyperparameters of our fine-tuning QLoRA are shown in

Table 2. Hyperparameter settings for QLoRA fine-tuning.

Hyperparameter	Value
rank	64
alpha	16
dropout	0.1
precision	bf16
quantization precision	INT4

.

5.4. Main Results

The comparative results on FB15k-237 and WN18RR are summarized in Table 3 and Table 4, respectively. Overall, our proposed EGIT framework consistently outperforms both traditional embedding-based baselines and recent LLM-based approaches. We highlight three key observations from the empirical analysis:

Synergy of Structure and Semantics. Compared to traditional KGE baselines (e.g., TransE, ComplEx, SimKGC), EGIT achieves significant performance gains. On the complex FB15k-237 dataset, the best variant of EGIT improves Hits@1 by an absolute margin of 7.0% over the base ComplEx (0.341 vs. 0.271). Traditional KGEs rely solely on structural topology and struggle with complex relations that require semantic understanding. By integrating a fine-tuned LLM as a reranker, EGIT successfully injects semantic reasoning into the prediction process, allowing the model to distinguish correct entities based on contextual descriptions even when structural cues are ambiguous.

Mitigation of Hallucinations. A critical advantage of EGIT is evident when compared with the LLM-based baseline, KICGPT. On the WN18RR dataset, KICGPT suffers a significant performance drop (MRR: 0.564), likely due to graph sparsity, which causes In-Context Learning to hallucinate. In contrast, EGIT maintains robust performance (MRR 0.674), outperforming KICGPT by 11.0% in MRR. This validates the effectiveness of our Structure-Aware Instruction Tuning. By constraining the LLM’s output space to the candidate list provided by the KGE model and using Attention-Enhanced QLoRA to focus on these candidates, EGIT effectively suppresses the open-world hallucinations that plague standard generative methods.

Robustness Across Backbones. EGIT consistently improves performance across different KGE backbones (TransE, SimKGC, ComplEx). Even with simple TransE candidates, Llama-3 achieves competitive results, demonstrating the model-agnostic nature of our “Retrieve-then-Rerank” paradigm, where the LLM acts as a universal semantic refiner.

Table 3. Results on the FB15k-237 dataset.

Method	LLM Backbone	MRR	Hits@1	Hits@3	Hits@10
Triple-based methods
TransE [18]	-	0.279	0.198	0.376	0.441
ConvE [27]	-	0.320	0.240	0.350	0.490
SimKGC [37]	-	0.338	0.252	0.364	0.390
RESCAL [46]	-	0.356	0.266	0.390	0.535
GenKGC [39]	-	-	0.192	0.355	0.439
ComplEx [24]	-	0.366	0.271	0.401	0.557
KGTuner [47]	-	0.345	0.252	0.381	0.534
KG-Mixup [48]	-	0.359	0.265	0.395	0.547
UniGE [49]	-	0.343	0.257	0.375	0.523
GNN-based methods
CompGCN [30]	-	0.355	0.264	0.390	0.535
NBFNet [31]	-	0.415	0.321	0.454	0.599
CSProm-KG [50]	-	0.355	0.261	0.389	0.531
LLM-based methods
KICGPT [13]	-	0.412	0.327	0.448	0.581
EGIT
+ TransE	Llama-3-8B	0.372	0.317	0.398	0.514
+ SimKGC	Llama-3-8B	0.398	0.329	0.446	0.539
+ ComplEx	Llama-3-8B	0.418	0.339	0.461	0.577
+ TransE	Llama-3.1-8B	0.368	0.313	0.394	0.512
+ SimKGC	Llama-3.1-8B	0.384	0.327	0.413	0.523
+ ComplEx	Llama-3.1-8B	0.416	0.341	0.454	0.562

Table 3. Results on the FB15k-237 dataset.

Method	LLM Backbone	MRR	Hits@1	Hits@3	Hits@10
Triple-based methods
TransE [18]	-	0.279	0.198	0.376	0.441
ConvE [27]	-	0.320	0.240	0.350	0.490
SimKGC [37]	-	0.338	0.252	0.364	0.390
RESCAL [46]	-	0.356	0.266	0.390	0.535
GenKGC [39]	-	-	0.192	0.355	0.439
ComplEx [24]	-	0.366	0.271	0.401	0.557
KGTuner [47]	-	0.345	0.252	0.381	0.534
KG-Mixup [48]	-	0.359	0.265	0.395	0.547
UniGE [49]	-	0.343	0.257	0.375	0.523
GNN-based methods
CompGCN [30]	-	0.355	0.264	0.390	0.535
NBFNet [31]	-	0.415	0.321	0.454	0.599
CSProm-KG [50]	-	0.355	0.261	0.389	0.531
LLM-based methods
KICGPT [13]	-	0.412	0.327	0.448	0.581
EGIT
+ TransE	Llama-3-8B	0.372	0.317	0.398	0.514
+ SimKGC	Llama-3-8B	0.398	0.329	0.446	0.539
+ ComplEx	Llama-3-8B	0.418	0.339	0.461	0.577
+ TransE	Llama-3.1-8B	0.368	0.313	0.394	0.512
+ SimKGC	Llama-3.1-8B	0.384	0.327	0.413	0.523
+ ComplEx	Llama-3.1-8B	0.416	0.341	0.454	0.562

Table 4. Results on the WN18RR dataset.

Method	LLM Backbone	MRR	Hits@1	Hits@3	Hits@10
Triple-based methods
TransE [18]	-	0.243	0.043	0.441	0.532
ConvE [27]	-	0.430	0.390	0.440	0.510
SimKGC [37]	-	0.671	0.595	0.719	0.802
RESCAL [46]	-	0.467	0.439	0.478	0.516
GenKGC [39]	-	-	0.287	0.403	0.535
ComplEx [24]	-	0.487	0.441	0.501	0.580
KGTuner [47]	-	0.481	0.438	0.499	0.556
KG-Mixup [48]	-	0.488	0.443	0.505	0.541
UniGE [49]	-	0.491	0.447	0.512	0.563
GNN-based methods
CompGCN [30]	-	0.479	0.443	0.494	0.546
NBFNet [31]	-	0.551	0.497	0.573	0.666
CSProm-KG [50]	-	0.569	0.520	0.590	0.675
LLM-based methods
KICGPT [13]	-	0.564	0.478	0.612	0.677
EGIT
+ TransE	Llama-3-8B	0.508	0.496	0.517	0.571
+ SimKGC	Llama-3-8B	0.674	0.620	0.723	0.796
+ ComplEx	Llama-3-8B	0.610	0.569	0.626	0.692
+ TransE	Llama-3.1-8B	0.494	0.479	0.506	0.564
+ SimKGC	Llama-3.1-8B	0.654	0.580	0.725	0.797
+ ComplEx	Llama-3.1-8B	0.604	0.568	0.625	0.689

Table 4. Results on the WN18RR dataset.

Method	LLM Backbone	MRR	Hits@1	Hits@3	Hits@10
Triple-based methods
TransE [18]	-	0.243	0.043	0.441	0.532
ConvE [27]	-	0.430	0.390	0.440	0.510
SimKGC [37]	-	0.671	0.595	0.719	0.802
RESCAL [46]	-	0.467	0.439	0.478	0.516
GenKGC [39]	-	-	0.287	0.403	0.535
ComplEx [24]	-	0.487	0.441	0.501	0.580
KGTuner [47]	-	0.481	0.438	0.499	0.556
KG-Mixup [48]	-	0.488	0.443	0.505	0.541
UniGE [49]	-	0.491	0.447	0.512	0.563
GNN-based methods
CompGCN [30]	-	0.479	0.443	0.494	0.546
NBFNet [31]	-	0.551	0.497	0.573	0.666
CSProm-KG [50]	-	0.569	0.520	0.590	0.675
LLM-based methods
KICGPT [13]	-	0.564	0.478	0.612	0.677
EGIT
+ TransE	Llama-3-8B	0.508	0.496	0.517	0.571
+ SimKGC	Llama-3-8B	0.674	0.620	0.723	0.796
+ ComplEx	Llama-3-8B	0.610	0.569	0.626	0.692
+ TransE	Llama-3.1-8B	0.494	0.479	0.506	0.564
+ SimKGC	Llama-3.1-8B	0.654	0.580	0.725	0.797
+ ComplEx	Llama-3.1-8B	0.604	0.568	0.625	0.689

5.5. Ablation Study

Analysis on Individual Component. To rigorously assess the contribution of individual components in the EGIT framework, we conduct an ablation study on the FB15k-237 dataset. We benchmark the full model against three strategic variants to isolate the effects of structural priors and task-specific adaptation: (1) w/o Fine-tuning, which utilizes the LLM in an inference-only mode with KGE-retrieved candidates but without parameter updates; (2) w/o Candidate List, which fine-tunes the LLM solely on triples without the structural constraints provided by the candidate set; and (3) Direct LLM Prediction, which serves as the lower bound where the vanilla LLM predicts the tail entity directly from the query.

The results are summarized in

Table 5. Ablation study on FB15k-237 dataset (using ComplEx as embedding model and Llama-3-8B).

Variant	MRR	Hits@1	Hits@3	Hits@10
EGIT (Full Model)	0.418	0.339	0.461	0.577
w/o Fine-tuning	0.381	0.302	0.423	0.541
w/o Candidate List	0.342	0.265	0.381	0.498
Direct LLM Prediction	0.287	0.210	0.325	0.443

. We observe that both the structural candidate retrieval and the instruction tuning are indispensable. First, removing the candidate list (w/o Candidate List) leads to a precipitous drop in performance (MRR decreases from 0.418 to 0.342). This shows that purely semantic reasoning is insufficient for KGC; the KGE-retrieved candidates serve as a necessary “structural anchor” to narrow the search space and mitigate open-world hallucinations. Second, even with candidates provided, the lack of fine-tuning (w/o Fine-tuning) results in suboptimal performance (0.381 MRR). This underscores the necessity of our structure-aware adaptation, which aligns the LLM’s reasoning patterns with the discriminatory logic of selecting from a closed set. Notably, the full EGIT framework achieves the highest performance across all metrics, confirming the synergistic effect of combining structural priors with semantic-aware instruction tuning.

Analysis on Hallucination Mitigation. We note that existing benchmark datasets for knowledge graph completion, such as FB15k-237 and WN18RR, do not provide explicit hallucination annotations. Under the standard closed-world evaluation protocol, hallucination is implicitly reflected by ranking-based metrics such as Mean Reciprocal Rank (MRR) and Hits@K, since any incorrect ranking corresponds to selecting a non-factual or structurally invalid entity. Moreover, generative hallucinations such as out-of-vocabulary entities or schema violations cannot occur in EGIT due to its candidate-constrained inference mechanism, whereas such errors may arise in unconstrained generative LLM-based KGC methods.

5.6. Training Cost and Efficiency

To assess the practicality of EGIT, we detail the computational costs involved. All experiments were conducted on a server equipped with an Intel(R) Xeon(R) Platinum 8468V CPU and 128GB of RAM, utilizing four NVIDIA RTX 3090 GPUs (24GB VRAM each). The training process consists of two main phases: (1) KGE Model Training: Training embedding models like TransE or ComplEx on FB15k-237 typically converges within 2–4 h. (2) LLM Fine-tuning: The instruction tuning of the Llama-3-8B model using QLoRA (with hyperparameters in Table 2) is highly efficient. On a single GPU, the fine-tuning process for one dataset completes within 6–8 h, leveraging the significant parameter reduction (e.g., updating only 0.1% of parameters with rank = 64) offered by QLoRA [16]. This demonstrates that EGIT achieves its performance gains without prohibitive computational overhead.

6. Conclusions

In this paper, we presented EGIT, a novel framework that synergizes the structural reliability of KGEs with the semantic reasoning capabilities of LLMs. First, we introduced an Embedding-Guided Instruction Generation pipeline, which synthesizes high-quality, annotation-free training data. Furthermore, we proposed a Structure-Aware Instruction Tuning protocol that incorporates semantic token initialization and Attention-Enhanced QLoRA to ground the model’s reasoning. Finally, we implemented a Joint Inference Mechanism using a “Retrieve-then-Rerank” strategy, which effectively transforms the LLM into a constrained discriminator to mitigate hallucinations.By explicitly constraining both the training and inference processes to structurally valid candidate entities, EGIT mitigates hallucination in KGC by design, aligning large language model reasoning with the closed-world assumptions of knowledge graphs.

Extensive experiments on standard benchmarks (FB15k-237 and WN18RR) demonstrate that EGIT achieves state-of-the-art performance, outperforming both traditional embedding models and recent LLM-based methods. We note that the inference latency introduced by the LLM reranking stage is relatively high compared with that of lightweight embedding models. In the future, we aim to explore knowledge distillation techniques to accelerate the inference process and extend our framework to inductive settings.