Building Knowledge Graphs with AI

The Evolution of Semantic Architecture: AI, Agents, and the Economics of Knowledge Graph Construction

TL;DR — For two decades, standing up an enterprise knowledge graph meant hiring ontologists, waiting roughly three years, and spending $10–20M to get there. That model is finished. LLMs now extract triples, draft ontologies, and resolve entities at a fraction of the cost — one published pipeline adjudicated 1,757 ambiguous entity pairs for four cents and hit 95% precision doing it. But the speed came with a tax: the same models that generate the graph also hallucinate it, so the hard part of the work has moved downstream — from building the graph to proving it’s true. The architecture that actually wins isn’t “let the AI build the graph.” It’s “the AI proposes, deterministic validation disposes.” And the ontology engineer’s job has quietly shifted from builder to governor.

The Map Is Not the Territory — But Now the AI Draws Both

Executive Summary

The construction of RDF graphs and knowledge graphs is undergoing the most significant change since the W3C standards were ratified — and most enterprise architects are still pricing it on the old model. The traditional approach treated the graph as a hand-curated, deterministic asset: experts authored the ontology, engineers wrote the R2RML mappings, and “quality by math” guaranteed precision before anything reached production. It worked, but it didn’t scale, and it didn’t survive contact with the volume and heterogeneity of real enterprise data — which is a large part of why an estimated 95% of these pilots never made it past proof-of-concept.

The evidence that AI changes this is now hard to argue with. The clearest signal comes from data.world’s benchmark on an insurance data model: a GPT-4-class model querying a raw SQL schema answered correctly 16.7% of the time and scored a flat 0% on the queries that required joining multiple tables. Point that same model at a knowledge graph built over the identical schema and accuracy tripled to 54.2%, with the hardest queries recovering from zero. The pattern repeats across the stack — GraphRAG pushing factual correctness from the mid-50s into the 80s, entity resolution precision jumping from the 30s to 95% once an LLM is used only as a judge on the borderline cases. The economics have inverted: the cost center is no longer years of upfront ontology design (CapEx), it’s metered inference and validation (OpEx).

The catch is structural, not incidental. LLMs hallucinate relations that are linguistically plausible and ontologically wrong; they drift from the schema; the smallest models fail to produce valid graphs more than 95% of the time. Worse, the obvious fix — using an AI to check the AI — creates recursive trust: a model that hallucinates an edge and a model that approves it can share the same blind spot. The serious answer emerging from the field is to stop asking the generator to also be the auditor. Cognitive-Executive Separation borrows from security-privilege design: the LLM reasons and proposes triples in an untrusted sandbox, while a separate deterministic engine — running SHACL constraints, incapable of reasoning and therefore incapable of hallucinating — validates against the human-approved ontology and executes only what passes.

That separation is the strategic point, and it reframes the role of everyone who owns this work. The narrative layer — reading text, mapping intent, drafting candidate triples — is being handed to probabilistic models, and that’s fine. The semantic layer — the operational topology, the entity identities, the business constraints — is being fortified with deterministic validation, and that’s where defensibility now lives. The ontology stops being a map of the data and becomes the intellectual property that keeps generative AI tethered to reality. The ontologist stops hard-coding linkages and starts authoring the rules an army of agents must obey. For leaders, the takeaway is not “automate the graph.” It’s “automate generation, govern validation, and treat the ontology as the asset” — because in this architecture, your ontology is your thumbprint.

Era-by-Era Findings: The Trajectory of Knowledge Graph Construction

To understand the magnitude of the shift occurring within semantic architectures, it is necessary to examine the evolution of knowledge graph construction across three distinct eras: the traditional baseline, the AI-assisted transition, and the emerging agentic frontier. Each era possesses a distinct economic profile, trust model, and set of technical methodologies.

Era 1: The Traditional Baseline and the Ontology Bottleneck

Before the advent of generative language models, the construction of enterprise knowledge graphs was a purely deterministic, human-curated endeavor. This era was characterized by manual ontology engineering, handcrafted R2RML/RML (RDF Mapping Language) mappings, and human-in-the-loop entity resolution. The primary objective was absolute semantic precision, guaranteed by adherence to standard frameworks such as SHACL (Shapes Constraint Language) and OWL (Web Ontology Language) [1].

The traditional method treated the knowledge graph as a heavily governed, rigid data asset. Domain experts collaborated with ontology engineers to define concepts, taxonomies, and hierarchies. Data was then mapped from relational databases or extracted from text using rigid, rule-based natural language processing (NLP) pipelines. The foundational building blocks relied on strict World Wide Web Consortium (W3C) standards, originally developed to support federated data sharing for the US Department of Defense [1].

These included Uniform Resource Identifiers (URIs) for identity resolution, ontologies for meaning resolution, triples for expression, and SHACL for business rules [1]. By enforcing “Quality by Math,” organizations ensured that definitional conflicts were resolved prior to entering operational systems [1].

However, the financial and temporal costs associated with this method were staggering, making it unviable for rapid iteration. Case studies indicate that achieving self-sufficiency in enterprise knowledge graph operations typically required up to three years of sustained engineering effort [1]. The combined budget for initial proofs of concept (POCs), operational pilots, and extensible platform migration reliably ranged between $1 million and $3 million, with true enterprise-scale implementations demanding long-term investments of $10 million to $20 million [1].

The extreme cost of manual construction resulted in widespread systemic failure patterns. Approximately 95% of enterprise AI and knowledge graph pilots failed to scale beyond the initial POC phase due to the “POC trap,” where models that functioned perfectly on curated datasets collapsed under the weight of enterprise data heterogeneity [9]. Furthermore, the traditional era was plagued by severe architectural inertia. Database architects invested in SQL actively resisted graph adoption, and middle management frequently blocked semantic collaboration due to a reluctance to surrender control over local application data models [1].

Most critically, this era suffered from the “ontology bottleneck.” The human capacity to examine massive datasets, identify inconsistencies, and manually code edge weights or RML mappings was severely constrained by labor hours [10]. The necessity of human review for every data source integration meant that traditional knowledge graph construction was entirely incompatible with the volume, velocity, and variety of modern enterprise big data [1].

Consequently, the traditional approach hit a scaling limit, setting the stage for algorithmic intervention.

Era 2: AI-Assisted Construction (Human-in-the-Loop)

The introduction of instruction-tuned LLMs fundamentally disrupted the ontology bottleneck. In this current era, AI acts as an accelerator for nearly all discrete knowledge engineering tasks, converting unstructured text and semi-structured tables into semantic triples at a scale previously impossible. The economic model shifts from labor-intensive manual mapping to compute-intensive inference, though human validation remains the ultimate arbiter of trust [3].

Triple and Relation Extraction from Text

The extraction of triples (subject-predicate-object) from unstructured text represents one of the most resource-intensive aspects of traditional knowledge engineering. The AI-assisted transition began with smaller, fine-tuned models like REBEL (Relation Extraction By End-to-end Language generation), which utilized distant supervision to serve as a pre-training step for relation extraction, achieving a 74 micro-F1 and 51 macro-F1 score across 220 different relation types [11].

As foundational models scaled, relation extraction accuracy improved dramatically. Standard evaluation sets like TACRED (incorporating 41 canonical relations) and DocRED (document-level extraction with 96 diverse relations) have become the proving grounds for LLM extraction capabilities [12]. Because original datasets like DocRED suffered from incomplete annotations, revised benchmarks like Re-DocRED were introduced to mitigate false negatives, allowing for more reliable evaluation of LLM performance [12].

On these rigorous benchmarks, advanced models such as GPT-4 have demonstrated exceptional comprehension, achieving F1 scores up to 87% in specialized domains such as chemical-disease relationship extraction [16]. Similarly, models trained specifically for low-resource languages, such as LUKE-RoRED for Romanian, have achieved macro-F1 scores of 0.8744 [13].

Despite these high-water marks, LLM-driven relation extraction remains highly susceptible to formatting degradation and multi-hop reasoning failures. Without explicit chain-of-thought prompting, LLMs tasked with extracting multiple relations and triplet facts across lengthy documents frequently see their F1 scores collapse to single digits [5]. Furthermore, standard foundation models struggle with structural reliability when forced to output rigid schema-compliant formats. General-purpose lightweight models like Gemini Nano and GPT 4.1 Nano recorded catastrophic structural reliability scores (3.03% and 10.92%, respectively) when attempting to output compliant graphs, effectively rendering them unusable for automated extraction pipelines [3].

To combat this, supervised fine-tuned (SFT) models specifically trained for knowledge extraction — such as Qwen 3 32B and Mistral Small 3.2 — have been developed. These SFT models demonstrate exceptional reliability, achieving 99.95% schema compliance and entity extraction F1 scores between 0.89 and 0.92, thereby solving the formatting failure modes inherent in generalist models [3].

Structured Data to RDF: Reimagining the Mapping Layer

Transforming tabular data, such as CSVs, JSON files, and SQL database exports, into RDF requires complex mapping languages. The traditional approach utilized tools like RML.io, Morph-KGC, and YARRRML to execute mappings manually [17]. Morph-KGC, for instance, represents the pinnacle of deterministic mapping, leveraging pandas and mapping partitions to process heterogeneous data sources efficiently, thereby reducing peak memory consumption and execution times significantly [19].

AI is now being deployed to reverse-engineer these mappings automatically, attempting to generate valid RML directly from tabular schemas. However, results in this specific subdomain remain mixed. In a 2025 benchmarking of LLM-generated RML mappings against expected RDF graphs, the LLM achieved a 63% success rate, successfully generating correct RML documents for 22 test cases but failing on 13. This performance remains 31% worse than deterministic, rule-based re-mapping approaches [20]. This highlights a critical, lingering failure mode: LLMs still struggle to generate highly rigid, syntactically complex semantic web code without human-in-the-loop intervention, proving that while AI excels at linguistic extraction, it falters at deterministic logic translation.

Ontology Learning and Generation

Ontology learning — the ability to propose classes, hierarchies, properties, and axioms directly from corpora — has been aggressively benchmarked by initiatives like Text2KGBench and the LLMs4OL (Large Language Models for Ontology Learning) challenge [21]. The LLMs4OL paradigm evaluates models on terminology extraction, conceptual typing, and relation discovery across complex domains like lexosemantics and biological functions [22].

Open-weights models fine-tuned on specialized datasets currently dominate this space, significantly outperforming zero-shot proprietary models. For example, Dolphin-Mistral-7B achieved a peak F1 score of 0.920, and the Mixtral model achieved 0.847 on ontology classification tasks [25]. On the Text2KGBench evaluation, which measures the capability of LLMs to generate knowledge graphs from text conforming to a specific ontology, fine-tuned proprietary models like Lettria Perseus achieved an Entity F1 score of up to 0.88, maintaining 100% schema-valid outputs [3].

Despite these successes, semantic inconsistencies persist. Models frequently hallucinate relations that are linguistically plausible but ontologically invalid, forcing practitioners to employ post-generation validators to align LLM outputs with strict domain semantics [26].

Entity Resolution: The Economic Disruption

Entity resolution (ER) — the task of identifying and linking disparate records that refer to the same real-world entity — has seen some of the most profound economic and performance gains through AI assistance. Traditional fuzzy matching (e.g., Jaro-Winkler, Token Sort) and embedding-based approximate nearest neighbor (ANN) retrieval often hit a ceiling in unstructured domains. For instance, on the Abt-Buy product matching benchmark, fuzzy matching alone yielded a 37% F1 score, while embedding and ANN retrieval yielded a 44.5% F1 score, hindered by an abysmal precision rate of 35.5% [4].

The introduction of a three-tier LLM-assisted architecture fundamentally altered this dynamic. A system like GoldenMatch v0.3.0 utilizes embeddings for high-recall filtering (Tier 1 auto-accepts near-identical records, Tier 3 auto-rejects vastly different records) and reserves an LLM (e.g., GPT-4o-mini) solely as an adjudicator for Tier 2 borderline similarity scores [4]. By prompting the LLM to act as a judge on these hard cases, precision skyrocketed to 95.4%, and the overall F1 score reached 66.3% [4].

The economic viability of this method is its most compelling feature: the compute cost to process 1,757 borderline entity pairs through GPT-4o-mini was a mere $0.0364 [4]. This demonstrates a mature application of AI-assisted construction where deterministic systems handle computational scale, and probabilistic AI handles edge-case cognitive reasoning, effectively driving the marginal cost of entity resolution toward zero.

SHACL Shape Generation and Validation

Ensuring that a generated graph conforms to business rules requires the Shapes Constraint Language (SHACL). Traditionally written by ontology engineers, LLMs are now being utilized to auto-generate constraints. Using few-shot prompting techniques, LLMs can ingest textual constraints and output valid SHACL shapes that can be integrated into systems like AllegroGraph to demonstrate correctness [28].

Furthermore, when an RDF graph fails validation, the resulting SHACL validation report can be fed back into an LLM alongside the original ontology. The LLM can interpret the report, identify the causes of the violations, and provide accurate suggestions for correcting the model [30]. This creates a powerful human-in-the-loop feedback cycle, drastically reducing the time required to debug complex enterprise graphs.

The Consumption Shift: Text-to-SPARQL and NL Querying

The consumption side of knowledge graphs has also fundamentally shifted. Enterprises have attempted to use LLMs to query relational databases directly using Natural Language to SQL (NL-to-SQL) pipelines. However, AI-assisted NL-to-SQL frequently fails in complex enterprise environments due to a complete lack of semantic business context within relational schemas. A comprehensive benchmark conducted by the data.world AI Lab demonstrated that zero-shot LLM queries against a raw enterprise SQL database yielded a dismal 16.7% accuracy [2].

However, when the same LLM queried a Knowledge Graph representation of that exact same database — leveraging the graph’s explicitly defined business rules, ontologies, and mappings — query accuracy improved threefold to 54.2% [2]. The disparity becomes even more pronounced in complex scenarios: for queries requiring high schema complexity (joining multiple disparate tables), the pure SQL approach failed completely, recording a 0% accuracy rate, while the KG-assisted approach maintained over 35% accuracy [2]. This quantitatively proves that while LLMs struggle to reason over raw data silos, the presence of a semantic knowledge graph acts as a critical context layer that unlocks the capabilities of enterprise AI.

Era 3: The Agentic and Autonomous Frontier

The bleeding edge of semantic architecture is transitioning toward fully agentic pipelines. In this era, the objective is to remove the human from the loop entirely, relying on multi-agent systems to dynamically extract, self-correct, and validate graph topologies iteratively. The core architectural debate in this era revolves around the efficacy of GraphRAG (Retrieval-Augmented Generation powered by Knowledge Graphs) and the systemic risk of autonomous validation.

Agentic GraphRAG and Vector Augmentation

Standard vector-based RAG relies entirely on semantic similarity via text embeddings. This approach structurally fails at global sense-making, corpus-level summarization, and multi-hop reasoning [31]. Research consistently demonstrates that as the number of entities in a user query increases beyond five, vector retrieval accuracy rapidly degrades toward zero, as the model cannot connect disparate chunks of text [33].

To solve this, autonomous pipelines construct knowledge graphs dynamically. Frameworks such as Microsoft GraphRAG utilize hierarchical community detection algorithms (like the Leiden algorithm) to index text into subgraphs and pre-compute community summaries [34]. When a query is issued, the system retrieves connected knowledge from the graph rather than isolated chunks, providing richer, structural context to the LLM [32].

The effectiveness of these agent-constructed KGs is highly measurable and statistically significant. Benchmarks comparing traditional VectorRAG to GraphRAG show massive disparities in factual correctness and context relevance. GraphRAG consistently achieves correct answer rates above 80% (81.67% vs 57.50% for VectorRAG in some benchmarks [35], and 80% vs 50.83% in others [36]). Advanced iterations, such as Hybrid GraphRAG, combine vector search with graph traversal, further improving factual correctness by 8% and context relevance by 7% over standard GraphRAG [37].

However, autonomous graph generation poses severe architectural risks. The most prominent is the “subgraph explosion” problem [32]. Because LLMs are sequence models and not native graph traversal engines, an unconstrained agentic pipeline will frequently generate redundant, overlapping, or semantically fragmented triples that bloat the semantic layer exponentially, driving up compute costs and degrading query latency in production environments [32].

Autonomous Validation: “Who Validates the Validator?”

The most critical open problem in the agentic era is the concept of recursive trust, frequently referred to as the “who validates the validator” problem [6]. When an LLM autonomously generates SHACL shapes, extracts entities, and asserts new triples, relying on another instance of an LLM to validate that output creates a recursive vulnerability. If an AI agent hallucinates an incorrect relationship, an AI judge may validate it due to shared parametric biases or an inability to conduct external grounding [38].

To address this systemic vulnerability, leading enterprise architectures are enforcing “Cognitive-Executive Separation” (CES) [6]. Inspired by privilege separation in cybersecurity (such as OpenSSH), CES divides the AI agent system into two distinct processes. The “agent process” hosts the LLM-powered reasoning system; it is treated as completely untrusted and runs in a sandboxed environment where it can only propose graph mutations [6].

The “engine process,” conversely, has full access to the host environment, executes the tool sets, and hosts the deterministic validation layer (such as SHACL constraints). The engine process possesses no reasoning model and is structurally unable to hallucinate [6]. It receives proposed actions from the untrusted agent, deterministically validates them against the enterprise ontology, and executes only those that pass. This synthesis of agentic proposal and deterministic validation is widely viewed as the only mathematically sound approach to maintaining trust and preventing memory poisoning in autonomously constructed enterprise KGs [6].

Tool and Library Inventory: The Actual Landscape

The tooling landscape for AI-driven RDF and KG construction is deeply bifurcated between rapid-prototyping open-source libraries optimized for speed, and governed commercial platforms optimized for enterprise security, scale, and compliance.

+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+
| Tool / Framework     | Type       | Primary Purpose          | Maintenance & Adoption   | Capabilities & Strengths | Known Limitations        |
|                      |            |                          | Signal                   |                          |                          |
+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+
| LangChain            | Open       | Rapid KG extraction      | High adoption;           | Excellent for            | High hallucination risk; |
| (LLMGraphTransformer)| Source     | from unstructured text.  | frequently updated core  | prototyping; converts    | lacks deep ontology      |
|                      |            |                          | library [32].            | raw text to graph        | alignment; generates     |
|                      |            |                          |                          | documents in minimal     | "flat" triples without   |
|                      |            |                          |                          | lines of Python code     | edge confidence weights  |
|                      |            |                          |                          | [32].                    | [32].                    |
+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+
| LlamaIndex           | Open       | Graph-based RAG and      | High adoption; integral  | Supports both dynamic    | Graph structural         |
| (PropertyGraphIndex) | Source     | dynamic triple           | to modern RAG            | and schema-driven        | coherence and entity     |
|                      |            | extraction.              | ecosystems [42].         | extraction paths,        | resolution can degrade   |
|                      |            |                          |                          | integrating tightly with | rapidly over massive     |
|                      |            |                          |                          | vector stores [42].      | document corpora.        |
+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+
| Morph-KGC            | Open       | Scalable KG              | Active repository;       | Leverages pandas and     | Requires manual or       |
|                      | Source     | materialization from     | strongly supported by    | mapping partitions to    | LLM-assisted mapping     |
|                      |            | tabular data.            | academic semantic web    | reduce memory peaks;     | authoring prior to       |
|                      |            |                          | community [17].          | supports RML-star and    | execution; steep         |
|                      |            |                          |                          | YARRRML [17].            | learning curve for       |
|                      |            |                          |                          |                          | non-semantic engineers.  |
+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+
| kglab                | Open       | Python integration for   | Maintained by Paco       | Bridges the gap between  | Not explicitly designed  |
|                      | Source     | semantic graphs.         | Nathan; widely utilized  | RDF/SPARQL and popular   | as an autonomous agent   |
|                      |            |                          | in advanced data science | data science stacks      | pipeline; requires       |
|                      |            |                          | [43].                    | (pandas, scikit-learn,   | custom code for LLM      |
|                      |            |                          |                          | PyTorch) [43].           | integration.             |
+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+
| OntoGPT / SPIRES     | Open       | Ontology-driven          | Active academic adoption | Strictly aligns LLM      | Struggles with           |
|                      | Source     | knowledge extraction via | for scientific text.     | extractions to           | open-domain exploration  |
|                      |            | LLMs.                    |                          | predefined ontologies,   | outside of strictly      |
|                      |            |                          |                          | minimizing structural    | defined biological/      |
|                      |            |                          |                          | hallucination.           | scientific schemas.      |
+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+
| Lettria (Perseus)    | Commercial | Enterprise Text-to-Graph | Active commercial        | Achieves 100% schema     | Requires integration     |
|                      |            | extraction and           | product benchmarked      | reliability, ultra-low   | into broader enterprise  |
|                      |            | alignment.               | heavily [3].             | latency (<20ms), and     | architectures; lacks     |
|                      |            |                          |                          | self-hosted privacy for  | broader market visibility|
|                      |            |                          |                          | sensitive data [3].      | of general foundational  |
|                      |            |                          |                          |                          | models.                  |
+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+
| Stardog (Voicebox)   | Commercial | Conversational AI over   | Major enterprise         | Agentic architecture     | Proprietary ecosystem;   |
|                      |            | enterprise data silos.   | deployments across       | designed for zero        | full feature tracking    |
|                      |            |                          | highly regulated sectors | hallucinations; leverages| and usage metrics        |
|                      |            |                          | (NASA, DoD) [44].        | virtual graphs and strict| require specific         |
|                      |            |                          |                          | business constraints     | platform versions        |
|                      |            |                          |                          | [45].                    | (v12.0.0+) [47].         |
+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+
| Neo4j                | Commercial | Ecosystem for property   | Dominant commercial      | High scalability; tight, | Native focus on property |
| (Knowledge Graph     |            | graph construction and   | property graph provider  | native integration with  | graphs rather than       |
| Builder)             |            | RAG.                     | [48].                    | LangChain and vector     | strictly validated       |
|                      |            |                          |                          | indexes for GraphRAG     | semantic web standards   |
|                      |            |                          |                          | deployments.             | (RDF/OWL).               |
+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+
| data.world           | Commercial | AI-ready data catalog    | Strong market presence;  | Links raw SQL catalogs   | Focuses heavily on the   |
|                      |            | and semantic platform.   | AI research led by Juan  | directly to business     | semantic layer mapping   |
|                      |            |                          | Sequeda [49].            | ontologies, drastically  | of structured data rather|
|                      |            |                          |                          | increasing LLM query     | than raw unstructured    |
|                      |            |                          |                          | accuracy [2].            | text ingestion.          |
+----------------------+------------+--------------------------+--------------------------+--------------------------+--------------------------+

Whitespace Analysis and Open Problems

Despite the rapid acceleration of AI-assisted knowledge engineering, severe functional gaps remain in the ecosystem. In several critical areas, mature, off-the-shelf tools simply do not exist, forcing practitioners to hand-roll custom pipelines.

• Validation at Scale and Recursive Trust: As discussed regarding Cognitive-Executive Separation, there is no out-of-the-box framework that seamlessly validates LLM-generated KGs at scale without significant custom engineering. Using LLMs to check LLM outputs leads to recursive hallucination [38]. Enterprises are forced to custom-build their SHACL-validation-to-LLM feedback loops because unified “secure agentic graph builders” are largely experimental [6].
• Cost Control and Subgraph Explosion: Autonomous extractors (like naive implementations of LLMGraphTransformer) blindly extract triples. There are no mature control planes to predict token costs, cap extraction depth, or manage the database bloat associated with uncontrolled multi-agent graph extraction over millions of enterprise documents [4]. GoldenMatch’s budget tracker for entity resolution is a rare exception in an otherwise unconstrained ecosystem [4].
• Ontology Alignment and Merging: While an LLM can propose a local ontology for a single document, merging thousands of disparate AI-generated subgraphs into a single, coherent global enterprise ontology remains an unsolved, highly manual process. The lack of standard tools for reconciling conflicting node schemas at scale represents a massive engineering bottleneck.
• Provenance, Lineage, and Temporal KGs: When an LLM hallucinates an edge in a graph, tracing that edge back to the specific source document chunk is difficult in dynamic agentic pipelines. The lack of standard temporal tracking (Temporal KGs) for AI-generated assertions compounds this difficulty, making auditing for compliance in regulated industries incredibly fraught.
• Evaluation Standards: The industry suffers from a lack of universally agreed-upon benchmarks for text-to-graph extraction. While Text2KGBench and LLMs4OL offer baseline academic metrics [21], there is no standardized way to penalize models for minor semantic drifts in proprietary business contexts, making ROI calculations difficult for enterprise architects.

Practitioner Perspective Bank

The pioneers and current leaders of the semantic web exhibit highly nuanced, often conflicting perspectives on the integration of Large Language Models and Knowledge Graphs. Capturing this friction is essential for understanding the true trajectory of the technology.

+-------------------+----------------------------+-----------------------+--------------------------------------------------------+
| Luminary          | Role / Affiliation         | Stance                | Attributable Statement                                 |
+-------------------+----------------------------+-----------------------+--------------------------------------------------------+
| Tony Seale        | Founder, The Knowledge     | Nuanced /             | "If you let somebody else take your ontology, learn    |
|                   | Graph Guys                 | Pro-Ontology          | the essence of what it is that you know that's out of  |
|                   |                            |                       | distribution with the rest of the world, you've just   |
|                   |                            |                       | given them everything valuable about your company...   |
|                   |                            |                       | Your ontology is like your thumbprint, your digital    |
|                   |                            |                       | thumbprint for your organization." [50]                |
+-------------------+----------------------------+-----------------------+--------------------------------------------------------+
| Juan Sequeda      | Head of AI Lab, data.world | Pro-Integration       | "Investing in Knowledge Graph provides higher accuracy |
|                   |                            |                       | for LLM powered question answering systems." [51]      |
|                   |                            |                       | "The way to think about this is real world concepts.   |
|                   |                            |                       | And they happen to be in the way of a graph." [52]     |
+-------------------+----------------------------+-----------------------+--------------------------------------------------------+
| Dean Allemang     | Author, Semantic Web for   | Nuanced /             | Highlights the distinction between "figuring out vs.   |
|                   | the Working Ontologist     | Foundational          | telling," noting that LLMs are probabilistic, whereas  |
|                   |                            |                       | graphs are declarative: "In a Knowledge Graph, you can |
|                   |                            |                       | write down ('telling' in the 'Figuring out vs.        |
|                   |                            |                       | Telling' sense) the fact that one entity is the same   |
|                   |                            |                       | as another... The customer who purchased this product  |
|                   |                            |                       | is the same as the person who filed this complaint."   |
|                   |                            |                       | [53]                                                   |
+-------------------+----------------------------+-----------------------+--------------------------------------------------------+
| Denny Vrandečić   | Founder, Wikidata;         | Structural /          | Advocates for strictly separating the narrative        |
|                   | Wikimedia Foundation       | Architectural         | abilities of LLMs from the factual grounding of graphs.|
|                   |                            |                       | Regarding LLM-driven personal wikis, he notes: "The    |
|                   |                            |                       | conclusion of this article is that one should design   |
|                   |                            |                       | the missing parts [the semantic layer] separately."    |
|                   |                            |                       | [54]                                                   |
+-------------------+----------------------------+-----------------------+--------------------------------------------------------+
| Paco Nathan       | Principal DevRel, Senzing; | Skeptical / Cautious  | "According to the current open source libraries for    |
|                   | Creator of kglab           |                       | GraphRAG, a dominant notion is: 'Just use an LLM to    |
|                   |                            |                       | generate a graph automatically, which should be        |
|                   |                            |                       | good...source isn't appropriate." [7]                  |
+-------------------+----------------------------+-----------------------+--------------------------------------------------------+
| Kendall Clark     | CEO, Stardog               | Pro-Deterministic     | Emphasizes the need for rigid semantic rules over pure |
|                   |                            | Validation            | generative AI: "Ontologies are a core part of our      |
|                   |                            |                       | platform and by providing a traceable and automated    |
|                   |                            |                       | ontology [we prevent hallucinations in regulated       |
|                   |                            |                       | industries]." [44]                                     |
+-------------------+----------------------------+-----------------------+--------------------------------------------------------+

Quantitative Evidence

The following structured data provides verifiably measured metrics to quantify the performance gap between traditional methods, unassisted LLMs, and optimized AI-KG pipelines.

+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| Metric / Finding            | Measured Value     | Benchmark / Source     | Caveat / Context                                      |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| Traditional Enterprise      | $10M - $20M        | Cutter Consortium [1]  | Represents total long-term integration for massive    |
| KG Cost                     |                    |                        | enterprises; smaller POCs are drastically cheaper     |
|                             |                    |                        | ($1M-$3M).                                            |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| Traditional KG              | ~3 Years           | Cutter Consortium [1]  | Time required for an organization to achieve pipeline |
| Time-to-Value               |                    |                        | reusability and operational self-sufficiency.         |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| Text-to-SQL Accuracy        | 16.7%              | data.world AI Lab [2]  | Represents zero-shot prompting directly against an    |
| (LLM Only)                  |                    |                        | enterprise SQL schema without semantic context.       |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| Text-to-SQL Accuracy        | 54.2%              | data.world AI Lab [2]  | Represents a 3x increase in query accuracy when the   |
| (KG Assisted)               |                    |                        | exact same schema is governed by an ontology.         |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| GraphRAG vs VectorRAG       | 81.67% vs 57.50%   | Lettria Blog / External| Accuracy jumps to >90% for GraphRAG if "acceptable"   |
| Accuracy                    |                    | Benchmark [35]         | answers are included in the scoring criteria.         |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| GraphRAG Factual            | +8%                | arXiv 2507.03608v1 [37]| Hybrid GraphRAG variants improve correctness          |
| Correctness Gain            |                    |                        | specifically over standard GraphRAG implementations.  |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| RML Mapping Gen             | 63%                | ESWC 2025 KGCW [20]    | LLM RML generation failed on 13 of 35 tests, proving  |
| Success Rate                |                    |                        | 31% worse than rule-based counterparts.               |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| Triple Extraction           | 74 Micro-F1        | REBEL (EMNLP 2021) [11]| Serves as a pre-training step and foundational        |
| F1 (REBEL)                  |                    |                        | baseline for fully supervised generative extraction   |
|                             |                    |                        | models.                                               |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| Entity Resolution           | 95.4%              | GoldenMatch            | Utilizes a three-tier architecture where the LLM is   |
| Precision (LLM)             |                    | (Abt-Buy) [4]          | solely used as a judge for borderline embedding       |
|                             |                    |                        | scores.                                               |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| Entity Resolution           | $0.04 per 1,757    | GoldenMatch            | Incredible cost-efficiency achieved by filtering      |
| Cost (LLM)                  | pairs              | (GPT-4o-mini) [4]      | exact matches deterministically before LLM invocation.|
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| Ontology Generation         | 99.95%             | Lettria Text-to-Graph  | Achieved by specialized fine-tuned models             |
| Reliability                 |                    | Benchmarks [3]         | (Qwen 3 32B); standard API models like GPT-4 hit      |
|                             |                    |                        | ~95.8%.                                               |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+
| Nano Model                  | ~97% Failure       | Lettria Text-to-Graph  | Gemini Nano scored 3.03% output reliability,          |
| Schema Failure Rate         |                    | Benchmarks [3]         | indicating small parameter models are structurally    |
|                             |                    |                        | incapable of KG construction.                         |
+-----------------------------+--------------------+------------------------+-------------------------------------------------------+

Mini Case Studies

To move beyond abstract benchmarks, the following concrete architectures and studies illustrate exactly how organizations are synthesizing AI and knowledge graphs in the field, providing actionable blueprints for enterprise architects.

Case Study 1: The data.world Enterprise SQL vs. KG Benchmark

The Problem: Enterprises continually struggle to deploy reliable “chat-with-your-data” capabilities over massive, cryptic SQL relational databases. Hallucinations are rampant because the raw tables lack explicit business context.

The Implementation: Dr. Juan Sequeda’s team at the data.world AI Lab constructed a rigorous benchmark using the official Object Management Group (OMG) Property and Casualty insurance data model. They queried 43 natural language questions mapped across four quadrants of complexity. In one test, GPT-4 queried the SQL database directly. In the second, GPT-4 queried a Knowledge Graph that mapped the SQL schema to a rich business ontology [2].

The Result: The findings were stark. For high-complexity queries requiring the model to join data from multiple tables, the pure SQL approach failed completely, recording a 0% accuracy rate [2]. The Knowledge Graph representation rescued these queries, achieving 38.7% accuracy on the hardest questions and raising overall average accuracy across all quadrants from 16.7% to 54.2% [2]. This proves quantitatively that KGs serve as an indispensable semantic layer that translates natural language intent into deterministic database retrieval.

Case Study 2: GoldenMatch’s Three-Tier Entity Resolution

The Problem: E-commerce and catalog datasets contain highly varied unstructured textual descriptions (e.g., “Sony Cyber-shot DSC-T77” vs. “Sony 10.1-Megapixel Camera”). Standard fuzzy matching algorithms achieve a poor 37% F1 score, and embedding vectors yield low precision (35.5%) because they cluster superficially similar, but technically distinct, model numbers [4].

The Implementation: GoldenMatch deployed a highly optimized three-tier hybrid pipeline to solve this. Tier 1 auto-accepts near-identical embeddings. Tier 3 auto-rejects vastly different embeddings. Crucially, Tier 2 packages the borderline pairs and sends them to a low-cost, high-speed LLM (GPT-4o-mini) with a strict, binary prompt: “Are these the same entity? YES or NO” [4].

The Result: The LLM applied cognitive reasoning to recognize that a “T77” is not a “T700,” rejecting the false positives that tricked the vector embeddings. Precision jumped to 95.4%, yielding a 66.3% overall F1 score. Through this intelligent, tiered routing, the computational cost to process the borderline pairs was kept under 4 cents, proving that AI-assisted entity resolution is economically viable at scale [4].

Case Study 3: Overcoming “Lost in the Middle” via Microsoft GraphRAG

The Problem: Traditional VectorRAG systems retrieve isolated chunks of text based on cosine similarity. When enterprise researchers attempt to extract macro-level insights requiring global context across thousands of documents, the LLM suffers from “lost in the middle” syndrome, severely degrading accuracy as the number of queried entities rises [32].

The Implementation: Microsoft Research and various commercial adopters introduced GraphRAG, which indexes source documents into a comprehensive knowledge graph prior to retrieval. It utilizes the Leiden algorithm for hierarchical community detection, recursively clustering entities and pre-computing natural language summaries of those entity clusters [34].

The Result: In query-based summarization tasks, VectorRAG captured only fine-grained, localized details. GraphRAG, by contrast, produced diverse, multi-faceted summaries, maintaining stable reasoning paths even when queries involved 10 or more interconnected entities [33]. Exhaustive testing showed factual correctness improving from approximately 50–57% with standard RAG to over 80% with GraphRAG [35].

Case Study 4: Parallax and Cognitive-Executive Separation

The Problem: Allowing an autonomous AI agent to read, write, and validate semantic constraints creates a massive security and data integrity vulnerability. If an LLM is prompt-injected or begins to hallucinate, it can silently overwrite the enterprise database ontology [6].

The Implementation: The Parallax architecture solves the “who validates the validator” problem by instituting Cognitive-Executive Separation (CES). The LLM is isolated in an unprivileged “agent process” where it reasons, plans, and proposes graph actions. A completely separate, deterministic “engine process” hosts the SHACL validation layer and executes the actual database tool calls [6].

The Result: Even if the LLM hallucinates wildly or is maliciously compromised, it possesses zero direct execution surface. The deterministic engine validates all proposed triples against the existing, human-approved enterprise ontology, guaranteeing that no rogue, non-compliant triples ever enter the production knowledge graph [6].

Gaps, Uncertainties, and the Future Trajectory

While the evidence heavily supports the shift toward AI-assisted knowledge graph construction, certain claims remain scientifically thin or unverified in the current literature, requiring enterprise architects to proceed with caution.

• Long-Term Maintenance of LLM KGs: The industry possesses highly verified, comprehensive data on the $10-$20 million CapEx required to build and maintain traditional KGs over multi-year lifespans [1]. However, because autonomous graph generators (like LangChain’s LLMGraphTransformer) are relatively nascent technologies, there is absolutely no verified longitudinal data on the operational expenditure (OpEx) cost of maintaining, patching, or querying continuously evolving, LLM-generated graphs over a 3- to 5-year enterprise horizon.
• The Illusion of True Autonomy: The claim that agentic pipelines can be entirely “self-correcting” with zero human input is largely restricted to controlled academic datasets or narrow commercial proofs-of-concept. In highly regulated environments (such as healthcare, finance, and defense), practitioners actively warn that human-in-the-loop review remains structurally mandated by law, overriding theoretical technical capabilities [7].

The 2–3 Year Enterprise Trajectory: Over the next 24 to 36 months, the semantic layer will fundamentally bifurcate. The narrative layer — responsible for processing natural language, generating hypotheses, mapping queries, and extracting initial triples — will be entirely surrendered to probabilistic LLMs [54]. Conversely, the semantic layer — representing the actual operational graph topology, taxonomies, and entity identities — will be heavily fortified using deterministic, cryptographically secure validation engines built on architectures like Cognitive-Executive Separation [6].

Ultimately, the primary role of the enterprise ontology engineer is actively transitioning. They are no longer a “builder” who manually hard-codes data linkages and RML maps; rather, they are becoming a “governor” who defines the strict constraints, rules, and shape maps that an army of AI agents must rigorously adhere to when building the graph autonomously. In the AI era, the ontology is no longer merely a map of the data; it is the fundamental, defensible intellectual property that keeps generative AI tethered to reality [50].

References & Further Readings

[1] Cutter Consortium, “Knowledge Graph Implementation: Costs & Obstacles,” 2026. [Online]. Available: https://www.cutter.com/article/knowledge-graph-implementation-costs-obstacles

[2] “Benchmark Report: The Role of Large Language Models in …,” 2026. [Online]. Available: https://medium.com/datadotworld/benchmark-report-the-role-of-large-language-models-in-enterprise-sql-database-queries-d1a282b4669d

[3] Lettria, “Benchmarking Text-to-Graph Performance: From General LLMs to …,” 2026. [Online]. Available: https://www.lettria.com/benchmarks/benchmarking-text-to-graph

[4] “Using GPT-4o-mini as an Entity Resolution Judge: 95% Precision for …,” 2026. [Online]. Available: https://pub.towardsai.net/using-gpt-4o-mini-as-an-entity-resolution-judge-95-precision-for-0-04-b216d44a7f20

[5] “Document-Level Relation Extraction with Large Language Models,” 2026. [Online]. Available: https://arxiv.org/html/2403.14888v1

[6] “Parallax: Why AI Agents That Think Must Never Act — arXiv,” 2026. [Online]. Available: https://arxiv.org/html/2604.12986v1

[7] “Paco Nathan’s Speaker Profile — Sessionize,” 2026. [Online]. Available: https://sessionize.com/s/pacoid/knowledge-graphs-construction-from-unstructured-da/102485/

[8] “On the Potential of Logic and Reasoning in Neurosymbolic Systems,” 2026. [Online]. Available: https://www.neurosymbolic-ai-journal.com/system/files/nai-paper-732.pdf

[9] Veriprajna, “Knowledge Graph & Domain Ontology Engineering for AI — Veriprajna,” 2026. [Online]. Available: https://veriprajna.com/services/knowledge-graph-domain-ontology-engineering

[10] “Automated Big Data Quality Assessment using Knowledge Graph,” 2026. [Online]. Available: https://arxiv.org/html/2605.18833v1

[11] “REBEL: Relation Extraction By End-to-end Language generation,” 2021. [Online]. Available: https://aclanthology.org/2021.findings-emnlp.204.pdf

[12] “A survey on cutting-edge relation extraction techniques based on,” 2026. [Online]. Available: https://arxiv.org/html/2411.18157v1

[13] “RoRED: A Romanian Relation Extraction Dataset — Preprints.org,” 2026. [Online]. Available: https://www.preprints.org/manuscript/202605.0578

[14] “LLM with Relation Classifier for Document-Level Relation Extraction,” 2026. [Online]. Available: https://arxiv.org/html/2408.13889v2

[15] “Building a Japanese Document-Level Relation Extraction Dataset,” 2024. [Online]. Available: https://aclanthology.org/2024.lrec-main.232.pdf

[16] “Prompting large language models to extract chemical-disease,” 2026. [Online]. Available: https://pmc.ncbi.nlm.nih.gov/articles/PMC11978106/

[17] “morph-kgc/morph-kgc: Powerful RDF Knowledge Graph Generation,” 2026. [Online]. Available: https://github.com/morph-kgc/morph-kgc

[18] “Morph-KGC — GitHub,” 2026. [Online]. Available: https://github.com/morph-kgc/morph-kgc

[19] “(PDF) Morph-KGC: Scalable knowledge graph materialization with,” 2026. [Online]. Available: https://www.researchgate.net/publication/362982745_Morph-KGC_Scalable_knowledge_graph_materialization_with_mapping_partitions

[20] “Towards an RML Mapping Reverse Engineering Pipeline,” 2026. [Online]. Available: https://kg-construct.github.io/workshop/2025/resources/paper5.pdf

[21] “[2308.02357] Text2KGBench: A Benchmark for Ontology-Driven,” 2026. [Online]. Available: https://arxiv.org/abs/2308.02357

[22] “LLMs4OL: Large Language Models for Ontology Learning — GitHub,” 2026. [Online]. Available: https://github.com/HamedBabaei/LLMs4OL

[23] “The 2nd Large Language Models for Ontology Learning Challenge,” 2026. [Online]. Available: https://www.researchgate.net/publication/396090734_LLMs4OL_2025_Overview_The_2nd_Large_Language_Models_for_Ontology_Learning_Challenge

[24] “LLMs4OL 2024 Datasets: Toward Ontology Learning with Large,” 2026. [Online]. Available: https://zenodo.org/records/13851373

[25] “Large Language Models for Scholarly Ontology Generation — arXiv,” 2026. [Online]. Available: https://arxiv.org/html/2412.08258v2

[26] “Guiding LLM Generated Mappings with Lifecycle-Based Metadata,” 2026. [Online]. Available: https://ceur-ws.org/Vol-4064/kgnesy-paper4.pdf

[27] “A Unified Benchmark for Evaluating Knowledge Graph Construction,” 2026. [Online]. Available: https://arxiv.org/html/2605.05476v1

[28] “An LLM-Aided Enterprise Knowledge Graph (EKG) Engineering,” 2026. [Online]. Available: https://ojs.aaai.org/index.php/AAAI-SS/article/download/31194/33354/35250

[29] “Automated Validation of Textual Constraints Against AutomationML,” 2026. [Online]. Available: https://arxiv.org/html/2506.10678v1

[30] “[Literature Review] Automated Validation of Textual Constraints,” 2026. [Online]. Available: https://www.themoonlight.io/en/review/automated-validation-of-textual-constraints-against-automationml-via-llms-and-shacl

[31] “RAG vs. GraphRAG: A Systematic Evaluation and Key Insights — arXiv,” 2026. [Online]. Available: https://arxiv.org/html/2502.11371v3

[32] “From RAG to Knowledge Graphs Why the Agent Era Is Redefining AI,” 2026. [Online]. Available: https://dev.to/sreeni5018/from-rag-to-knowledge-graphs-why-the-agent-era-is-redefining-ai-architecture-3fgc

[33] “GraphRAG vs. Vector RAG: When Knowledge Graphs Outperform,” 2026. [Online]. Available: https://flur.ee/blog/graphrag-vs-vector-rag-when-knowledge-graphs-outperform-semantic-search

[34] Airbyte, “Graph RAG Explained: Knowledge Graphs + Retrieval — Airbyte,” 2026. [Online]. Available: https://airbyte.com/agentic-data/graph-rag-explained

[35] Lettria, “VectorRAG vs. GraphRAG: a convincing comparison — Lettria,” 2026. [Online]. Available: https://www.lettria.com/blogpost/vectorrag-vs-graphrag-a-convincing-comparison

[36] “Improving Retrieval Augmented Generation accuracy with GraphRAG,” 2026. [Online]. Available: https://aws.amazon.com/blogs/machine-learning/improving-retrieval-augmented-generation-accuracy-with-graphrag/

[37] “Benchmarking Vector, Graph and Hybrid Retrieval Augmented,” 2026. [Online]. Available: https://arxiv.org/html/2507.03608v1

[38] “Did Claude just reveal why AI’s can seem so smart but are … — Reddit,” 2026. [Online]. Available: https://www.reddit.com/r/ClaudeAI/comments/1li6rc1/did_claude_just_reveal_why_ais_can_seem_so_smart/

[39] “LLMGraphTransformer with tools and Ollama triggers Pydantic,” 2026. [Online]. Available: https://github.com/langchain-ai/langchain/issues/29515

[40] “Enhancing RAG-based application accuracy by constructing and,” 2026. [Online]. Available: https://www.langchain.com/blog/enhancing-rag-based-applications-accuracy-by-constructing-and-leveraging-knowledge-graphs

[41] “What Is GraphRAG? Architecture, Enterprise Use Cases, and RAG,” 2026. [Online]. Available: https://atlan.com/know/what-is-graphrag/

[42] “Comparing LLM Path Extractors for Knowledge Graph Construction,” 2026. [Online]. Available: https://developers.llamaindex.ai/python/examples/property_graph/dynamic_kg_extraction/

[43] “Graph-Based Data Science Masterclass. Paco Nathan … — YouTube,” 2026. [Online]. Available: https://www.youtube.com/watch?v=ePPafn36mLg

[44] “Stardog’s ‘hallucination-free’ answer engine brings AI insights to,” 2026. [Online]. Available: https://siliconangle.com/2025/09/03/stardogs-hallucination-free-answer-engine-brings-ai-insights-high-stakes-industries/

[45] “Stardog Voicebox FAQ: How LLM, Generative AI, and Knowledge,” 2026. [Online]. Available: https://www.stardog.com/blog/stardog-voicebox-faq-how-llm-generative-ai-and-knowledge-graphs-are-the-future-of-data-management/

[46] “Stardog Voicebox — SoftwareOne Marketplace,” 2026. [Online]. Available: https://platform.softwareone.com/product/stardog-voicebox/PCP-2129-3830

[47] “release-notes.md — stardog-union/launchpad-docs — GitHub,” 2026. [Online]. Available: https://github.com/stardog-union/launchpad-docs/blob/main/release-notes.md

[48] “GraphRAG vs hipporag, lightrag and vectorRAG benchmarks — Reddit,” 2026. [Online]. Available: https://www.reddit.com/r/Rag/comments/1sysbf1/graphrag_vs_hipporag_lightrag_and_vectorrag/

[49] “The Role of Knowledge Graphs for LLM accuracy in the … — YouTube,” 2026. [Online]. Available: https://www.youtube.com/watch?v=xLjufsJ8NMM

[50] “How Semantic Layers and Ontologies Create Trusted AI — ThoughtSpot,” 2026. [Online]. Available: https://www.thoughtspot.com/data-chief/ep135/how-semantic-layers-and-ontologies-create-trusted-ai

[51] “A Benchmark to Understand the Role of Knowledge Graphs … — arXiv,” 2026. [Online]. Available: https://arxiv.org/abs/2311.07509

[52] “Knowledge Graphs with Juan Sequeda — AgileData.io,” 2026. [Online]. Available: https://agiledata.io/podcast/agiledata-podcast/knowledge-graphs-with-juan-sequeda/

[53] “AI’s Woolf at the door — LLMs and Knowledge Graphs — Medium,” 2026. [Online]. Available: https://medium.com/@dallemang/ais-woolf-at-the-door-llms-and-knowledge-graphs-eecd6289380f

[54] “LLM Wiki and Wikipedia/Wikidata: Bridging Narrative and Semantic,” 2026. [Online]. Available: https://zenn.dev/knowledge_graph/articles/llm-wiki-wikidata-narrative-semantic?locale=en

[55] “ESWC 2025 Workshop KGCW — OpenReview,” 2026. [Online]. Available: https://openreview.net/group?id=eswc-conferences.org/ESWC/2025/Workshop/KGCW

[56] “Revisiting Relation Extraction in the era of Large Language Models,” 2026. [Online]. Available: https://pmc.ncbi.nlm.nih.gov/articles/PMC10482322/

[57] “A Benchmark to Understand the Role of Knowledge Graphs … — arXiv,” 2026. [Online]. Available: https://arxiv.org/pdf/2311.07509

[58] “(PDF) RAG vs. GraphRAG: A Systematic Evaluation and Key Insights,” 2026. [Online]. Available: https://www.researchgate.net/publication/389090754_RAG_vs_GraphRAG_A_Systematic_Evaluation_and_Key_Insights