Four things go by “semantic”. They do not mean the same thing.
A KPI semantic layer, semantic search, a property graph and an ontology are constantly confused — because one word is doing four different jobs. This page takes them apart, requirement by requirement.
One question per world.
The fastest test of which world you are in: which question does the technology actually answer?
- Semantic Layer
OSIdbtCube
Compute
Do all tools calculate the same metric identically?A library of metric definitions on top of existing tables. Standardised as YAML.
- Semantic Search (RAG)
Vector DBEmbeddings
Retrieve
Which documents sound most similar to my question?Text chunks ranked by statistical similarity. Excellent for finding passages — it retrieves, it does not know.
- Labeled Property Graph
Neo4jGQL
Connect
How is everything connected, so that I can traverse paths?Data as nodes and edges with properties. Optimised for traversing relationships at speed.
- RDF Knowledge Graph
RDFSHACLOWL
Understand
What do things mean — and which rules hold when machines act on them?A formal model of your business terms (the ontology), populated with your real entities (the graph). Meaning, rules and data in one place.
One distinction before we compare: the ontology is the schema — the formal definition of what a “customer” or a “vehicle” is. The knowledge graph is that schema plus your real instances. And yes: you can build a knowledge graph on a property graph, too. What you then add by hand is exactly what RDF ships as standard — formal meaning, global identity, enforced rules. That difference is what the rest of this page measures.
Five requirements to consider.
Forget the feature lists. An enterprise that wants machines to act on its knowledge has five requirements — each one is a plain question. Here is how each approach answers it.
Is the same thing the same thing in every system?
One customer, one vehicle, one contract — regardless of which system stores it.
Semantic Layer
Semantic Search (RAG)
Property Graph
RDF Knowledge Graph
When people say “customer”, do they all mean the same thing?
Shared, formal definitions of business terms — not per-team folklore.
Semantic Layer
Semantic Search (RAG)
Property Graph
RDF Knowledge Graph
Is a rule enforced — or just written down?
The difference between a policy document and a locked door. For autonomous agents, this is the requirement that makes autonomy defensible.
This is the starkest difference. See the live proof below.Semantic Layer
Semantic Search (RAG)
Property Graph
RDF Knowledge Graph
When two sources meet, does knowledge grow together — or does silo no. 5 appear?
Integration as a defined mechanism, not a per-project negotiation.
Semantic Layer
Semantic Search (RAG)
Property Graph
RDF Knowledge Graph
Who changed what, when — and which definition was in force yesterday?
Knowledge changes. Decisions made under an old definition must stay explainable.
Semantic Layer
Semantic Search (RAG)
Property Graph
RDF Knowledge Graph
Inference you can touch.
A restaurant scene. Nobody ever types “pesto is a risk for Anna”. Step 1: the machine derives it. Step 2: a rule — not a prompt — blocks the order. That second step is the line no YAML, no prompt and no vector index crosses.
Knowledge graph reasoner
Step 1: run the inference. Step 2: try to place the order.
Entered facts (typed by a human)
- :Anna a :Guest
- :Anna :hasAllergy :Nut
- :Pesto :contains :Walnut
- :Walnut :isKindOf :Nut
- :Table7 :serves :Pesto
- :Anna :sitsAt :Table7
Derived facts (by the machine — never typed in)
- Nothing has been inferred yet …
The capability matrix.
No concept is “better” — they solve different problems. Whoever conceals that loses the sceptics.
| Requirement | LLM alone | YAML / Data Catalog | Semantic Layer (dbt / OSI-style) | Labeled Property Graph (Neo4j & Co.) | Open Semantic Standard (RDF + SHACL) |
|---|---|---|---|---|---|
| AIdentitySame thing = same name, across systems | No stable symbol-to-entity binding | References by string convention | IDs per platform, not across systems | Database-local node IDs | Global identifiers — “DNS for business concepts” |
| BVocabularyEntities & relationships, formally defined | Inferred per prompt — plausible, not defined | Described in text — meaning lives in each consumer's code | Metrics & joins only, no full model | Rich typed nodes — meaning lives in app code | Formal, standardized, portable classes & relations |
| CRulesDescribed vs. enforced | Not reference-stable: new phrasing, new interpretation | Prose or per-tool tests — each engine interprets differently | Computes metrics — doesn't enforce meaning | Code-based, outside the model | Enforced constraints (SHACL): validated, not interpreted |
| DCompositionIndependent domain models, defined merge | Re-derived on every call, never shared | Merge = key collision, not meaning | Breaks across domains | Merge result undefined | Merge mechanism defined — alignment stays modeling work |
| EChangeVersioned, attributable meaning (audit trail) | No audit trail — answers can't be tied to a definition version | Git per repo — no cross-consumer view | Versioned code, meaning still text | Schema not standard-portable | Versioned, exportable, auditable |
| Best fit for … | … drafting and exploring — not decisions that bind | … describing single, isolated assets | … governed metrics and KPIs | … graph analytics and a fast start | … autonomous agents that must be trusted |
“BUT you can also do that with …”
Every objection you hear after the surface-level explanation — with the precise answer.
BUT“OSI has relationships and joins in the YAML too — that is basically a graph.”
Joins in OSI describe how two tables are combined for a calculation — the computation path for a metric. That is a SQL optimisation, not a model of the world.
A “relationship” in the YAML has no identity, no logic, no class that anything could reason over. It is an instruction to the query engine, not knowledge.
Test: can the system derive a new fact that was never entered from the relationship? No → it is a join, not an ontology.
BUT“In Neo4j I can model meaning just as well — labels are concepts.”
A label like :Allergen is, to the database, just a search string. It does not know that a walnut is an allergen unless you draw every edge yourself.
No class hierarchy kicks in automatically, no disjointness, no inverse property. You would have to rebuild the logic as application code — a hand-written substitute ontology.
To be fair: you can build a knowledge graph on an LPG. The question is whether meaning, identity and rules are standard — or your team's hand-maintained code.
LPG = topology + strings. Ontology = topology + formal semantics that can be reasoned over.
BUT“We'll put our business logic into dbt / SQL — then we don't need a KG.”
That works — as long as the logic is procedural and known up front. SQL executes what you specify. It discovers nothing you haven't already poured into a query.
Chained rules (“A implies B, B implies C …”) turn into SQL cascades that only their author can maintain. Declared as rules, they are formulated once, checked everywhere, and changed with a version — modelling remains work, but it happens in one place.
Rule of thumb: three or more chained if-then rules across heterogeneous data — that is where declared rules beat hand-written queries.
BUT“A vector store / RAG with an LLM understands meaning — why ontologies?”
An LLM estimates statistical similarity. Excellent at sounding plausible, unreliable at being guaranteed correct. It cannot prove that a conclusion necessarily follows.
A knowledge graph delivers verifiable statements with provenance — it is as right as its curation, and it shows its sources. The LLM delivers language. Together they work; alone, the LLM sounds right without being checkable.
“Close in vector space” is a ranking — not a statement anyone can verify.
BUT“OSI does call itself Semantic Interchange — that is the new layer of meaning.”
The name is the source of the confusion. OSI standardises the definition of metrics, so that “revenue” is calculated identically everywhere. Enormously valuable — but a metrics interchange format.
It contains no class logic, no reasoning, no open-world semantics, no global identity. It makes numbers consistent, not knowledge derivable.
OSI standardises how things are calculated. RDF/OWL, what something is and what follows from it. Different problems.
BUT“Then we'll take all of them — isn't a KG slow and overcomplex on top of it?”
Fair, and answered honestly: yes, the knowledge graph has the highest barrier to entry on the modelling side, and it is not the fastest place for bulk aggregation. Both true.
But the conclusion “so buy all three next to each other” rebuilds the silo problem one level up: metric definitions in one tool, paths in a second, meaning in a third — three systems, three lifecycles, and nobody guarantees that the metric in tool one uses the same definition of “customer” as the rule in tool three.
The KPI layer, the traversal view and the agent context are three projections of the same knowledge. The architecture that holds is one versioned model from which these projections are generated — not three purchases.
BUT“Nobody in our team writes SPARQL — this is not operable for us.”
Correct, and it should stay that way. Nobody in your team should write SPARQL, just as nobody writes the bytecode of your BI tool. Consumers get generated APIs and prepared context for agents; the query language is an implementation detail below them.
The barrier to entry is real — for the modellers. It is not an argument against the layer, but for one place where that work happens once.
When do you use which?
Four legitimate questions — and one warning: these are projections of one knowledge base, not four shopping-list items.
- 01
Semantic Layer
- A metric must be the same everywhere
- BI dashboards & reporting
- AI agent needs to calculate correctly
- Stable, known data structure
- 02
Semantic Search (RAG)
- Finding passages in large document sets
- “Where does it say …?”
- Drafting and exploring with an LLM
- Answers that may be checked by a human
- 03
Property Graph
- Fraud rings, recommendations, networks
- “How do I get from A to B?”
- Fast traversal across many hops
- Graph algorithms (centrality …)
- 04
RDF Knowledge Graph
- Merging heterogeneous sources
- Rules that derive new knowledge
- Shared meaning across departments
- A factual anchor against LLM hallucination
