GraphNews

T-Box: The secret sauce of knowledge graphs and AI Ever wondered how knowledge graphs “understand” the world? Meet the T-Box, the part that tells your graph what exists and how it can relate. Think of it like building a LEGO set: T-Box (Terminological Box) = the instruction manual (defines the pieces and how they fit) A-Box (Assertional Box) = the LEGO pieces you actually have (your data, your instances) Why it’s important for RDF knowledge graphs: - Gives your data structure and rules, so your graph doesn’t turn into spaghetti - Enables reasoning, letting the system infer new facts automatically - Keeps your graph consistent and maintainable, even as it grows Why it’s better than other models: Traditional databases just store rows and columns; relationships have no meaning RDF + T-Box = data that can explain itself and connect across domains Why AI loves it: - AI can reason over knowledge, not just crunch numbers - Enables smarter recommendations, insights, and predictions based on structured knowledge Quick analogy: T-Box = blueprint/instruction manual (the ontology / what is possible) A-Box = the real-world building (the facts / what is true) Together = AI-friendly, smart knowledge graph #KnowledgeGraph #RDF #AI #SemanticWeb #DataScience #GraphData

Comparing LPG and RDF in Recent Graph RAG Architectures As a follow-up to my previous posts and discussions, I would like to share three papers on arXiv that demonstrate the wide range of design choices in combining LPG and RDF. Here’s a brief overview of each: 1. RAGONITE: Iterative Retrieval on Induced Databases and Verbalized RDF arXiv:2412.17690 This paper builds on RDF knowledge graphs. Rather than relying solely on SPARQL queries, it establishes two retrieval pathways: one from an SQL database generated from the KG, and another from text searches over verbalised RDF facts. A controller decides when to combine or switch between them, with results passed to an LLM. The insight: RDF alone is not robust enough for conversational queries, but pairing it with SQL and text dramatically improves coverage and resilience. 2. GraphAr: Efficient Storage for Property Graphs in Data Lakes arXiv:2312.09577 This article addresses LPGs. It introduces a storage scheme that preserves LPG semantics in formats such as Parquet, while significantly boosting performance. Reported gains are impressive: neighbour retrieval is ~4452× faster, label filtering 14.8× faster, and end-to-end workflows 29.5× faster compared to baseline Parquet methods. Such optimisations are critical for GraphRAG, where low-latency retrieval is essential. 3. CypherBench: Towards Precise Retrieval over Full-scale Modern Knowledge Graphs in the LLM Era arXiv:2412.18702 This work brings a benchmarking perspective, targeting Cypher queries over large-scale LPGs. It emphasises precision retrieval across full-scale graphs, something crucial when LLMs are expected to interact with enterprise-scale knowledge. By formalising benchmarks, it encourages more rigorous evaluation of GraphRAG retrieval techniques and raises the bar for future architectures. Takeaway Together, these works highlight the diverse strategies for bridging RDF and LPG in GraphRAG — from hybrid retrieval pipelines to optimised storage and precision benchmarks. They show how research is steadily moving from demos to architectures that balance semantics, performance, and accuracy.

Interesting, and something I've been suspecting for a while. In semantics, one of the things that eventually all ontologists encounter is the fact that a human being cannot readily visualize large graphs, or even moderate-sized ones. Graphs are networks, and most networks can at best only be navigated from within. All graphs are collections of interconnected links between things; semantically we simplify those links, abstract them to a certain degree, but links in turn are also themselves describable as graphs, and when describing a system, those links in turn are dynamic and changing. One thing that marks the boundary between algorithms and intentional systems is complexity. Intentional systems, such as large language models, are more complex than the human brain can understand. We have to use computers to handle this complexity, because it is outside of the scope of our human wetware. This is a humbling realisation, and is the real power of AI; the point where we reached a level of complexity that is no longer completely comprehensible to mere mortals. This isn't going to change, regardless of what model we use for that AI. | 15 comments on LinkedIn

Learn how neurosymbolic frameworks and knowledge graphs are the key to bring structure, context, and flexibility to LLM-powered systems.

Executive Summary While both Vector Databases and Graph Databases are pivotal technologies in modern artificial intelligence (AI) and data management, they operate on fundamentally different principles of data organization and retrieval. Vector Databases manage data based on statistical similarity w

Now we can build knowledge graphs without tedious text preprocessing using smaller LLMs on laptops

A framework for measuring retrieval quality in Model Context Protocol agents

AI-Assisted Ontology Mapping Ontology alignment, glossary mapping, semantic integration - none are new. For decades: TF-IDF, WordNet, property matching, supervised models. They work - but remain rule-bounded. The new Google + Harvard research (2025-09-08) signals a paradigm shift: Ontologies are no longer static. Every conceptual decision can be treated as a measurable task. Ontologies as Living Systems An ontology is not a document. It is a formalized knowledge backbone, where: - Concepts are expressed declaratively (OWL, RDF, OntoUML) - Relations exist as axioms - Every inference is machine-checkable In this world, the semantic layer isn’t a BI artifact - it’s the formal contract of meaning: business glossaries, KPIs, and data attributes all refer to the same conceptual entities. Measuring Ontological Precision The Google–Harvard approach reframes ontology engineering as scorable tasks: - Mapping-F1 → accuracy of mappings between glossaries and semantic layers. - Alignment% → conceptual overlap between ontologies. - Consistency → are KPI definitions aligned with their OWL/RDF axioms? Once we define these metrics, semantic mappings stop being static deliverables. They become living quality signals - ontological KPIs. AI as a Sandbox Co-Scientist The breakthrough is not automation. It’s the ability to generate, test, and validate conceptual hypotheses iteratively: - LLM proposes alternative mapping strategies: embeddings, synonym discovery, definition-based similarity. - Tree Search explores promising branches, sandbox-validating each. - Research Injection pulls external knowledge - papers, books, benchmarks - into the loop. In one small-scale ontology alignment task: - Task: map 20 glossary terms into a semantic layer. - Baseline: manual mapping → Mapping-F1 = 0.55. - AI loop: hypotheses generated, sandbox-validated. - Breakthrough: after 8 iterations, Mapping-F1 reached 0.91. This isn’t “AI hallucination.” It’s measured, validated ontology evolution. The Ontological Cockpit An ontology cockpit tracks the health of your knowledge model: - Mapping-F1 trends - how well glossaries and layers align. - Alignment% by domain - where conceptual drift emerges. - Consistency-break log - where KPI definitions diverge from formal models. - Drift detection - alerts when semantics shift silently. This cockpit is the dynamic mirror of formalism. BI 2.0 dashboards can later inherit these metrics. AI-Supported Formalism Jessica Talisman - this is close to what you’ve been advocating: formal knowledge models supported, not replaced, by AI. - Sandbox validation ensures every hypothesis is tested and versioned. - Research injection integrates state-of-the-art ontological heuristics. - Ontologies evolve iteratively, without compromising formal rigor. The Google + Harvard research shows us: a semantic backbone that learns, an ontology that continuously integrates new knowledge, and a future where conceptual precision is measurable, auditable, and improvable. | 73 comments on LinkedIn

The Neo4j Infinigraph uses property sharding to distribute properties across multiple database shards while keeping the graph structure intact.

Graph retrieval-augmented generation (GraphRAG) has effectively enhanced large language models in complex reasoning by organizing fragmented knowledge into explicitly structured graphs. Prior...

Artificial Intelligence (AI) has made astonishing progress in recent years. Large Language Models (LLMs) can write essays, summarize…

🚀 I’m excited to announce Stanford Graph Learning Workshop 2025, happening Tuesday, October 14, 2025 at Stanford University (with online livestream). Free registration! Submit a talk/poster. 📍 This year’s workshop will spotlight three fast-moving frontiers in AI & data science: -- Agents — Autonomous systems reshaping how we interact with tech -- Relational Foundation Models — Unlocking structure and meaning in complex data -- Fast LLM Inference — Pushing the boundaries of speed & scalability for large language models We’re bringing together researchers, innovators, and practitioners for a full day of cutting-edge talks, interactive sessions, and collaborative discussions. Whether you’re working in industry, academia, or startup land, there will be something to spark your curiosity and drive your work forward. 🔍 Want to share your work? We have a Call for Contributed Talks and Posters/Demos open now. ✅ Register now (free): https://lnkd.in/dm9JUnH6 📅 Save the date: Oct 14, 2025 | 13 comments on LinkedIn

Showrooms vs. Production Reality: Why is RDF still not widely used? The debate around RDF never really goes away. Advocates highlight its strong foundations, interoperability and precision. However, critics point to its steep learning curve, unwieldy tools, and limited adoption beyond academia and government circles. So why is RDF still a hard sell in enterprise settings? The answer lies less in ignorance and more in reality. Enterprises operate in dynamic environments. Data is constantly being created, updated, versioned and retired. Complex CRUD operations, integration pipelines and governance processes are not exceptions, but part of the daily routine. RDF, with its emphasis on formal representation, often finds it difficult to keep up with this level of operational activity. Performance matters, too. Systems that appear elegant in theory often encounter scaling and latency issues in practice. Enterprises cannot afford philosophical debates when customers expect instant results and compliance teams demand verifiable evidence. Usability is another factor. While RDF tooling is powerful, it is geared towards specialists. Enterprises need platforms that are usable by architects, data stewards, analysts and developers, without requiring them to master semantic web standards. Meanwhile, pragmatic approaches to GraphRAG — combining graph models with embeddings — are gaining traction. While they may lack the rigour of RDF, they offer faster integration, better performance and easier adoption. For many enterprises, 'good enough and working' is preferable to 'perfect but unused'. This doesn’t mean that RDF has no place. It remains relevant in classical information systems where interoperability and formal semantics are essential, such as in the healthcare, government and regulated industries. However, the centre of gravity has shifted. In today's LLM and GraphRAG pipelines, with all their complexity and pragmatic constraints, enterprises prioritise solutions that work, scale and can be trusted. Therefore, the real question may no longer be “Why don’t enterprises adopt RDF?”, but rather, “Can RDF remain relevant in the noisy, fast-moving world of enterprise AI?” #KnowledgeGraphs #EnterpriseAI #GraphRAG #RDF #DataArchitecture #AIinEnterprise #LLM #AIAdoption | 22 comments on LinkedIn

Ontology-driven vibe coding Build a reliable app in a matter of minutes in just five steps: 1. Define concepts 2. Define relationships 3. Connect concepts through relationships 4. Define attributes 5. Connect attributes to concepts Then click on 'go to app -' and you are ready to go! What does Hapsah.org provide: - Business glossary with terms and definitions - Conceptual modelling environment - Business rule authoring tool - App running environment - Admin environment - APIs for operational data access (for data manipulation) - APIs for meta data access (glossary, conceptual model and business rules) Making changes or additions to your app is just as easy. You never run into debugging issues. There is no spaghetti codebase that is created and managed under the hood. So no debugging hell, just a smoothly running app. #vibecoding #nocode #ontology #semantic #app #development #businessrules | 18 comments on LinkedIn

If you could hire the smartest engineers and drop them in your code base would you expect miracles overnight? No, of course not! Because even if they are the best of coders, they don’t have context on your project, engineering processes and culture, security and compliance rules, user personas, business priorities, etc. The same is true of the very best agents.. they may know how to write (mostly) technically correct code, and have the context of your source code, but they’re still missing tons of context. Building agents that can deliver high quality outcomes, faster, is going to require much more than your source code, rules and a few prompts. Agents need the same full lifecyle context your engineers gain after being months and years on the job. LLMs will never have access to your company’s engineering systems to train on, so something has to bridge the knowledge gap and it shouldn’t be you, one prompt at a time. This is why we're building what we call our Knowledge Graph at GitLab. It's not just indexing files and code; it's mapping the relationships across your entire development environment. When an agent understands that a particular code block contains three security vulnerabilities, impacts two downstream services, and connects to a broader epic about performance improvements, it can make smarter recommendations and changes than just technically correct code. This kind of contextual reasoning is what separates valuable AI agents from expensive, slow, LLM driven search tools. We're moving toward a world where institutional knowledge becomes portable and queryable. The context of a veteran engineer who knows "why we built it this way" or "what happened last time we tried this approach" can now be captured, connected, and made available to both human teammates and AI agents. See the awesome demos below and I look forward to sharing more later this month in our 18.4 beta update!

GraphRAG doesn’t lack ideas, it struggles to scale up. It’s easy to be impressed by a demo that runs on a few documents and carefully curated questions. In that controlled environment, the answers appear seamless, latency is low and everything seems reliable. But the reality of enterprise is very different. Production workloads involve gigabytes of content, thousands of questions and tens of thousands of documents that are constantly changing. In such an environment, manual review is no longer an option. You can’t hire teams to check every answer against every evolving dataset. For GraphRAG to succeed in enterprise production, it must therefore rely on automated control mechanisms that continuously validate efficiency. Validation cannot be based on subjective impressions of 'good answers'. What is needed is a synthetic index of accuracy: a measurable framework that automatically tests and reflects performance at each stage of the workflow. This means validating ingestion (are we capturing the correct data?), embeddings (are entities represented consistently?), retrieval (are relevant entities retrieved reliably?) and reasoning (is the output aligned with the validated context?). Each step must be monitored and tested continuously as data and queries evolve. Another critical requirement is repeatability. In chatbot use cases, a degree of LLM creativity might be tolerated. In enterprise environments, however, it undermines trust. If the same query over the same dataset yields different answers each time, the system cannot be relied upon. Reducing the LLM's freedom to enforce repeatable, auditable answers is essential for GraphRAG to transition from prototype to production. The real differentiator will not be which graph model is 'purest', or which demo looks smoothest, but rather which implementation can demonstrate efficiency within enterprise constraints. This requires automation, accuracy, repeatability, and resilience at scale. Without these features, GraphRAG will remain an experimental solution rather than a practical one. #GraphRAG #RAG #AITrust #AutomatedValidation #AIBechmark

It is here: the second edition of An Introduction to Ontology Engineering, also published with the non-profit College Publications and making its way through the distribution channels (e.g., on ama…

Meet Infinigraph, a scalable, distributed graph architecture that allows you to run 100TB+ operational and analytical graph workloads in a single system.

Atomic Facts, Validation, Entity Resolution, KG and more

Labeled property graphs often contain rich textual attributes that can enhance analytical tasks when properly leveraged. This work explores the use of pretrained text embedding models to enable...

💡 Graph of Ideas -- LLMs paired with knowledge graphs can be great partners for ideation, exploration, and research. We've all seen the classic detective corkboard, with pinned notes and pictures, all strung together with red twine. 🕵️  The digital version could be a mind-map, but you still have to draw everything by hand. What if you could just build one from a giant pile of documents? Enter GoAI - a fascinating approach that just dropped on arXiv combining knowledge graphs with LLMs for AI research idea generation. While the paper focuses on a graph of research papers, the approach is generalizable. Here's what caught my attention: 🔗 It builds knowledge graphs from AI papers where nodes are papers/concepts and edges capture semantic citation relationships - basically mapping how ideas actually connect and build on each other 🎯 The "Idea Studio" feature gives you feedback on innovation, clarity, and feasibility of your research ideas - like having a research mentor in your pocket 📈 Experiments show it helps produce clearer, more novel, and more impactful research ideas compared to traditional LLM approaches The key insight? Current LLMs miss the semantic structure and prerequisite relationships in academic knowledge. This framework bridges that gap by making the connections explicit. As AI research accelerates, this approach can be be used for any situation where you're looking for what's missing, rather than answering a question about what exists. Read all the details in the paper... https://lnkd.in/ekGtCx9T

Our RDF Sketch extension (https://lnkd.in/d_T4SUGX) for VS Code now works directly in the browser. You can use it in:  - https://vscode.dev - https://github.dev - GitLab Web IDE We’d love your feedback if you try it out. #RDF #LinkedData #KnowledgeGraphs #VSCode #DevTools #SemanticWeb

There are people who seem to reject Knowledge Graphs while claiming that they do not allow AI Agents to make decisions under uncertainty. This article aims at refuting this claim and showing that, apart from supporting decisions based on reasoning grounded in logic, they are also capable of supporti

Seven knowledge graph quality problems that undermine GraphRAG performance and how to detect them

What they mean, what they don’t, and how to use them

Citation metrics are widely used to assess academic impact but suffer from social biases, including institutional prestige and journal visibility. Here we introduce rXiv Semantic Impact (XSI), a...

In an era where software systems are increasingly complex and interconnected, effectively managing the relationships between packages, maintainers, dependencies, and vulnerabilities is both a challenge and a necessity. This paper explores the integration of knowledge graphs into the Debian ecosystem as a powerful means to bring structure, semantics, and coherence to diverse sources of package-related data. By unifying information such as package metadata, security advisories, and reproducibility reports into a single graph-based representation, we enable richer visibility into the ecosystem's structure and behavior. Beyond constructing the DebKG graph, we demonstrate how it supports practical, high-impact applications — such as tracing vulnerability propagation and identifying gaps between community needs and development activity — thereby offering a foundation for smarter, data-informed decision-making within Debian.

Wikidata Knowledge Graph to Enable Equitable and Validated Generative AI - Jonathan Fraine & Lydia Pintscher, Wikimedia DeutschlandGenerative AI has changed ...