Skip to content
Back to search

open-ontologies

A Terraforming MCP for Knowledge Graphs: validate, classify, and govern AI-generated ontologies.

Safety scan

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

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026. Its scripts were only partly scanned.

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/fabio-rovai/open-ontologies 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/fabio-rovai/open-ontologies'

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/fabio-rovai--open-ontologies/badge.svg)](/listings/fabio-rovai--open-ontologies)

HTML

<a href="/listings/fabio-rovai--open-ontologies"><img src="/api/listings/fabio-rovai--open-ontologies/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

# macOS (Apple Silicon)
curl -LO https://github.com/fabio-rovai/open-ontologies/releases/latest/download/open-ontologies-aarch64-apple-darwin
chmod +x open-ontologies-aarch64-apple-darwin && mv open-ontologies-aarch64-apple-darwin /usr/local/bin/open-ontologies

# Linux (x86_64)
curl -LO https://github.com/fabio-rovai/open-ontologies/releases/latest/download/open-ontologies-x86_64-unknown-linux-gnu
chmod +x open-ontologies-x86_64-unknown-linux-gnu && mv open-ontologies-x86_64-unknown-linux-gnu /usr/local/bin/open-ontologies

# Docker
docker pull ghcr.io/fabio-rovai/open-ontologies:latest

# From source (Rust 1.88+)
cargo build --release --features embeddings,plugins,sql

For Intel macOS, for native Windows and for other systems, read [docs/quickstart.md](docs/quickstart.md) and [docs/windows.md](docs/windows.md).

The Docker image is for linux/amd64 only, so on Apple silicon run it under emulation with `docker run --rm -i --platform linux/amd64 ghcr.io/fabio-rovai/open-ontologies:latest`.

The `serve` command starts an MCP server. That server speaks JSON-RPC on stdin and stdout. Thus, at start, the server looks as if it stopped, while it waits for a client. This behaviour is correct. From a terminal, use the CLI subcommands instead, for example `open-ontologies validate <file.ttl>`.

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.

.claude-plugin/plugin.json · Manifest · 11 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "open-ontologies",
  3. "description": "A Terraforming MCP for Knowledge Graphs: validate, classify, and govern AI-generated ontologies.",
  4. "version": "2.1.0",
  5. "author": {
  6. "name": "fabio-rovai"
  7. },
  8. "homepage": "https://github.com/fabio-rovai/open-ontologies",
  9. "repository": "https://github.com/fabio-rovai/open-ontologies",
  10. "license": "MIT"
  11. }
README.md · README · 571 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <!-- mcp-name: io.github.fabio-rovai/open-ontologies -->
  2. <p align="center">
  3. <img src="docs/assets/logo.png" alt="Open Ontologies" width="170">
  4. </p>
  5. <h1 align="center">Open Ontologies</h1>
  6. <p align="center">
  7. <strong>Plan a change to a production ontology. See every consequence before you apply it.<br>
  8. Then give the reviewer a proof that they can check without trust in you.</strong><br>
  9. Open Ontologies is written in Rust. It ships as one binary.
  10. </p>
  11. <p align="center">
  12. <a href="https://tesseractsemantics.com"><strong>tesseractsemantics.com</strong></a>
  13. </p>
  14. <p align="center">
  15. <a href="https://tesseractsemantics.com"><img src="https://img.shields.io/badge/Tesseract%20Semantics-tesseractsemantics.com-111827?style=for-the-badge" alt="Tesseract Semantics"></a>
  16. <a href="https://github.com/fabio-rovai/open-ontologies/stargazers"><img src="https://img.shields.io/github/stars/fabio-rovai/open-ontologies?style=for-the-badge&logo=github&color=0b5fff" alt="Stars"></a>
  17. <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge" alt="MIT"></a>
  18. <a href="https://github.com/fabio-rovai/open-ontologies/pkgs/container/open-ontologies"><img src="https://img.shields.io/badge/GHCR-pull%20the%20image-2496ED?style=for-the-badge&logo=docker&logoColor=white" alt="GHCR"></a>
  19. <a href="https://github.com/sponsors/fabio-rovai"><img src="https://img.shields.io/github/sponsors/fabio-rovai?style=for-the-badge&label=Sponsor&logo=GitHub%20Sponsors" alt="Sponsors"></a>
  20. </p>
  21. <p align="center">
  22. <a href="https://www.star-history.com/fabio-rovai/open-ontologies">
  23. <picture>
  24. <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/badge?repo=fabio-rovai/open-ontologies&type=trending&theme=dark">
  25. <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/badge?repo=fabio-rovai/open-ontologies&type=trending">
  26. <img alt="GitHub Trending Repository of the Day" src="https://api.star-history.com/badge?repo=fabio-rovai/open-ontologies&type=trending">
  27. </picture>
  28. </a>
  29. </p>
  30. <p align="center">
  31. <strong>English</strong> · <a href="README.zh-CN.md">简体中文</a>
  32. </p>
  33. <p align="center">
  34. <a href="https://open-ontologies-try.vercel.app/?sample=epc-sample.csv&auto=1"><img src="https://img.shields.io/badge/%E2%96%B6%20TRY%20IT%20IN%20THE%20BROWSER-e11d48?style=for-the-badge&labelColor=e11d48&color=e11d48" alt="Try it in the browser" height="44"></a>
  35. </p>
  36. <p align="center">
  37. <sub>Put in one spreadsheet. Get one ontology, with the evidence for each line. Then change one
  38. cell, and see the shape find the error. The page runs the released binary.</sub>
  39. </p>
  40. <p align="center">
  41. <a href="https://tesseractsemantics.com"><b>Look for enterprise support? tesseractsemantics.com</b></a><br>
  42. <sub>The engine is MIT, and it stays MIT. The platform is the hosted version of the engine.</sub>
  43. </p>
  44. ---
  45. <p align="center">
  46. <a href="docs/assets/knowledge-graph.svg"><img src="https://raw.githubusercontent.com/fabio-rovai/open-ontologies/main/docs/assets/knowledge-graph.webp" alt="A hand-drawn animation of ies-core.ttl. A person asserts the grey edges. The engine derives the green edges, and Lean 4 checks the one certificate that holds them. Four provers read the clauses and give opinions. A forged red line is refused, and a question the file cannot be asked comes back unasked." width="100%"></a>
  47. </p>
  48. <p align="center">
  49. <sub><b>426 asserted, 259 certified, 1 rejected.</b> The engine derived the green edges. A Lean 4
  50. checker then <i>proved</i> them. One certificate holds all 259, and one run of the checker accepts it.
  51. The red edge is a forged line. The same checker refused that line, gave exit 1, and named the rule.
  52. The run supplies each count. Nobody writes a count into the caption.</sub>
  53. </p>
  54. <p align="center">
  55. <img src="https://raw.githubusercontent.com/fabio-rovai/open-ontologies/main/docs/assets/hqdm-audit.svg" alt="HQDM as two shipped files side by side. Left, the RDFS rendering: 23 terms used as a class but never declared drawn as hollow red rings and 12 rdfs:range declarations naming a relation drawn as red edges. Right, the OWL rendering: 190 named classes this engine found satisfiable and 39 it found unsatisfiable drawn red, with a red ring on the 39 that HermiT calls unsatisfiable, the same 39." width="100%">
  56. </p>
  57. <p align="center">
  58. <sub><b>The same machinery, on a file from a different group, two times. HQDM ships as two files.</b>
  59. <code>hqdmTop/hqdmFramework</code> publishes an RDFS file. MagmaCore keeps a copy of that file, byte
  60. for byte. <code>gchq/HQDM</code> publishes an OWL file. The two files fail different checks. The RDFS
  61. file has no <code>owl:</code> term and no disjointness axiom. Thus <i>no named class in that file can be
  62. unsatisfiable</i>. But the file has <b>23</b> terms that it uses as a class and never declares. It has
  63. <b>12</b> <code>rdfs:range</code> declarations that name a relation and not a class. It also has <b>13</b>
  64. pairs of names that differ by one final underscore. Three of those pairs have the same domain and the
  65. same range. The OWL file passes all three checks, and the OWL file is not coherent. The tableaux of
  66. this engine finds <b>190</b> of its named classes satisfiable. The tableaux finds <b>39</b> unsatisfiable.
  67. HermiT calls the same <b>39</b> unsatisfiable, and HermiT is an opinion in the vocabulary of this
  68. repository. This figure proves nothing, and the figure does not claim a proof. A test computes each
  69. count again, and the test also computes that intersection. For the source and the method, read
  70. <a href="docs/assets/hqdm/PROVENANCE.md"><code>docs/assets/hqdm/PROVENANCE.md</code></a>.</sub>
  71. </p>
  72. ### One triple. Nothing added, nothing removed, blast radius zero. 901 consequences that were not there before.
  73. ```
  74. $ printf 'load base.ttl\nplan proposed.ttl\n' | open-ontologies batch -
  75. # the whole change: ex:hasParent rdfs:domain ex:Person
  76. added_classes 0
  77. removed_classes 0
  78. blast_radius 0 triples affected
  79. risk_score low
  80. ────────────────────────────────────────────
  81. conservativity not_conservative_under_rule_table
  82. new consequences 901 rule table owl-rl, in 0.04s
  83. ```
  84. Each number from a shape diff tells you that this change is safe. But the change
  85. gave a new type to each individual that the property already had. **The tool
  86. closes this gap.** A text diff cannot show you the gap. The change is one correct
  87. line, and the text diff is one line long.
  88. **Then give the reviewer the proof.** The run writes a certificate. A different
  89. person re-verifies months later. That person needs no instance of this software
  90. and no network. The command is `oo-cert asserted.tsv derivations.tsv`. The exit
  91. code is 0, and the theorem `OOCert.certificate_sound` covers the result.
  92. **The checker also refuses a forged proof.** Write a false conclusion into the
  93. derivation file. The same checker exits 1 and names the rule that does not hold.
  94. This is the red edge in the figure above. This refusal, and not the headline, is
  95. the part that survives examination.
  96. > **This is not an ontology editor.** Use Protégé to draw class hierarchies. You
  97. > run Open Ontologies on the change, before the change goes to production.
  98. >
  99. > **The tool is like Terraform, and this is on purpose. But the plan checks what a
  100. > change means and what it breaks, not only its text.** A text diff is `git diff`,
  101. > and you have `git diff` already.
  102. You do not need a JVM. You do not need Protégé. The engine speaks MCP to Claude,
  103. to Cursor, and to other clients of that protocol.
  104. ## See the engine at work
  105. <p align="center">
  106. <img src="https://raw.githubusercontent.com/fabio-rovai/open-ontologies/main/docs/assets/demo-certify.svg" alt="A terminal runs the Lean certificate checker while a supplier graph lights up beside it: three asserted edges in grey, three derived edges in green that the checker accepts, then one conclusion forged and the same checker refusing it in red" width="940">
  107. </p>
  108. Three triples go in, and three triples come out. A person asserted only that
  109. `ex:Northwind` is in a sanctioned jurisdiction. The engine *derived* the need for
  110. enhanced due diligence. A different person can check that derivation. That person
  111. does not have to trust you, or this engine, or the model that wrote the ontology.
  112. Watch the last seconds. Somebody forges one conclusion, and leaves the two
  113. premises exactly as they were. The same checker refuses the conclusion and names
  114. the rule. `oo-horn` printed each line in that terminal for the fixtures in
  115. [`tests/fixtures/horn/supplier/`](tests/fixtures/horn/supplier). A test runs the
  116. checker again. The test fails if the figure and the checker do not agree.
  117. ## With a proof, and without a proof
  118. | | An ordinary reasoner | Open Ontologies |
  119. | --- | --- | --- |
  120. | The answer | `Northwind needs enhanced due diligence` | the same answer |
  121. | Why the answer holds | "the reasoner says so" | a certificate that names each rule and each premise |
  122. | Who can check the answer | a second implementation can agree, and some reasoners give an explanation. No verified checker accepts either one | anybody, with a checker that shares no code with the engine |
  123. | If the engine has a defect | a second implementation can disagree. Then you know only that one of the two is wrong | the checker refuses the answer, exit 1 |
  124. | If a person edits the output | you cannot find the edit | the checker refuses it, and names the line and the rule |
  125. | If a rule was yours, not the standard's | the report is the same | a different verdict word, and a test holds that word |
  126. | What an auditor receives | a screenshot | a file that the auditor can check again |
  127. | Guarantee on an unsatisfiability answer | asserted | **none, and the tool says so** |
  128. If the tool measures a property, the tool says *measured*. If a prover gives an opinion, that opinion never takes the
  129. vocabulary of the checker. Read [what the tool proves, and what it does not
  130. prove](#what-the-tool-proves).
  131. ## What the tool does
  132. | Capability | What you get |
  133. | --- | --- |
  134. | Reason over OWL and RDFS | Materialised inferences **and** a derivation certificate that a proved checker accepts |
  135. | Use your own rules | SWRL, RIF Core or a Horn table, evaluated, with a verdict word that says the rules were yours |
  136. | Validate against SHACL | A report from an evaluator with a measurement against the W3C suite, not an assertion of success |
  137. | Ask if something is satisfiable | A finite model, replayed and checked, and not only a yes |
  138. | Ask if something is inconsistent | A refutation, if one is certifiable. If not, an honest opinion from the engine |
  139. | Retrieve a slice for RAG | Entailment preservation for each claim, because 99% coverage can still lose the one triple that mattered |
  140. | Change an ontology in production | Plan, blast radius, risk score, locked IRIs, apply, monitor, drift, rollback |
  141. | Load real data | CSV, JSON, XML, YAML, XLSX, Parquet, PostgreSQL and DuckDB into RDF |
  142. | Give the problem to a prover | TPTP, CLIF, SMT-LIB and LADR from one translation. The tool names and counts what it cannot export |
  143. | Work from an assistant | An MCP server, so Claude or Cursor operates all of it in conversation |
  144. ## Run the checker yourself
  145. The repository holds the three files. The output shows only the important fields.
  146. ```bash
  147. $ cd lean && lake build # builds the checkers, core Lean 4, no Mathlib
  148. $ F=../tests/fixtures/horn
  149. $ lake exe oo-horn check $F/builtin_rules.tsv $F/asserted.tsv $F/good.tsv
  150. {"ok":true,"verdict":"entailed","theorem":"OOCert.entails_of_builtin_horn",
  151. "means":"every conclusion is true in every model of the asserted graph"}
  152. $ lake exe oo-horn check $F/builtin_rules.tsv $F/asserted.tsv $F/bad_conclusion.tsv
  153. {"ok":false} # one IRI in the conclusion changed. exit 1.
  154. $ lake exe oo-horn check $F/user_rules.tsv $F/asserted.tsv $F/good.tsv
  155. {"ok":true,"verdict":"entailed_under_supplied_rules","theorem":"OOCert.horn_certificate_sound"}
  156. ```
  157. The third line is the important one. The inference is the same. But you wrote one
  158. of the rules. Thus the rule is an assumption that the certificate carries, and it
  159. is not a fact that the certificate establishes. The verdict word changes. A test
  160. fails if that word stops changing.
  161. ```mermaid
  162. flowchart LR
  163. E["Untrusted engine<br/>Rust, or the pure-Python one"] -->|certificate| C["Verified checker<br/>core Lean 4"]
  164. I["Isabelle/HOL<br/>independent second kernel"] -.->|same bytes| C
  165. C -->|built-in rules| A["entailed"]
  166. C -->|your rules| B["entailed_under_supplied_rules"]
  167. C -->|forged| X["refused, exit 1"]
  168. ```
  169. ## Run the tool on your own ontology
  170. The repository ships those fixtures. Now do the same steps with a file that you
  171. write. These steps take one minute.
  172. ```bash
  173. mkdir /tmp/oo-demo && cd /tmp/oo-demo
  174. cat > coffee.ttl <<'EOF'
  175. @prefix ex: <http://example.org/> .
  176. @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
  177. ex:Espresso rdfs:subClassOf ex:Coffee .
  178. ex:Coffee rdfs:subClassOf ex:Drink .
  179. ex:myCup a ex:Espresso .
  180. EOF
  181. export OPEN_ONTOLOGIES_STORAGE_MODE=persistent # in-memory by default, see below
  182. open-ontologies --data-dir /tmp/oo-demo/store load coffee.ttl
  183. open-ontologies --data-dir /tmp/oo-demo/store reason --profile rdfs --certificate ./cert
  184. ```
  185. Three triples go in, and three triples come out. The cup is a Coffee. The cup is
  186. a Drink. Espresso is a subclass of Drink. Each RDFS reasoner can do this much.
  187. The directory that the run wrote is the difference.
  188. ```bash
  189. lake exe oo-cert /tmp/oo-demo/cert/asserted.tsv /tmp/oo-demo/cert/derivations.tsv
  190. {"ok":true,"asserted":3,"derivations":3,"theorem":"OOCert.certificate_sound"}
  191. ```
  192. Now tell the checker a lie. Keep the premises, and forge one conclusion. The
  193. forged conclusion says that the cup is a Beer:
  194. ```bash
  195. cp -r /tmp/oo-demo/cert /tmp/oo-demo/forged
  196. sed -i '' 's|example.org/Drink>\t<http://example.org/myCup>|example.org/Beer>\t<http://example.org/myCup>|' \
  197. /tmp/oo-demo/forged/derivations.tsv # GNU sed: drop the '' after -i
  198. lake exe oo-cert /tmp/oo-demo/forged/asserted.tsv /tmp/oo-demo/forged/derivations.tsv
  199. ```
  200. ```json
  201. {"ok":false,"asserted":3,"derivations":3,"first_rejected":2,"rule":"rdfs9",
  202. "conclusion":"<http://example.org/myCup> <...#type> <http://example.org/Beer>",
  203. "premises":["<http://example.org/myCup> <...#type> <http://example.org/Coffee>",
  204. "<http://example.org/Coffee> <...#subClassOf> <http://example.org/Drink>"]}
  205. ```
  206. The exit code is 1. The output gives the number of the bad line. It names the
  207. rule. It also shows the premises, so that you can see that the premises do not
  208. support the conclusion.
  209. ### What the proof contains
  210. The proof is two tab-separated files. For the run above, the two files are 1.3 KB.
  211. `asserted.tsv` holds your claims:
  212. ```
  213. <ex:myCup> <rdf:type> <ex:Espresso>
  214. <ex:Coffee> <rdfs:subClassOf> <ex:Drink>
  215. <ex:Espresso> <rdfs:subClassOf> <ex:Coffee>
  216. ```
  217. `derivations.tsv` holds one line for each step. Each line gives the rule, then
  218. the conclusion, then the premises for that conclusion.
  219. ```
  220. rdfs9 <ex:myCup> <rdf:type> <ex:Coffee> <ex:myCup> <rdf:type> <ex:Espresso> <ex:Espresso> <rdfs:subClassOf> <ex:Coffee>
  221. rdfs11 <ex:Espresso> <rdfs:subClassOf> <ex:Drink> <ex:Espresso> <rdfs:subClassOf> <ex:Coffee> <ex:Coffee> <rdfs:subClassOf> <ex:Drink>
  222. rdfs9 <ex:myCup> <rdf:type> <ex:Drink> <ex:myCup> <rdf:type> <ex:Coffee> <ex:Coffee> <rdfs:subClassOf> <ex:Drink>
  223. ```
  224. That is the full proof. It needs no model, no network and no vendor.
  225. A checker reads each line. For each line, the checker derives the conclusion again
  226. from the premises of that line, under the rule that the line names. The checker
  227. then confirms that each premise is asserted, or that an **earlier** line concluded
  228. it. Anybody can write such a checker. This checker has a soundness theorem.
  229. ### Who checks the certificate, and when
  230. The certificate is a file. Thus the person who holds the file can check it, at
  231. any time that they choose.
  232. | Who | When | What they run |
  233. | --- | --- | --- |
  234. | You, in the loop | at each run, before you trust an answer | `lake exe oo-cert`, next to the reasoner |
  235. | A reviewer | when a change lands | the same command in CI, on the artefact that the run wrote |
  236. | An auditor, months later | long after the engine moved on | the same command, on the archived files |
  237. | A different agent | when it receives a claim from an agent that it does not trust | the same command, before it acts on the claim |
  238. The tool streams nothing, and the tool calls no home server. The engine and the
  239. checker share bytes on a disk, and they share no protocol. This is what makes the
  240. last two rows possible. An auditor who checks a claim next year needs the two
  241. files and a Lean build. That auditor does not need an instance of this software.
  242. The certificate records a digest of the assertions that the run used. The file
  243. `asserted.sha256` holds that digest, next to the two other files. A holder of a
  244. store runs `certificate-check <dir>`. The command reads the digest, computes the
  245. same digest from the store, and reports whether the two agree.
  246. That answer has a limit, and the command states the limit. A digest binds a
  247. certificate to bytes. It does not bind a certificate to a state of the world. A
  248. store that changed and then changed back gives the same answer. The type-level
  249. form of this work is [decision
  250. 0010](docs/decisions/0010-the-input-is-a-value-and-not-a-store.md), and that
  251. work is open.
  252. One case needs a word, because you will meet it. `reason` writes its inferences
  253. into the store by default. A check after such a run finds more triples in the
  254. store than the certificate lists. The report names that cause, and it does not
  255. call the store a different graph. It says *different graph* only when a triple
  256. in the store is not a conclusion of the run.
  257. Two defaults can cause you trouble. First, storage is in-memory, unless you set
  258. `OPEN_ONTOLOGIES_STORAGE_MODE=persistent`. Thus a `load` and then a `reason`
  259. starts from an empty store, and certifies nothing. The tool gives a warning, and
  260. you can miss that warning easily. Second, `--data-dir` is a flag and not an
  261. environment variable. Thus a demonstration without that flag writes into
  262. `~/.open-ontologies`, next to your real work.
  263. The discipline behind this work has a cost, and the discipline has earned that
  264. cost: [what the rules are, and what each rule caught](docs/decisions/).
  265. ## Three claims that used to travel on trust
  266. ![Three claims, each one checked against a real run](docs/assets/certified-claims.svg)
  267. A crosswalk states a match type. Nothing checked that statement. The engine now reasons over each side alone. It compares what each side entails, through the mapping itself. It then reports the tightest match type the evidence supports.
  268. An `exactMatch` that the entailments do not support comes back downgraded. The report gives the reason. It also names every term the crosswalk does not carry. That second list is the one that disappears from most crosswalk files. The output is valid SSSOM, so your tools read it today.
  269. The check compares where two terms sit in their hierarchies. It does not compare what the terms mean. Two sibling terms under one mapped parent look the same to it. So it can refute a match type, and it never makes a claim stronger. A parent that the mapping does not carry is a gap, and the report names it. A row with nothing to compare says so and is not certified.
  270. A second question is sharper than a downgrade. The engine carries the translated claims into the target and reasons again. A clash means the target denies what the mapping carried in. That is a disagreement, and a person must settle it. Run it with `crosswalk-probe`.
  271. Contexts can disagree. Birds fly. Penguins are birds, and penguins do not fly. One graph that holds both is inconsistent, and this engine finds the clash. Each module reasons alone instead. A fact earns "true everywhere" when k modules of n entail it.
  272. A number can now carry a certificate. `oo-matcert` recomputes a matrix product from the definition. It prints `MatCert.mul_of_check` when it accepts. Integers only, and that is the condition for the sentence to hold. Freivalds costs less and gives a probability, so it stays an opinion with its bound printed. Floating point reports a tolerance, because a proof over the real numbers says nothing about IEEE-754.
  273. ```bash
  274. open-ontologies batch plan.json # crosswalk-certify, crosswalk-probe, modules --threshold k, matcert
  275. open-ontologies crosswalk-probe source.ttl target.ttl mapping.tsv # exits 1 on a clash
  276. ```
  277. ## What the tool proves
  278. | You ask | You get back | Checked against |
  279. | --- | --- | --- |
  280. | Reason over OWL | A derivation certificate | `OOCert.certificate_sound` |
  281. | Reason with rules that you wrote | A certificate, and a different verdict word | `OOCert.horn_certificate_sound` |
  282. | Is this satisfiable | A finite model | `Dl.satisfiable_of_checkModel` |
  283. | Is the model of a solver real | The model, replayed | `Fol.satisfiable_of_check` |
  284. | Is this inconsistent | A refutation | `OOCert.refutation_sound` |
  285. | Does this data fit the shapes | A validation report | `Shacl.validate_spec` |
  286. | Does a retrieval slice still support the answer | Preservation for each claim | `OOCert.certificate_sound` |
  287. A retrieval slice with 99% coverage can lose the one triple that an answer needs. A slice with 60% coverage can keep each claim that
  288. matters. Coverage is a proxy, and the proxy rises as the slice grows.
  289. Thus a retriever that you tune on coverage learns to fetch more, and not to fetch
  290. the correct triples. Entailment preservation is the property that you want. The
  291. tool can decide that property here, and it gives one certificate for each claim.
  292. See [decision 0007](docs/decisions/0007-a-slice-preserves-a-conclusion-or-it-does-not.md).
  293. A measurement of the loss is the second-best answer. The best answer is a subset
  294. that can lose nothing. `onto_module_extract` computes such a subset. It computes a
  295. syntactic locality module over a signature. Each entailment of the full ontology
  296. over those terms is also an entailment of the subset.
  297. That guarantee is a theorem of Cuenca Grau, Horrocks, Kazakov and Sattler, JAIR 31
  298. (2008). The tool CITES that
  299. theorem, and no machine checks it here. No file under [lean/](lean/) is about
  300. locality, and the report says exactly that.
  301. The report names no theorem of this project. It offers a measurement instead. It
  302. reasons over the ontology and over the module to a fixpoint. It then reports each
  303. conclusion over the signature that the module does not reach. On the pizza
  304. ontology of this repository, the module is 238 of 1,345 axioms.
  305. The run lost zero conclusions out of 2,583 differences. `onto_conservative_check`
  306. uses the same machinery for the lifecycle. It answers one question: does the
  307. addition of these axioms change any consequence over the names that the ontology
  308. already used? See
  309. [decision 0011](docs/decisions/0011-a-module-carries-a-theorem-and-a-slice-carries-a-measurement.md).
  310. ## Install
  311. ```bash
  312. # macOS (Apple Silicon)
  313. curl -LO https://github.com/fabio-rovai/open-ontologies/releases/latest/download/open-ontologies-aarch64-apple-darwin
  314. chmod +x open-ontologies-aarch64-apple-darwin && mv open-ontologies-aarch64-apple-darwin /usr/local/bin/open-ontologies
  315. # Linux (x86_64)
  316. curl -LO https://github.com/fabio-rovai/open-ontologies/releases/latest/download/open-ontologies-x86_64-unknown-linux-gnu
  317. chmod +x open-ontologies-x86_64-unknown-linux-gnu && mv open-ontologies-x86_64-unknown-linux-gnu /usr/local/bin/open-ontologies
  318. # Docker
  319. docker pull ghcr.io/fabio-rovai/open-ontologies:latest
  320. # From source (Rust 1.89+)
  321. cargo build --release --features embeddings,plugins,sql
  322. ```
  323. For Intel macOS, for native Windows and for other systems, read
  324. [docs/quickstart.md](docs/quickstart.md) and [docs/windows.md](docs/windows.md).
  325. The Docker image is for linux/amd64 only, so on Apple silicon run it under
  326. emulation with
  327. `docker run --rm -i --platform linux/amd64 ghcr.io/fabio-rovai/open-ontologies:latest`.
  328. The `serve` command starts an MCP server. That server speaks JSON-RPC on stdin and
  329. stdout. Thus, at start, the server looks as if it stopped, while it waits for a
  330. client. This behaviour is correct. From a terminal, use the CLI subcommands
  331. instead, for example `open-ontologies validate <file.ttl>`.
  332. ## Connect the tool to Claude
  333. For Claude Code, add this block to `~/.claude/settings.json`. For Claude Desktop,
  334. add the block to `~/Library/Application Support/Claude/claude_desktop_config.json`:
  335. ```json
  336. {
  337. "mcpServers": {
  338. "open-ontologies": {
  339. "command": "/path/to/open-ontologies",
  340. "args": ["serve"]
  341. }
  342. }
  343. }
  344. ```
  345. Start the client again, and the `onto_*` tools are available. For Cursor, for
  346. Windsurf, for Zed and for VS Code, read [docs/quickstart.md](docs/quickstart.md).
  347. ## Stars
  348. <a href="https://star-history.com/#fabio-rovai/open-ontologies&Date">
  349. <img src="https://api.star-history.com/svg?repos=fabio-rovai/open-ontologies&type=Date" alt="Star history" width="600">
  350. </a>
  351. ## What the box contains
  352. **One loop:** `plan` a change, `apply` the change, watch for `drift`, `certify`
  353. what the engine derived, and `rollback` when the change was wrong. That loop is
  354. the whole of this front page, and that loop is the purpose of the tool.
  355. The other parts have their own documentation and their own code. They are
  356. alignment, embeddings, PDDL planning, clinical crosswalks, the plugin marketplace
  357. and CIVeX. [docs/tool-reference.md](docs/tool-reference.md) lists them one time,
  358. and this page does not list them. A large list of features is not the argument.
  359. Some tools need an optional Cargo feature, and they return an error without that
  360. feature. Four tools need `embeddings`. Two tools need `plugins`. Two tools need
  361. `postgres` or `duckdb`. The release binaries have `embeddings` and `plugins`, so
  362. they lack only the two tools that need `postgres` or `duckdb`. The GHCR image also
  363. has `sql`, which turns on `postgres` and `duckdb`, so it carries all eight tools.
  364. The Python package `open-ontologies-lite` also reasons now. It reasons in pure
  365. Python, and it needs no Rust toolchain. The same Lean binaries check its
  366. certificates. The package is a second engine. The lack of trust in that engine
  367. costs nothing, because the warrant was never in the engine.
  368. `tools/horn_differential.py` runs both engines and the Lean checker over each RDF
  369. document in the repository. **The two engines are not independent.** They run the
  370. same algorithm over the same rule table, and the comments in the Python cite the
  371. Rust by file and by line. Thus their agreement is strong evidence against a
  372. transcription error, and it is almost no evidence against a shared misreading of a
  373. W3C rule. The independent leg is the Lean checker. The tool prints that caveat
  374. next to its agreement count at each run.
  375. [docs/lean-certificates.md](docs/lean-certificates.md#known-limitations) also
  376. states the caveat as a limitation.
  377. With those parts, the repository holds a marketplace of 33 standard ontologies,
  378. clinical crosswalks, semantic embeddings and a lineage audit trail. It also holds
  379. a desktop Studio, with a virtualized ontology tree, an AI chat panel and an
  380. inspector in the style of Protégé. You need no JVM. You need no Protégé.
  381. ## Documentation
  382. | Topic | Link |
  383. | --- | --- |
  384. | Quickstart | [docs/quickstart.md](docs/quickstart.md) |
  385. | Architecture | [docs/architecture.md](docs/architecture.md) |
  386. | Derivation certificates and the Lean checkers | [docs/lean-certificates.md](docs/lean-certificates.md) |
  387. | Which axioms a conclusion rests on, and provenance semirings | [docs/explanation.md](docs/explanation.md) |
  388. | What the Lean proofs assume about the Rust | [docs/trusted-computing-base.md](docs/trusted-computing-base.md) |
  389. | Aeneas at the Rust and Lean boundary: what it proves, and what it costs | [docs/aeneas-boundary.md](docs/aeneas-boundary.md) |
  390. | Which gates a green CI tick ran | [docs/ci-gates.md](docs/ci-gates.md) |
  391. | First-order export, TPTP and Common Logic | [docs/first-order-export.md](docs/first-order-export.md) |
  392. | Each reasoning system, and why the project used or refused it | [docs/reasoning-systems-inventory.md](docs/reasoning-systems-inventory.md) |
  393. | Design decisions, one rule for each file | [docs/decisions/](docs/decisions/) |
  394. | SHIQ reasoning | [docs/reasoning.md](docs/reasoning.md) |
  395. | Schema alignment | [docs/alignment.md](docs/alignment.md) |
  396. | Data pipeline | [docs/data-pipeline.md](docs/data-pipeline.md) |
  397. | Ontology lifecycle | [docs/lifecycle.md](docs/lifecycle.md) |
  398. | Locality modules and conservative extensions | [docs/modules-and-conservativity.md](docs/modules-and-conservativity.md) |
  399. | Semantic embeddings | [docs/embeddings.md](docs/embeddings.md) |
  400. | Clinical crosswalks | [docs/clinical.md](docs/clinical.md) |
  401. | IES support | [ecosystem](docs/ies-ecosystem.md) · [alignment](docs/ies-alignment.md) · [SPARQL examples](docs/ies-examples.md) |
  402. | Benchmarks | [docs/benchmarks.md](docs/benchmarks.md) |
  403. | Determinism and corrected results | [docs/determinism.md](docs/determinism.md) |
  404. | Windows | [docs/windows.md](docs/windows.md) |
  405. | Contributing | [CONTRIBUTING.md](CONTRIBUTING.md) |
  406. ## Open Ontologies for teams
  407. The engine in this repository has an MIT licence, and it keeps that licence. The
  408. engine does not give you a place for the evidence. You need a place that keeps
  409. certificates. You need a review of each change to an ontology, before that change
  410. ships. You need an auditor who can check an answer again, months later, with no
  411. installation.
  412. We build [**tesseractsemantics.com**](https://tesseractsemantics.com) for that
  413. purpose. If a wrong answer from your ontologies has a cost, a conversation is
  414. worth your time.
  415. <p align="center">
  416. <a href="https://tesseractsemantics.com"><b>tesseractsemantics.com &rarr;</b></a>
  417. </p>
  418. ## Stack
  419. Rust edition 2024, one binary, no JVM. Oxigraph 0.5 for RDF and for SPARQL 1.1.
  420. `rmcp` for MCP over streamable HTTP. SQLite for state, for lineage and for
  421. feedback. Lean 4 v4.33.1 for the checkers, core Lean only, no Mathlib.
  422. Tauri 2, React 19 and Tailwind 4 for the Studio. The full table is in
  423. [docs/architecture.md](docs/architecture.md).
  424. ## Citation
  425. - **Open Ontologies: Tool-Augmented Ontology Engineering with Stable Matching Alignment.** Fabio
  426. Rovai, 2026. [arXiv:2605.09184](https://arxiv.org/abs/2605.09184)
  427. - **CIVeX: Causal Intervention Verification for Language Agents.** Fabio Rovai, 2026.
  428. [arXiv:2605.09168](https://arxiv.org/abs/2605.09168)
  429. [`CITATION.cff`](CITATION.cff) holds machine-readable metadata. It also operates
  430. the "Cite this repository" button of GitHub.
  431. ## Language of this page
  432. This page follows the writing rules of ASD-STE100 Simplified Technical English.
  433. The rules are one idea for each sentence, the active voice and simple tenses. A
  434. descriptive sentence has a maximum of 25 words. A paragraph has a maximum of 6
  435. sentences. The same term always keeps the same meaning.
  436. `tests/readme_simplified_english_test.rs` measures those rules. That test fails
  437. the build if this page breaks them. The same test holds the translated page to
  438. the structure of this one.
  439. The official STE dictionary of approved words is a licensed document, and this
  440. project does not hold a copy. Thus this page claims the writing rules only. It
  441. does not claim approved-word compliance. The technical names and technical verbs
  442. of this domain stay in use. Examples are *ontology*, *triple*, *reason* and
  443. *certify*. STE permits such terms for a technical domain.
  444. ## License
  445. MIT. [Fabio Rovai](https://github.com/fabio-rovai) maintains this project at
  446. [Tesseract Semantics](https://tesseractsemantics.com). If this project is useful
  447. to you, you can support it through
  448. [GitHub Sponsors](https://github.com/sponsors/fabio-rovai).

Version history

  • v2.1.011/5/2026

  • v0.1.010/24/2026

Ratings and comments

Sign in to rate this skill.

Sign in

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