💬 NLP

Graph Fusion Across Languages using Large Language Models

This paper proposes a novel framework that leverages Large Language Models' in-context reasoning and multilingual capabilities to perform cross-lingual graph fusion by linearizing graph triplets into natural language sequences, thereby effectively resolving semantic heterogeneity and enabling the scalable agglomeration of heterogeneous knowledge graphs.

Original authors: Kaung Myat Kyaw, Khush Agarwal, Jonathan Chan

Published 2026-03-24

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Kaung Myat Kyaw, Khush Agarwal, Jonathan Chan

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build the world's biggest, most complete encyclopedia. But here's the catch: you have thousands of different notebooks. Some are written in English, some in Chinese, some in French, and some in Japanese.

The problem? They don't just use different words; they organize information differently.

In the English notebook, there's a page for "The Eiffel Tower."
In the French notebook, there's a page for "La Tour Eiffel."
In the Chinese notebook, the facts are grouped under a different category entirely.

If you try to glue these notebooks together manually, it would take a lifetime. If you try to use old computer programs to do it, they often get confused because they need a "cheat sheet" (a list of pre-matched pairs) to start, and for many languages, that cheat sheet doesn't exist.

This paper introduces a new, smarter way to do this using Large Language Models (LLMs)—the same kind of AI that powers chatbots like the one you're talking to now.

Here is how their solution works, broken down into simple analogies:

1. The Problem: The "Tower of Babel" of Data

Think of Knowledge Graphs as giant webs of facts.

Old Method: Imagine trying to match two webs by looking at the color of the threads. If the English web uses red thread for "Capital City" and the French web uses blue, the old computers get confused. They need a human to say, "Hey, red means blue here," before they can start.
The New Problem: What if you have 10 different webs (10 languages)? If you try to match them all at once, the computer gets overwhelmed. It's like trying to solve a puzzle with 10,000 pieces while blindfolded.

2. The Solution: The "Universal Translator" (The LLM)

The authors propose using an LLM as a Universal Semantic Bridge.

The Magic Trick: Instead of trying to translate code or math, they ask the AI to read the facts as if they were sentences in a story.
- Old way: (Entity: Paris, Relation: CapitalOf, Entity: France)
- New way: "Paris is the capital of France."
Because LLMs have read almost everything on the internet in dozens of languages, they "know" that "Paris" and "Paris" (in French) are the same thing, even if the grammar is different. They don't need a cheat sheet; they just use their common sense.

3. The Strategy: "The Rolling Snowball"

Matching 10 graphs at once is too hard. So, they use a Sequential Agglomeration strategy.

Imagine a Snowball: You start with one small snowball (Graph 1).
Rolling: You roll it through a field of snow (Graph 2). It picks up new snow and grows.
Repeat: Now you have a bigger snowball. You roll it through Graph 3, then Graph 4.
Why this helps: The AI only has to compare the current big snowball against the next small one. It doesn't have to look at everything at once. This prevents the computer from crashing (the "computational explosion").

4. The Safety Net: "The Neighborhood Watch"

LLMs have a limit on how much text they can read at once (like a short attention span). If you feed them a whole encyclopedia, they forget the beginning.

The Fix: The authors chop the big webs into tiny, manageable chunks called "Batches."
The Rule: They make sure that if they are looking at "Paris," they also include all the facts connected to Paris (its museums, its mayor, its population) in that same chunk.
Why? Context is king. If the AI sees "Paris" alone, it might think of the city in Texas. But if it sees "Paris, capital of France, home of the Louvre," it knows exactly which Paris they mean.

5. The Result: A High-Confidence Match

The AI acts like a very careful librarian.

It reads the chunks from the English notebook and the French notebook.
It says, "I am 98% sure these two facts are about the same thing."
If the confidence is high (above 90%), it glues them together. If it's unsure, it leaves them apart to avoid mistakes.

What Did They Find?

They tested this on a massive dataset (DBP15K) involving Chinese, English, Japanese, and French.

The Good News: The AI was incredibly accurate. When it said two things were the same, it was right 88% to 92% of the time.
The Bad News: It missed a few things (it didn't find every single match), mostly because it couldn't read every possible combination due to time and memory limits.
The Big Win: It did all this without any human training data. It didn't need a list of pre-matched pairs. It just used its own knowledge.

The Bottom Line

This paper shows that we can finally start stitching together the world's knowledge across languages without needing armies of human translators to create "cheat sheets" first. By treating data like stories and using AI as a smart, rolling editor, we can build a truly global brain that understands us all, no matter what language we speak.

1. Problem Statement

The paper addresses the challenge of Cross-Lingual Graph Fusion, specifically the task of merging multiple heterogeneous Knowledge Graphs (KGs) from different languages into a single, unified global graph.

Core Challenges:
- Semantic Heterogeneity: Differences in lexical gaps, schema drift (divergent relational ontologies), and variations in expressive granularity across languages.
- Scalability in N-Graph Scenarios: Existing methods struggle when moving from binary alignment (Graph A $\to$ Graph B) to the sequential agglomeration of $N$ graphs, where errors can propagate transitively.
- Dependency on Seed Data: Traditional embedding-based methods (e.g., TransE, GNNs) and Graph Neural Networks require substantial manually curated "seed" alignments (pre-aligned entity pairs). This creates a barrier for low-resource languages or emerging domains where such gold-standard data is non-existent.
- Context vs. Linearity: KGs are non-linear, high-dimensional structures, while Large Language Models (LLMs) operate on linear sequences. Flattening graphs risks losing critical "topological neighborhood" context needed for disambiguation.

2. Methodology

The authors propose a modular, zero-shot framework that leverages the in-context reasoning and multilingual priors of LLMs to act as a "semantic glue." The framework operates via a sequential agglomeration pipeline:

A. Sequential Agglomeration Strategy

Instead of aligning all $N$ graphs simultaneously (which causes computational explosion), the framework integrates graphs one by one.

At iteration $t$ , a new candidate graph $G_t$ is aligned with the previously synthesized global graph $G_{c}^{(t-1)}$ .
This rolling strategy prevents transitive error propagation from compounding too rapidly and maintains linear computational complexity relative to the number of graphs.

B. Entity-Centric Graph Partitioning

To handle the finite context windows of LLMs:

The graph is partitioned into batches based on head entities.
All triplets sharing a specific head entity are grouped together. This preserves the local topological neighborhood within a single batch, allowing the LLM to see the structural context of an entity (its neighbors and relations) rather than just isolated triplets.

C. Exhaustive Batch Pairing

The framework constructs a Cartesian product of all batch pairs between the source (global) and target (candidate) graphs.
While computationally intensive, this ensures that every entity neighborhood in the source is compared against every neighborhood in the target, maximizing the discovery of semantic anchors without relying on heuristic blocking or pre-computed candidates.

D. Linearization and In-Context Reasoning

Linearization: Structural triplets $(h, r, t)$ are transformed into natural language sequences: [head_label] [relation_label] [tail_label].
Prompting: The LLM receives a system prompt defining constraints and a user prompt containing the linearized batches from both graphs.
Zero-Shot Alignment: The LLM performs reasoning to identify semantic equivalences without any training or seed data, leveraging its internal multilingual knowledge to bridge lexical and schema gaps.

E. Robust Response Parsing and Aggregation

Parsing: A multi-stage parser handles LLM output failures (e.g., truncation) by recovering partial JSON objects.
Max-Confidence Aggregation: Since the same entity pair might appear in multiple batch comparisons, the system applies a rule to select the alignment with the highest confidence score ( $\sigma$ ) across all occurrences.
Schema Unification: Aligned nodes are collapsed into a single unified node with multilingual labels, and aligned predicates are merged via "Relation Folding."

3. Key Contributions

Novel N-Graph Fusion Framework: Introduces a "rolling" sequential agglomeration pipeline that scales to multiple languages without the computational explosion of simultaneous multi-graph matching.
Context-Aware Partitioning: Implements an entity-centric batching strategy that preserves local structural context, enabling LLMs to disambiguate entities based on their topological neighborhood.
Zero-Shot Capability: Demonstrates that LLMs can serve as a universal semantic bridge for cross-lingual alignment without requiring expensive, manually curated seed alignments.
Modular Architecture: Provides a plug-and-play infrastructure where researchers can swap LLMs or partitioning strategies, moving away from rigid "black box" alignment models.

4. Experimental Results

The framework was evaluated on the DBP15K dataset (Chinese-English, Japanese-English, French-English pairs) using Gemini 2.5 Flash in a zero-shot setting.

Performance Metrics (Chinese-English):
- Precision: Achieved 65.4% overall. When filtered by a confidence threshold ( $\tau = 0.90$ ), precision rose to 88.0% with negligible recall loss.
- Recall: 23.6% (limited by the total volume of predictions generated vs. the 15,000 ground-truth pairs).
- F1 Score: 34.7% (baseline), improving to 37.0% with high-confidence filtering.
Accuracy of Top Predictions:
- Hits@1 Accuracy: 88.3%. The model is highly precise when it decides to make a prediction.
- Confidence Correlation: True Positives had a mean confidence of 0.980, while False Positives averaged 0.738, indicating the model's internal confidence score is a reliable quality discriminator.
Efficiency: The exhaustive processing of the dataset took approximately 5–6 hours.

5. Significance and Future Directions

Significance: This study proves that LLMs can effectively replace traditional embedding-based methods for cross-lingual entity alignment, particularly in scenarios where seed data is unavailable. It offers a scalable, modular path toward building truly universal, multilingual knowledge bases.
Limitations: The current approach relies on exhaustive pairing, which is computationally heavy, and recall is currently bounded by context window limitations.
Future Work:
- Heuristic Blocking: Transitioning from exhaustive pairing to multi-stage candidate selection using lightweight embeddings to reduce computational overhead.
- Global Context: Incorporating schema-level overviews or hub-node summaries into prompts to improve disambiguation for entities with identical labels but different roles.
- Hybrid Systems: Using LLM-discovered alignments as "silver seeds" to bootstrap and fine-tune traditional Graph Neural Networks (GNNs), combining generative reasoning with structural efficiency.

In conclusion, the paper establishes that LLMs, when structured with appropriate linearization and partitioning strategies, can act as a powerful, zero-shot engine for synthesizing global knowledge across linguistic boundaries.