Skip to content
Back to search

ontobricks

Transforms Unity Catalog tables into a dynamic, understandable knowledge graph, with ontology design and reasoning exposed to AI agents as MCP tools

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked yesterday

Check it deeper on your machine

It has changed since its scan on 19 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/databrickslabs/ontobricks with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/databrickslabs/ontobricks'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/databrickslabs--ontobricks/badge.svg)](/listings/databrickslabs--ontobricks)

HTML

<a href="/listings/databrickslabs--ontobricks"><img src="/api/listings/databrickslabs--ontobricks/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 262 lines
  1. <p align="center">
  2. <img src="src/front/static/global/img/ontobricks-icon.svg" alt="OntoBricks Logo" width="120" height="120">
  3. </p>
  4. <h1 align="center">OntoBricks 0.9.2</h1>
  5. <p align="center">
  6. <strong>Turn your Databricks tables into a living knowledge graph — in four clicks.</strong>
  7. </p>
  8. <p align="center">
  9. <a href="https://ontobricks.org/">Website</a>
  10. ·
  11. <a href="https://ontobricks.org/">Demos &amp; Screenshots</a>
  12. ·
  13. <a href="https://github.com/databrickslabs/ontobricks">GitHub</a>
  14. ·
  15. <a href="docs/README.md">Documentation</a>
  16. </p>
  17. <p align="center">
  18. <img src="https://img.shields.io/badge/runs%20on-Databricks%20Apps-FF3621.svg" alt="Databricks Apps">
  19. <img src="https://img.shields.io/badge/python-3.11+-blue.svg" alt="Python">
  20. <img src="https://img.shields.io/badge/standards-OWL%20·%20R2RML%20·%20SPARQL-6E4AFF.svg" alt="Standards">
  21. <img src="https://img.shields.io/badge/AI-MCP%20ready-10B981.svg" alt="MCP ready">
  22. </p>
  23. ---
  24. ### What's new in 0.9.2
  25. - **Several datasets per class**: Ontology Studio links multiple Unity Catalog tables, views, or **metric views** to one class. Graph Explorer, Graph Chat, and MCP surface all of them.
  26. - **MCP identity and domain resolution**: graph tools run as the end user again, and domain-scoped tools work without a sticky session (`domain_name`).
  27. - **SPARQL value filters**: typed `FILTER(STR(?v) = …)` and `CONTAINS(…)` compile to SQL instead of returning unfiltered results.
  28. - **Apps deploy and local setup fixes**: identity scopes are no longer declared, and `./scripts/start.sh` works when the default `python3` is 3.9.
  29. - **Dependency security floors** raised (Authlib, dnspython, msgpack, nltk, pyasn1, graphql-core, joserfc); the MCP server now requires Python ≥ 3.11.
  30. Full details are in the [Release Notes](releases/ReleaseNotes_V0.9.2.md).
  31. ### What's new in 0.9.1
  32. - **Viewer search and Graph Chat**: Viewers can search / expand Explorer and chat over the graph; load and node-action writes stay blocked.
  33. - **SWRL builtins**: `swrlb:` filters apply on inference **and** materialization (Lakebase `TRY_CAST` included).
  34. - **Auto-Map Metric Views**: the agent emits `MEASURE(...)` + `GROUP BY` and rejects table-style `SELECT *`.
  35. - **Faster Data Quality**: bulk checks snapshot the gateway VIEW once, run in parallel, and stream a live activity log (entity checks too).
  36. - **Lakebase quality SQL** always uses the Build warehouse, not a Lakehouse//RT query warehouse.
  37. - **Security floors** raised (Pillow, certifi, GitPython, MLflow, …); `uv.lock` regeneration is still required.
  38. Full details are in the [Release Notes](releases/ReleaseNotes_V0.9.1.md).
  39. ### What's new in 0.9.0
  40. - **Lakehouse//RT graph queries**: Knowledge Graph reads can run on a serverless Lakehouse//RT warehouse, while builds keep a classic or serverless one.
  41. - **Three-stage Ontology Generate**: detect entities, lock the catalog, then complete relations, attributes and axioms. The result is appended to your ontology instead of replacing it.
  42. - **Knowledge Store**: parsed documents live in Lakebase and are shared by Generate and Mapping. No Volume grants are needed.
  43. - **Unity Catalog Metric Views**: Metric Views import as data assets with dimension/measure roles.
  44. - **Entity Data Quality Checks**: right-click a node in Explorer, or call it from MCP, to check that entity against every SHACL shape that applies, with gauges for each dimension.
  45. - **Entity business rules**: attach SWRL rules, aggregate rules and decision tables to a class, then run them on one entity from Explorer or MCP.
  46. - **Databricks Jobs as class actions**: trigger a workspace Job for an entity next to Unity Catalog functions.
  47. - **SPARQL playground**: query the graph in SPARQL and inspect the generated SQL.
  48. - **GitHub domain mirror**: push the domain configuration (OWL, R2RML, SHACL, rules) to a GitHub repository and restore it from there.
  49. - **OBX Import as**: rename a domain on import; a renamed copy does not reuse the previous graph objects.
  50. - **Faster Explorer**: indexed search, paged expansion and no blocking `COUNT(*)` on first load.
  51. - **Ontology Studio**: the renamed Designer adds multi-select, Business Views, cross-domain import, and OWL/R2RML export from the canvas.
  52. - **Load opens Domain → General**: opening a domain from Home, the navbar, Registry, or Versions lands on Domain → General instead of staying on the current page.
  53. - **Security hardening**: stricter CSRF, a `/health` that leaks no internals, dialect-aware SQL escaping and sanitised Markdown.
  54. Full details are in the [Release Notes](releases/ReleaseNotes_V0.9.0.md).
  55. ---
  56. Every enterprise has the data. Almost none have the **meaning**. Your Lakehouse
  57. stores billions of rows, but nothing captures what they *represent* — that a
  58. *Customer* holds *Contracts*, which contain *Invoices*, governed by rules only
  59. your senior engineers remember.
  60. **OntoBricks closes that gap.** It is a Databricks-native app that turns Unity
  61. Catalog tables into an explorable, queryable **knowledge graph** — design the
  62. meaning, let AI map it to your data, and navigate the result visually or expose
  63. it to your favorite LLM. No separate graph platform, no RDF expertise, no
  64. months-long integration project.
  65. ## Why OntoBricks
  66. - **From schema to graph in minutes, not months.** LLM-powered automation drives
  67. the whole pipeline — import metadata, generate the ontology, map the data,
  68. materialize the graph.
  69. - **Lives inside Databricks.** Deploys as a Databricks App and reuses what you
  70. already have: Unity Catalog, SQL Warehouse, AI Gateway or Model Serving,
  71. and Lakebase. Your
  72. triples stay in your Lakehouse.
  73. - **Standards under the hood, simplicity on top.** OWL, R2RML and SPARQL power
  74. the engine; everything executes as Spark SQL. Your users never touch RDF.
  75. - **Built for the AI era.** Publish any domain to LLM agents over the Model
  76. Context Protocol (MCP) and let them reason over governed, explainable
  77. business semantics.
  78. - **Governed by design.** Versioned domains, DRAFT → IN-REVIEW → PUBLISHED
  79. lifecycle, single-editor locking, and an append-only review audit trail.
  80. - **Parse documents once, reuse them everywhere.** Uploaded PDF, Office, image,
  81. and text sources are parsed into a versioned **Knowledge Store** (parsed text
  82. in Lakebase; originals are not retained) shared by ontology Generate and
  83. Mapping; failed parses are visible and retryable.
  84. ## From tables to a knowledge graph in four clicks
  85. | Step | Action | What happens | Powered by |
  86. |------|--------|--------------|------------|
  87. | **1** | **Import Metadata** — Domain &gt; Metadata | Fetches table &amp; column metadata from Unity Catalog | Unity Catalog |
  88. | **2** | **Generate Ontology** — Ontology &gt; Wizard | The LLM designs entities, relationships &amp; attributes from your metadata | AI Gateway / Model Serving |
  89. | **3** | **Auto-Map** — Mapping &gt; Auto-Map | The LLM generates SQL mappings for every entity and relationship | AI Gateway / Model Serving |
  90. | **4** | **Synchronize** — Knowledge Graph &gt; Status | Executes the mappings and populates the triple store | SQL Warehouse |
  91. Prefer full control? Every step is also available as a guided **manual
  92. workflow** — design, map, build, query, and reason at column-level precision.
  93. See the [User Guide](docs/user-guide.md).
  94. ### Run a domain without an LLM
  95. Selecting **No LLM** is a strict domain-level opt-out. LLM actions remain
  96. visible but unavailable and direct API calls are rejected with guidance to
  97. select a model in **Domain Information → AI**. Select and save an LLM there to
  98. make those actions available again without reloading the page. Deterministic
  99. reasoning and validation, including OWL/SWRL inference, ontology pitfalls, and
  100. SHACL data-quality checks, remain available while No LLM is selected.
  101. ## What's inside
  102. ### Design ontologies visually or with AI
  103. Drag-and-drop entities, relationships and inheritance on the **OntoViz** canvas,
  104. or import industry standards in one click (FIBO, CDISC, IOF, HL7 FHIR
  105. R4/R4B/R5) and your own OWL/RDFS. A floating **AI Assistant** edits your
  106. ontology through natural language. Catch design issues early with the built-in
  107. **Ontology Pitfalls Detector** (19 structural, logical and semantic checks).
  108. **Generate** drives that AI design through a resumable, human-in-the-loop
  109. wizard — **Detect** candidate entities from metadata and your parsed document
  110. corpus, **Review** them (include/exclude, edit labels, add your own), then
  111. **Complete** relations, attributes, and axioms in that order. Every run
  112. **appends** to your existing ontology — locked entities are never renamed or
  113. removed — and a stale draft (source changed since detection) is flagged with
  114. a one-click **Re-detect** instead of silently reusing outdated candidates.
  115. ### Map to your data — automatically
  116. Let the LLM generate SQL and column mappings for every entity and relationship,
  117. then refine with live data preview. Mappings compile to W3C-compliant **R2RML**
  118. you never have to write. Schema-drift warnings flag upstream renames and drops
  119. before they break your graph.
  120. ### Build, reason and explore
  121. Materialize triples incrementally, then **reason** over the graph with OWL 2 RL
  122. inference, SWRL rules and SHACL validation. Explore interactively: two-phase
  123. search, N-hop neighbour expansion, cross-domain bridge navigation, community
  124. detection (Louvain, Label Propagation, Greedy Modularity), and explainable
  125. **cohort discovery**. Lakehouse domains can optionally read from a **Lakehouse//RT**
  126. query warehouse while builds stay on a classic or serverless warehouse. Query
  127. everything through an auto-generated **GraphQL** API or open **Knowledge Graph
  128. → Query → SPARQL** for read-only SELECT queries, sample queries, CSV export,
  129. generated SQL inspection, and triple-shaped results that open in Explorer.
  130. See the [SPARQL Playground guide](docs/user-guide.md#sparql-playground),
  131. [Get Started](docs/getting-started.md), and
  132. [Cohort Discovery](docs/advanced_features.md#cohort-discovery).
  133. ### Publish to AI agents (MCP)
  134. Expose your knowledge graph to Cursor, Claude Desktop or the Databricks
  135. Playground over the [Model Context Protocol](https://modelcontextprotocol.io/).
  136. Each domain decides exactly **what it publishes** — which tools, which datasets,
  137. which class actions and virtual attributes — right down to ontology-only domains
  138. that expose a single `describe_ontology` tool. See
  139. [MCP Integration](docs/mcp.md).
  140. ### Govern the whole lifecycle
  141. Every domain version carries a **DRAFT / IN-REVIEW / PUBLISHED** status enforced
  142. server-side. A **single editor** holds a DRAFT at a time (auto-releasing leases,
  143. admin take-over), a business-friendly **review workflow** collects sign-offs
  144. with a configurable quorum, and every decision is persisted append-only. Move
  145. domains between environments with the **OBX** export/import (UI or
  146. [CLI](docs/advanced_features.md#registry-import-and-export)).
  147. ### Pluggable graph engine
  148. Pick a backend **per domain**: **Lakebase (Postgres)** by default,
  149. **Lakehouse** (governed Delta triple tables, zero extra infra), **Neo4j**, or
  150. **No Backend** for ontology-only domains that publish their ontology with no
  151. graph built (Mapping and Knowledge Graph are disabled and the MCP surface
  152. serves only ontology information).
  153. Connection config stays workspace-global. Lakehouse and Lakebase Build also
  154. materialise Explorer indexes (`_adj_out` / `_adj_in`, `_entity_search`,
  155. `_entity_search_asserted`, `_props`); Neo4j keeps native traversal. Full reference:
  156. [Lakebase Graph DB](docs/backend.md#lakebase-graph-store) ·
  157. [Graph DB Integration](docs/backend.md#engine-integration) ·
  158. [Graph Query Optimizations](docs/backend.md#graph-query-optimizations).
  159. ## Runs entirely on your Databricks
  160. OntoBricks is not a separate platform. It deploys as a **Databricks App** and
  161. uses the services you already run — Unity Catalog for storage and metadata, a
  162. SQL Warehouse for execution, AI Gateway or Model Serving for LLM automation, and
  163. Lakebase for the registry and graph store. Your data and your triples never leave your
  164. workspace. Architecture deep-dive: [architecture.md](docs/architecture.md).
  165. ## Get started
  166. **Try it locally**
  167. ```bash
  168. git clone <repository-url> && cd OntoBricks
  169. uv sync --frozen --extra lakebase # install the committed public-PyPI lock
  170. cp .env.example .env # set your Databricks host, token, warehouse ID
  171. scripts/start.sh # open http://localhost:8000
  172. ```
  173. Always use `--frozen` for routine `uv sync` / `uv run` commands. The lock
  174. records package indexes as `https://pypi.org/simple` and immutable artifact
  175. downloads on `https://files.pythonhosted.org`; do not commit internal
  176. `pypi-proxy.dev.databricks.com` URLs.
  177. **Deploy to Databricks Apps**
  178. ```bash
  179. databricks auth login --host https://<workspace>
  180. # edit scripts/deploy.config.sh (profile, warehouse, registry, Lakebase), then:
  181. make deploy
  182. ```
  183. Prerequisites (Databricks workspace with Apps enabled, a SQL Warehouse, a
  184. **Lakebase Autoscaling** database, and a Unity Catalog Volume) and the full,
  185. idempotent deploy checklist — including one-click graph-DB provisioning and
  186. permission bootstrap — are in the
  187. **[Get Started](docs/getting-started.md)** and
  188. **[Deployment Guide](docs/deployment.md)**.
  189. The bundle syncs only runtime source, the MCP and graph-job files, dependency
  190. locks, and the in-app Help Center set. `databricks.yml` `sync.exclude` is
  191. authoritative; `.databricksignore` is a reviewer/test mirror and is not read
  192. by the Databricks CLI.
  193. ## Documentation
  194. - **[Documentation hub](docs/README.md)** — start here
  195. - **[Value proposition](docs/product.md)** — the business case &amp; go-to-market
  196. - **[User Guide](docs/user-guide.md)** · **[Feature inventory](docs/user-guide.md#feature-inventory)** · **[Architecture](docs/architecture.md)** · **[API](docs/api.md)**
  197. - **[MCP](docs/mcp.md)** · **[Graph DB](docs/backend.md)** · **[Import / Export](docs/advanced_features.md#registry-import-and-export)**
  198. - **[Developing OntoBricks](docs/development.md)** — build, test, contribute
  199. Product overview, screenshots and videos:
  200. [ontobricks.org](https://ontobricks.org/).
  201. ## License
  202. OntoBricks, including OntoViz, is source-available under the
  203. [Databricks License](LICENSE.txt).
  204. ## Project Support
  205. Please note that all projects in the /databrickslabs github account are provided
  206. for your exploration only, and are not formally supported by Databricks with
  207. Service Level Agreements (SLAs). They are provided AS-IS and we do not make any
  208. guarantees of any kind. Please do not submit a support ticket relating to any
  209. issues arising from the use of these projects.
  210. Any issues discovered through the use of this project should be filed as GitHub
  211. Issues on the Repo. They will be reviewed as time permits, but there are no
  212. formal SLAs for support.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.