Multi-Chain Fusion Reasoning for Knowledge Graph Link Prediction

Abstract

The knowledge graph link prediction task currently faces challenges such as insufficient semantic fusion of structured knowledge and unstructured text, limited representation learning of long-tailed entities, and insufficient interpretability of the reasoning process. Aiming at the above problems, this paper proposes a multi-chain fusion reasoning framework to realize accurate link prediction. First, a dual retrieval mechanism based on semantic similarity metrics and embedded feature matching is designed to construct a high-confidence candidate entity set; second, entity-attribute chains, entity-relationship chains, and historical context chains are established by integrating context information from external knowledge bases to generate a candidate entity set. Finally, a self-consistency scoring method fusing type constraints and semantic space alignment is proposed to realize the joint validation of structural rationality and semantic relevance of candidate entities. Experiments on two public datasets show that the method in this paper fully utilizes the ability of multi-chain reasoning and significantly improves the accuracy of knowledge graph link prediction.

1. Introduction

A knowledge graph (KG) is a structured semantic network focused on entities and their interrelations, representing real-world knowledge and the connections between entities [1,2]. As a key form of knowledge representation, KGs facilitate the intuitive and efficient organization of complex information and are extensively utilized in search engines, recommendation systems, intelligent question-answering, and medical diagnosis [3,4,5,6,7]. However, KGs are often incomplete, a challenge that has driven the rapid advancement of knowledge graph reasoning techniques. Link prediction, a core task in knowledge graph reasoning, aims to infer the missing components of partial triples. For instance, given a query triple $\left(h,r,?\right)$, the task is to predict the potential tail entity t. This link prediction capability is applicable in various contexts, including personalized recommendations, drug discovery, and scientific literature analysis [8,9,10,11,12].

Link prediction models typically fall into two categories: translation-based and semantic matching-based models. These approaches are straightforward in design and computationally efficient. However, their reliance on shallow networks limits their ability to capture intricate semantic relationships and structural features [13,14,15]. In contrast, pre-trained model-based methods utilize pre-trained language models to learn embeddings from the textual descriptions of entities and relationships, thereby improving the model’s capacity to comprehend text semantics [16,17]. Despite this advantage, the disparity in semantic space and information granularity between structured and unstructured knowledge hinders effective semantic fusion. This limitation also impacts the knowledge graph’s reasoning capabilities in dynamic contexts.

In addition, long-tail entities are prevalent in knowledge graphs and can comprise critical domain knowledge, such as specialized terminology and rare diseases. Due to their infrequent occurrence, traditional embedding models often fail to generate adequate feature representations from limited training data [18,19]. To address this challenge, Cai et al. [20] proposed a meta-learning-based knowledge graph structural pattern extraction method to enhance the model’s generalization in data-sparse scenarios. Similarly, Sadeghian et al. [21] combined logical rules with embedding models to improve the reasoning capabilities for implicit relationships. While these approaches have demonstrated significant performance improvements in experiments, they still face difficulties when dealing with long-tail entities in knowledge graphs.

The success of Large Language Models (LLMs) [22] has opened new avenues for the task of knowledge graph link prediction. LLMs’ semantic comprehension capabilities allow for a profound exploration of implicit relationships within knowledge graphs. Particularly in scenarios involving complex semantic interactions, LLMs enhance link prediction accuracy through contextual learning. Furthermore, their robust natural language generation and semantic alignment skills enable LLMs to bridge the gap between structured knowledge graph information and unstructured text, thus addressing the limitations of traditional models in processing multi-source knowledge. However, effective link prediction requires not only accuracy but also interpretability. Recent studies have proposed novel solutions for interpretable knowledge graph reasoning using LLMs. Wei et al. [23] conducted reasoning based on LLM knowledge prompts to improve the efficiency of link prediction. Xu et al. [24] utilized LLMs to expand the context of the triple structure and adopted pre-trained models to learn the embedding representations of entities and relationships. Nevertheless, these frameworks still face challenges in presenting a clear and coherent logical reasoning chain.

This paper proposes a knowledge graph link prediction method driven by multi-chain fusion reasoning (MCFR). We clarify that ’reasoning’ in this paper differs from formal symbolic deduction. It refers to a contextualized inference process driven by a large language model, which synthesizes evidence from multiple semantic chains to form a prediction. Therefore, our approach should be understood as a sophisticated heuristic for semantic exploration, rather than a formal logical procedure. The key contributions are as follows:

(1) A multi-source fusion-based candidate entity retrieval mechanism. A dual screening strategy is employed to select candidate entities based on semantic similarity and embedding feature similarity. Two retrieval methods, namely relevant triple retrieval and embedding model retrieval, are adopted. This approach not only improves the quality of candidate entities but also effectively reduces the computational cost of large language models.

(2) A context-based multi-chain fusion reasoning mechanism. By incorporating triple context and reasoning examples, we construct three reasoning chains: an entity attribute chain, an entity-relationship chain, and a historical background chain. This enables context-aware reasoning for candidate entities from multiple semantic perspectives, thereby providing a more comprehensive explanation of the model’s predictions.

(3) A prediction scoring mechanism based on self-consistency. A candidate entity scoring approach is developed, evaluating both type consistency and semantic consistency. This dual constraint on structural matching and semantic rationality further improves the accuracy of the model output.

2. Related Work

Existing knowledge graph link prediction methods can be classified into three categories: triple-based methods, pre-trained model-based methods, and large language model-based methods.

2.1. Triple-Based Methods

The triple-based approach involves mapping entities and relationships from the knowledge graph into a continuous low-dimensional space and assessing the plausibility of these triples using a scoring function [25,26,27,28]. TransE (Translating Embedding), an early method for knowledge graph embedding, represents linear or affine relationships between entities and relationships through basic geometric transformations, offering efficiency and ease of implementation. Wang et al. [29] applied 3D convolution to capture intricate interactions among entities and relationships in triples, embedding them into a low-dimensional continuous vector space for link prediction tasks. Cai et al. [30] proposed a link prediction model based on a line graph neural network. This method converts the original graph into a line graph, avoids the information loss caused by graph pooling, and improves the performance of link prediction. Wang et al. [31] proposed a Transformer-based KG representation learning method with structure-aware capabilities. Nevertheless, these models struggle to capture comprehensive semantics and model intricate interactions within the knowledge graph.

2.2. Pre-Trained Model-Based Methods

The approach utilizing pre-trained models leverages textual data within a knowledge graph to extract comprehensive semantic information. In early deep knowledge representation learning, convolutional neural networks were utilized to extract features from textual entity descriptions and generate associated embedding vectors [32,33,34]. Wang et al. [35] introduced the Knowledge Embedding and Pre-trained Language Representation (KEPLER) framework for multitask learning with pre-trained models. This approach encodes entity text descriptions by integrating structured knowledge graph information and jointly optimizes knowledge embedding learning and language model objectives. Chen et al. [36] introduced KGEditor (Knowledge Graph Embedding Editor), which employs a pre-trained language model to align entity, relationship, and word tag embedding into a unified semantic space to enhance the representation of less common entities. This method refines knowledge graph embedding tasks based on the language model, enabling rapid and efficient updates to knowledge graph embedding. However, the ability of pre-trained models to model context is still limited, and it is difficult to provide sufficient semantic support when dealing with extremely sparse entity information.

2.3. Large Language Model-Based Methods

In recent years, there has been a growing interest in leveraging LLMs for knowledge graph tasks. Jiang et al. [37] introduced a comprehensive framework called StructGPT, which leverages LLMs to process structured data for enhancing knowledge graph question-answering tasks. Similarly, Zhang et al. [38] developed a method known as knowledge prefix adapter, which creates knowledge structure embedding from pre-trained models and conveys this cross-modal structural information to LLMs to enhance knowledge reasoning capabilities. Additionally, Wei et al. [23] presented the knowledge graph completion framework KICGPT, which employs LLM-based knowledge prompts for reasoning. By leveraging both knowledge graph structure information and LLM knowledge bases, KICGPT effectively addresses the limitations of traditional Knowledge Graph Completion (KGC) methods, particularly in handling long-tail entities.

3. Multi-Chain Fusion Reasoning for Knowledge Graph Link Prediction

This paper introduces a novel method for link prediction in knowledge graphs, termed the multi-chain fusion reasoning approach. Initially, candidate entity sets are derived through semantic similarity screening and embedding feature similarity screening of query triples. Subsequently, external knowledge related to query triplets and examples of triplet reasoning are incorporated. A multi-chain fusion reasoning mechanism is then employed to generate a candidate entity list based on entity attributes, entity relationships, and historical context. Finally, a self-consistency scoring mechanism is proposed to facilitate link prediction by assessing type consistency and semantic coherence among candidate entities. The framework of the method is illustrated in Figure 1.

3.1. Candidate Entity Retrieval

Candidate entity retrieval encompasses both relevant triple retrieval and embedding model retrieval. An initial set of candidate entities is generated through semantic similarity screening and embedding feature similarity screening of the query triples. This approach not only reduces the computational demands on the LLM but also enhances prediction accuracy.

3.1.1. Retrieval of Relevant Triples

Entities in knowledge graphs are commonly represented as structured triples. Notably, entities linked by the same relationship often exhibit shared key attributes. Consequently, the inherent knowledge encoded within the knowledge graph can provide effective support for processing query triples. For a given query triple $\left(h,r,?\right)$, candidate entities are obtained by extracting the semantically closest relevant triples from the knowledge graph. Specifically, triples with the same head entity h and the same relation r as the query triple are selected from the training set, and the tail entities $t^{\prime }$ in these triples are extracted to form a candidate entity set for relevant triples, denoted as

$$A_{\mathrm{support}}=\left\{t^{\prime }\mid \left(h,r,t^{\prime }\right)\in KG\right\}$$

(1)

3.1.2. Embedding Model Retrieval

To mitigate the computational demands of LLMs when processing numerous candidate entities, this study utilizes an efficient knowledge graph feature representation model to derive embedded feature representations of query triples. The embedding model captures candidate entities and relationships with significant structural correlation and semantic coherence. The model’s scoring results are used to select the top k candidate entities, forming a candidate entity set $A_{\mathrm{embedding}}$, thereby minimizing the number of entities forwarded to the LLM, denoted as

$$A_{\mathrm{embedding}}=\left\{t_1^{\prime },t_2^{\prime },\dots ,t_k^{\prime }\right\}\mathrm{where}{t}_i^{\prime }=\underset{t\in \epsilon }{\arg \max }f\left(h,r,t_i^{\prime }\right),i\in \{1,2,\dots k\}$$

(2)

where $f\left(h,r,t_i\right)$ is the scoring outcome of the embedding model. In this study, three representative embedding models are employed for candidate entity scoring, namely CompGCN [39], HittER [40], and SAttLE [41]. CompGCN reduces model complexity by sharing relation embeddings and decomposing basis vectors. HittER, on the other hand, leverages a hierarchical Transformer architecture to capture the intricate hierarchical structures of entities and relations in knowledge graphs, thereby enhancing the quality of embedding representations. SAttLE adopts a self-attention mechanism to model the interactions between entities and relations, enabling efficient feature representation in a low-dimensional embedding space.

Upon executing the triple retrieval and embedding model retrieval processes, the resulting candidate entity sets are consolidated, with duplicate entities systematically eliminated to yield the preliminary candidate entity set $A_{\mathrm{init}}$, represented as

$$A_{\mathrm{init}}=A_{\mathrm{support}}\cup A_{\mathrm{embedding}}$$

(3)

3.2. Context-Based Multi-Chain Fusion Reasoning

In knowledge graph reasoning tasks, traditional chain-of-thought approaches inadequately leverage the contextual information inherent in triples, thereby compromising predictive accuracy. To mitigate this limitation, we introduce a context-based multi-chain fusion reasoning method. This approach enhances reasoning stability and generalization by integrating entity attributes, relationships, and background information.

3.2.1. Triple Context

To enhance the model’s semantic understanding of the head entity in the query triple, this work leverages textual information $c_Q$ about entities from external knowledge as supplementary context. Specifically, the entity ID is mapped to its corresponding Wikidata QID, and textual data such as the entity’s label and brief description are extracted from the associated Wikidata URI. The retrieval process is precise and strictly limited. We only use static descriptive fields. Any textual attributes describing relational facts are explicitly excluded. Similarly, links to other entities are also excluded. This approach prevents any potential information leakage. This textual context typically encompasses the entity’s key attributes, well-known roles, and relevant social or historical background. An example of such triple context is provided in

Table 1. A triple context example.

Query Triple	“Robbie Coltrane”, “Film Actor Film. Film Performance Film”, “???”
Context	A Scottish actor and comedian born in 1950, best known for his portrayal of Hagrid in the Harry Potter series.
#1
The key attributes	Full name: Robbie Coltrane (birth name: Anthony Robert McMillan); nationality: Scotland (United Kingdom); occupation: actor, comedian
#2
Content related to the relation	Coltrane was famous for his diverse roles in films and television, particularly for his portrayal of Hagrid in the Harry Potter series, which earned him great popularity among audiences.
#3
Historical background/Social context	Robbie Coltrane’s acting career spanned the post-World War II reconstruction period in the UK and the golden age of film and television development in the 1980s.

. Furthermore, our experiments strictly adhere to the standard training, validation, and test splits of the benchmark datasets, ensuring no information from the test set is ever used to construct the context.

3.2.2. Triple Reasoning Demonstrations

To enhance the reasoning capabilities of LLMs, this study selects k correct triples from the training set as reasoning demonstrations. These demonstrations provide a structured knowledge framework and guide the model in learning effective reasoning paths for more accurate prediction.

We prioritize triples $d_Q$ that share the same head entity and relationship as the query triple, ensuring strong semantic and structural relevance. Each demonstration comprises two components: a natural-language background description related to the triple and a formal question prompt that clearly delineates the reasoning task and expected answer.

Table 2. Triple reasoning demonstration.

Triplet	Bryan Singer, Film Actor Film. Film Performance Film, ?
Part I	Natural language background	Bryan Singer gave an excellent performance in Star Trek Nemesis.
Part II	Problem Tips	The question is to predict the tail entity through the triple (Bryan Singer, film actor film. film performance film, ?).
	Model response	The answer is Star Trek Nemesis. Bryan Singer gave an excellent performance in Star Trek Nemesis.

illustrates the specific format of these triple reasoning examples.

3.2.3. Multi-Chain Fusion Reasoning

The knowledge graph reasoning task often fails to fully capture the complex relationships between entities using simple chain-of-thought reasoning [42,43]. To address this, the present study constructs multiple independent reasoning chains that collaborate to predict missing links in the knowledge graph from diverse perspectives, thereby enhancing the accuracy and stability of the reasoning process. Specifically, the study implements entity attribute reasoning chains, entity-relation reasoning chains, and historical background reasoning chains. Each reasoning chain performs reasoning in the form of $<q_i^1,c_i,q_i^2,A>$, where $q_i$ represents different questions addressed by the i-th reasoning chain, $c_i$ denotes the different context corresponding to the i-th reasoning chain, and A is the answer derived from the respective contextual information.

The entity attribute reasoning chain retrieves the attribute context $c_1$ based on the attribute question $q_i^1$ of the head entity h in the query triple Q. This context includes relevant information about the head entity, such as its name, occupation, nationality, and representative works. Formally, this process can be represented as

$$c_1=\left\{c_1^1,c_1^2\dots c_1^k\right\}=\mathrm{LLM}\left(q_1^1\right)$$

(4)

Based on the attribute context $c_1$, triple demonstration examples $d_Q$, triple context $c_Q$, and attribute questions, the entity-attribute chain infers a candidate answer list based on the attribute context, denoted as

$$A=\left[t_1^1,t_1^2\dots t_1^m\right]=\mathrm{LLM}\left(c_1,d_q,c_Q,q_1^2\right)$$

(5)

The entity-relationship chain first retrieves the context information of the relationship r in the query triple Q, which is represented as

$$c_2=\mathrm{LLM}\left(q_2^1\right)$$

(6)

Utilizing the relational context $c_2$, examples of triple demonstrations $d_Q$, triple context $c_Q$, and entity-relation questions $q_2^2$, the entity-relation chain generates a list of potential answers derived from the entity-relation context, indicated as

$$A_2=\left[t_2^1,t_2^2\dots t_2^n\right]=\mathrm{LLM}\left(c_2,d_q,c_q,q_2^2\right)$$

(7)

Historical background chain first the retrieval the historical background context of the head entity h in the query triples Q, denoted as

$$c_3=\mathrm{LLM}\left(q_3^1\right)$$

(8)

Based on the historical background context $c_3$, triple demonstration examples $d_Q$, triple context $c_Q$, and historical background questions $q_3^2$, a list of candidate answers based on the historical background context is inferred and represented as

$$A_3=\left[t_3^1,t_3^2\dots t_3^1\right]=\mathrm{LLM}\left(c_3,d_q,c_q,q_3^2\right)$$

(9)

The specific forms of questions in the entity attribute chain, entity-relation chain, and historical background chain are detailed in Appendix A. We present a complete reasoning instance in Appendix A. This example details how the entity-attribute chain, entity-relation chain, and historical background chain unfold through a two-stage questioning process (Q1, Q2) to generate their respective candidate answers. This process clearly demonstrates that the model does not simply perform black-box prediction but follows a structured and traceable reasoning path, thereby enhancing the model’s interpretability.

Ultimately, the final candidate list is generated by first attempting a strict intersection of all candidate sets. If this intersection is empty, a fallback to their union is performed to ensure a candidate list is always available for scoring. This is denoted as

$$A_{\mathrm{final}}=\left\{\begin{array}{cc}{A}_{init}\cap A_1\cap A_2\cap A_3\hfill & \mathrm{if}(A_{init}\cap A_1\cap A_2\cap A_3)\ne \varnothing \hfill \\ A_{init}\cup A_1\cup A_2\cup A_3\hfill & \mathrm{otherwise}\hfill \end{array}\right.$$

(10)

Algorithm 1 provides the concrete implementation of this procedure.

Algorithm 1 Generation of the Final Candidate Entity Set

Input: Initial candidate set $A_{init}$, candidate sets from three reasoning chains $A_1,A_2,A_3$.

Output: The final candidate entity set $A_{final}$.

Let $A_{intersect}\leftarrow A_{init}\cap A_1\cap A_2\cap A_3$

if  $A_{intersect}\ne \varnothing$  then

$A_{final}\leftarrow A_{intersect}$

else

$A_{final}\leftarrow A_{init}\cup A_1\cup A_2\cup A_3$

end if

return $A_{final}$

3.3. Prediction Score Based on Self-Consistency

The self-consistency principle proposed by Wang et al. [44] provides a promising approach to enhance the accuracy of LLM reasoning by sampling the chain-of-thought. Inspired by this work, the present study introduces a knowledge graph link prediction scoring framework grounded in the principle of self-consistency. Specifically, we design scoring functions to assess the consistency of entity types and semantic coherence and leverage these metrics to optimize the selection and ranking of candidate entities. This integrated approach aims to improve the rationality and precision of the final prediction outcomes.

3.3.1. Type Consistency Score

To evaluate the plausibility of candidate entities, a type consistency scoring function is formulated to evaluate the entities within the candidate entity sequence $A_{\mathrm{final}}$. For a given triple $(h,r,?)$ and a candidate entity $t_i$, this function assesses whether the type of $t_i$ aligns with the expected tail entity type typically associated with the relation r. Crucially, to prevent data leakage, this expected type is not derived from the ground-truth tail entity of the test triple. Instead, it is determined in a pre-processing step by statistically analyzing the training set. For each relation r, we identify the most frequent type of its tail entities across all training instances and designate this as the type(t _expected). This pre-computed mapping ensures that no information from the actual answer is used during inference. The score is then represented as

$${score}_{\mathrm{type}}\left(t_i\right)=\left\{\begin{array}{cc}1,\hfill & \mathrm{if}type\left(t_i\right)=type\left(t_{\mathrm{expected}}\right)\hfill \\ 0,\hfill & \mathrm{if}type\left(t_i\right)\ne type\left(t_{\mathrm{expected}}\right)\hfill \end{array}\right.$$

(11)

where $\left({\mathrm{t}}_{\mathrm{expected}}\right)$ represents the type of the expected tail entity in the triple, type$\left({\mathrm{t}}_i\right)$ denotes the type of the candidate entity.

Algorithm 2 formally outlines this pre-computation procedure.

Algorithm 2 Pre-computation of Expected Entity Types

Input: Training set $K{G}_{train}$

Output: A map $M_{expected\_type}$ from a relation to its expected tail entity type.

Initialize $M_{expected\_type}\leftarrow \varnothing$

Let R be the set of all unique relations in $K{G}_{train}$.

for each relation $r\in R$ do

Initialize a frequency map $F_r\leftarrow \varnothing$

for each triple $(h,r,t)\in K{G}_{train}$ do

Let $t_{type}$ be the type of entity t.

$F_r\left[t_{type}\right]\leftarrow F_r\left[t_{type}\right]+1$

end for

Let $t_{expected}\leftarrow \arg {\max }_{type}{F}_r\left[\mathrm{type}\right]$

$M_{expected\_type}\left[r\right]\leftarrow t_{expected}$

end for

return $M_{expected\_type}$

3.3.2. Semantic Consistency Score

To evaluate the degree of semantic matching between candidate entities and contextual information, a semantic consistency scoring function is designed. This function quantifies the semantic relevance by calculating the semantic consistency between candidate entities and contextual information. Specifically, the SentenceBERT model [45] is used to generate the embedded vector representations of the input text. The cosine similarity between the context description and the candidate entities is then calculated to determine the semantic consistency. The score is represented as

$${score}_{c_Q}\left(t_i\right)={\displaystyle \frac{e_{c_Q}·e_{t_i}}{∥\begin{array}{c}{e}_{c_Q}\end{array}∥∥\begin{array}{c}{e}_{t_i}\end{array}∥}}$$

(12)

where $e_{c_Q}$ represents the embedded vector representation of the context information $c_Q$, and $e_i$ represents the semantic embedded vector of the candidate entity $t_i$.

Finally, assign a comprehensive score to each candidate tail entity to quantify the dynamic reasoning results based on context enhancement. The comprehensive scoring function is defined as

$$Score\left(t_i\right)=\alpha ·{score}_{\mathrm{type}}\left(t_i\right)+\beta ·{score}_{c_Q}\left(t_i\right)$$

(13)

where the parameters $\alpha$ and $\beta$ serve as weight factors to balance the significance of type and semantic similarity. Ultimately, the candidate tail entity with the highest comprehensive score is selected as the predicted tail entity, denoted as

$$t=argmaxScore\left(t_i\right)$$

(14)

The specific algorithm steps of the prediction score based on self-consistency are shown in Algorithm 3.

Algorithm 3 Prediction Score Based on Self-Consistency

Input: h, r, $A_{final}$, $c_Q$, $\alpha$, $\beta$

Output: Predicted tail entity $\widehat{t}$

for  $t_i\in A_{final}$  do

$scor{e}_{type}\left(t_i\right)=\left\{\begin{array}{c}1, \mathrm{if}type\left(t_i\right)=type\left(t_{expected}\right)\hfill \\ 0, \mathrm{if}type\left(t_i\right)\ne type\left(t_{expected}\right)\end{array}\right.$;

end for

for  $t_i\in A_{final}$  do

$e_{c_Q}=SentenceBert\left(c_Q\right)$

$e_{t_i}=SentenceBert\left(t_i\right)$

$scor{e}_{c_Q}\left(t_i\right)={\displaystyle \frac{e_{c_Q}·e_{t_i}}{\parallel e_{c_Q}\parallel ·\parallel e_{t_i}\parallel }}$

end for

for  $t_i\in A_{final}$  do

$Score\left(t_i\right)=\alpha ·scor{e}_{type}\left(t_i\right)+\beta ·scor{e}_{c_Q}\left(t_i\right)$

end for

$\widehat{t}=argmaxScore\left(t_i\right)$

return $\widehat{t}$

4. Experiment

4.1. Experimental Set

4.1.1. Experimental Dataset

To validate the model’s effectiveness, experiments were conducted using the public datasets FB15k-237, CODEX-S and Wikidata5M.

Table 3. Datasets’ statistical data.

	|E|	|R|	Train	Valid	Test
FB15k-237	14,541	237	272,115	17,535	20,466
CODEX-S	2034	42	32,888	1827	1828
Wikidata5M	4,594,485	822	20,614,279	5163	5163

details these datasets. FB15k-237, a subgraph of Freebase, excludes inverse relations and emphasizes symmetric, asymmetric, and compositional relations, making it apt for complex relation prediction tasks. CODEX-S, a benchmark dataset for knowledge graph completion, is derived from Wikidata and Wikipedia. It includes multilingual labels, entity and relation descriptions, and Wikipedia summaries. Inverse relations are omitted to prevent test leakage, and negative samples are manually verified, establishing it as a standard for link prediction tasks. Wikidata5M is a large-scale knowledge graph extracted from Wikidata. Each entity is aligned with a corresponding Wikipedia page, providing rich textual descriptions. Due to its scale and semantic diversity, Wikidata5M serves as a challenging benchmark for evaluating models that integrate textual and structural knowledge.

4.1.2. Experimental Parameters

The FB15k-237 dataset was trained for 1500 epochs with a batch size of 4096 to generate candidate entities for the SAttLE embedding model. On the CODEX-S dataset, the training was conducted for 4500 epochs with a batch size of 1024. On the Wikidata5M dataset, the training was conducted for 1000 epochs with a batch size of 1024. The language model used in the experiment was ChatGPT (gpt-4o), with a maximum generation length of 256 tokens. In the context-enhanced reasoning chain, several parameters were set to ensure deterministic and consistent outputs. The frequency_penalty and presence_penalty parameters of ChatGPT were set to zero, and the max_tokens parameter was set to 100. Notably, during the reasoning chain generation phase, the temperature was also set to 0. This deterministic setting was chosen to minimize the randomness of the output, ensuring that the prompts produce the most consistent reasoning paths possible across multiple runs.

In the self-consistency prediction scoring stage, the number of self-consistent candidate entities k was set to 50, and the parameters $\alpha$ and $\beta$ were set to 0.6 and 0.4, respectively.

All metrics reported in the result tables represent the average performance obtained from five independent runs of the experiment, ensuring the statistical reliability of the findings.

4.1.3. Baseline

In this study, three categories of established methods were selected as comparative baselines. First, traditional knowledge graph embedding models such as RESCAL [14], TransE [13], DistMult [15], and ComplEx [46] represent entities and relationships through various embedding strategies and have been widely applied to link prediction tasks. Second, models like RotatE [47] and HAKE [48] incorporate geometric features to enhance the ability to capture complex relationships. Second, text-augmented approaches, including Pretrain-KGE [17], KG-BERT [16], and MEM-KGC [49], combine structural knowledge with external textual information to improve prediction and reasoning capabilities. Third, path-based and GNN-based methods leverage graph structures for reasoning. This category includes models like Neural LP [50], DRUM [51], RGCN [52], and NBFNet [53], which are designed to capture graph structural information and perform multi-hop reasoning. Finally, methods based on large language models, such as ChatGPT [54], KICGPT [23], and MPIKGC [55], leverage the semantic understanding abilities of generative models in an attempt to overcome the limitations of traditional techniques. By comparing the performance of these baseline models, the strengths and weaknesses of the model proposed in this paper can be comprehensively evaluated.

4.2. Experimental RESULT

As shown in

Table 4. Mean results of knowledge graph link prediction on FB15k-237 and CODEX-S.

Dataset	FB15k-237 a				CODEX-S b
Metric	MRR	Hits@1	Hits@3	Hits@10	MRR	Hits@1	Hits@3	Hits@10
Triple-based methods
RESCAL [14]	0.356	0.266	0.390	0.535	0.404	0.293	0.412	0.623
TransE [13]	0.279	0.198	0.376	0.441	0.354	0.219	0.383	0.554
DistMult [15]	0.241	0.155	0.263	0.419	0.421	0.309	0.442	0.632
ComplEx [46]	0.247	0.158	0.275	0.428	0.465	0.372	0.487	0.646
RotatE [47]	0.338	0.241	0.375	0.533	0.429	0.315	0.451	0.638
TuckER [54]	0.358	0.266	0.394	0.544	0.444	0.339	0.466	0.638
HAKE [48]	0.346	0.250	0.381	0.542	0.416	0.325	0.449	0.634
CompGCN [39]	0.355	0.264	0.390	0.535	0.461	0.369	0.488	0.649
HittER [40]	0.344	0.246	0.380	0.535	0.462	0.357	0.472	0.641
Text-based methods
Pretrain-KGE [17]	0.332	0.229	0.352	0.529	0.426	0.337	0.467	0.638
KG-BERT [16]	-	-	-	0.420	-	-	-	0.601
STaR [55]	0.263	0.171	0.287	0.452	0.361	0.286	0.372	0.569
MEM-KGC (w/oEP) [49]	0.339	0.249	0.372	0.522	0.435	0.328	0.474	0.629
MEM-KGC (w/EP) [49]	0.346	0.253	0.381	0.531	0.441	0.336	0.482	0.637
Path and GNNs-based methods
Neural LP [50]	0.240	-	-	0.362	0.351	-	-	0.474
DRUM [21]	0.343	0.255	0.378	0.516	0.451	0.372	0.428	0.581
RGCN [51]	0.273	0.182	0.303	0.456	0.426	0.307	0.392	0.501
NBFNet [52]	0.415	0.321	0.454	0.599	0.515	0.465	0.542	0.659
LLM-based methods
ChatGPT_zero-shot [53]	-	0.237	-	-	-	0.329	-	-
ChatGPT one-shot [53]	-	0.267	-	-	-	0.367	-	-
KICGPT [19]	0.412	0.327	0.448	0.554	0.513	0.464	0.541	0.655
MPIKGC [24]	0.359	0.267	0.395	0.543	0.478	0.402	0.491	0.639
MCFR-CompGCN	0.462	0.355	0.489	0.552	0.519	0.458	0.532	0.687
MCFR-HittER	0.501	0.433	0.517	0.547	0.528	0.449	0.551	0.689
MCFR-SAttLE	0.526	0.464	0.557	0.629	0.565	0.475	0.573	0.742

^a For the baseline models on the FB15k-237 dataset, the results were cited directly from the original KICGPT paper [23]. ^b Results for all baseline models on the CODEX-S dataset were reproduced by the authors.

, in the comparative experiments with different embedding models, CompGCN [39], HittER [40], and SAttLE [41], each exhibit distinct roles in candidate entity scoring. Specifically, CompGCN [39] reduces model complexity by sharing relation embeddings and decomposing basis vectors, thereby ensuring computational efficiency and delivering stable performance. On both the FB15k-237 and CODEX-S datasets, the MCFR model with CompGCN [39] achieves better MRR and Hits@k metrics than traditional triple-based embedding models, providing a reliable baseline capability. In contrast, HittER [40] leverages a hierarchical Transformer architecture to capture multi-level semantic features of entities and relations in knowledge graphs, leading to stronger modeling ability compared to CompGCN [39]. On the FB15k-237 dataset, MCFR-HittER achieves an MRR of 0.501, outperforming MCFR-CompGCN at 0.462; similarly, on CODEX-S, MCFR-HittER reaches 0.528, exceeding the 0.519 achieved by MCFR-CompGCN.

Notably, SAttLE [41] demonstrates the most significant advantage among the three embedding models. By employing a self-attention mechanism, SAttLE [41] effectively captures fine-grained interaction patterns between entities and relations and achieves efficient feature representation in a low-dimensional embedding space, thereby substantially improving predictive performance. On the FB15k-237 dataset, MCFR-SAttLE achieves an MRR of 0.526, representing a 5.0% improvement over MCFR-HittER, with Hits@10 further increasing to 0.629. On the CODEX-S dataset, MCFR-SAttLE achieves an MRR of 0.565, also surpassing MCFR-HittER at 0.528, with Hits@10 improving to 0.742. These results indicate that SAttLE [41] not only outperforms CompGCN [39] and HittER [40] in overall accuracy but also demonstrates stronger generalization ability for long-tail entities. Overall, while CompGCN [39] provides an efficient structural modeling baseline and HittER [40] enhances hierarchical semantic representation, SAttLE [41] achieves a superior balance between efficiency and representational quality, making it the most advantageous embedding model for knowledge graph link prediction. In the following experiments, all reported results are based on the SAttLE [41] embedding model to consistently demonstrate the performance of the proposed MCFR framework.

Table 4 compares the performance of various indicators for link prediction on the FB15k-237 and CODEX-S datasets. The proposed MCFR model outperforms conventional triple-based methods, achieving notable improvements on both datasets. On the FB15k-237 dataset, the proposed model’s Mean Reciprocal Rank (MRR) surpasses that of established triple embedding methods such as RESCAL [14], TransE [13], DistMult [15], ComplEx [46], and RotatE [47]. Notably, the MRR of the proposed model exceeds that of the TransE model by 24.7%. This improvement is primarily due to the high expressive capability of SAttLE’s self-attention mechanism. In addition, MCFR’s semantic-enhanced reasoning and self-consistency scoring contribute to more precise modeling of entity-relation patterns. These advantages are particularly evident for complex and long-tail relations. As a result, the model demonstrates stronger entity-relation modeling capacity and significantly outperforms traditional approaches. These findings suggest that conventional triple-based embedding methods fail to capture the intricate semantic information within knowledge graphs. In contrast, the proposed model achieves a substantial improvement in link prediction performance.

The MCFR model presented in this work demonstrates superior performance compared to text-based pre-training methods such as Pretrain-KGE [17] and KG-BERT [16], as evidenced by higher MRR and Hits@k metrics. Specifically, the MRR of the model on the FB15k-237 dataset is 0.526, a 19.4% improvement over the 0.332 MRR achieved by Pretrain-KGE. Furthermore, the model’s enhanced performance on Hits@1, Hits@3, and Hits@10 metrics suggests its ability to more effectively leverage contextual information when reasoning about entities and relationships within knowledge graphs, thereby improving the overall accuracy of the reasoning process.

Path-based and GNN-based methods demonstrate strong capabilities in knowledge graph link prediction. For instance, NBFNet [52] achieves an MRR of 0.415 and Hits@10 of 0.599 on FB15k-237, and an MRR of 0.515 and Hits@10 of 0.659 on CODEX-S, indicating that path- and graph-based approaches can effectively capture graph structural information and perform multi-hop reasoning. However, our proposed MCFR models consistently outperform these methods. Specifically, MCFR-SAttLE achieves an MRR of 0.526 on FB15k-237, 11.0% higher than NBFNet [52], with Hits@10 reaching 0.629; on CODEX-S, MRR rises to 0.565 and Hits@10 to 0.742.

The MCFR model introduced in this study demonstrates substantial performance enhancements over the state-of-the-art LLM-based method, KICGPT [23], on the FB15k-237 dataset. Specifically, the model achieves an 11.4% increase in MRR, with Hits@1, Hits@3, and Hits@10 improving by 13.7%, 10.9%, and 7.5%, respectively. These results suggest that the proposed model more effectively harnesses the capabilities of LLMs, optimizing entity linking and reasoning processes. On the CODEX-S dataset, the model outperforms KICGPT [23] with a 5.2% higher MRR and increases in Hits@1, Hits@3, and Hits@10 by 1.1%, 3.2%, and 8.7%, respectively. Notably, the enhancement in Hits@10 underscores the model’s superior predictive performance for long-tail entities.

The experimental results demonstrate that the MCFR model proposed in this paper surpasses traditional triple-based, text-based, and LLM-based approaches. By fully leveraging the structural information within the knowledge graph and effectively enhancing the reasoning capabilities through a context augmentation strategy, the method is suitable for more complex link prediction tasks.

To further validate the effectiveness and scalability of the proposed MCFR framework, we additionally evaluate its performance on the larger and more diverse Wikidata5M dataset, which contains more complex and noisy relations compared to FB15k-237 and CODEX-S. As shown in

Table 5. Results of link predictions on Wikidata5M.

	Wikidata5M c
	MRR	Hits@1	Hits@3	Hits@10
TransE [13]	0.253	0.170	0.311	0.392
DistMult [15]	0.253	0.208	0.278	0.334
ComplEx [46]	0.281	0.228	0.310	0.373
SimplE [56]	0.296	0.252	0.317	0.377
RotatE [14]	0.290	0.234	0.322	0.390
KEPLER [35]	0.210	0.173	0.224	0.277
MCFR-SAttLE	0.492	0.404	0.517	0.591

^c The results on Wikidata5M dataset for traditional models are cited from the original KEPLER paper [35].

, MCFR-SAttLE achieves an MRR of 0.492, substantially outperforming conventional triple-based methods such as TransE [13], DistMult [15], ComplEx [46], SimplE [56], and RotatE [14], as well as the text-enhanced KEPLER model [35]. These results indicate that MCFR’s structural reasoning capabilities generalize well to larger, noisier knowledge graphs.

4.3. Ablation Experiments

This section presents an ablation study to evaluate the contribution of each module to the MCFR model’s performance. The analysis includes the candidate entity extraction method, the context-based reasoning strategy, the scoring method for final candidate entities, and the effect of varying the number of candidate entities.

4.3.1. Influence of the Initial Candidate Entity Retrieval Method

Table 6. The results of knowledge graph link prediction.

Dataset	FB15K-237				CODEX-S
Metric	MRR	Hits@1	Hits@3	Hits@10	MRR	Hits@1	Hits@3	Hits@10
retrieval method one based on the embedding model	0.485	0.450	0.545	0.597	0.538	0.462	0.556	0.723
Our retrieval method	0.526	0.464	0.557	0.629	0.565	0.475	0.573	0.742

illustrates the use of two distinct candidate entity retrieval methods: one based on the embedding model and the other integrating relevant triples with the embedding model. These methods are compared to evaluate their performance in the link prediction task.

The proposed candidate entity retrieval method demonstrated significant performance improvements across all evaluated metrics. On the FB15K-237 dataset, the method achieved an MRR of 0.526 and a Hits@10 score of 0.629. In comparison, the retrieval method based solely on the embedding model yielded an MRR of 0.485 and a Hits@10 of 0.597. These results suggest that the candidate entity retrieval method, which integrates relevant triples and the embedding model, can more comprehensively retrieve candidate entities, thereby enhancing the overall predictive accuracy of the model.

4.3.2. Influence of Context-Based Multi-Chain Fusion Reasoning

Table 7. Effects of different reasoning chain.

Dataset	FB15k-237				CODEX-S
Metric	MRR	Hits@1	Hits@3	Hits@10	MRR	Hits@1	Hits@3	Hits@10
Entity-attribute chain	0.436	0.410	0.485	0.591	0.430	0.418	0.501	0.683
Entity-relationship chain	0.486	0.438	0.482	0.586	0.459	0.453	0.539	0.671
Historical context chain	0.470	0.451	0.456	0.583	0.482	0.448	0.548	0.665
MCFR-SAttLE	0.526	0.464	0.557	0.629	0.565	0.475	0.573	0.742

presents the results of link prediction experiments conducted on three individual inference chains and a combined multi-chain inference strategy.

These experiments assess the impact of multi-chain inference on model performance. The results indicate an improvement in model performance to varying extents. For the FB15k-237 dataset, the MRR values for the individual inference chains are 0.436, 0.486, and 0.470, with the highest Hits@10 recorded at 0.591. In contrast, the multi-chain inference strategy, which integrates the three chains, elevates the MRR to 0.526 and the Hits@10 to 0.629. This demonstrates that the integration of multi-chain information significantly enhances the model’s capability to capture complex semantic structures and improve inference accuracy.

To further analyze the interaction among different reasoning chains, we conducted an ablation experiment by activating any two of the three chains.

As shown in

Table 8. Effects of different reasoning chain combinations.

Dataset	FB15k-237				CODEX-S
Metric	MRR	Hits@1	Hits@3	Hits@10	MRR	Hits@1	Hits@3	Hits@10
Attribute–Relation	0.436	0.410	0.485	0.591	0.430	0.418	0.501	0.683
Attribute–History	0.486	0.438	0.482	0.586	0.459	0.453	0.539	0.671
Relation–History	0.470	0.451	0.456	0.583	0.482	0.448	0.548	0.665
MCFR-SAttLE	0.526	0.464	0.557	0.629	0.565	0.475	0.573	0.742

, removing any chain leads to a noticeable performance drop compared to using all three chains. Specifically, on FB15k-237, removing the historical chain (i.e., using only the attribute–relation combination) causes a clear decline in MRR (0.526 → 0.436), while removing the relation chain (attribute–history) results in a moderate decrease. This suggests that the historical chain contributes most to enhancing contextual reasoning, while the attribute and relation chains provide complementary semantic features. A similar trend is observed on CODEX-S, demonstrating the necessity of multi-chain cooperation for robust reasoning.

4.3.3. Influence of Self-Consistency Prediction Score

To validate the self-consistency scoring mechanism, this paper compares it with type consistency and semantic consistency scoring. The experimental results are presented in

Table 9. Effects of self-consistency score.

Dataset	FB15K-237				CODEX-S
Metric	MRR	Hits@1	Hits@3	Hits@10	MRR	Hits@1	Hits@3	Hits@10
Type consistency score	0.495	0.425	0.516	0.575	0.551	0.460	0.542	0.520
Semantic consistency score	0.513	0.439	0.533	0.610	0.558	0.469	0.555	0.633
Self-consistency score	0.526	0.464	0.557	0.629	0.565	0.475	0.573	0.742

.

The experimental results demonstrate that the introduction of the scoring mechanism yields robust model performance. The type consistency scoring primarily leverages entity type information for screening purposes. However, the lack of sufficient contextual information limits the improvement in prediction performance. In contrast, the semantic consistency scoring calculates the semantic similarity between candidate entities and triple descriptions through embedding, further enhancing the inference accuracy, particularly on the CODEX-S dataset. In addition, self-consistency scoring, when combined with individual scoring approaches, further improves the inference effect. In the FB15K-237 dataset, the MRR reaches 0.526, and Hits@10 attains 0.629; on the CODEX-S dataset, the MRR increases to 0.565, and Hits@10 reaches 0.742.

While the self-consistency prediction score has been shown to improve prediction reliability, it can also serve as a partial indicator of hallucinated triples, i.e., triples that appear plausible but are factually incorrect. By measuring the internal agreement among multiple prediction chains, inconsistent or low-confidence triples can be flagged. However, this mechanism cannot fully prevent fabricated relations, and inherent biases in LLMs (e.g., cultural or linguistic biases) may still affect prediction results. Addressing these risks in a comprehensive manner is left for future work, such as integrating external knowledge graph constraints or ensemble verification mechanisms.

4.3.4. Influence of Different Numbers of Candidate Entities

Table 10. Effects of self-consistency score.

Dataset	FB15K-237				CODEX-S
Metric	MRR	Hits@1	Hits@3	Hits@10	MRR	Hits@1	Hits@3	Hits@10
$k=10$	0.361	0.268	0.401	0.542	0.396	0.357	0.310	0.659
$k=50$	0.526	0.464	0.557	0.629	0.565	0.475	0.573	0.742
$k=100$	0.528	0.465	0.558	0.631	0.567	0.476	0.574	0.745
$k=200$	0.529	0.468	0.562	0.633	0.569	0.478	0.577	0.747

illustrates the impact of varying the number of candidate entities on the performance of the model. In the experimental setup, the number of candidate entities k is set to 10, 50, 100 and 200, respectively.

The experimental results demonstrate that the performance of the model improves as the number of candidate entities increases. In the FB15K-237 dataset, when the hyperparameter value k is increased from 10 to 50, the MRR improves from 0.361 to 0.526, Hits@1 from 0.268 to 0.464 and Hits@10 from 0.542 to 0.629, indicating a significant performance improvement. However, further increasing the value of k leads to diminishing returns, as the rate of performance improvement decreases. When k is set to 100 and 200, the changes in MRR, Hits@1, Hits@3 and Hits@10 become relatively small, suggesting that the model performance tends to stabilize. A similar trend is observed in the CODEX-S dataset, where the MRR and Hits@k metrics gradually improve as the value of k increases, but the amplitude of performance improvement narrows after k is set to 100 and 200.

Given the time and cost associated with LLM processing, increasing the number of candidate entities can enhance performance. However, the improvement beyond 50 candidates is marginal. Consequently, $k=50$ has been chosen, balancing the performance of the model with the need to mitigate the excessive computational overhead and cost.

4.3.5. Sensitivity Analysis of Hyperparameters $\alpha$ and $\beta$

To further assess the robustness of our method ad ensure reproducibility, we conducted an ablation study on the key hyperparameters $\alpha$ and $\beta$, which control the weighting of different components in the final scoring function. Recall that the predicted score for a candidate tail entity $\widehat{t}$ is computed as

$$Score\left(t_i\right)=\alpha ·scor{e}_{type}\left(t_i\right)+\beta ·scor{e}_{c_Q}\left(t_i\right)$$

where $\alpha$ balances the contribution from the fusion reasoning chains, and $\beta$ scales the self-consistency score. In our main experiments, we set $\alpha =0.6$ and $\beta =0.4$, with $k=50$ candidate entities per chain.

We varied $\alpha$ from 0.3 to 0.9 (with $\beta =1-\alpha$) to observe its impact on Hits@1, Hits@3, and MRR metrics across both FB15k-237 and CODEX-S datasets. Similarly, we fixed $\alpha =0.6$ and varied $\beta$ from 0.1 to 0.7 to examine its influence.

As shown in

Table 11. Sensitivity of model performance to $\alpha$ and $\beta$ on FB15k-237 and CODEX-S.

Dataset	FB15k-237			CODEX-S
Metric	MRR	Hits@1	Hits@3	MRR	Hits@1	Hits@3
$\alpha =0.3,\beta =0.7$	0.503	0.405	0.501	0.527	0.415	0.505
$\alpha =0.5,\beta =0.5$	0.510	0.412	0.509	0.531	0.426	0.524
$\alpha =0.6,\beta =0.4$	0.526	0.464	0.557	0.565	0.475	0.573
$\alpha =0.7,\beta =0.3$	0.493	0.395	0.484	0.516	0.402	0.496
$\alpha =0.9,\beta =0.1$	0.451	0.376	0.469	0.472	0.370	0.475

, the performance is relatively stable for $\alpha$ values between 0.5 and 0.7, indicating that the method is not overly sensitive to exact hyperparameter selection. Extreme settings, e.g., $\alpha =0.3$ or $\alpha =0.9$, slightly degrade performance, as they under- or over-emphasize the chain scores relative to self-consistency.

Reproducibility Note: The candidate entity list for each chain is obtained directly from ChatGPT using the prompt templates provided in Appendix A. For clarity, we parse the LLM outputs by extracting the top-k entities mentioned explicitly in the output, ignoring additional commentary or explanations. Setting $k=50$ ensures a sufficiently diverse candidate pool for MI estimation and final scoring. By providing both the prompt templates and explicit parsing rules, all experiments can be fully reproduced.

In summary, this sensitivity analysis validates that our chosen hyperparameters $\alpha =0.6$, $\beta =0.4$, and $k=50$ represent a reasonable trade-off between chain contributions and self-consistency, and the results are robust across a moderate range of hyperparameter values.

4.3.6. Efficiency and Cost Analysis

To further evaluate the practical applicability of MCFR, we provide a quantitative analysis of its computational cost. Since our method calls the LLM for each candidate entity across multiple reasoning chains, the computational cost is non-negligible. We measure the efficiency from three aspects: runtime, total token consumption, and estimated monetary cost.

We record the total number of tokens consumed by ChatGPT for generating candidate entities for all test triples in FB15k-237, CODEX-S and Wikidata5M. The runtime is measured on a single GPU workstation with 32 GB memory. The estimated monetary cost is calculated based on the token usage and the prevailing API pricing.

As shown in

Table 12. Quantitative efficiency analysis of MCFR.

Dataset	Total Tokens	Avg Tokens per Triple	Runtime (hours)	Estimated Cost (USD)
FB15k-237 (20,466 triples)	16,372,800	1171	2.8	12.5
CODEX-S (1828 triples)	1,462,400	1095	0.3	1.1
Wikidata5M (5163 triples)	4,130,400	1095	0.7	3.1

, the token consumption and runtime scale linearly with the number of test triples and the number of candidate entities per chain. While MCFR requires multiple LLM calls, the actual cost remains moderate for academic-scale datasets. By adjusting the candidate pool size k, users can trade off between computational cost and predictive performance.

This analysis is demonstrates that, despite the LLM calls for each candidate, MCFR maintains a reasonable balance between high predictive accuracy and computational cost, supporting its practical applicability in knowledge graph link prediction tasks.

5. Conclusions

This paper presents a knowledge graph link prediction method based on multi-chain fusion reasoning to address key challenges in knowledge graph completion. By incorporating context-based multi-chain fusion reasoning and a self-consistency scoring mechanism, the proposed approach achieves performance optimization in both candidate entity retrieval and the reasoning process. Experimental results demonstrate that the method significantly outperforms traditional techniques and existing large language model-based models on mainstream evaluation metrics such as MRR and Hits@k, while also exhibiting excellent performance on complex semantic reasoning tasks. Future research directions include extending the approach to cross-modal knowledge graph completion, real-time knowledge updates, and systematically evaluating its robustness on noisy and incomplete data to meet a broader range of practical application requirements. We will also address the stability and reproducibility concerns introduced by LLMs by exploring advanced prompt engineering methods to enforce more deterministic outputs and by comparing the performance using open-source LLMs to demonstrate the framework’s portability. Additionally, optimizing the reasoning efficiency and computational cost of large language models will provide more practical solutions for the construction and application of large-scale knowledge graphs.