An Overview on Graph Types for Graph RAG: Structures, Schemas, and When to Use Each One

Ontology Design Patterns Part 6: *Multiple Inheritance, Not Multiple Instantiation*

#Anthropic just disrupted the first AI-orchestrated cyberattack.

Earlier this year, I discovered Larry Swanson podcast on Knowledge Graphs. One of the first episodes I listened to was with George Anadiotis Six months later, I finally met George in person. And not just George! Amy Hodler from GraphGeeks was there too, hosting an excellent event on graph technologies. I’m still quite new to the graph tech world. My initial interest came from exploring how graphs can support legal reasoning and inference in LLMs, mainly because graphs help introduce logic, determinism, and reduce hallucinations. But this event (and the people there) helped me understand how much broader the applications really are. One of the first things I learned was that graph technologies largely fall into two families: Label-Property Graphs (LPG) and RDF. With the help of the experts onsite, I explored the most common use cases for each. For LPG (structured knowledge): • Pattern recognition – Finance: fraud detection, anti-fraud behavior chains (something SQL can’t trace) – Compliance & risk: the London Stock Exchange uses LPG to trace paths leading to risk concentration for DORA compliance • Route / path finding – Cybersecurity: mapping exploit paths – Supply chain: modelling supply routes and comparing alternatives – Incident analysis: understanding causal chains inside complex systems For RDF (built for meaning and semantics): • Domain modeling and knowledge engineering • AI memory architectures There were also discussions about hybrid approaches where both frameworks work together: Natural language query → grounded semantically with RDF → executed through an LPG engine. In practice, this looks like: LLMs providing the interface, RDF providing the semantics, and LPG providing the performance. A powerful combination for building the next generation of intelligent systems. Thank you George, Amy, Maja and everyone else for the insights and conversations. And thanks to GraphGeeks and Connected Data for bringing such a strong community together.

2026 Is the Year Ontology Breaks Out — And Why Getting It Wrong Is Dangerous Neil Gentleman-Hobbs is spot on. 2026 is the tipping point where enterprises finally realize that AI can’t act intelligently without a semantic foundation. LLMs can produce language, but without ontology they cannot understand anything they output. A while back I wrote the Palantir piece about Alex Karp’s “chips and ontology” quote — and the reaction was huge. Not because Palantir isn’t doing important work, but because there’s a major misunderstanding in the market about what ontology actually is. And here’s the core truth: **Palantir is not doing ontology. They are doing a configurable data model with workflow logic.** Their “ontology” has: • no OWL or CLIF • no TBox or ABox structure • no identity conditions • no logical constraints • no reasoner • no formal semantics at all It’s powerful, yes. It’s useful, yes. But it is not ontology. Why this is dangerous When companies believe they have ontology but instead have a dressed-up data model, three risks emerge: 1. False confidence You think your AI can reason. It can’t. It can only follow whatever imperative code a developer wrote. 2. No logical guarantees Without identity, constraints, and semantics, the system cannot detect contradictions, errors, or impossible states. It hallucinates in a different way — structurally. 3. Brittleness at scale Every new policy or relationship must be coded by hand. That’s not semantic automation, it’s enterprise-scale brute force. This is exactly where systems crack under combinatorial growth. In other words: you don’t get an enterprise brain, you get a beautiful spreadsheet with an API. At Interstellar Semantics, this is the gap we focus on closing: building real ontologies with identity, constraints, time, roles, and reasoning — the kind of foundations AI systems actually depend on. If your organization wants to understand what real ontology looks like: 👉 https://lnkd.in/ek3sssCY #Ontology #SemanticAI #EnterpriseAI #AI2026 #Palantir #SemanticReasoning #KnowledgeGraphs #DataStrategy #AITrustworthiness | 12 comments on LinkedIn

Accounting for How We Work

𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 𝗪𝗶𝘁𝗵 𝗚𝗿𝗮𝗽𝗵𝗥𝗔𝗚: 𝗗𝗼𝗻’𝘁 𝗕𝘂𝘆 𝗮 𝗠𝗮𝗽 𝘄𝗶𝘁𝗵𝗼𝘂𝘁 𝗔𝘀𝗸𝗶𝗻𝗴 𝗪𝗵𝗼 𝗨𝗽𝗱𝗮𝘁𝗲𝘀 𝗧𝗵𝗲 𝗧𝗲𝗿𝗿𝗮𝗶𝗻

Continuing our exploration of Knowledge Graphs and LLMs: a systematic analysis of RAG techniques for Intelligent Advisory Systems

Summary of the things I learned at the 2025 International Semantic Web Conference, my scientific home.

What is knowledge engineering?

After seeing one too many Neo4j tutorials teaching developers to hide nouns inside relationships, I’ve had enough. Here’s why this…

Summary of what I learned at Connected Data London (CDL2025). The winners are clear: companies who have quietly been investing in knowledge graphs for the last decade, way before this current AI wave

Here it is - the draft of the latest chapter on meaning in data modeling.

Ontologists, rejoice!

LPG is NOT a hypergraph

I just stepped off the stage at Connected Data London, where we talked about the black box of AI and the critical role of ontologies. We ended that talk by saying that we, as a community, have a responsibility to cut through the noise. To offer clarity. That is why today, we're launching The Knowledge Graph Academy. For too long, education in semantic technology has tended to sit at one of two extremes: highly abstract academic theory, or tool-focused training that fails to teach the underlying principles. We are building something different. Where educational rigour meets real-world practice. And I’m not doing this alone. If we are going to define the field, we need the leaders who are actually out there building it. I am incredibly proud to announce that I’ve teamed up with two of the sharpest minds in the industry to lead this programme with me: 🔵 Katariina Kari (Lead Ontologist): Katariina has spent years building KG teams at retail giants. She knows exactly how to capture business expertise to drive ROI. She’s the master of the philosophy: "a little semantics goes a long way." 🔵 Jessica Talisman Tallisman (Senior KG Consultant): With 25+ years in data architecture, Jessica is a true veteran of the trenches. She’s a LinkedIn Top Voice, an expert on the W3C SKOS standard, and creator of the 'Ontology Pipeline' framework. This isn't just training. It’s a shift in mindset. This course doesn't just teach you which syntax to use or buttons to press, The Knowledge Graph Academy is designed to change how you think. Whether you are a practitioner, a leader shaping AI strategy, or someone looking to pivot your career: this is your invitation. Let’s turn ideas into understanding, and understanding into impact. ⭕ The Knowledge Graph Academy: https://lnkd.in/ecQBMCg3 | 59 comments on LinkedIn

The Sketch and The Blueprint

Table of Contents

The first in a series of posts about knowledge graphs and ontology design patterns that I swear by. They will lead you through how at Yale we went from a challenge from leadership (build a system that allows discovery of cultural heritage objects across our libraries, archives and museums) to a fully functioning, easy to use, easy to maintain, extremely robust, public knowledge graph. *The 10 Design Principles to Live By* 1. Scope design through shared use cases 2. Design for international use 3. Make easy things easy, complex things possible 4. Avoid dependency on specific technologies 5. Use REST / Don’t break the web / Don’t fear the network 6. Design for JSON-LD, using LOD principles 7. Follow existing standards & best practices, when possible 8. Define success, not failure 9. Separate concerns, keep APIs & systems loosely coupled 10. Address concerns at the right level You must first agree on your design principles and priorities. These are crucial because when the inevitable conflicts of opinion arise, you have a set of neutral requirements to compare the different options against. (1) The first keeps you honest: good ideas are only ideas if they don't advance your business / use cases. Keeping to scope is critical as ontologies have a tendency to expand uncontrollably, reducing usability and maintainability. (2) Internationalization of knowledge is important because your audience and community doesn't just speak your language, or come from your culture. If you limit your language, you limit your potential. (3) Ensure that your in-scope edge cases aren't lost, but that in solving them, you haven't made the core functionality more complicated than it needs to be. If your KG isn't usable, then it won't be used. (4) Don't build for a specific software environment, because that environment is going to change. Probably before you get to production. Locking yourself in is quickest way to obsolescence and oblivion. (5) Don't try to pack everything a consuming application might need into a single package, browsers and apps deal just fine with hundreds of HTTP requests. Especially with web caches. (6) JSON-LD is the serialization to use, as devs use JSON all the time, and those devs need to build applications that consume your knowledge. Usability first! (7) Standards are great... especially as there are so many of them. Don't get all tied up trying to follow a standard that isn't right, but don't invent the wheel unnecessarily. (8) Define the ontology/API, but don't require errors for all other situations, as you've made versioning impossible. Allow extensions to co-exist, as tomorrow they might be core. (9) Don't require a single monolith if you can avoid it. If a consuming app only needs half of the functionality, don't make them implement everything. (10) If there's a problem with the API, don't work around it in the ontology, or vice versa. Solve model problems in the model, vocabulary problems in vocabulary, and API problems in the API. | 12 comments on LinkedIn

A Case Study in Context Engineering & How We Can Apply Learnings In Data Platforms

What if ontology can be better approached as a spectrum?

After a vivid conversation with Juan Sequeda and others at Connected Data London 2025 about how to start with Ontologies at business clients w/o relying on another KG platform, I have now started to roll (eh vibe coding 🤓) my own Ontology Builder as a simple Streamlit app! Have a look and collaborate if you like. https://lnkd.in/egGZJHiP

Simple way of starting with ontologies: start with your favorite LLM and the following prompt:

✨ #NeurIPS2025 paper: Scalable Feature Learning on Huge Knowledge Graphs for Downstream Machine Learning Combining contrastive learning and message passing markedly improves features created from embedding graphs, scalable to huge graphs. It taught us a lot on graph feature learning 👇 Graphs can represent knowledge and have scaled to huge sizes (115M entities in Wikidata). How to distill these into good downstream features, eg for machine learning? The challenge is to create feature vectors, and for this graph embeddings have been invaluable. Our paper shows that message passing is a great tool to build feature vectors from graphs As opposed to contrastive learning, message passing helps embeddings represent the large-scale structure of the graph (it gives Arnoldi-type iterations). Our approach uses contrastive learning on a core subset of entities, to capture a large-scale structure. Consistent with knowledge-graph embedding literature, this step represents relations as operators on the embedding space. It also anchors the central entities. Knowledge graphs have long-tailed entity distributions, with many weakly-connected entities on which contrastive learning is under constrained. For these, we propagate embeddings via the relation operators, in a diffusion-like step, extrapolating from the central entities. To have a very efficient algorithm, we split the graph in overlapping highly-connected blocks that fit in GPU memory. Propagation is then simple in-memory iterations, and we embed huge graphs on a single GPU. Splitting huge knowledge graphs in sub-parts is actually hard because of the mix of very highly-connected nodes, and a huge long tail hard to reach. We introduce a procedure that allows for overlap in the blocks, relaxing a lot the difficulty. ‪Our approach, SEPAL, combines these elements for feature learning on large knowledge graphs. It creates feature vectors that lead to better performance on downstream tasks, and it is more scalable. Larger knowledge graphs give feature vectors that provide downstream value. We also learned that performance on link prediction, the canonical task of knowledge-graph embedding, is not a good proxy for downstream utility. We believe this is because link prediction only needs local structure, unlike downstream tasks The papier is well reproducible, and we hope it will unleash more progress in knowledge graph embedding. We'll present at #NeurIPS and #Eurips

Graph-constrained Reasoning (GCR) is a novel framework that bridges structured knowledge in knowledge graphs (KG) with unstructured reasoning in LLMs.

# ⚙️ Ontology Evolution: When New Knowledge Challenges Old Categories  When new entities don’t fit existing assumptions, your ontology must **evolve logically**, not patch reactively. --- ## 🧩 The Challenge: Going Beyond Binary Thinking  Early models often start simple:   **Appliance → ElectricityConsumer OR NonElectricAppliance** But what happens when a *WindTurbine* appears?  It **produces** more electricity than it consumes.  --- ## 🔧 Step 1: Extend the Energy Role Taxonomy  To reflect the real world:  ``` EnergyRole ├─ ElectricityConsumer ├─ ElectricityProducer   ├─ ElectricityProsumer (both) └─ PassiveComponent (neither) ``` Now we can classify correctly:   - 🏠 HVAC → ElectricityConsumer   - ☀️ Solar Panel → ElectricityProducer   - 🔋 Battery → ElectricityProsumer   - 🪟 Window → PassiveComponent  This simple hierarchy shift restores consistency — every new entity has a logical home. --- ## 🧠 Step 2: Add Axioms for Automated Reasoning  Instead of manual assignment, let the reasoner decide. Example rule set: - If `producesPower consumesPower` → ElectricityProducer   - If `consumesPower producesPower` → ElectricityConsumer   - If both 0 → ElectricityProsumer   - If both = 0 → PassiveComponent  💡 **Outcome:** The system adapts dynamically to new data while preserving logical harmony. --- ## ⚡ Step 3: Support Evolution, Don’t Break History  When expanding ontologies: 1. Preserve backward compatibility — old data must still make sense.   2. Maintain logical consistency — define disjoint and equivalent classes clearly.   3. Enable gradual migration — version and document each model improvement.   4. Use reasoning — automate classification from quantitative features.  Evolution isn’t about tearing down—it’s about **strengthening the structure**. --- ## 🌍 Real-World Analogy  Think of this like upgrading an energy grid:   You don’t replace the whole system — you extend the schema to accommodate solar panels, batteries, and wind farms while ensuring the old consumers still work.  Ontology evolution works the same way — graceful adaptation ensures **stability + intelligence**. --- ## 💬 Key Takeaway  *WindTurbine* example shows why **ontology evolution** is essential:   - Models must expand beyond rigid assumptions.   - Axiomatic rules make adaptation automatic.   - Logic-based flexibility sustains long-term scalability.  In short: **don’t model just the present — model the principles of change.** #Ontology #KnowledgeEngineering #KnowledgeGraphs #ExplainableAI #OntologyEvolution #NeuroSymbolicAI #AITransformation #KnowledgeManagement 👉 Follow me for Knowledge Management and Neuro Symbolic AI daily nuggets. 👉 Join my group for more insights and community discussions [Join the Group](https://lnkd.in/d9Z8-RQd)

Scientific Reports - Research on the construction and application of retrieval enhanced generation (RAG) model based on knowledge graph

Introducing the ONTO-TRON-5000. A personal project that allows users to build their ontologies right from their data! The onto-tron is built with the Basic Formal Ontology (BFO) and Common Core Ontologies (CCO) as semantic frameworks for classification. This program emphasizes the importance of design patterns as best practices for ontology documentation and combines it with machine readability. Simply upload your CSV, set the semantic types of your columns and continuously build your ontology above. The program has 3 options for extraction: RDF, R2RML, and the Mermaid Live Editor syntax if you would like to further develop your design pattern there. Included is a BFO/CCO ontology viewer, allowing you to explore the hierarchy and understand how terms are used- no protege required. This is the alpha version and would love feedback as there is a growing list of features to be added. Included in the README are instructions for manual installation and Docker. Enjoy! https://lnkd.in/ehrDwVrf | 13 comments on LinkedIn

Why Your Knowledge Graph Project Will Fail: The Leadership Gap No One Talks About