Product & go-to-market

OntoBricks -- Value Proposition Deck

Slide-ready content for presenting OntoBricks to enterprise stakeholders. Each section maps to one slide or slide group.

Agenda

• The data semantics Gap
• Where OntoBricks fits
• The 4-Click pipeline
• Key features and capabilities
• Competitive landscape
• Value Proposition
• Conclusion & next steps

---

Slide 1: The Data Semantics Gap

Every enterprise has the data. Almost none have the meaning.

Organizations invest heavily in Lakehouse platforms to store and process data at scale. But structured data alone does not capture what the data means -- the entities it represents, how they relate, and what business rules apply.

The five gaps:

The result: data is stored but not understood, relationships are implicit but not navigable, and graph viewer adoption stalls because the infrastructure barrier is too high.

---

Slide 2: Where OntoBricks Fits

A Graph Viewer Builder that lives inside Databricks.

OntoBricks is not a separate platform. It deploys as a Databricks App and uses the services you already have.

flowchart LR
    subgraph databricksPlatform ["Databricks Platform"]
        UC["Unity Catalog<br/>Tables, Volumes, Metadata"]
        WH["SQL Warehouse<br/>Query Execution"]
        MS["Model Serving<br/>LLM Endpoints"]
        TS["Delta Triple Store<br/>Subject-Predicate-Object"]
    end

    subgraph ontoBricks ["OntoBricks App"]
        OD["Ontology Designer<br/>OWL / RDFS"]
        MA["Mapping<br/>R2RML Mapping"]
        DT["Knowledge Graph<br/>Graph Viewer"]
    end

    UC -->|metadata| OD
    OD -->|entities & rules| MA
    UC -->|table data| MA
    WH -->|SQL execution| MA
    MS -->|LLM automation| OD
    MS -->|LLM automation| MA
    MA -->|materialized triples| TS
    TS -->|graph data| DT

Key architecture points:

Standards bridge: OntoBricks uses W3C semantic web standards internally (OWL, R2RML, SPARQL) but translates everything to Spark SQL for execution. Users never need to learn RDF.

---

Slide 3: The 4-Click Pipeline

From raw tables to a queryable graph viewer in minutes, not months.

After a one-time setup (Databricks connection, LLM endpoint, triple store table), the entire pipeline is four actions:

flowchart LR
    S1["1. Import Metadata"]
    S2["2. Generate Ontology"]
    S3["3. Auto-Mapping Data"]
    S4["4. Sync Triple Store"]

    S1 -->|"UC tables & columns"| S2
    S2 -->|"LLM designs entities"| S3
    S3 -->|"LLM maps SQL"| S4
    S4 -->|"Delta materialization"| KG["Graph Viewer Ready"]

Traditional approach: weeks of manual ontology design, custom ETL pipelines, separate graph database setup.

OntoBricks approach: minutes of guided, LLM-automated interaction -- all within the Databricks platform.

---

Slide 4: Key Features and Capabilities

Four pillars, one integrated experience.

Ontology Design

Mapping (Data Mapping)

Knowledge Graph (Sync and Explore)

Domain Management

External Access

---

Slide 5: Competitive Landscape

No existing solution provides an integrated, Databricks-native graph viewer experience.

OntoBricks differentiator

OntoBricks is the only solution that combines all of the following in a single application:

• Databricks-native (deploys as an App, uses UC + SQL Warehouse)
• W3C standards-based (OWL, R2RML, SPARQL)
• LLM-automated (ontology generation + data mapping)
• Graph-visualizing (interactive graph viewer)
• Industry-standard ready (FIBO, CDISC, IOF)
• Source-available (Databricks License)

---

Slide 6: Value Proposition

Quantified benefits for the enterprise.

Who benefits

---

Slide 7: Conclusion and Next Steps

Deploy a graph viewer on Databricks in minutes.

Get started:

databricks apps deploy --app-name ontobricks

Requirements:

Resources:

Next steps for your organization:

1. Try it -- Deploy OntoBricks on a development workspace with sample data
2. Identify a use case -- Pick a domain with complex entity relationships (e.g., customer-contract-invoice, clinical trial data, manufacturing processes)
3. Run the 4-click pipeline -- Import metadata, generate ontology, run auto-mapping, sync
4. Explore the graph -- Navigate entities and relationships visually; run quality checks
5. Evaluate -- Compare the time, cost, and insight quality against your current approach

---

OntoBricks -- Bridging relational data and graph viewers on Databricks.

---

OntoBricks — Field Engineering Innovation Project

Summary

OntoBricks is a Graph Viewer Builder for Databricks that brings graph database capabilities and formal reasoning to the Lakehouse — without requiring separate graph infrastructure. It transforms relational tables stored in Unity Catalog into a structured graph viewer by leveraging semantic web standards (OWL, R2RML, RDF), a Lakebase Postgres graph engine, OWL 2 RL reasoning, and LLM-powered automation.

Users can design ontologies visually or import industry standards (FIBO for finance, CDISC for clinical data, IOF for manufacturing), map ontology entities to Databricks tables, materialize the result into a Delta-backed triple store mirrored on Lakebase Postgres, run formal reasoning (OWL 2 RL deductive closure, SWRL rules, transitive/symmetric inference), and explore the graph viewer through interactive visualization. The entire pipeline — from raw tables to a reasoned, queryable graph viewer — can be completed in as few as four clicks thanks to LLM-driven ontology generation and automatic data mapping.

OntoBricks runs as a Databricks App, making it natively integrated with the Databricks platform: Unity Catalog for storage and metadata, SQL Warehouses for query execution, and Model Serving endpoints for LLM features.

---

Problem Statement

Organizations on Databricks accumulate large volumes of structured data across catalogs and schemas, but understanding and navigating the relationships between entities hidden in those tables remains difficult:

• No semantic layer: Databricks provides excellent storage and compute, but no built-in tooling to define or visualize the meaning of data — what entities exist, how they relate, and what constraints apply.
• Knowledge is siloed: Domain knowledge about entity relationships (e.g., "a Customer has Contracts, which have Invoices") lives in documentation, tribal knowledge, or ER diagrams disconnected from the actual data.
• Exploration is query-driven: Understanding how entities connect requires writing ad-hoc SQL joins. There is no visual, graph-based way to navigate data across tables.
• Industry standards are inaccessible: Established ontologies like FIBO (finance), CDISC (clinical), and IOF (manufacturing) exist but require specialized tooling (Protégé, TopBraid) that doesn't integrate with the Databricks ecosystem.
• No path from schema to graph viewer: Building a graph viewer from Databricks tables today requires stitching together multiple external tools, custom ETL pipelines, and manual RDF generation — a process that is expensive, fragile, and disconnected from the data platform.

---

Proposed Solution

OntoBricks provides an end-to-end, web-based solution that runs directly on Databricks:

Ontology Design

• Visual designer (OntoViz) with drag-and-drop entity creation, relationship wiring, and inheritance hierarchies.
• LLM-powered Wizard: Point to Unity Catalog tables, and the LLM generates a complete OWL ontology from table/column metadata — entities, relationships, attributes, and inheritance.
• Industry-standard import: One-click import of FIBO (6 domains), CDISC (5 standards), and IOF (3 domains) with automatic module fetching, merging, and parsing.
• OWL/RDFS import: Load existing ontologies from files or Unity Catalog Volumes.

Data Mapping

• Visual mapping: Click entities on an interactive graph to configure their SQL source.
• LLM-powered Auto-Map: The LLM generates SQL queries and column mappings for every entity and relationship automatically, using domain metadata as context.
• R2RML generation: W3C-compliant R2RML mappings are generated behind the scenes — users never need to write mapping rules manually.

Triple Store + Graph DB Layers

• Delta view (SQL Warehouse): Materialize triples into a governed Delta view (subject, predicate, object) with Liquid Clustering, full Unity Catalog lineage, and SQL-based graph reasoning (recursive CTEs for transitive closure, anti-joins for symmetric expansion).
• Lakebase Postgres (Graph DB engine): A flat triple table on the App-bound Lakebase Postgres instance, populated either by app_managed COPY FROM STDIN streaming or by managed_synced Lakeflow synced tables. The same SQL primitives used on Delta run on Lakebase, with sub-second latency from the FastAPI process. The Graph DB layer is pluggable behind GraphDBBackend and GraphDBFactory — capability flags (supports_cypher, is_cypher_backend, query_dialect) reserve a slot for plugging in a future Cypher / Gremlin engine.
• Quality checks: Validate the triple store against ontology constraints — cardinality, value constraints, functional/symmetric properties, orphan detection, and more.
• SHACL Data Quality: Define W3C SHACL shapes across six quality categories (completeness, cardinality, uniqueness, consistency, conformance, structural) — shapes are compiled to SQL for execution against the triple store or validated in-memory via PySHACL.

Reasoning & Inference

• OWL 2 RL Reasoner: Forward-chaining deductive closure on the ontology using the owlrl library — infers subclass hierarchies, property entailments, domain/range typing, and class axioms.
• SWRL Rule Engine: User-defined Horn-clause rules with a graphical D3-based editor — compiled to SQL (Spark SQL on Delta, Postgres SQL on Lakebase) for violation detection and triple materialization.
• Graph Reasoning: Automatic transitive closure and symmetric expansion based on OWL property characteristics.
• Constraint Validation: Formal checking of cardinality, functional/inverse-functional properties, value constraints, and global rules (no orphans, require labels).

Graph Viewer Exploration

• Interactive Graph Viewer: Sigma.js WebGL-powered graph with search, filtering, depth control, and entity detail panels.
• Data Cluster Detection: Detect communities using Louvain, Label Propagation, or Greedy Modularity — client-side (Graphology) for the visible subgraph, server-side (NetworkX) for the full graph; color-by-cluster mode, adjustable resolution, collapse clusters into navigable super-nodes.
• Triples grid: Sortable, searchable table view of all materialized triples.
• Dashboard integration: Embed Databricks SQL dashboards with parameter mapping to ontology entities.

External & Programmatic Access

• Knowledge Graph REST API: Stateless endpoints for triple store status, ontology/R2RML/SQL retrieval, entity search, and build triggers (/api/v1/digitaltwin/).
• GraphQL API: Auto-generated typed schema per domain with configurable relationship depth and GraphiQL playground.
• MCP Server: Model Context Protocol server deployable as a Databricks App (mcp-ontobricks) for Databricks Playground integration and LLM client access (Cursor, Claude Desktop).
• Ontology Assistant: Conversational LLM agent for natural-language ontology editing.

---

What Solutions Exist Today

Gap: No existing solution provides an integrated, Databricks-native experience that combines ontology design, industry-standard import, LLM-powered automation, graph database capabilities (embedded Cypher engine), formal OWL 2 RL reasoning, SWRL rule evaluation, W3C SHACL data quality validation, triple store materialization in Delta, and visual graph viewer exploration — all deployable as a Databricks App without requiring separate graph infrastructure.

---

Final Deliverable and Impact

Deliverable

A production-ready Databricks App (Databricks License) that:

• Deploys in minutes via databricks apps deploy
• Requires only a SQL Warehouse and (optionally) a Model Serving endpoint
• Stores all domain data in Unity Catalog Volumes (no external dependencies)
• Supports the full lifecycle: design → map → materialize → explore → validate

Expected Impact

Target Users

• Data engineers building semantic layers on Databricks
• Domain experts (finance, healthcare, manufacturing) who need to model and explore entity relationships
• Data architects evaluating graph viewer approaches on Lakehouse platforms
• Field engineers demonstrating Databricks capabilities for knowledge management and data governance use cases

---

Additional Information for Support Requested

Technical Stack

Current State

• Fully functional application with all features implemented
• Tested with CRM, IoT, energy, and healthcare ontologies
• Industry-standard imports operational (FIBO, CDISC, IOF)
• LLM-powered wizard and auto-map working with Databricks Model Serving endpoints
• Reasoning engine operational: OWL 2 RL deductive closure, SWRL rule engine (SQL translator) with graphical D3 editor, graph reasoning (transitive closure, symmetric expansion), constraint validation, and SHACL data quality shapes (PySHACL + SQL compilation)
• Triple store + Graph DB layers: Delta view (Unity Catalog) + Lakebase Postgres flat store, pluggable behind GraphDBFactory
• MCP server deployed and operational for Databricks Playground
• Entity Groups: OWL-compliant class grouping via owl:equivalentClass + owl:unionOf, with expand/collapse super-nodes in the Graph Viewer visualization
• Data Cluster Detection: Client-side Louvain (Graphology) and server-side community detection (NetworkX: Louvain, Label Propagation, Greedy Modularity) with color-by-cluster, resolution control, and cluster collapse/expand super-nodes
• Knowledge Graph REST API with design status, ontology, R2RML, Spark SQL endpoints
• GraphQL API with configurable depth and auto-generated schema
• Documentation: README, user guide, architecture, API reference, import guide, automated pipeline guide

Resources Needed

• Databricks workspace with a SQL Warehouse (Serverless recommended) for demo and testing
• Model Serving endpoint for LLM features (e.g., Meta Llama 3.3 70B or equivalent)
• Unity Catalog with sample datasets for demonstration scenarios
• Visibility and feedback from field engineering teams working on graph viewer, data governance, and semantic layer use cases