Neo4j's Graph Technology Narrative vs Virtuoso's

Eight agreements, three disagreements, and four capabilities the property-graph stack does not have — computed from the graph, not asserted.

12dimensions compared
5convergent
3divergent
4unaddressed
KG curated by kg-generator, rdf-infographic-skill, and Claude Opus 5 on behalf of Kingsley Idehen
Executive SummaryBy Kingsley Uyi Idehen

Synopsis

Neo4j's 2026 article What is graph technology? argues that graph technology is the knowledge layer enterprise AI has been missing, supplying agents with memory, context, and reasoning. It is a well-made case — and across eight of twelve dimensions examined here, it converges with the position OpenLink Virtuoso has held for two decades.

The divergence is narrower than the marketing on either side suggests, and it concentrates in one place: where the knowledge layer lives. Neo4j sells a tier you populate above your stack; the RDF position is that a layer you must copy data into is a cache with ambitions. What separates the two most sharply, though, is not a stated disagreement but a silence. The article contains no mention of RDF, SPARQL, ontologies, IRIs, or any W3C standard — so entity identity, entailment, cross-graph federation, and standards go unaddressed entirely.

This dataset makes that claim testable rather than rhetorical. Every position is a named resource, every customer outcome is typed, and the four silences are returned by a FILTER NOT EXISTS anti-join you can run yourself against the live named graph.

View this analysis as a KG entity
THE FINDING

What the Argument Never Mentions

Across 12 dimensions, Neo4j Graph Intelligence Platform states a position on every one but 4. These are not editorial oversights: in each case the capability is absent from the property-graph stack, and the argument's silence tracks that absence. Each omission below is returned by a FILTER NOT EXISTS anti-join against the live graph — computed, not asserted — and states the specific gap.

01

Cross-graph federation

The article addresses connecting your own systems into one graph, but never querying across two independently authored graphs.

The gap

Neo4j Fabric composes queries across Neo4j databases the same operator runs. There is no mechanism for querying across independently governed graphs belonging to different parties, which is what SPARQL SERVICE provides by specification.

OpenLink Virtuoso answerssparql-federation

SPARQL SERVICE federates live across independently governed endpoints without copying data into a shared instance.

02

Entailment and inference

Inference is never distinguished from traversal anywhere in the article; 'reasoning' means hops.

The gap

Neo4j ships no reasoner. Cypher can traverse asserted relationships but cannot derive unasserted ones from schema semantics; any inference must be hand-written and materialised as additional data, then re-maintained as the graph changes.

OpenLink Virtuoso answersrdfs-owl-entailment

RDFS/OWL semantics let a reasoner derive statements that were never asserted, which traversal alone cannot produce.

Counter-evidenceApplying Semantic Reasoning to Neo4j using VirtuosoMost Prolific Directors Dashboard
03

Entity identity

The article's Customer 360 and master data management use cases are entity-resolution problems, but identity is described only as stitching fragments inside one instance. No cross-organisation identifier scheme is named.

The gap

Neo4j node identifiers are local to the database instance. There is no dereferenceable global identifier and no sameAs semantics, so an entity resolved in one instance cannot be recognised as the same entity in another organisation's graph without bespoke key-matching agreed out of band.

OpenLink Virtuoso answersdereferenceable-iri

Entities are named by dereferenceable IRIs and reconciled across organisations with owl:sameAs, so identity survives outside any single store.

04

Standards and portability

No W3C standard, specification, or interchange format is mentioned. 'Knowledge graph' is defined as a modelling style rather than a data model with an interoperability contract.

The gap

The property-graph data model is vendor-defined. GQL (ISO/IEC 39075:2024) standardises the query language, and it is a genuine standard, but it does not define a vendor-neutral data model with global identifiers or ontology semantics. RDF, OWL, SHACL and SPARQL are W3C Recommendations covering exactly that layer, so a property graph remains portable only as far as an agreed export mapping carries it.

OpenLink Virtuoso answersw3c-specified

RDF, SPARQL, OWL, and SHACL are W3C Recommendations, so the knowledge layer is specified independently of any vendor's engine.

HEAD TO HEAD

Comparison Matrix

5 convergent3 divergent4 unaddressed
Dimension Neo4j Graph Intelligence PlatformLabelled Property Graph Database OpenLink VirtuosoMulti-Model RDF Quad Store and RDBMS
Agent memoryconvergent context-graphThree memory forms — short-term, long-term, and reasoning memory — together forming a 'context graph': 'the record of everything the agent has seen, decided, and learned.' engine-independent-rdfThe same three tiers — sessions/ episodic, entities/ semantic, preferences.ttl behavioural — held as RDF-Turtle documents that are independent of any one engine. The identical files serve either as filesystem-hosted graphs or, once the corpus outgrows what a filesystem scan can serve, loaded into a local or designated Virtuoso instance. Retrieval is SPARQL-first against that endpoint with filesystem reads as the fallback path, so scaling is a deployment choice rather than a migration.
Cross-graph federationunaddressedThe article addresses connecting your own systems into one graph, but never querying across two independently authored graphs. Not addressed sparql-federationSPARQL SERVICE federates live across independently governed endpoints without copying data into a shared instance.
Data modeldivergent
EvidenceApplying Semantic Reasoning to Neo4j using VirtuosoMost Prolific Directors — Neo4j Movie DatabaseVirtuoso Multi-Model Data Management Breakdown
 property-graphLabelled nodes and relationships with key-value properties, queried in Cypher. Presented as the only graph model; no alternative graph model is named. rdf-quad-storeRDF triples in named graphs, queried in SPARQL, alongside SQL and GraphQL over one engine.
Entailment and inferenceunaddressedInference is never distinguished from traversal anywhere in the article; 'reasoning' means hops.
Counter-evidenceApplying Semantic Reasoning to Neo4j using VirtuosoMost Prolific Directors Dashboard
 Not addressed rdfs-owl-entailmentRDFS/OWL semantics let a reasoner derive statements that were never asserted, which traversal alone cannot produce.
Entity identityunaddressedThe article's Customer 360 and master data management use cases are entity-resolution problems, but identity is described only as stitching fragments inside one instance. No cross-organisation identifier scheme is named. Not addressed dereferenceable-iriEntities are named by dereferenceable IRIs and reconciled across organisations with owl:sameAs, so identity survives outside any single store.
Explainabilityconvergent answer-is-a-path'Every answer is a path through the graph, so anyone can walk back through the exact facts and relationships that produced it.' answer-is-a-pathSame path-based account, with the path's predicates drawn from a published ontology so a third party can interpret it without vendor documentation.
Governance and auditconvergent reasoning-memory-as-audit'The reasoning memory the agent already keeps doubles as an audit trail.' prov-o-and-webaclPROV-O provenance plus WebID/WebACL, so the audit trail is a portable standard artifact and access is decided by verified reader identity.
Knowledge layer placementdivergent
EvidenceCustomer Sales Performance Dashboard — SPASQLInfographic: Generating Knowledge Graphs from DatabasesKnowledge Graph — Entity Type & Sample Entities Query ResultsNorthwind Sales Performance Dashboard — Interactive RDF Data AnalyticsVirtuoso Multi-Model Data Management Breakdown
 layer-above-stackA knowledge layer added above existing systems: 'Whatever you already run keeps doing its job.' Populated by sync, or queried in place via Virtual Graph. layer-is-the-stackRDF Views and R2RML expose live relational data as RDF in place; SPASQL mixes SQL and SPARQL in a single statement, so no separate tier is populated.
Operational scaleconvergent hundred-tbA purpose-built engine 'runs operational and analytical workloads together at 100TB+ scale.' quad-store-scaleSingle-engine quad store serving comparable operational and analytical workloads.
Reasoningdivergent multi-hop-traversalReasoning is multi-hop traversal: 'Relational joins degrade past three or four hops. Native graph traversal doesn't.' traversal-plus-entailmentTraversal plus entailment — RDFS/OWL inference and SPIN rules derive statements never explicitly stored.
Retrieval strategyconvergent graphragGraphRAG extends vector search by 'following the relationships around those snippets and handing the model connected facts.' sparql-routed-contextPrompt-intent classification selects a relevance budget over a SPARQL endpoint rather than dumping the graph.
Standards and portabilityunaddressedNo W3C standard, specification, or interchange format is mentioned. 'Knowledge graph' is defined as a modelling style rather than a data model with an interoperability contract. Not addressed w3c-specifiedRDF, SPARQL, OWL, and SHACL are W3C Recommendations, so the knowledge layer is specified independently of any vendor's engine.
Neo4j Graph Intelligence PlatformLabelled Property Graph Database
Agent memoryconvergent
context-graphThree memory forms — short-term, long-term, and reasoning memory — together forming a 'context graph': 'the record of everything the agent has seen, decided, and learned.'
Cross-graph federationunaddressed
Not addressed
Data modeldivergent
EvidenceApplying Semantic Reasoning to Neo4j using VirtuosoMost Prolific Directors — Neo4j Movie DatabaseVirtuoso Multi-Model Data Management Breakdown
property-graphLabelled nodes and relationships with key-value properties, queried in Cypher. Presented as the only graph model; no alternative graph model is named.
Entailment and inferenceunaddressed
Counter-evidenceApplying Semantic Reasoning to Neo4j using VirtuosoMost Prolific Directors Dashboard
Not addressed
Entity identityunaddressed
Not addressed
Explainabilityconvergent
answer-is-a-path'Every answer is a path through the graph, so anyone can walk back through the exact facts and relationships that produced it.'
Governance and auditconvergent
reasoning-memory-as-audit'The reasoning memory the agent already keeps doubles as an audit trail.'
Knowledge layer placementdivergent
EvidenceCustomer Sales Performance Dashboard — SPASQLInfographic: Generating Knowledge Graphs from DatabasesKnowledge Graph — Entity Type & Sample Entities Query ResultsNorthwind Sales Performance Dashboard — Interactive RDF Data AnalyticsVirtuoso Multi-Model Data Management Breakdown
layer-above-stackA knowledge layer added above existing systems: 'Whatever you already run keeps doing its job.' Populated by sync, or queried in place via Virtual Graph.
Operational scaleconvergent
hundred-tbA purpose-built engine 'runs operational and analytical workloads together at 100TB+ scale.'
Reasoningdivergent
multi-hop-traversalReasoning is multi-hop traversal: 'Relational joins degrade past three or four hops. Native graph traversal doesn't.'
Retrieval strategyconvergent
graphragGraphRAG extends vector search by 'following the relationships around those snippets and handing the model connected facts.'
Standards and portabilityunaddressed
Not addressed
OpenLink VirtuosoMulti-Model RDF Quad Store and RDBMS
Agent memoryconvergent
engine-independent-rdfThe same three tiers — sessions/ episodic, entities/ semantic, preferences.ttl behavioural — held as RDF-Turtle documents that are independent of any one engine. The identical files serve either as filesystem-hosted graphs or, once the corpus outgrows what a filesystem scan can serve, loaded into a local or designated Virtuoso instance. Retrieval is SPARQL-first against that endpoint with filesystem reads as the fallback path, so scaling is a deployment choice rather than a migration.
Cross-graph federation
sparql-federationSPARQL SERVICE federates live across independently governed endpoints without copying data into a shared instance.
Data modeldivergent
rdf-quad-storeRDF triples in named graphs, queried in SPARQL, alongside SQL and GraphQL over one engine.
Entailment and inference
rdfs-owl-entailmentRDFS/OWL semantics let a reasoner derive statements that were never asserted, which traversal alone cannot produce.
Entity identity
dereferenceable-iriEntities are named by dereferenceable IRIs and reconciled across organisations with owl:sameAs, so identity survives outside any single store.
Explainabilityconvergent
answer-is-a-pathSame path-based account, with the path's predicates drawn from a published ontology so a third party can interpret it without vendor documentation.
Governance and auditconvergent
prov-o-and-webaclPROV-O provenance plus WebID/WebACL, so the audit trail is a portable standard artifact and access is decided by verified reader identity.
Knowledge layer placementdivergent
layer-is-the-stackRDF Views and R2RML expose live relational data as RDF in place; SPASQL mixes SQL and SPARQL in a single statement, so no separate tier is populated.
Operational scaleconvergent
quad-store-scaleSingle-engine quad store serving comparable operational and analytical workloads.
Reasoningdivergent
traversal-plus-entailmentTraversal plus entailment — RDFS/OWL inference and SPIN rules derive statements never explicitly stored.
Retrieval strategyconvergent
sparql-routed-contextPrompt-intent classification selects a relevance budget over a SPARQL endpoint rather than dumping the graph.
Standards and portability
w3c-specifiedRDF, SPARQL, OWL, and SHACL are W3C Recommendations, so the knowledge layer is specified independently of any vendor's engine.
How-To

How-To Guide

1

Read the source in full and inventory what is actually extractable

Fetch the article and extract its complete text rather than relying on a summary. Separate what is quantitatively typed (customer outcomes, headline metrics) from what is prose. Record cardinalities honestly: ten customers, eight with a figure, three with a before/after pair, one worked traversal path with three of four nodes unnamed.

2

Check the corpus for an existing comparison vocabulary before minting anything

Grep the entity registries for the subjects and for any comparison class already in use. Here that surfaced cdx:ComparisonDimension as a canonical corpus IRI with two re-mints already aligned, plus two prior Neo4j comparison documents. Reuse the canonical class via a bound prefix; do not re-mint a document-local equivalent.

3

Model positions as named resources, never as side-specific predicates

Give every position its own IRI carrying :ofDimension, :ofSubject, a short controlled :stance token, and a prose schema:description. This is what makes a generic both-sides query possible, allows a third subject to be added later, and lets stance values group cleanly under aggregation.

4

Leave a genuine silence unasserted

Where the source addresses a dimension, assert a position. Where it does not, assert nothing and record why in the dimension's own schema:description. Resist the temptation to encode absence as a value — an unasserted position is what allows FILTER NOT EXISTS to compute the omissions instead of restating them.

5

Materialise enough instance data for traversal queries to discriminate

One path answers every query identically. Keep the source's own example verbatim, then synthesise siblings and branches until results differ meaningfully across orders. Balance the disruption so a useful fraction is affected — 15 of 25 orders here, after an initial pass produced 21 and was rebalanced.

6

Type every quantitative claim, and let missing baselines stay missing

Decompose each cited outcome into metric name, unit, and typed before/after values. Where the source gives no baseline, leave :beforeValue unasserted rather than imputing one. The absences are findings in their own right, and they give OPTIONAL and NOT EXISTS real work to do.

7

Characterise every minted property before loading anything

Give each new term rdfs:domain, rdfs:range, and the applicable OWL characteristics — functional, asymmetric, irreflexive, inverse-functional. A small vocabulary is not exempt from this; a two-term ontology with no domain or range is an under-specified one, not a lightweight one.

8

Validate the Turtle locally, then upload and confirm the graph materialised

Parse with rdflib to catch syntax errors and confirm the triple count. PUT to the DAV endpoint over mTLS on port 5443, then immediately count triples in the resulting named graph — a successful upload is not proof the quad store loaded what you intended.

9

Run every query against the live endpoint before publishing a link

Re-reading the Turtle cannot catch relative-IRI resolution failures, engine-specific syntax limits, or datatype arithmetic bugs. Execute each query and check both status code and row count. This pass caught integer division silently reporting a 4.33x improvement factor as 4, fixed by retyping the literals as xsd:decimal.

FAQ

Frequently Asked Questions

Does the Neo4j article mention RDF, SPARQL, or the semantic web at all?▼

No. A full-text reading of the 2026-08-19 article finds zero occurrences of RDF, SPARQL, ontology, IRI, semantic web, W3C, or standard. 'Knowledge graph' is defined as a modelling style — 'model the whole domain this way' — rather than as a data model with an interoperability contract. The one crack is the Merck citation, which praises the Synaptix ecosystem for connecting 20 billion triples of R&D data: a triples-native workload held up as a flagship result in an article that never names the technology that produces triples.

Where do the two narratives actually agree?▼

On more than either side's marketing admits. Eight of the twelve dimensions in this dataset are marked convergent: relationships are data rather than schema accidents; vector-only retrieval returns text that merely sounds like the question; explainability is a path through the graph; agent memory needs a graph rather than a transcript buffer; and reasoning memory doubles as an audit trail. Neo4j has arrived at the semantic-web thesis by a different road, and is currently selling it better.

What is the single sharpest difference?▼

Where the knowledge layer lives. Neo4j's answer is a new tier added above your existing systems, populated by sync or queried in place via Virtual Graph. Virtuoso's answer is that the stack is already multi-model: RDF Views and R2RML expose live relational data as RDF where it sits, and SPASQL mixes SQL and SPARQL in a single statement, so no separate tier is ever populated. A knowledge layer you must copy data into is a cache with ambitions.

What does the article mean by 'reasoning', and how does that differ from RDF reasoning?▼

In the article, reasoning means multi-hop traversal: 'Relational joins degrade past three or four hops. Native graph traversal doesn't.' That is a real and correctly described capability. RDF reasoning includes traversal but adds entailment — RDFS and OWL semantics, plus SPIN rules, let a reasoner derive statements that were never explicitly asserted. The article never distinguishes inference from traversal, which is why the entailment dimension has no Neo4j position in this dataset.

Why is entity identity treated as a silence rather than a disagreement?▼

Because the article raises the problem and then solves it only locally. Its Customer 360 and master data management use cases are entity-resolution problems — 'a graph stitches the fragments into one connected view' — but identity is described purely as stitching inside one instance, and no cross-organisation identifier scheme is named. That works until the second Neo4j instance, or the partner's, or the regulator's. Dereferenceable IRIs plus owl:sameAs were designed for exactly that boundary.

Is the RDF-star point a fair criticism of property graphs?▼

No, and this dataset deliberately does not make it. Qualifying a statement — attaching provenance or a date to an individual assertion — is something LPG handles natively with relationship properties, which is precisely how the article puts 'the lost week on the supply link itself'. RDF-star and n-ary reification reach the same end. Treating it as an RDF advantage would be a strawman, so the supply-chain data here models the qualified edge as a named SupplyLink resource and the comparison stays honest.

How good is the article's evidence, measured rather than asserted?▼

Mixed, and the dataset lets you check. Ten named customers are cited across ten use cases, but only two — Adobe and Arhasi — carry a clean before/after pair permitting a computed improvement factor (16x and 4.33x respectively). Eight of the ten are cited with no baseline figure at all; two of those, Intuit and Tripadvisor, carry no quantitative figure whatsoever. That is normal for vendor marketing, but it is the kind of claim texture that only becomes visible once the outcomes are typed.

Why are the sample orders synthesised rather than taken from the article?▼

Because the article supplies exactly one path — Order A-1042 through a product, a part, and a supplier — and three of those four nodes are unnamed. A single path answers every traversal query identically, so it cannot discriminate between a good query and a bad one. This dataset keeps A-1042 and its one-week materials shortage verbatim, then materialises 25 orders over 8 products, 12 parts, and 6 suppliers, with disruption on only some links, so 15 orders ship late and 10 do not.

Can the Cypher query in the article be run against this dataset?▼

No, and it is stored as illustrative reference rather than as an executable artifact. The article's MATCH statement is preserved verbatim as a SoftwareSourceCode entity with programmingLanguage 'Cypher' so the two query languages can be set side by side, but only the SPARQL counterparts are executable. Each SPARQL query here has been run against the live named graph and returns a verified non-zero row count.

What does the 'silences' query actually prove?▼

That an argument's omissions can be computed rather than asserted. Because every position is a named resource keyed to a subject and a dimension, a FILTER NOT EXISTS anti-join returns every dimension where one subject has a stated position and the other has none. Run against this graph it returns exactly four rows: cross-graph federation, entailment and inference, entity identity, and standards and portability. In each of those four the capability is genuinely absent from the property-graph stack, and the article's silence tracks that absence — Neo4j ships no reasoner, node identifiers are instance-local with no sameAs semantics, Fabric composes only across databases one operator runs, and GQL standardises a query language rather than a vendor-neutral data model. The silence is evidence, not an editorial oversight.

Why were the comparison positions modelled as named resources instead of side-specific predicates?▼

Because the older corpus pattern — :hasNeo4jApproach and :hasAgentRdfMemoryApproach carrying long prose literals — cannot support generic comparative SPARQL. You cannot write a query returning both sides of every dimension without hardcoding the two predicate names, you cannot add a third subject without reshaping the graph, and prose paragraphs are not aggregatable. Named Position resources carrying :ofDimension, :ofSubject, and a short controlled :stance token fix all three at once.

Where does the RDF position have to concede ground?▼

On onboarding and packaging. The article puts a working Cypher traversal on the page and promises a free instance with a first query the same afternoon; RDF's equivalent ask begins with 'choose your ontology'. Neo4j also named GraphRAG, the context graph, and the knowledge layer — three ideas the RDF world had first and named memorably never. RDF's advantages are paid for upfront in modelling discipline, and that cost is real.

Glossary

Glossary of Terms

Resource Description Framework (RDF)

A W3C standard data model representing information as subject-predicate-object triples, where subjects and predicates are named by IRIs. The data model the Neo4j article never mentions.

SPARQL

The W3C query language and protocol for RDF. Supports property paths, aggregation, federation via SERVICE, and negation via FILTER NOT EXISTS — the last of which produces the silences query in this dataset.

Graph database

A database that stores relationships as first-class data and answers questions by traversing them rather than by computing joins. The article's central subject, presented there exclusively in its labelled-property-graph form.

Knowledge graph

A graph-structured representation of entities and their relationships, organised by a schema or ontology. The article defines it as a modelling style rather than as a data model with an interoperability contract.

Web Ontology Language (OWL)

A W3C ontology language whose formal semantics let a reasoner derive statements never explicitly asserted. Supplies the property characteristics — functional, asymmetric, irreflexive — that every minted term in this dataset carries.

Cypher

Neo4j's declarative graph query language, using ASCII-art patterns to express traversals. The article's single worked query is one line of Cypher, preserved verbatim here as illustrative reference.

Named graph

An IRI-identified set of RDF triples within a quad store, allowing provenance and scope to be attached to a group of statements. Every query in this dataset is scoped with FROM to one named graph.

Linked data

The practice of publishing structured data with dereferenceable IRIs so that following a link returns further machine-readable description. The mechanism by which entity identity survives outside a single database instance.

Ontology

A formal specification of the types, properties, and relationships in a domain. Distinguishes an RDF knowledge graph, whose predicates come from a published vocabulary, from a property graph whose labels are local convention.

Triplestore

A database purpose-built to store and query RDF triples. Virtuoso extends the pattern to a quad store, adding the named-graph dimension used to scope every query here.

Reification

Treating a statement as an object that further statements can describe, enabling provenance or confidence on an individual assertion. Realised in this dataset as the named SupplyLink resource carrying the article's lost week.

Retrieval-augmented generation (RAG)

Grounding a language model's output in retrieved documents. The article's critique is that vector-only RAG 'returns snippets that sound like the question' without the relationships around them.

Semantic reasoner

Software deriving logical consequences from asserted facts and ontology axioms. The capability separating entailment from traversal — a distinction the article never draws.

Entity linking

Resolving mentions to canonical identifiers. The unnamed problem underneath the article's Customer 360 and master data management use cases, solved there per-instance rather than across organisations.

Context graph

A knowledge graph capturing decision reasoning and operational context — answering why something was allowed to happen, not merely what happened. The article's own term for the union of short-term, long-term, and reasoning memory.

GraphRAG

Retrieval that begins with vector search and then follows the relationships around the retrieved snippets, handing the model connected facts instead of isolated passages. Named and popularised by Neo4j.

Knowledge layer

A tier sitting between systems of record and the AI agents consuming them, supplying memory, context, and reasoning. The article's central architectural proposition, and the dimension on which the two narratives most sharply diverge.

Labelled property graph (LPG)

A graph model of labelled nodes and relationships carrying key-value properties, with identifiers local to the database. The model underlying Cypher and the only graph model the article describes.

Knowledge Graph Explorer 302 nodes · 726 links

Interactive graph visualization derived from the companion RDF. Click nodes to resolve, drag to explore. Graph data embedded from companion RDF at generation time.

Neo4j's Graph Technology Narrative vs Virtuoso's

Nodes: 0 Links: 0
Click SVG to activate zoom, click outside to release | Drag nodes to pin, double-click to unpin
Classes Properties Instances

SPARQL Workbench 23 sample queries

Query this knowledge graph on URIBurner. The editor opens on the canonical SAMPLE entity-type summary (DAV named graph). Pick a recipe, edit freely, then run live or copy.

Sample Queries

Reproduced verbatim from the companion RDF. Execute loads the query into the workbench below and runs it live.

SPARQL counterpart of the article's traversal
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.html#>
SELECT ?supplier ?weeksLost ?cause
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.ttl>
WHERE {
  ?order schema:identifier "A-1042" ;
         :includesProduct/:containsPart ?part .
  ?part :hasSupplyLink ?link .
  ?link :linkSupplier ?s ; :weeksLost ?weeksLost .
  OPTIONAL { ?link :disruptionCause ?cause }
  ?s schema:name ?supplier .
}
Every comparison dimension, both sides
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.html#>
PREFIX schema: <http://schema.org/>
PREFIX prov: <http://www.w3.org/ns/prov#>
SELECT ?dimension ?subject ?stance ?relation
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.ttl>
WHERE {
  ?d a <https://neo4j.com/blog/graph-database/introducing-neo4j-virtual-graph-graph-reasoning-on-the-data-you-already-have/#ComparisonDimension> ; schema:name ?dimension ; :hasRelation ?relation .
  ?p :ofDimension ?d ; :ofSubject ?s ; :stance ?stance .
  ?s schema:name ?subject .
}
ORDER BY ?dimension ?subject
Dimensions the Neo4j article never addresses
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.html#>
PREFIX schema: <http://schema.org/>
PREFIX prov: <http://www.w3.org/ns/prov#>
SELECT ?dimension ?virtuosoStance ?whyNeo4jIsSilent
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.ttl>
WHERE {
  ?d a <https://neo4j.com/blog/graph-database/introducing-neo4j-virtual-graph-graph-reasoning-on-the-data-you-already-have/#ComparisonDimension> ; schema:name ?dimension ; schema:description ?whyNeo4jIsSilent .
  ?pv :ofDimension ?d ; :ofSubject :virtuoso ; :stance ?virtuosoStance .
  FILTER NOT EXISTS { ?pn :ofDimension ?d ; :ofSubject :neo4j }
}
ORDER BY ?dimension
Convergent, divergent, and unaddressed dimensions counted
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.html#>
PREFIX schema: <http://schema.org/>
PREFIX prov: <http://www.w3.org/ns/prov#>
SELECT ?relation (COUNT(?d) AS ?dimensions) (GROUP_CONCAT(?dimension; SEPARATOR=", ") AS ?which)
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.ttl>
WHERE {
  ?d a <https://neo4j.com/blog/graph-database/introducing-neo4j-virtual-graph-graph-reasoning-on-the-data-you-already-have/#ComparisonDimension> ; schema:name ?dimension ; :hasRelation ?relation .
}
GROUP BY ?relation
ORDER BY DESC(?dimensions)
The article's own traversal, order A-1042
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.html#>
PREFIX schema: <http://schema.org/>
PREFIX prov: <http://www.w3.org/ns/prov#>
SELECT ?product ?part ?supplier ?weeksLost ?cause
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.ttl>
WHERE {
  ?order schema:identifier "A-1042" ; :includesProduct ?prod .
  ?prod schema:name ?product ; :containsPart ?pt .
  ?pt schema:name ?part ; :hasSupplyLink ?link .
  ?link :linkSupplier ?s ; :weeksLost ?weeksLost .
  OPTIONAL { ?link :disruptionCause ?cause }
  ?s schema:name ?supplier .
}
ORDER BY DESC(?weeksLost)
Late orders grouped by culprit supplier and country
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.html#>
PREFIX schema: <http://schema.org/>
PREFIX prov: <http://www.w3.org/ns/prov#>
SELECT ?country ?supplier ?cause (COUNT(DISTINCT ?order) AS ?lateOrders) (MAX(?w) AS ?weeksLost)
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.ttl>
WHERE {
  ?order a :Order ; :shippedLate true ; :includesProduct/:containsPart ?pt .
  ?pt :hasSupplyLink ?link .
  ?link :linkSupplier ?s ; :weeksLost ?w ; :disruptionCause ?cause .
  FILTER(?w > 0)
  ?s schema:name ?supplier ; schema:addressCountry ?country .
}
GROUP BY ?country ?supplier ?cause
ORDER BY DESC(?lateOrders)
All fifteen late orders with their worst delay
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.html#>
PREFIX schema: <http://schema.org/>
PREFIX prov: <http://www.w3.org/ns/prov#>
SELECT ?orderId ?orderDate ?worstDelayWeeks (GROUP_CONCAT(DISTINCT ?supplier; SEPARATOR=" + ") AS ?culprits)
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.ttl>
WHERE {
  {
    SELECT ?order (MAX(?w) AS ?worstDelayWeeks)
    WHERE {
      ?order a :Order ; :includesProduct/:containsPart/:hasSupplyLink ?l .
      ?l :weeksLost ?w .
    } GROUP BY ?order
  }
  ?order schema:identifier ?orderId ; schema:orderDate ?orderDate ;
         :includesProduct/:containsPart/:hasSupplyLink ?link .
  ?link :weeksLost ?worstDelayWeeks ; :linkSupplier ?s .
  FILTER(?worstDelayWeeks > 0)
  ?s schema:name ?supplier .
}
GROUP BY ?orderId ?orderDate ?worstDelayWeeks
ORDER BY DESC(?worstDelayWeeks) ?orderId
Customer outcomes ranked by improvement factor
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.html#>
PREFIX schema: <http://schema.org/>
PREFIX prov: <http://www.w3.org/ns/prov#>
SELECT ?customer ?useCase ?metric ?before ?after ?unit (ROUND((?before/?after)*100)/100 AS ?improvementFactor)
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.ttl>
WHERE {
  ?o a :CustomerOutcome ; :ofCustomer ?c ; :ofUseCase ?u ;
     :metricName ?metric ; :metricUnit ?unit ;
     :beforeValue ?before ; :afterValue ?after .
  ?c schema:name ?customer . ?u schema:name ?useCase .
}
ORDER BY DESC(?improvementFactor)
Outcomes cited with no baseline figure
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.html#>
PREFIX schema: <http://schema.org/>
PREFIX prov: <http://www.w3.org/ns/prov#>
SELECT ?customer ?useCase ?scale ?scaleUnit
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.ttl>
WHERE {
  ?o a :CustomerOutcome ; :ofCustomer ?c ; :ofUseCase ?u .
  ?c schema:name ?customer . ?u schema:name ?useCase .
  FILTER NOT EXISTS { ?o :beforeValue ?b }
  OPTIONAL { ?o :scaleFigure ?scale ; :scaleUnit ?scaleUnit }
}
ORDER BY ?customer
Headline claims with their attribution
PREFIX : <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.html#>
PREFIX schema: <http://schema.org/>
PREFIX prov: <http://www.w3.org/ns/prov#>
SELECT ?claim ?value ?unit ?attributedTo ?published
FROM <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-rdf-claude_opus_5-1.ttl>
WHERE {
  ?c a :Claim ; schema:name ?claim ; :claimValue ?value ; :claimUnit ?unit ;
     prov:wasAttributedTo ?src .
  ?src schema:name ?attributedTo .
  OPTIONAL { ?src schema:datePublished ?published }
}
ORDER BY ?claim

Query editor

▶ Run live on URIBurner SELECT: text/x-html+tr | DESCRIBE/CONSTRUCT: text/x-html-nice-turtle