Found 6069 bookmarks
Newest
Ontologies and Knowledge Graphs: Why They Work Better Together I d.AP Blog
Ontologies and Knowledge Graphs: Why They Work Better Together I d.AP Blog

ONTOLOGIES VS. SEMANTIC LAYERS: WHY ENTERPRISE AI NEEDS BOTH, AND WHICH DOES WHAT

One of the most persistent confusions in enterprise AI discussions is the conflation of semantic layers and ontologies. A new analysis from d.AP makes the distinction crisp and practically useful. A semantic layer is for lookup — it normalises labels and definitions to make metrics consistent across reporting tools. An ontology is for context and reasoning — it encodes what entities are, how they relate, what can be inferred, and what constraints must hold.

The difference surfaces sharply in deployment. A knowledge graph built without an overarching ontology may contain connected data, but it lacks a shared interpretive framework. Different departments build incompatible schemas. Integration logic becomes inconsistent. Every new use case requires a partial rebuild rather than a reuse of existing structure. The ontology is what allows a new data source to be added by updating the rules, rather than rewriting the graph.

The analysis draws on a useful structural metaphor: the ontology is the architectural blueprint; the knowledge graph is the physical building. You can have a blueprint without a building (a purely conceptual model), but a well-formed building requires a blueprint — whether or not that blueprint is made explicit. Most enterprise knowledge graphs have implicit ontologies; the question is whether those implicit structures are consistent, maintained, and capable of supporting the reasoning that agentic AI requires.

Gartner’s 2026 positioning — naming knowledge graphs and semantic enrichment as non-negotiable budget items for enterprise AI — suggests the enterprise market is arriving at this conclusion independently, through the painful experience of deploying agents on unstructured, under-governed data.

·digetiers-dap.com·
Ontologies and Knowledge Graphs: Why They Work Better Together I d.AP Blog
LOINC Ontology Technical Release Notes – LOINC / SNOMED CT
LOINC Ontology Technical Release Notes – LOINC / SNOMED CT

THE LOINC ONTOLOGY 2.0: 41,000+ CLINICAL CONCEPTS NOW IN SEMANTIC FORM

Healthcare informatics reached a significant milestone with the September 2025 production release of the LOINC Ontology 2.0 — a formal semantic representation of LOINC terms developed jointly by Regenstrief Institute and SNOMED International. The release now covers over 41,000 concepts representing laboratory LOINC terms, with approximately 78% of concepts sufficiently defined and a new LABORDERS.ONTOLOGY class providing 2,500 grouper concepts for hierarchical navigation.

The ontology is distributed as a SNOMED CT extension in RF2 format via loincsnomed.org, which means it carries the formal semantics and maintenance discipline of the SNOMED ecosystem. For implementers, this matters: LOINC has historically been a relational dataset — an extremely well-maintained one, but without the formal class hierarchy, property axioms, and reasoning support that clinical decision systems increasingly require.

The collaboration between Regenstrief and SNOMED International that produced this release began with a 2013 partnership linking SNOMED’s clinical semantics to LOINC’s observational concepts, and formalised into an extension agreement in 2022. The March 2025 production release — covering the top 200 most-used lab tests first — and the September 2025 expansion represent the payoff of nearly a decade of alignment work.

For those building healthcare knowledge graphs, the LOINC Ontology provides a canonical semantic anchor for laboratory observations that was previously absent. The RF2 format requires conversion to OWL or RDF for direct use in a triplestore, but established pipelines for that conversion exist. This is now the right starting point for any clinical ontology stack that needs to model test orders and results formally.

·loincsnomed.org·
LOINC Ontology Technical Release Notes – LOINC / SNOMED CT
Agentic SPARQL: Evaluating SPARQL-MCP-powered Intelligent Agents...
Agentic SPARQL: Evaluating SPARQL-MCP-powered Intelligent Agents...

AGENTIC SPARQL: LLMS MEET FEDERATED KNOWLEDGE GRAPH QUERYING VIA MCP

One of the most technically significant papers of the spring quietly updated its second version in April. “Agentic SPARQL,” from researchers at arXiv, explores what happens when you combine SPARQL federation with the Model Context Protocol — giving LLM agents the ability to discover endpoints, explore schemas, decompose queries across distributed RDF datasets, and return grounded answers without hallucinating.

The architecture is elegant in its standardisation strategy. SPARQL already provides a native federation mechanism via the SERVICE operator, and endpoints can self-describe using VoID vocabulary. MCP provides the JSON-RPC bridge between the LLM’s tool-calling interface and the SPARQL endpoint registry. The combination means an agent can be handed a natural-language question, select the relevant endpoints itself, and issue a federated SPARQL query — without the query being hard-coded by a developer.

The paper extends the Spider4SPARQL benchmark towards a federated variant, cross-partitioning 19 RDF datasets across multiple endpoints in ways that require the agent to reason about data locality rather than simply executing pre-known queries. That is a realistic test of agentic behaviour, and the results are instructive about where endpoint discovery and schema exploration remain unsolved problems.

For those of us working at the intersection of RDF tooling and LLM integration, this paper is required reading. It suggests that SPARQL endpoints, far from being a legacy retrieval mechanism, are well-positioned as the native data layer for agentic AI — precisely because they combine a standardised query language, formal metadata, and federation in a single protocol stack.

·arxiv.org·
Agentic SPARQL: Evaluating SPARQL-MCP-powered Intelligent Agents...
Semantica 0.5.0 is out
Semantica 0.5.0 is out

SEMANTICA V2: 10× EMBEDDING CACHE PERFORMANCE AND SEMANTIC NEIGHBOURHOOD SEARCH

The Hawksight-AI team released Semantica v2 on 11 May, and the performance improvements are substantial. The headline figure — over 10× embedding cache performance — is achieved through per-session revision-based caching with thread-safe invalidation, addressing one of the most persistent bottlenecks in production knowledge graph systems that blend vector and symbolic retrieval.

The new Semantic Neighbourhood Search capability is conceptually interesting. Rather than returning a flat ranked list of similar entities, it provides context-aware similarity with proximity metrics — effectively treating the neighbourhood of a node as a structured semantic space rather than a distance function. That distinction matters for applications where the meaning of an entity depends on its immediate relational context rather than its isolated embedding.

The v2 release also improves entity extraction speed at up to 6.98× over the previous version, with improved deduplication strategies including Jaro-Winkler, semantic, and hybrid approaches. For pipelines that ingest free text and build knowledge graphs incrementally — precisely the use case that is becoming standard in enterprise RAG architectures — the deduplication improvement is as practically significant as the cache gains.

Semantica is positioning itself as an AI-native knowledge graph intelligence framework: semantic retrieval, ontology reasoning, context graphs, and explainable AI in a single integrated system. The v2 release suggests the team is taking the production performance story seriously, which distinguishes it from the many knowledge graph projects that are research-grade demonstrations rather than deployable infrastructure.

·linkedin.com·
Semantica 0.5.0 is out
Knowledge Graph Market to Surge from US$1.34 Billion in 2025 to US$19.16 Billion by 2033 as Enterprises Use GraphRAG to Ground AI, Reduce Hallucinations, and Scale Secure Copilots
Knowledge Graph Market to Surge from US$1.34 Billion in 2025 to US$19.16 Billion by 2033 as Enterprises Use GraphRAG to Ground AI, Reduce Hallucinations, and Scale Secure Copilots

The numbers are in, and they are striking. A new market analysis places the global knowledge graph sector at $1.34 billion in 2025, on a trajectory to $19.16 billion by 2033 — a compound annual growth rate of 30.8%. What is driving the surge? Enterprises are moving past the AI experimentation phase and into production deployments that require something vector search alone cannot provide: internal context, multi-hop reasoning, access-controlled querying, and the ability to explain how an answer was derived.

The shift is architectural. Organisations that spent the last two years evaluating generative AI pilots are now discovering that a model connected to a flat document store cannot answer the questions that actually matter — questions that cross customers, contracts, suppliers, transactions, and policies simultaneously. Knowledge graphs provide the semantic fabric that makes those cross-domain queries possible.

The US market, representing roughly 38–42% of global revenue, is itself expected to exceed $7 billion by 2033. The analysis notes a distinct shift in enterprise buying behaviour: procurement is no longer framed as “graph storage” but as “grounded enterprise AI with evidence, permissions, and multi-hop reasoning.” That repositioning matters. It signals that the semantic web community’s longstanding argument — that meaning precedes scale — has finally found its commercial moment.

For practitioners in ontology, SHACL, and RDF, the implication is straightforward: the infrastructure you have been building for a decade is now the thing enterprises are paying to acquire.

·openpr.com·
Knowledge Graph Market to Surge from US$1.34 Billion in 2025 to US$19.16 Billion by 2033 as Enterprises Use GraphRAG to Ground AI, Reduce Hallucinations, and Scale Secure Copilots
Most teams treat OWL and SHACL as design-phase paperwork. Ship the ontology, archive it, let the agent improvise at runtime. The teams shipping reliable agents do the opposite. The reasoner lives inside the loop.
Most teams treat OWL and SHACL as design-phase paperwork. Ship the ontology, archive it, let the agent improvise at runtime. The teams shipping reliable agents do the opposite. The reasoner lives inside the loop.
Most teams treat OWL and SHACL as design-phase paperwork. Ship the ontology, archive it, let the agent improvise at runtime. ⭕️ The teams shipping reliable agents do the opposite. The reasoner lives inside the loop. An agent proposes an action: cancel a reservation, modify a record, write a triple. Before execution, the harness calls an automated reasoner against the OWL ontology and a SHACL shape graph. Three possible answers. PROOF it respects policy. PROOF it violates a constraint. UNDEFINED. PROOF answers are derivations a domain expert can read line by line. This is what Amazon Neptune demonstrated at KGC 2026. KG-based validation as a steering hook for agentic guardrails. The outcome steers the next step: execute, generate an alternative, or escalate. The same shape graph governs design-time ontology review and runtime writes. The graph is the terrain, the LLM is the explorer. The explorer walks a network with structure. Every step is constrained by the edges that exist and the typed relationships permitted. That structure is what makes agent reasoning inspectable by a clinician, an auditor, a regulator. The equation that lands: OWL Inference × SHACL Validation × Mid-Loop Call = Pre-Mutation Proof LLMs got better at function calling. They did not get better at proving that a function call respects the domain model. AWS Automated Reasoning Checks, Amazon Neptune AgentCore guardrails, OWL DL reasoners, SHACL 1.2 rules. These compose with LLM generation to produce a verified output, not a hopeful one. The cost equation favors it. A reasoner call before every mutating action raises per-step cost. It lowers the voting budget for million-step reliability by an order of magnitude, because invalid candidates leave the pool before the vote. Five layers ship in production. T-Box is the agent's world model. A-Box is its knowledge base. Inference materializes what the agent implicitly knows. S-Box gates writes. Reports give the auditor the line-by-line trail. The 2024 substitution question is dead. "Will LLMs replace knowledge graphs" presupposed competition between layers that compose. The 2026 question is what structure the LLM needs before any team trusts it with a regulated decision. The answer sits in twenty years of W3C standards, finally reaching the runtime. Build the ontology. Wire the reasoner into the harness. Validate every mutating action against the shape graph. Ship what survives all three.
Most teams treat OWL and SHACL as design-phase paperwork. Ship the ontology, archive it, let the agent improvise at runtime. ⭕️The teams shipping reliable agents do the opposite. The reasoner lives inside the loop.
·linkedin.com·
Most teams treat OWL and SHACL as design-phase paperwork. Ship the ontology, archive it, let the agent improvise at runtime. The teams shipping reliable agents do the opposite. The reasoner lives inside the loop.
Building Agentic GraphRAG Systems
Building Agentic GraphRAG Systems

AGENTIC GRAPHRAG: WHY MCP NEEDS A KNOWLEDGE GRAPH TO DELIVER ON ITS PROMISE

A well-circulated analysis this week put a precise framing on a problem that practitioners have been circling for months: MCP without a smart retrieval layer is like opening all the valves to a data lake without a map. Connectivity is necessary but not sufficient. An agent that can reach everything retrieves nothing useful unless it knows what to retrieve, why it is relevant, and how different pieces of information relate.

Knowledge graphs address this directly. Where vector search returns a ranked list of similar chunks, a knowledge graph returns a traversable semantic structure — one in which the agent can follow relationships across multiple hops, distinguish between types of connections, and reason about the implications of what it finds. The article positions GraphRAG not as an enhancement to standard RAG but as a fundamentally different retrieval architecture suited to agents operating on evolving, interconnected enterprise data.

The temporal dimension is worth highlighting. Static knowledge graphs are snapshots. Agentic systems operating on real-world data need to know not just what is true, but what was true and when — especially in domains like healthcare, finance, and supply chain where decisions are time-sensitive and auditable. Frameworks like Graphiti are beginning to address this with explicit validity windows on facts, ensuring that when information changes, old facts are invalidated rather than overwritten.

For practitioners building on the RDF stack, the implication is clear: the provenance and temporal modelling that PROV-O and RDF-star enable are not academic features. They are the operational requirements of production agentic systems.

·decodingai.com·
Building Agentic GraphRAG Systems
Is a Knowledge Graph a Digital Twin of a Use Case ?
Is a Knowledge Graph a Digital Twin of a Use Case ?
Is a Knowledge Graph a Digital Twin of a Use Case  This is a powerful question and one worth unpacking carefully.  Short answer   No, but the analogy makes sense if you understand the limits. A knowledge graph is not a digital twin of a use case, but a well designed graph can serve as the **semantic backbone** of a digital twin. A use case can be expressed as a set of **competency questions** that the graph must answer.  What is a Digital Twin   A digital twin is a **dynamic real time mirror** of a physical system process or product.  Key traits  - Continuous synchronisation via real time data feeds   - Simulation and prediction capabilities for what if scenarios   - Bidirectional control where system changes can influence the physical environment   - Focused on a specific asset or process such as a factory an energy plant or an industrial robot  What is a Knowledge Graph   A knowledge graph is a **semantic interconnected model** of entities and relationships, typically built from static or slowly changing data.  Core characteristics  - Resolves identifiers and schemas across data silos   - Enables reasoning and causal inference   - Provides deterministic answers to competency questions   - Updated periodically rather than continuously  ## Digital Twin of a Use Case   A **use case** describes a scenario or requirement. A **digital twin of a use case** would be a dynamic executable model that mirrors that scenario and can simulate outcomes.  A knowledge graph could be the **core semantic layer** of such a twin, but the twin would also need   - Streaming data pipelines   - Predictive or probabilistic models   - Feedback loops and control components  When a Knowledge Graph is Like a Digital Twin   - **Static twin snapshot** When you freeze the data at a specific time the graph becomes a snapshot of domain state that you can interrogate for deterministic analysis   - **Deterministic simulation** Through property paths and reasoning you can test what if cases and causal impacts, though not in real time  When a Knowledge Graph is Not a Digital Twin   - Lacks inherent time dimension for dynamic updates   - Lacks continuous real time data feed   - Does not directly actuate or control systems   - Contains no built in predictive engine or simulation loop  The Better Framing   A knowledge graph should be seen as a **deterministic and queryable semantic model** that forms the **intelligent layer of a digital twin architecture**.  👉 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)  #KnowledgeGraphs #DigitalTwins #OntologyEngineering #SemanticAI #KnowledgeManagement #DataGovernance #ExplainableAI #AIEngineering #DataIntegration #CPS #SmartSystems #NeuroSymbolicAI #DigitalTransformation #GraphTechnology
·linkedin.com·
Is a Knowledge Graph a Digital Twin of a Use Case ?
Communicating Ontology Knowledge with an LLM in Graph RAG: The power of simplicity and standards
Communicating Ontology Knowledge with an LLM in Graph RAG: The power of simplicity and standards
One of the biggest challenges in Graph Retrieval Augmented Generation (RAG) systems is how to communicate knowledge from the ontology (e.g., subclasses, types, property values) to the LLM. The approach described in this post is very simple and easy to reuse but surprisingly effective.
·michaeldebellis.com·
Communicating Ontology Knowledge with an LLM in Graph RAG: The power of simplicity and standards
Tacit Knowledge Extraction via Logic Augmented Generation
Tacit Knowledge Extraction via Logic Augmented Generation
I think the market is waking up to the problem of tacit knowledge, or at least research is. I’m seeing more research papers mention it now, and that feels significant. So much of what we do remains in our brains, bodies, habits, teams, tools, and environments. Much of it never gets formally documented, and that is a huge problem for AI. But we have to be careful how we define tacit knowledge, even when it appears in the title of a research paper. This paper is not capturing the situated judgement of an expert operating inside a messy live environment. It is extracting and inferring implicit procedural knowledge around tasks: tools, artefacts, prerequisites, warnings, constraints, and missing steps. That is still useful. They are right that LLMs alone are a poor vehicle for this. Unconstrained generation will either miss what is implicit or invent structure that feels plausible. Their solution is sensible: constrain the model with an ontology, preserve provenance, separate explicit observations from inferred assumptions, and require justifications for inferred elements. That is exactly the kind of control layer needed if AI is going to touch knowledge transfer. They are also right that explicit documentation is often procedurally incomplete. A novice can follow the written steps and still fail because the real work depends on unstated conditions: pressure, sequence, tool choice, alignment, warning signs, material behaviour, and the feel of whether something is seated correctly. The paper has a useful handle on that problem. Where I think it is weaker is the concept of tacit knowledge itself. Much of what it calls tacit knowledge is more accurately recoverable implicit knowledge. “Use tweezers for a small bracket” is not the same category as a senior technician sensing that a part is about to shear, or knowing from vibration, resistance, smell, sound, or past failure patterns that the documented procedure should be paused. The system can infer typical missing conditions. It cannot reliably extract the lived judgement of expertise. Tacit knowledge is not simply undocumented information waiting to be formalised. Some of it only exists in practice, under conditions of participation, feedback, apprenticeship, repetition, and context. Once you convert it into a knowledge graph, you have captured a representation of the knowledge, not the knowledge itself. That distinction matters because AI programmes will increasingly be tempted to treat extraction as transfer. They are not the same thing. The useful move is not pretending tacit knowledge has been solved, but building systems that show what was observed, what was inferred, what needs verification, and where human expertise still carries the work. Tacit knowledge is not a database problem. But some of its shadows can be made visible. | 20 comments on LinkedIn
·linkedin.com·
Tacit Knowledge Extraction via Logic Augmented Generation
OptimusKG, a modern open-source multimodal biomedical knowledge graph that integrates molecular, anatomical, clinical, and environmental data
OptimusKG, a modern open-source multimodal biomedical knowledge graph that integrates molecular, anatomical, clinical, and environmental data
OptimusKG, a modern open-source multimodal biomedical knowledge graph that integrates molecular, anatomical, clinical, and environmental data
·linkedin.com·
OptimusKG, a modern open-source multimodal biomedical knowledge graph that integrates molecular, anatomical, clinical, and environmental data
RDF: What makes AI understand
RDF: What makes AI understand
The 𝐦𝐨𝐬𝐭 𝐟𝐮𝐧𝐝𝐚𝐦𝐞𝐧𝐭𝐚𝐥 𝐮𝐧𝐢𝐭 𝐨𝐟 "𝐮𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝𝐢𝐧𝐠" couldn't be simpler than how RDF defines it. One semantic relationship: how A relates to B. But how do we build this understanding at scale? All data infrastructures in the world have heavy investments backing them. Picture everything from ingestion pipelines and lakehouse architectures to governance frameworks and metadata management. Then an AI initiative lands and the first question is: "Does our data actually mean anything to a machine?" Usually, the answer is: not without a lot of manual wiring. RDF is part of how you solve this architecture problem. 𝐖𝐡𝐚𝐭 𝐢𝐬 𝐑𝐃𝐅 (per W3C) RDF is a W3C standard framework for representing information on the Web. Its data model is built entirely on triples: Subject → Predicate → Object "Order_4821" → "belongs_to" → "Customer_99" "Customer_99" → "operates_in" → "Region_APAC" Chain enough triples and you have a graph that a machine can traverse, reason over, and use as grounded context. 𝐓𝐡𝐞 𝐖3𝐂 𝐬𝐭𝐚𝐜𝐤 𝐨𝐧 𝐭𝐨𝐩 𝐨𝐟 𝐑𝐃𝐅 𝐢𝐧𝐜𝐥𝐮𝐝𝐞𝐬: → SPARQL: the standard query language for RDF graphs, built for relationship traversal the relational model wasn't designed for → OWL: a computational logic-based language that lets machines not just store knowledge, but actively reason and infer from it → SHACL: the W3C standard for describing and validating the shape of RDF data, enforcing structural contracts on your graphs → RDFS: a vocabulary, in RDF, that explains how nodes of a graph relate. LLMs are powerful but context-blind outside their training data. 𝐈𝐧𝐜𝐫𝐞𝐚𝐬𝐢𝐧𝐠 𝐢𝐧𝐭𝐞𝐫𝐞𝐬𝐭 𝐢𝐧 𝐀𝐩𝐚𝐜𝐡𝐞 𝐉𝐞𝐧𝐚, 𝐒𝐇𝐀𝐂𝐋, 𝐚𝐧𝐝 𝐅𝐈𝐁𝐎 over the past few months signals that enterprises are building this semantic backbone now. 𝐓𝐡𝐞 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐚𝐥 𝐬𝐡𝐢𝐟𝐭 Data platforms that serve AI well are semantically aware. That means 𝐝𝐞𝐬𝐢𝐠𝐧𝐢𝐧𝐠 𝐝𝐞𝐥𝐢𝐛𝐞𝐫𝐚𝐭𝐞𝐥𝐲 𝐟𝐨𝐫: → Ontology management alongside data modelling → Knowledge graph layers above your lakehouse → Metadata that carries lineage alongside meaning Building successful AI pods at scale requires focusing on the feed that goes into AI. Are you factoring these semantic necessities into platform design? #DataArchitecture #KnowledgeGraph #SemanticWeb | 21 comments on LinkedIn
·linkedin.com·
RDF: What makes AI understand
Can we trust ontologies generated by LLMs?
Can we trust ontologies generated by LLMs?
🚨 Can we trust ontologies generated by LLMs? Large Language Models are becoming powerful assistants for Knowledge Graph and Ontology Engineering. But when they generate ontologies, they can also introduce subtle — and sometimes critical — modeling mistakes. At the LLM-driven Knowledge Graph and Ontology Engineering Workshop (LLM4KGOE), co-located with ESWC - European Semantic Web Conference , I have just presented: “Pitfalls in AI-Generated Ontologies: Strategies for Detection and Mitigation” where I discuss how to move from enthusiasm to reliability when using LLMs for ontology engineering, with two concrete outcomes: ✅ Ontology Pitfalls Detector A new open-source tool that detects mistakes in LLM-generated ontologies. GitHub: https://lnkd.in/e3zeSdjb ✅ Ontology Toolkit by Lettria A platform for automatically building ontologies from documents — while avoiding common ontology design mistakes. Try it: https://lnkd.in/eWnDfFES LLMs can accelerate ontology engineering, but quality assurance must be built into the workflow from the start. Slides are available at https://lnkd.in/edTnwrJK Looking forward to further discussing pitfalls, validation strategies, and trustworthy ontology generation with the ESWC community! Joint work with Pasquale Lisena, Julien PLU, Oscar Moreno Escobar and Edouard Trouillez in the context of #LettRAGraph / EURECOM and Lettria #ESWC2026 #LLMs #KnowledgeGraphs #OntologyEngineering #SemanticWeb #AI #GenerativeAI #ResponsibleAI #KnowledgeRepresentation
·linkedin.com·
Can we trust ontologies generated by LLMs?