SPARQLWorks Visualizer
Virtuoso R2RML Documentation
OpenLink Virtuoso Homepage
W3C R2RML Specification
W3C SPARQL 1.1 Query Language
W3C RDF Standard
A method of publishing structured data using HTTP URIs and RDF so that it can be interlinked and become more useful through semantic queries.
Linked Data
The conversion of R2RML mappings into Virtuoso's internal Quad Map format for efficient SPARQL-to-SQL translation.
Quad Map Generation
SPARQL Protocol and RDF Query Language — the W3C standard query language for RDF graphs. In the virtual knowledge graph, SPARQL queries are translated to SQL and executed against the live Databricks warehouse.
SPARQL
Is this approach suitable for real-time or high-frequency workloads?
An extension of the World Wide Web where data is given well-defined meaning through standards like RDF, SPARQL, and OWL — enabling machines and AI agents to reason about interconnected data across system boundaries.
Semantic Web
Why use Virtuoso with Databricks instead of Databricks' built-in graph features?
Databricks-Virtuoso Virtual Knowledge Graph FAQ
danielhmills
danielhm
SPARQL SELECT rdf:type FROM <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> WHERE { ?s a ?o } LIMIT 10
Entity Type Discovery
SELECT * WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> { ?s a ?o } } LIMIT 10
Clone the Demo Repository
Clone the companion GitHub repository containing ODBC templates, R2RML mapping files, ontology, and setup scripts: git clone https://github.com/danielhmills/databricks-sample-kg.git.
R2RML mappings add ontology-defined classes, properties, and inferred relationships — transforming implicit foreign keys into navigable semantic links.
Semantic enrichment
Supply chain visibility — traces supplier ingredients to the franchises that use them for a supply chain dashboard.
Dashboard: Supplier-Ingredient-Franchise Product Flow
PREFIX : <http://www.databricks.com/bakehouse#> SELECT ?supplierName ?ingredientName (COUNT(DISTINCT ?franchise) AS ?franchisesServed) WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> { ?supply a :SupplyContract; :supplier ?supplier; :ingredient ?ingredient; :franchise ?franchise. ?supplier :supplierName ?supplierName. ?ingredient :ingredientName ?ingredientName. } } GROUP BY ?supplierName ?ingredientName ORDER BY DESC(?franchisesServed) LIMIT 15
The use of IRIs (Internationalized Resource Identifiers) as globally unique, dereferenceable entity identifiers — enabling entities from different systems (Databricks tables, external reference data, other knowledge graphs) to be linked and reasoned over as a single connected graph.
Hyperlink-Based Entity Identity
What are Quad Maps in Virtuoso?
Comprehensive RDF knowledge graph covering the value proposition of generating AI Agent-friendly Knowledge Graphs from Databricks-hosted data using Virtuoso, R2RML, SPARQL, and Linked Data principles.
Databricks-Virtuoso Virtual Knowledge Graph — RDF Knowledge Graph
A knowledge graph constructed over existing relational data without physical data movement — using virtual database attachment to expose tables, R2RML to define semantic mappings, and SPARQL for graph querying.
Virtual Knowledge Graph (VKG)
How do AI agents consume this knowledge graph?
Virtuoso's capability to attach remote tables from ODBC/JDBC data sources — tables appear in the local catalog as virtual references without copying data.
Virtual Database (VDB)
Answer: Can I use this approach with data sources other than Databri...
Yes. Virtuoso's Virtual Database supports any ODBC or JDBC data source — PostgreSQL, MySQL, Oracle, SQL Server, Snowflake, BigQuery, and many others. The same pattern applies: attach tables via ODBC, define R2RML mappings, load the ontology, generate quad maps, and query via SPARQL. The knowledge graph becomes a unified semantic layer spanning multiple heterogeneous data platforms.
The process of augmenting relational data with ontology-defined classes, properties, and inferred relationships to produce a knowledge graph.
Semantic Enrichment
Answer: Is this approach suitable for real-time or high-frequency wo...
The virtual knowledge graph approach using ODBC attachment is best suited for batch reasoning, GraphRAG over reference data, or exploratory graph analytics. For millisecond-latency graph traversals or high-frequency transactional writes, a native graph store may be more appropriate. However, for the majority of enterprise AI agent use cases — where agents need to discover entity relationships, traverse connections, and retrieve structured context — the performance characteristics are more than adequate.
Can I use this approach with data sources other than Databricks?
Answer: What is R2RML and why is it important?...
R2RML (RDB to RDF Mapping Language) is a W3C recommendation that defines how relational database tables, columns, and foreign keys map to RDF classes, properties, and relationships. It provides a declarative, standards-based bridge between the SQL world and the semantic graph world — no custom code needed. The mapping is a Turtle file that can be version-controlled, reviewed, and reused across projects.
Public SPARQL endpoint for querying knowledge graphs hosted in Virtuoso-backed URIBurner.
URIBurner SPARQL Endpoint
Capabilities Enabled
Answer: What is content negotiation and why does it matter for AI ag...
Content negotiation is an HTTP mechanism where the server inspects the client's Accept header to determine the response format. For the bakehouse knowledge graph: browsers requesting text/html receive a human-readable HTML description page with navigable links; AI agents and RDF clients requesting application/ld+json or text/turtle receive machine-readable RDF. This single-URI, multi-format approach means the same entity identifier works for both human exploration and automated agent consumption — a cornerstone of Linked Data and the Semantic Web.
Databricks ODBC/JDBC Documentation
A W3C R2RML declarative mapping that defines how relational tables and columns map to RDF classes and properties.
R2RML Mapping
Customer reviews and ratings for franchises.
sales_reviews
OpenLink Demo SPARQL Endpoint
Supplier records for ingredients and materials.
sales_suppliers
A software component or driver required for the pipeline.
requires component
A formal vocabulary defining classes, properties, and relationships within a domain. The bakehouse ontology defines Transaction, Franchise, Customer classes and franchise, totalPrice, city properties.
Ontology
Answer: How do AI agents consume this knowledge graph?...
AI agents consume the virtual knowledge graph through three standard interfaces: (1) SPARQL endpoint — structured graph queries returning typed results with entity IRIs; (2) Linked Data entity URIs — dereferenceable HTTP URIs that return RDF (Turtle, JSON-LD, RDF/XML) when requested with the appropriate Accept header; (3) HTML entity descriptions — human-readable pages with navigable hyperlinks for agentic browsing. No custom API, SDK, or platform-specific integration is required — any standards-compliant SPARQL client or HTTP agent can interact with the graph.
ACID compliance through the underlying Databricks warehouse, federated SPARQL for cross-graph queries, and Virtuoso's proven SPARQL-to-SQL query federation.
Production-grade infrastructure
Lightweight ontology for modelling the Databricks-to-Virtuoso virtual knowledge graph pipeline: ODBC attachment, R2RML mapping, SPARQL querying, Linked Data entity dereferencing, and AI Agent consumption patterns.
Databricks-Virtuoso Knowledge Graph Ontology
Databricks-Virtuoso KG Ontology
The ability to dereference entity URIs via HTTP content negotiation, receiving HTML for browsers or RDF for machines.
Linked Data Entity Navigation
A knowledge graph constructed over existing relational data without physical data movement, using virtual database attachment and R2RML declarative mappings.
Virtual Knowledge Graph
OpenLink Virtuoso
Database Management System
Knowledge Graph Platform
SPARQL Endpoint
A secure, high-performance, cross-platform relational and graph database server with virtual database, SPARQL, RDF, SQL, and R2RML support.
Virtuoso Universal Server
Key Concepts
A semantic enrichment layer that sits atop existing data platforms without tight coupling — replacing ETL-driven data copying with standards-based virtualization. The knowledge graph is an overlay, not a replacement or another silo.
Loosely Coupled Semantic Layer
A step-by-step guide demonstrating how to unlock machine-computable entity relationships across existing Databricks data without migration, duplication, or platform lock-in — using RDF, SPARQL, R2RML, and Virtuoso's Virtual Database to create an AI Agent-friendly Knowledge Graph deployed on the Semantic Web.
Modern AI and analytics need graph reasoning capabilities — the ability to traverse relationships and discover patterns across connected data — but most enterprise data sits in relational warehouses where relationships rely on implicit foreign keys. This guide shows how to bridge that gap using open W3C standards: RDF for entity relationships, SPARQL for graph querying, and R2RML for exposing relational data as graphs. Hyperlinks (IRIs) serve as globally unique identifiers enabling disparate systems to be connected and reasoned over as a whole. The result is a Knowledge Graph that extends beyond the boundaries of any single database, platform, or application.
From Databricks Tables to a Virtual Knowledge Graph with Virtuoso
Ontology graph — defines the bakehouse vocabulary: classes (Transaction, Franchise, Customer) and properties (franchise, totalPrice, city).
Bakehouse Sample Dataset
Answer: What skills or expertise are needed to implement this?...
SQL knowledge for table attachment and testing; basic understanding of RDF and SPARQL for query writing; familiarity with R2RML for mapping design (the Turtle syntax is straightforward for anyone comfortable with data modelling); and Virtuoso administration basics (Conductor UI or isql command-line). The companion GitHub repository provides templates and working examples — most practitioners can have a working virtual knowledge graph running within an hour.
The process of augmenting relational data with ontology-defined classes (e.g., :Transaction, :Franchise), properties (e.g., :franchise, :totalPrice), and inferred relationships to produce a machine-readable knowledge graph. R2RML mappings are the declarative bridge between SQL schemas and RDF vocabularies.
Open Database Connectivity — standard API for accessing database management systems.
ODBC
Customer value analysis — ranks customers by total spend across all their transactions for a CRM dashboard.
Dashboard: Top 10 Customers by Total Spend
PREFIX : <http://www.databricks.com/bakehouse#> SELECT ?customerName (COUNT(DISTINCT ?transaction) AS ?purchaseCount) (SUM(?totalPrice) AS ?lifetimeValue) (ROUND(SUM(?totalPrice)/COUNT(DISTINCT ?transaction)) AS ?avgPurchaseValue) WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> { ?transaction a :Transaction; :customer ?customer; :totalPrice ?totalPrice. ?customer :customerName ?customerName. } } GROUP BY ?customerName ORDER BY DESC(?lifetimeValue) LIMIT 10
An HTTP mechanism where the server inspects the client's Accept header to determine the response format — returning an HTML description page for browsers and RDF (Turtle, JSON-LD, RDF/XML) for semantic agents and RDF clients.
Content Negotiation
What skills or expertise are needed to implement this?
Databricks-Virtuoso Knowledge Graph Glossary
SPARQL Protocol and RDF Query Language — W3C standard for querying and manipulating RDF graphs.
Companion GitHub Repository
R2RML Mappings (Turtle)
Customer records with names, contact details, and loyalty status.
sales_customers
What is content negotiation and why does it matter for AI agents?
A knowledge graph designed for consumption by AI agents — featuring dereferenceable entity URIs, machine-readable RDF representations, SPARQL endpoints for structured querying, and navigable entity relationships. The Databricks-Virtuoso pipeline produces such a graph: an AI agent can follow entity links, execute SPARQL queries, and retrieve structured context without custom API integration.
AI Agent-Friendly Knowledge Graph
SPARQL CONSTRUCT extracting the Transaction-Franchise-City subgraph for interactive node-link visualization in SPARQLWorks.
CONSTRUCT for Graph Visualization (SPARQLWorks)
PREFIX : <http://www.databricks.com/bakehouse#> CONSTRUCT { ?transaction a :Transaction; :franchise ?franchise; :totalPrice ?totalPrice. ?franchise :city ?franchiseCity. } WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> { ?transaction a :Transaction; :franchise ?franchise; :totalPrice ?totalPrice. ?franchise :city ?franchiseCity. } } LIMIT 100
Full README
A capability unlocked by the virtual knowledge graph approach.
enables capability
Transaction records linking customers to franchises with line items and pricing.
sales_transactions
A defining characteristic of the virtual knowledge graph approach — Databricks tables are attached via ODBC as virtual references, not copied. SPARQL queries are translated to SQL and executed remotely against the Databricks warehouse at query time.
Zero Data Movement
Creator of Virtuoso Universal Server, URIBurner, and enterprise knowledge graph infrastructure.
OpenLink Software
Revenue segmentation analysis — buckets transactions by value range for a financial performance dashboard.
Dashboard: Order Size Distribution (Revenue Segmentation)
PREFIX : <http://www.databricks.com/bakehouse#> SELECT ?orderSizeBucket (COUNT(?transaction) AS ?transactionCount) (SUM(?totalPrice) AS ?totalRevenue) (ROUND(AVG(?totalPrice)) AS ?avgValue) WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> { ?transaction a :Transaction; :totalPrice ?totalPrice. BIND( IF(?totalPrice < 10, "Small (<$10)", IF(?totalPrice < 30, "Medium ($10-$30)", IF(?totalPrice < 60, "Large ($30-$60)", "Enterprise (>$60)"))) AS ?orderSizeBucket) } } GROUP BY ?orderSizeBucket ORDER BY DESC(?totalRevenue)
Verify the Knowledge Graph with SPARQL
Run SPARQL queries against the virtual knowledge graph — test entity type discovery (SELECT * FROM <...> WHERE { ?s a ?o }), cross-table joins (Revenue by Franchise), and CONSTRUCT queries for graph visualization in SPARQLWorks. Confirm dereferenceable entity URIs respond to both browsers and RDF clients via content negotiation.
A fictional bakery chain dataset provided by Databricks as a public sample — includes customers, franchises, suppliers, transactions, and reviews tables.
samples.bakehouse
Database Driver
ODBC driver enabling SQL connectivity between Virtuoso and Databricks SQL warehouses for virtual database attachment.
Databricks ODBC Driver
Answer: Why use Virtuoso with Databricks instead of Databricks' buil...
Databricks provides graph capabilities within its platform, but Virtuoso adds: (1) standards-based interoperability via W3C RDF/SPARQL/R2RML — no vendor lock-in; (2) Linked Data entity URIs enabling cross-system entity navigation; (3) federated SPARQL across multiple data sources; (4) AI Agent-friendly machine-readable RDF with content negotiation; and (5) a loosely coupled architecture where the knowledge graph is an overlay, not yet another silo.
W3C standards (RDF, SPARQL, R2RML) prevent vendor lock-in — the knowledge graph is portable and queryable by any standards-compliant SPARQL client or AI agent.
Standards-based interoperability
A cloud or on-premises platform hosting structured data (warehouses, lakes, lakehouses).
Data Platform
Geographic revenue breakdown — aggregates totalPrice by franchise city for a regional performance dashboard.
Dashboard: Revenue by City (Geographic Distribution)
PREFIX : <http://www.databricks.com/bakehouse#> SELECT ?city (COUNT(DISTINCT ?transaction) AS ?orderCount) (SUM(?totalPrice) AS ?revenue) (ROUND(AVG(?totalPrice)) AS ?avgOrderValue) WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> { ?transaction a :Transaction; :franchise ?franchise; :totalPrice ?totalPrice. ?franchise :city ?city. } } GROUP BY ?city ORDER BY DESC(?revenue)
What Databricks components are required?
Graph Visualization
A SPARQL query visualisation tool that renders CONSTRUCT query results as interactive node-link diagrams for exploring knowledge graph relationships.
SPARQLWorks
Answer: What is a Virtual Knowledge Graph?...
A Virtual Knowledge Graph (VKG) is a semantic layer constructed over existing relational data without physical data movement. It uses virtual database attachment (ODBC/JDBC) to connect to source systems, R2RML mappings to declare how tables and columns map to RDF classes and properties, and SPARQL-to-SQL query translation to execute graph queries against the live relational data at query time. The data stays in place; the semantics are layered on top.
Answer: Does data get copied from Databricks to Virtuoso?...
No. The virtual knowledge graph approach achieves zero data movement. Databricks tables are attached via ODBC as virtual references — they appear in Virtuoso's local catalog but no data is copied. SPARQL queries are translated to SQL at query time and executed remotely against the live Databricks SQL warehouse. This means the knowledge graph always reflects current data without ETL pipelines or stale copies.
Test the Attached Tables
Verify the virtual attachment by running a SQL SELECT query against the virtual tables (e.g., SELECT TOP 10 * FROM databricks.bakehouse.sales_customers) via isql or the Conductor iSQL UI.
Connect to the Data Source
Find databricks_odbc in the External Data Sources list, click Connect, supply the username (token) and password (personal access token), and establish the ODBC connection from Virtuoso to the Databricks SQL warehouse.
Seven-step guide to creating an AI Agent-friendly knowledge graph from Databricks-hosted data without migration, duplication, or platform lock-in.
How to Build a Virtual Knowledge Graph from Databricks Tables using Virtuoso
R2RML mapping graph — defines the SQL-to-RDF mapping rules for the bakehouse schema.
What is a Virtual Knowledge Graph?
A globally unique, dereferenceable HTTP identifier for a knowledge graph entity (e.g., http://demo.openlinksw.com/databricks/bakehouse/franchise-3000046#this). When dereferenced, returns either human-readable HTML or machine-readable RDF depending on the client.
Entity URI
Demo SPARQL endpoint hosting the bakehouse virtual knowledge graph for live query testing.
An HTTP mechanism where a server returns different representations of the same resource based on the client's Accept header — HTML for browsers, RDF for semantic agents.
W3C Standards
SQL script that attaches Databricks tables to Virtuoso's local catalog, grants SPARQL access, loads R2RML mappings and ontology, generates quad maps, and configures URL rewrite rules for Linked Data.
quick_setup.sql
What is R2RML and why is it important?
Answer: What are Quad Maps in Virtuoso?...
Quad Maps are Virtuoso's internal representation of R2RML mappings — they define how SPARQL graph patterns translate to SQL queries against virtual tables. The R2RML_MAKE_QM_FROM_G function converts declarative R2RML Turtle mappings into optimized Quad Maps that Virtuoso's SPARQL engine uses at query time. This is what makes SPARQL queries executable against remote relational tables without data movement.
Databricks ODBC Driver Download
Virtuoso's internal compiled representation of R2RML mapping rules — the SPARQL engine uses quad maps at query time to translate SPARQL graph patterns into SQL queries against virtual tables.
Quad Map
A knowledge graph designed for AI agent consumption — featuring dereferenceable entity URIs, machine-readable RDF, SPARQL endpoints, and navigable entity relationships without custom API integration.
A method of publishing structured data on the web using HTTP URIs, RDF, and content negotiation — enabling entities to be interlinked across systems and consumed by both humans and machines.
Virtuoso's Virtual Database attaches Databricks tables via ODBC as virtual references — no ETL, no duplication, no stale copies.
Zero data movement
Answer: How does this compare to traditional ETL-based knowledge gra...
Traditional ETL-based approaches: extract data from source, transform to RDF, load into a triplestore — creating a copy that must be kept in sync. The virtual approach: no extraction, no transformation pipeline, no load step, no stale copies. R2RML mappings define the semantic model declaratively; SPARQL queries execute against live data. Changes in Databricks tables are immediately visible in SPARQL results. The trade-off is query latency versus data freshness — the virtual approach prioritizes freshness and simplicity over raw graph traversal speed.
Cloud data platform provider offering data lakehouse architecture combining data lakes and data warehouses.
Databricks
Franchise locations with city, country, and coordinate data.
sales_franchises
Register the DSN in Virtuoso
Access the External Data Sources Manager in Virtuoso Conductor at /conductor/vdb_conn_dsn.vspx to register the databricks_odbc DSN for use by Virtuoso's Virtual Database engine.
Every entity (customer, franchise, transaction) receives a dereferenceable HTTP URI with content negotiation — browsers see HTML descriptions, AI agents retrieve machine-readable RDF.
Linked Data entity navigation
SPARQL SELECT with SUM aggregation joining Transaction and Franchise tables via the :franchise property, grouped by franchise and city.
Revenue by Franchise (Cross-Table SPARQL Join)
PREFIX : <http://www.databricks.com/bakehouse#> SELECT ?franchise ?franchiseCity SUM(?totalPrice) as ?revenue WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> { ?transaction a :Transaction; :franchise ?franchise; :totalPrice ?totalPrice. ?franchise :city ?franchiseCity. } } GROUP BY ?franchise ?franchiseCity ORDER BY DESC(?revenue) LIMIT 10
Companion repository containing ODBC configuration templates, R2RML mappings, ontology, and setup scripts for the Databricks-to-Virtuoso virtual knowledge graph pipeline.
databricks-sample-kg
A knowledge graph constructed over existing relational data without physical data movement — using virtual database attachment to expose tables, R2RML to define semantic mappings, and SPARQL for graph querying. The data stays in Databricks; the semantics are layered on top via Virtuoso.
The ability to traverse relationships and discover patterns across connected data using ontology-defined semantics rather than implicit foreign keys. In the bakehouse example, foreign keys become navigable hyperlinks connecting Transaction→Franchise→City through named relationships.
Graph Reasoning
Instance data graph — the runtime virtual knowledge graph containing entity triples generated by applying R2RML mappings to the live Databricks tables.
Software Stack
Run the Quick Setup Script
Execute quick_setup.sql via isql — this script attaches each Databricks table (ATTACH TABLE ... FROM 'databricks_odbc'), grants SPARQL_SELECT privileges, loads the R2RML mapping and ontology via SPARQL LOAD, generates quad maps via R2RML_MAKE_QM_FROM_G, and configures URL rewrite rules for Linked Data content negotiation.
Create the ODBC DSN
Configure a Databricks ODBC Data Source Name (DSN) — install the Databricks ODBC Driver, obtain workspace Host/HTTP Path/Personal Access Token, and populate odbcinst.ini and odbc.ini with the driver and connection details.
The ability to traverse relationships and discover patterns across connected data using ontology-defined semantics rather than implicit foreign keys.
Graph Reasoning Capability
How does this compare to traditional ETL-based knowledge graph construction?
A W3C or industry standard employed in the solution.
implements standard
Resource Description Framework — W3C standard for representing entity relationships as subject-predicate-object triples.
RDF
Customer satisfaction metrics — averages review ratings per franchise for a quality monitoring dashboard.
Dashboard: Top Rated Franchises (Customer Satisfaction)
PREFIX : <http://www.databricks.com/bakehouse#> SELECT ?franchiseName ?city (COUNT(?review) AS ?reviewCount) (ROUND(AVG(?rating))*10/10 AS ?avgRating) WHERE { GRAPH <https://linkeddata.uriburner.com/DAV/demos/daas/databricks-virtuoso-kg-deepseek_v4pro-1.ttl> { ?review a :Review; :franchise ?franchise; :rating ?rating. ?franchise :city ?city. OPTIONAL { ?franchise :franchiseName ?franchiseName. } } } GROUP BY ?franchiseName ?city HAVING (COUNT(?review) >= 3) ORDER BY DESC(?avgRating) LIMIT 10
Answer: What Databricks components are required?...
You need: (1) a Databricks SQL warehouse (Serverless, Pro, or Classic) to provide the ODBC endpoint; (2) the Databricks ODBC Driver installed on the Virtuoso host; (3) a Personal Access Token for authentication; and (4) the workspace Host and HTTP Path for the SQL warehouse. The public samples.bakehouse dataset provides the example tables — your own Databricks catalogs and schemas work the same way.
The RDF class or property a relational construct maps to.
maps to
A standard API for accessing database management systems — used by Virtuoso to connect to Databricks SQL warehouses for virtual table attachment.
ODBC (Open Database Connectivity)
Connecting to a remote database via ODBC/JDBC without copying data — tables appear in the local catalog as virtual references.
Virtual Database Attachment
A W3C recommendation that declaratively defines how relational database tables, columns, primary keys, and foreign keys map to RDF classes, properties, and object relationships.
R2RML (RDB to RDF Mapping Language)
SPARQL queries over Databricks tables without data movement — SQL is generated and executed at query time against the live Databricks warehouse.
Graph reasoning on existing data
Bakehouse Ontology (Turtle)
RDB to RDF Mapping Language — W3C recommendation for exposing relational data as RDF graphs using declarative mappings.
R2RML
The data platform whose tables are being virtualized into the knowledge graph.
uses data platform
Knowledge graph generation skill for AI agents — transforms documents and web content into structured RDF.
kg-generator skill
Does data get copied from Databricks to Virtuoso?
An artifact (named graph, entity URI, SPARQL result) produced by the pipeline.
produces artifact