Linked Data Meshup · Comparative Analysis

The knowledge layer, two dialects: Virtuoso's open standards vs Neo4j's property graph

KG curated by kg-generator, rdf-infographic-skill and DeepSeek V4 Flash on behalf of Kingsley Uyi Idehen
Source: Neo4j blog
01
The question

“Why did this order ship late?” — the answer lives in connections, not single tables.

02
The gap

The databases hold every fact, but the links between them do not exist for the agent.

03
The layer

Graph technology becomes the knowledge layer — memory, context, and reasoning.

04
The moat

Knowledge — governed, queryable, self-owned — is the durable advantage.

Virtuoso

RDF knowledge layer — open standards

Graph as standards, not a platform: RDF/SPARQL, RDF Views since ~2007, hyperlinks as identifiers, SPARQL-FED federation — with agent-rdf-memory as the reference showcase.

VS
Neo4j

Property-graph knowledge layer

Graph as a platform category — nodes, relationships, properties, Cypher, GraphRAG, and Virtual Graph over the warehouses you already run.

Thesis at a Glance

Neo4j's manifesto argues that AI agents fail at cross-cutting questions — 'why did this order ship late?' — because the connections between facts do not exist in the databases the agent queries. Graph technology fills that gap by storing nodes, relationships, and properties, turning the question into a traversal.

The article positions graph technology as the knowledge layer between data sources and AI agents, delivering a knowledge trifecta of memory, context, and reasoning, backed by the vendor's measurable claims of accuracy and ROI gains. It distinguishes native graph traversal from graph features bolted onto row stores, presents Virtual Graph as a zero-copy bridge to warehouses, and closes on knowledge as the durable moat once intelligence itself is a commodity — the same story OpenLink has advanced in RDF terms for two decades, now demonstrated live by agent-rdf-memory, Virtuoso's reference showcase implementation of an RDF-based agent memory harness.

Convergence Thesis

Intelligence is now a commodity. The durable moat is a governed, queryable record of what an agent or organization knows — kept under its own control. Neo4j defends that moat inside a platform-coupled graph; Virtuoso defends it — with agent-rdf-memory as its reference showcase implementation — inside a loosely-coupled, open-standards RDF harness.

01 · The thesis

One story, two dialects

The Neo4j article tells the same story OpenLink has advanced in RDF terms for two decades: the graph, in the form of a Semantic Web, is the semantic harmonization layer between your data and your software applications (agents), delivering connectivity and context that informs reasoning and inference.

Memory

Neo4j view

Short-term, long-term, and reasoning memory together form a context graph — the record of everything the agent has seen, decided, and learned.

VirtuosoEpisodic sessions/, semantic entities/, and procedural preferences.ttl + howto/ tiers, all queryable RDF.
Context

Neo4j view

GraphRAG follows relationships around vector-similar snippets to hand the model connected facts, instead of snippets that merely sound like the question.

VirtuosoSPARQL-routed, relevance-budgeted context selection over a Virtuoso endpoint, with file-read fallback.
Reasoning

Neo4j view

The article argues multi-hop traversal outperforms relational joins beyond three or four hops.

VirtuosoTransitive and property-graph traversal at massive scale — URIBurner, DBpedia, the LOD Cloud — plus SPARQL-FED federation and HowToStep chains for procedural reasoning.

Knowledge is the moat

Neo4j closes on “data is abundant, but understanding is scarce” and grounds its knowledge layer in measured claims of accuracy and ROI gains. Virtuoso’s narrative grounds the same claim in open standards and longevity — a converged virtual DBMS since the 1990s, RDF Views since ~2007, SPARQL-FED for a decade-plus — now proven live by agent-rdf-memory, Virtuoso's reference showcase implementation.

02 · The head-to-head

Twelve comparison dimensions

Every aspect is a first-class entity in the companion knowledge graph — click a dimension name to open its RDF description.

Table view on wide screens; entity cards on narrow screens.
AspectVirtuoso — open standardsNeo4j knowledge layer
Context retrievalVirtuoso: SPARQL-routed context selection as the standard retrieval path; agent-rdf-memory showcases relevance-budgeted selection over a Virtuoso endpoint with file-read fallback.Neo4j: GraphRAG — follow relationships around vector-similar snippets to hand the model connected facts.
Core thesisVirtuoso: intelligence is a commodity; the moat is a governed, queryable record of what an organization or agent knows, kept under the operator's own control — a claim demonstrated by agent-rdf-memory, Virtuoso's reference showcase implementation of an RDF-based agent memory harness.Neo4j: graph technology is the knowledge layer that delivers accurate, explainable, and trusted AI; grounding agents in a knowledge graph is the path to production.
Coupling & ownershipVirtuoso: loosely coupled, open standards (HTTP, SQL, SPARQL, RDF, R2RML, ODBC, JDBC); agent-rdf-memory showcases the pattern with plain-text RDF the operator owns and any LLM can read.Neo4j: a platform-coupled knowledge layer — you operate the graph on the Neo4j Graph Intelligence Platform.
Data modelVirtuoso: RDF triples (subject-predicate-object) under W3C standards, queried in SPARQL, with relational tables as a co-equal model in the same engine — the model agent-rdf-memory uses as its reference showcase.Neo4j: labeled property graph — nodes and relationships with key-value properties, queried in Cypher.
Evidence & maturityVirtuoso: standards longevity — virtual DBMS since the 1990s, RDF Views since ~2007, SPARQL-FED for a decade-plus, DBpedia and URIBurner in production, with agent-rdf-memory as the live reference showcase implementation.Neo4j: vendor-commissioned metrics (IDC May 2026 hallucination-cut study and ROI claims); category pitch of 2026.
ExplainabilityVirtuoso: PROV-O provenance as a first-class data model; agent-rdf-memory showcases prompt recording and intent-to-outcome traceability in session memory.Neo4j: every answer is a path through the graph, so anyone can walk back through the exact facts and relationships that produced it.
Governance & policyVirtuoso: RDF-backed policy and governance at the data layer; agent-rdf-memory showcases a policy layer in preferences.ttl with 200+ HowToSteps, many as hard blocking gates, plus session governance and secret redaction.Neo4j: the reasoning memory the agent keeps doubles as an audit trail.
Identifier systemVirtuoso: HTTP URIs as global identifiers — hyperlinks as identifiers (Linked Data / Platinum Layer); owl:sameAs reconciles identities across the open web; agent-rdf-memory applies the same discipline to agent identity (WebID).Neo4j: internal node IDs plus foreign keys; the graph is a closed world.
Memory modelVirtuoso: graph-backed memory at any scale, from enterprise context graphs to agent memory; agent-rdf-memory is its reference showcase — episodic memory in sessions/, semantic memory in entities/, procedural and behavioral memory in preferences.ttl and howto/, all queryable RDF on Virtuoso.Neo4j: short-term memory for the session, long-term memory for organizational knowledge, reasoning memory for how decisions get made — together a context graph.
Ontology postureVirtuoso: formal RDFS/OWL/SKOS ontologies as first-class citizens of the engine; agent-rdf-memory demonstrates this with an ontology.ttl that imports shared vocabularies and a typed entity registry for deterministic resolution.Neo4j: labels and properties, AI-generated graph models and LLM-assisted discovery from schemas.
ReasoningVirtuoso: a multimodel DBMS that performs transitive (recursive) and property-graph traversals at massive scale — live instances include URIBurner, DBpedia, and many others across the Linked Open Data (LOD) Cloud — plus SPARQL-FED federation, RDFS/OWL inference, and agent-rdf-memory's procedural HowToStep chains.Neo4j: native graph traversal at any depth; the article argues relational joins degrade past three or four hops.
Zero-copy over existing dataVirtuoso: RDF Views / Quad Map Patterns rewrite SPARQL as SQL against live relational tables — zero replication, no ETL — since ~2007; the zero-copy pattern Neo4j's Virtual Graph restates in 2026.Neo4j: Virtual Graph maps tables to nodes and foreign keys to relationships and queries warehouses in place; otherwise a sync builds the graph.
Virtuoso

Virtuoso Universal Server

Context retrieval
Virtuoso: SPARQL-routed context selection as the standard retrieval path; agent-rdf-memory showcases relevance-budgeted selection over a Virtuoso endpoint with file-read fallback.
Core thesis
Virtuoso: intelligence is a commodity; the moat is a governed, queryable record of what an organization or agent knows, kept under the operator's own control — a claim demonstrated by agent-rdf-memory, Virtuoso's reference showcase implementation of an RDF-based agent memory harness.
Coupling & ownership
Virtuoso: loosely coupled, open standards (HTTP, SQL, SPARQL, RDF, R2RML, ODBC, JDBC); agent-rdf-memory showcases the pattern with plain-text RDF the operator owns and any LLM can read.
Data model
Virtuoso: RDF triples (subject-predicate-object) under W3C standards, queried in SPARQL, with relational tables as a co-equal model in the same engine — the model agent-rdf-memory uses as its reference showcase.
Evidence & maturity
Virtuoso: standards longevity — virtual DBMS since the 1990s, RDF Views since ~2007, SPARQL-FED for a decade-plus, DBpedia and URIBurner in production, with agent-rdf-memory as the live reference showcase implementation.
Explainability
Virtuoso: PROV-O provenance as a first-class data model; agent-rdf-memory showcases prompt recording and intent-to-outcome traceability in session memory.
Governance & policy
Virtuoso: RDF-backed policy and governance at the data layer; agent-rdf-memory showcases a policy layer in preferences.ttl with 200+ HowToSteps, many as hard blocking gates, plus session governance and secret redaction.
Identifier system
Virtuoso: HTTP URIs as global identifiers — hyperlinks as identifiers (Linked Data / Platinum Layer); owl:sameAs reconciles identities across the open web; agent-rdf-memory applies the same discipline to agent identity (WebID).
Memory model
Virtuoso: graph-backed memory at any scale, from enterprise context graphs to agent memory; agent-rdf-memory is its reference showcase — episodic memory in sessions/, semantic memory in entities/, procedural and behavioral memory in preferences.ttl and howto/, all queryable RDF on Virtuoso.
Ontology posture
Virtuoso: formal RDFS/OWL/SKOS ontologies as first-class citizens of the engine; agent-rdf-memory demonstrates this with an ontology.ttl that imports shared vocabularies and a typed entity registry for deterministic resolution.
Reasoning
Virtuoso: a multimodel DBMS that performs transitive (recursive) and property-graph traversals at massive scale — live instances include URIBurner, DBpedia, and many others across the Linked Open Data (LOD) Cloud — plus SPARQL-FED federation, RDFS/OWL inference, and agent-rdf-memory's procedural HowToStep chains.
Zero-copy over existing data
Virtuoso: RDF Views / Quad Map Patterns rewrite SPARQL as SQL against live relational tables — zero replication, no ETL — since ~2007; the zero-copy pattern Neo4j's Virtual Graph restates in 2026.
Neo4j

Neo4j Graph Intelligence Platform

Context retrieval
Neo4j: GraphRAG — follow relationships around vector-similar snippets to hand the model connected facts.
Core thesis
Neo4j: graph technology is the knowledge layer that delivers accurate, explainable, and trusted AI; grounding agents in a knowledge graph is the path to production.
Coupling & ownership
Neo4j: a platform-coupled knowledge layer — you operate the graph on the Neo4j Graph Intelligence Platform.
Data model
Neo4j: labeled property graph — nodes and relationships with key-value properties, queried in Cypher.
Evidence & maturity
Neo4j: vendor-commissioned metrics (IDC May 2026 hallucination-cut study and ROI claims); category pitch of 2026.
Explainability
Neo4j: every answer is a path through the graph, so anyone can walk back through the exact facts and relationships that produced it.
Governance & policy
Neo4j: the reasoning memory the agent keeps doubles as an audit trail.
Identifier system
Neo4j: internal node IDs plus foreign keys; the graph is a closed world.
Memory model
Neo4j: short-term memory for the session, long-term memory for organizational knowledge, reasoning memory for how decisions get made — together a context graph.
Ontology posture
Neo4j: labels and properties, AI-generated graph models and LLM-assisted discovery from schemas.
Reasoning
Neo4j: native graph traversal at any depth; the article argues relational joins degrade past three or four hops.
Zero-copy over existing data
Neo4j: Virtual Graph maps tables to nodes and foreign keys to relationships and queries warehouses in place; otherwise a sync builds the graph.
03 · First-party evidence

OpenLink Weblog RDF Views corpus

Five user-approved posts from the OpenLink Software Weblog, meshed as Virtuoso-side evidence for the head-to-head — RDF Views, conceptual data virtualization, Neo4j-LPG bridging, and knowledge graph guides.

Applying Semantic Reasoning to Neo4j using Virtuoso

https://www.openlinksw.com/weblog/?post=lpg2rdf-guide.html

Bridges Neo4j's property graph to Virtuoso with SQL and SPARQL-within-SQL (SPASQL), then applies RDFS/OWL reasoning to enrich Neo4j data.

Datamodel Identifiers

Infographic: Generating Knowledge Graphs from Databases

https://www.openlinksw.com/weblog/?post=relations-rdfviews-virtuoso-1.html

Knowledge graphs from databases without moving your data — conceptual data harmonization and Virtual Knowledge Graphs, with hyperlinks as entity names.

Zerocopy Ontology

Northwind Sales Performance Dashboard — Interactive RDF Data Analytics

https://www.openlinksw.com/weblog/?post=northwind-dashboard-rdf-views-claude-3.html

A working zero-copy demo: the Northwind relational schema queried as a knowledge graph via Virtuoso RDF Views with an interactive SPARQL dashboard.

Zerocopy Evidence

Conceptual Data Virtualization for SQL and RDF — RDF + HTML Collection

https://www.openlinksw.com/weblog/?post=conceptual-data-virtualization-sql-rdf-deepseek_v4flash-1.html

One multi-model engine representing relations as SQL tables and RDF graphs, queried with ANSI SQL or SPARQL, zero data copies — 'one engine, both worlds, zero impedance'.

Zerocopy Coupling

Virtuoso | Building and Using Knowledge Graphs Guide

https://www.openlinksw.com/weblog/?post=building-a-knowledge-using-virtuoso.html

Virtuoso Knowledge Graph guide: building and using knowledge graphs, including OPAL-assisted exploration of a running instance's graphs.

Ontology Evidence
04 · The evaluation

Evaluate a graph-backed AI agent memory layer

A seven-step evaluation that reads the Neo4j knowledge-layer argument against Virtuoso's RDF approach, with agent-rdf-memory as its reference showcase implementation.

Identify the cross-cutting questions

List the questions your agents must answer that cut across data silos — 'why did this order ship late' style questions whose answers live in connections, not in single tables or chunks.

Map each question to a traversal

For each question, draw the path: start at the entity, follow the relationship chain to the answer. If the path needs three or more hops, the question is a graph question.

Choose the graph data model

Decide between a labeled property graph queried in Cypher (Neo4j's proprietary query language) and RDF triples queried in SPARQL — both open standards, both supported by Virtuoso. The choice determines ontology-influenced quality, scope, and range of inference, and how the graph interoperates across disparate data spaces rather than becoming yet another silo built around proprietary product functionality.

Choose the identifier system

Decide how entities are identified: internal node IDs and foreign keys (closed world) or HTTP URIs with hyperlinks as identifiers (Linked Data / Platinum Layer), reconciled with owl:sameAs.

Wire memory and context retrieval

Give the agent memory tiers (session, organizational, reasoning) and a context path: GraphRAG following relationships around vector snippets, or SPARQL-routed relevance-budgeted context selection from a Virtuoso endpoint.

Establish governance and audit trails

Make every answer traceable: paths through the graph, or PROV-O provenance and prompt recording in session memory. Enforce policy as reasoning-memory audit trails or as preferences.ttl blocking gates.

Measure accuracy, explainability, and adoption

Track hallucination reduction, explanation walk-backs, time to production, and total cost of ownership — then compare vendor metrics against open-standards longevity and a live implementation you control.

05 · Questions & answers

Frequently asked questions

What is graph technology?▼
A family of technologies that stores, analyzes, and reasons over connected data, rooted in graph theory. Entities become nodes, connections become relationships, properties hold the details of both, and modeling a whole domain this way builds a knowledge graph.
How does the article address explainability and governance?▼
Explainability is built in: every answer is a path through the graph, so anyone can walk back through the exact facts and relationships that produced it. Governance rides the same structure: the reasoning memory the agent keeps doubles as an audit trail.
How does agent-rdf-memory differ from a platform knowledge layer?▼
Neo4j's knowledge layer is platform-coupled — you operate the graph on the Neo4j Graph Intelligence Platform. agent-rdf-memory is a loosely coupled, plain-text RDF harness under the operator's own control, model-agnostic: Claude, GPT, DeepSeek, GLM, and Grok all read the identical contract, so identity, preferences, and history never leak into a frontier model vendor's systems.
Does adopting graph technology require replacing existing databases?▼
No. The article says graph technology joins the stack as a knowledge layer above existing architecture, often via a sync — and Virtual Graph skips even that by querying warehouses in place. Virtuoso's conceptual data virtualization makes the same claim: R2RML Quad Maps rewrite queries against live relational tables, with zero replication.
Why can't a vector-only RAG answer 'why did this order ship late?'▼
Vector search returns snippets that sound like the question. The answer to a cross-cutting question runs through multiple connection hops — the order included a product, the product needed a part, the part came from a supplier — and those relationships only exist in a graph. GraphRAG follows the relationships around the snippets and hands the model connected facts.
What is the difference between a graph database and graph analytics?▼
Graph databases store nodes, relationships, and properties natively and answer questions by traversing them; each node points directly to its neighbors. Graph analytics applies graph algorithms and machine-learning pipelines to the network itself to find communities, rank influence, and expose hidden structures.
What is the knowledge trifecta of memory, context, and reasoning?▼
Memory gives the agent continuity — short-term for the session, long-term for organizational knowledge, reasoning memory for how decisions get made. Context is the slice of the graph bearing on the task. Reasoning is multi-hop: connecting dots across entities, one relationship at a time.
How do Neo4j's memory forms map to agent-rdf-memory's tiers?▼
Short-term memory maps to the dated session files in sessions/; long-term memory maps to entities/ and projects/ semantic memory; reasoning memory maps to preferences.ttl and howto/ procedural rules. Neo4j's 'context graph' — the record of everything the agent has seen, decided, and learned — maps to the SPARQL-queryable store itself.
What is GraphRAG and how does it differ from vector RAG?▼
Most RAG pipelines assemble context with vector search alone, returning snippets that sound like the question. GraphRAG keeps going: it follows the relationships around those snippets and hands the model connected facts, so the agent returns a grounded answer instead of the first plausible-sounding text.
What is Neo4j Virtual Graph and how does it compare to Virtuoso RDF Views?▼
Virtual Graph (2026) maps tables to nodes and foreign keys to relationships, compiles Cypher into SQL, and runs graph queries directly against warehouses — zero copy, data never moves. Virtuoso RDF Views (via R2RML or native Quad Map Patterns, ~2007) declaratively map relational schemas to RDF ontologies with SPARQL compiled to SQL — the same zero-copy pattern about two decades earlier, plus federation across SPARQL endpoints via SPARQL-FED. Everything is based on open standards that have stood the test of time.
Why does the article claim relational joins hit a three-or-four-hop wall?▼
The article argues that a graph feature bolted onto a row store rebuilds connections with joins and indexes and degrades past three or four hops, while a purpose-built graph engine stores connections and traverses them at any depth. That framing is incomplete: a multimodel DBMS such as Virtuoso supports transitivity and property-graph traversals at massive scale — demonstrated by live instances on the Web, including this URIBurner instance, DBpedia, and many others across the Linked Open Data (LOD) Cloud.
What evidence does the article cite for graph technology?▼
The article cites a May 2026 IDC study of Neo4j deployments finding that grounding AI in knowledge graphs cut hallucination rates, and reports measurable ROI for graph-powered AI deployments, with named customers including BMW, TripAdvisor, and Intuit.
06 · The vocabulary

Core terms

Context Graph

Neo4j's term for the record of everything an agent has seen, decided, and learned — agent memory as a graph.

Convergent dimension

Both approaches agree in substance; they differ in vocabulary and coupling, not in the underlying claim.

Cypher

Neo4j's declarative graph query language with ASCII-art pattern syntax; contributed to the ISO GQL standard.

Data Virtualization

Querying heterogeneous data in place without copying, through a virtual layer such as RDF Views or Virtual Graph.

Divergent dimension

The approaches differ in kind: who owns the layer, what the identifiers are, and how open the substrate is.

Graph Database

A database that stores nodes, relationships, and properties natively and answers questions by traversing them.

GraphRAG

Graph-based retrieval-augmented generation: following relationships around vector-similar snippets to hand the model connected facts.

Knowledge Graph

A graph-based model of a domain in which entities become nodes, connections become relationships, and rules organize it all.

Knowledge Layer

The connective tissue between data sources and AI agents that provides memory, context, and reasoning.

Linked Data

Best practices for publishing structured data on the web using HTTP URIs as identifiers and hyperlinks to connect entities.

Property Graph

The labeled property graph model: nodes and relationships carry key-value properties, queried in Cypher or GQL.

RDF

The W3C data model of subject-predicate-object triples — the foundation of the Semantic Web and Linked Data, and the model behind agent-rdf-memory.

RDF Views

Virtuoso's declarative mapping of relational schemas to RDF ontologies via Quad Map Patterns; SPARQL is compiled to SQL and runs in place.

SPARQL

The W3C query language for RDF graphs; the native graph query language of Virtuoso.

Semantic Web

A web of data in which information is given well-defined meaning, using URIs, RDF, and ontologies.

Knowledge Graph

Interactive Knowledge Graph Explorer

Drag to pin nodes, double-click to unpin, click a node or edge to open its RDF description via URIBurner. Click the graph surface to arm zoom; click outside to release.

0 nodes / 0 links

KG Settings

Physics

Charge-350
Link distance110
Collision16

Node filters

Resolver

Arrow style

Predicates

Articles Approaches Organizations Software Concepts Dimensions Sources People
Workbench

SPARQL Workbench

Query the companion knowledge graph live on URIBurner. Select a recipe, edit, and run — or open the query in the workbench.

Open in URIBurner workbench
Weblog RDF Views corpus sources▼
SELECT ?post ?title ?url (GROUP_CONCAT(?dimName; SEPARATOR=", ") AS ?dimensions)
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-agent-rdf-memory-meshup-deepseek_v4flash-1.ttl> {
    ?post a schema:Article ; schema:name ?title ; schema:url ?url ; schema:about ?dim .
    ?dim a cdx:ComparisonDimension ; schema:name ?dimName .
  }
}
GROUP BY ?post ?title ?url
ORDER BY ?title
Run live
Comparison dimensions and both approaches▼
PREFIX cdx: <https://linkeddata.uriburner.com/DAV/demos/daas/ontology-terms#>
PREFIX : <https://neo4j.com/blog/graph-database/graph-technology#>
SELECT ?dim ?name ?neo4jApproach ?virtuosoApproach
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-agent-rdf-memory-meshup-deepseek_v4flash-1.ttl> {
    ?dim a cdx:ComparisonDimension ; schema:name ?name ;
      :hasNeo4jApproach ?neo4jApproach ; :hasVirtuosoApproach ?virtuosoApproach .
  }
}
ORDER BY ?name
Run live
FAQ questions and answers▼
SELECT ?question ?questionText ?answerText
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-agent-rdf-memory-meshup-deepseek_v4flash-1.ttl> {
    ?question a schema:Question ; schema:name ?questionText ;
      schema:acceptedAnswer/schema:text ?answerText .
  }
}
ORDER BY ?question
Run live
Glossary terms and definitions▼
SELECT ?term ?name ?definition
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-agent-rdf-memory-meshup-deepseek_v4flash-1.ttl> {
    ?term a schema:DefinedTerm ; schema:name ?name ; schema:description ?definition .
  }
}
ORDER BY ?name
Run live
HowTo steps in order▼
SELECT ?step ?position ?title
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-agent-rdf-memory-meshup-deepseek_v4flash-1.ttl> {
    ?howto a schema:HowTo ; schema:step ?step .
    ?step schema:position ?position ; schema:name ?title .
  }
}
ORDER BY ?position
Run live
Entity-type summary of the knowledge graph▼
SELECT ?type (SAMPLE(?s) AS ?sampleEntity) (SAMPLE(?label) AS ?sampleLabel) (COUNT(?s) AS ?entityCount)
WHERE {
  GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/neo4j-graph-technology-vs-virtuoso-agent-rdf-memory-meshup-deepseek_v4flash-1.ttl> {
    ?s rdf:type ?type .
    OPTIONAL { ?s rdfs:label ?label }
  }
}
GROUP BY ?type
ORDER BY DESC(?entityCount)
Run live