Privacy-Preserving Collaborative Knowledge Graph Creation with LLMs — IEEE Transactions 2025 Base Paper Project

Industrial knowledge is valuable precisely because it is hard won: equipment behaviour, failure causes, and maintenance practice live in manuals, logs, and engineers' heads across many separate organisations. A large language model can help turn that knowledge into a knowledge graph by generating likely entities and triplets, but its answers are uncertain, and no stakeholder wants to hand its commercially sensitive records to a shared pool. The paper by Xia, Fan, Parlikad, Huang and Zheng, published in IEEE Transactions on Big Data in 2025, tackles both problems together: a multi-field hyperbolic (MFH) graph embedding method gives entities mathematical representations that capture low-frequency entities and their logical meaning, a federated learning framework encryptedly identifies and fuses common entities so updated embeddings can refine each stakeholder's private entities locally, and a knowledge-graph complement method refines triplets to improve overall graph quality. Its experiments across different industrial knowledge graphs confirmed the approach as a viable solution for collaborative knowledge-graph creation while maintaining data security. This project implements that system for a student build, evaluated on link prediction over an illustrated industrial graph, and adds a clearly separate Indian contribution: a maintenance and fault-diagnosis question-answering assistant for Indian manufacturing SMEs, answering English and Hindi queries over the merged graph from equipment manuals and maintenance logs held as local stakeholder sources.

This is a built-to-order software project: the federated knowledge-graph system, demo console, report, presentation, and viva Q&A are prepared fresh for you. Starting price: Rs 28,000 (final price confirmed after topic, base paper and compute scope are locked).

The Problem

Small and mid-sized manufacturers hold the knowledge they most need in fragmented, private form. One plant knows why a bearing overheats; another knows which coolant contamination pattern precedes a failure; neither can use the other's knowledge without exposing its own records, and neither has enough data alone to build a large knowledge graph. Large language models promise a shortcut — ask the model, generate triplets, grow the graph — but generated knowledge is uncertain, and an uncorrected triplet can drive a wrong maintenance decision. The paper's answer keeps the two halves separate and safe: each stakeholder's graph is expanded locally with LLM-generated triplets, embedded with a hyperbolic method designed for long-tailed industrial entities, and then improved collaboratively by fusing only the embeddings of entities that stakeholders share, under encryption, so private entities are refined locally without ever being revealed. A complement step then refines and clarifies the triplets themselves. The student build reproduces that reasoning chain on an illustrated industrial graph, then faces the variant the paper does not cover: an Indian SME workshop where the merged graph must answer a technician's plain-language question — in English or Hindi — about a machine fault, grounded in manuals and maintenance logs rather than in a pooled database.

Base paper at a glance

Base paper

• Paper: "Unlocking Large Language Model Power in Industry: Privacy-Preserving Collaborative Creation of Knowledge Graph", Liqiao Xia, Junming Fan, Ajith Parlikad, Xiao Huang and Pai Zheng, IEEE Transactions on Big Data, 2025, vol. 11, no. 4, pp. 2046–2060.
• DOI: https://doi.org/10.1109/TBDATA.2024.3522814 (IEEE Xplore document 10816465; pre-published version, separate from the DOI record: http://ira.lib.polyu.edu.hk/bitstream/10397/116435/1/Xia_Unlocking_Large_Language.pdf).
• Problem the paper tackles: integrating large language models with the collective knowledge of multiple industrial stakeholders to build large, high-quality knowledge graphs, without raising privacy concerns for stakeholders whose data is commercially sensitive.
• What is implemented from the paper: LLM-assisted knowledge-graph expansion by triplet completion; the multi-field hyperbolic (MFH) graph embedding method for entity vectors; the federated learning framework that encryptedly identifies and fuses common entities; local refinement of private entities from updated embeddings; the knowledge-graph complement method for refining triplets; and link-prediction evaluation as in the paper.
• What is deliberately not claimed: no numeric result, accuracy figure, or dataset name beyond the paper's four industrial knowledge graphs is quoted, because no numeric figure is verified for this listing; the paper's industrial graphs are private to its experiments and are never presented as the student build's data; and no Indian dataset is claimed for the SME layer.
• Paper-reported results (the paper's own findings, not this build's measured results): the paper's experiments across different industrial knowledge graphs confirmed its effectiveness as a viable solution for collaborative knowledge-graph creation while maintaining data security. No numeric figure is attached to that finding here, because none is verified for this listing, and the student build's report records only the figures its own link-prediction runs actually produce.

Own features

These are the student's own contribution, clearly distinct from the base paper:

• [Indian manufacturing-SME maintenance and fault-diagnosis Q&A assistant] A question-answering layer over the merged graph: a technician asks about a machine symptom in English or Hindi, and the assistant answers from merged-graph triplets grounded in equipment manuals and maintenance logs held as local stakeholder sources. The paper creates the collaborative graph; it does not add this SME question-answering layer. This is presented as a demonstrated scenario layer in the console, not as a validated deployment on real SME data, and no Indian dataset is claimed.
• [English and Hindi query handling] Queries in English or Hindi are matched to the same graph entities and relations, so a Hindi symptom description retrieves the same maintenance knowledge as its English equivalent. The paper's scope does not cover bilingual SME queries.
• [Interactive federated demo console with visible fusion] A demo that shows each stakeholder's local graph behind a privacy boundary, the encrypted fusion of common entities, the merged graph, and the Q&A assistant, so a reviewer can see what stays private, what is shared, and what the merged graph knows, instead of taking the privacy claim on trust.

The pipeline runs as a visible chain, and each stage's output is shown in the demo so a student can explain it in a viva. First, each stakeholder builds its own local knowledge graph from its own records — in the student build, illustrated industrial entities such as bearings, motors, and failure causes stand in for a stakeholder's private graph. A large language model expands each local graph with generated triplets. The multi-field hyperbolic embedding method converts every entity into a vector. The federated framework encryptedly identifies entities common to stakeholders and fuses their embeddings, and each stakeholder refines its private entities locally from the fused result. The knowledge-graph complement method refines and clarifies the triplets. The console draws the local graphs, the fusion step, and the merged graph, and the SME layer answers maintenance questions over the merged graph in English or Hindi.

1. Build each stakeholder's local knowledge graph from its own private records (illustrated industrial demo graph in the student build; the paper's industrial graphs are not reused).
2. Expand each local graph with LLM-generated triplets from tailored question prompts.
3. Embed every entity with the multi-field hyperbolic (MFH) method, including low-frequency entities.
4. Encryptedly identify entities common across stakeholders, without exposing private triplets.
5. Fuse the common entities' embeddings and distribute the updated embeddings to stakeholders.
6. Refine each stakeholder's private entities locally from the fused embeddings.
7. Apply the knowledge-graph complement method to refine and clarify triplets.
8. Draw the local graphs, the fusion step, and the merged graph in the demo console.
9. Evaluate with link prediction on held-out triplets, and record only the figures the student's own runs produce.
10. Show the SME adaptation panel: English and Hindi maintenance and fault-diagnosis questions answered from the merged graph, grounded in manuals and maintenance logs as local stakeholder sources, kept distinct from the paper's industrial-graph creation focus.

Tech stack:

• Python 3 · PyTorch · NetworkX graph handling
• Multi-field hyperbolic embedding · federated learning
• LLM-assisted knowledge graph expansion · triplet completion
• Encrypted common-entity fusion · average fusion
• HTML · CSS · JavaScript demo console
• SQLite · local stakeholder data stores
• Matplotlib · evaluation plots
• Git · Jupyter Notebook

Dataset & model details

• Dataset (paper): The paper's experiments investigate four distinct industrial knowledge graphs, labelled KG 1 to KG 4 in the paper, evaluated by link prediction with triplet data split into training and test subsets. The paper's industrial graphs are not named public datasets and are not available to the student build, and no dataset name is quoted for them here.
• Dataset (student build): An illustrated industrial demo graph built for the student project (manufacturing entities such as bearings, motors, and failure causes), evaluated by link prediction on its own held-out triplets. The build's figures are its own and are not presented as the paper's results.
• Dataset (SME adaptation): Equipment manuals and maintenance logs shown in the demo console as local stakeholder sources for the SME question-answering layer. The adaptation is demonstrated on illustrated demo scenarios in the console, not on a published Indian dataset, and it is labelled as such wherever it appears. No Indian dataset is claimed.
• Task: Privacy-preserving collaborative knowledge-graph creation; input = each stakeholder's private local graph, output = a merged knowledge graph of higher quality plus maintenance answers over that merged graph.
• Model: The paper's system — LLM-assisted knowledge-graph expansion, multi-field hyperbolic (MFH) graph embedding, federated learning with encrypted common-entity fusion and local private-entity refinement, and knowledge-graph complement triplet refinement. No architecture detail beyond the paper's description is claimed for it here.
• Metrics: Link-prediction quality as in the paper (recovery of held-out triplets); the student build's report records only the figures its own link-prediction runs actually produce, and no figure is claimed before those runs.

Privacy-preserving collaborative knowledge-graph creation delivers seven working capabilities: LLM-assisted triplet expansion, multi-field hyperbolic embeddings, encrypted common-entity fusion, local private-entity refinement, knowledge-graph complement refinement, link-prediction evaluation, and an Indian SME maintenance Q&A console, all visible in a demo a reviewer can operate. Local graphs grow with language-model help, hyperbolic embeddings give rare entities a faithful mathematical form, encrypted fusion lets stakeholders improve each other's graphs without exposing raw records, and the complement step cleans the triplets that result. The SME layer then makes the system demonstrable in an Indian setting: a technician's question, in English or Hindi, answered from the merged graph.

• [LLM-assisted knowledge-graph expansion] Grows each stakeholder's local graph by generating likely entities and triplets from tailored question prompts, expanding triplet count beyond what the stakeholder collected alone.
• [Multi-field hyperbolic (MFH) embedding] Vectorizes entities with a hyperbolic method that apprehends low-frequency entities and delineates their logical meaning, giving rare industrial entities a usable mathematical representation.
• [Encrypted common-entity fusion] Identifies entities shared across stakeholders and fuses their embeddings under encryption, so the shared knowledge improves without revealing any stakeholder's raw triplets.
• [Local private-entity refinement] Uses updated common-entity embeddings to refine each stakeholder's private entities locally, so every participant's own graph improves from collaboration.
• [Knowledge-graph complement refinement] Refines and clarifies triplets after fusion, correcting errors that LLM generation or fusion may introduce, and improving overall graph quality.
• [Link-prediction evaluation] Scores the graph by link prediction, measuring whether held-out triplets are recovered, and reports only the figures the student's own runs produce.
• [SME maintenance Q&A console] Answers English and Hindi maintenance and fault-diagnosis questions from the merged graph, grounded in equipment manuals and maintenance logs held as local stakeholder sources, keeping the team's contribution visibly separate from the paper.

• Complete federated knowledge-graph pipeline source code (LLM-assisted triplet expansion, MFH embedding, encrypted common-entity fusion, local private-entity refinement, knowledge-graph complement refinement, SME Q&A layer)
• Interactive demo console (the web demo shown on this page) with stakeholder view, fusion view, merged-graph view, and SME maintenance Q&A tab
• Project report PDF (background, base paper, methodology, experiments, limitations)
• PPT presentation for final review
• Viva Q&A preparation document (MFH embeddings, encrypted fusion, federated learning, knowledge-graph complement, link-prediction evaluation, SME adaptation, limitations)
• Starting price: Rs 28,000 (final price confirmed after topic, base paper and compute scope are locked)
• Specific next step: message on WhatsApp for a quotation stating scope (privacy-preserving federated knowledge-graph creation with MFH embeddings and encrypted common-entity fusion plus Indian SME maintenance and fault-diagnosis Q&A assistant in English and Hindi), starting price Rs 28,000, and delivery under the 110-hour work plan as a built-to-order project

Work plan & timeline

Total work plan: 110 hours, split across six phases. Phase 1, base-paper study and environment setup: 15 hours — reading the Xia et al. paper, setting up Python, PyTorch, and the graph data pipeline. Phase 2, LLM expansion and MFH embedding: 25 hours — LLM-assisted triplet expansion and the multi-field hyperbolic embedding method. Phase 3, encrypted fusion and federated framework: 25 hours — encrypted common-entity identification and fusion, local private-entity refinement, and federated rounds. Phase 4, KG complement and link-prediction evaluation: 15 hours — triplet refinement and link-prediction evaluation on the illustrated industrial demo graph. Phase 5, SME Q&A assistant: 15 hours — English and Hindi maintenance and fault-diagnosis questions over the merged graph, grounded in manuals and maintenance logs. Phase 6, presentation and viva preparation: 15 hours — PPT, demo walkthrough, and the viva Q&A document.

Support

Support covers setup help for the delivered code, a walkthrough of the system and the demo console, and fixes for defects in the delivered code. Guidance is also provided for adapting the report and presentation to the student's college format and for answering guide questions about the base paper, MFH embeddings, encrypted fusion, and the student's own contribution. Support does not cover re-running experiments on the student's personal machine beyond the setup walkthrough, and it does not invent results for experiments that were not run.