Open Source Project #186: Open Ontologies — Rust MCP Server for AI-Native Ontology Engineering, 70+ Tools, Single Binary, No JVM, Builds in 5 Minutes What Takes 4 Hours in Protégé

Introduction

"The Pizza ontology is the classic exercise for learning OWL. Doing it by hand in Protégé takes about four hours. With this MCP server, an AI agent gets 96% coverage in five minutes."

This is article #186 in the "One Open Source Project a Day" series. Today's project is Open Ontologies — a Rust MCP server from The Tesseract Academy (UK) that packages the full ontology engineering toolchain as callable tools for AI agents.

Article #183 covered Microsoft's Ontology Playground — a learning tool for understanding what ontologies are and how to design them. Open Ontologies targets a different scenario: you already know what ontologies are, and you need an AI agent to build production-grade OWL ontologies while handling validation, reasoning, alignment, and governance in a complete engineering pipeline.

Single binary. No JVM (Protégé needs Java). Connects to Claude Code, Claude Desktop, Cursor, or any MCP-compatible client. 341 Stars. MIT license.

What You'll Learn

• How Open Ontologies and Ontology Playground differ: production engineering vs. learning
• Three-layer architecture: what Dynamics, Causal, and Planner each do
• The 70+ MCP tools, categorized and explained
• Studio desktop app: building ontologies via AI chat
• Benchmarks: Pizza ontology, OAEI alignment, consistency check performance
• IES framework and UK National Digital Twin Programme support

Prerequisites

• Basic ontology concepts (classes, properties, OWL) — see #183 if you need to start there
• Experience connecting an MCP server to Claude Code or Claude Desktop
• No Rust knowledge needed

Background: The Ontology Toolchain Problem

Traditional ontology engineering runs on Protégé — a JVM-based desktop application that's been the field standard for decades. It's complete but has structural problems for modern AI workflows:

• JVM dependency: heavy install, slow startup
• No AI integration: no API, agents can't call it programmatically
• Weak governance: no version control, change management, or policy enforcement for production use
• Performance: HermiT reasoner hits 4,936 microseconds median latency for consistency checks

Open Ontologies rebuilds this toolchain in Rust with MCP: consistency checks drop to 0.3 microseconds median latency (16,000x faster), every feature exposed to AI agents via MCP protocol.

Three-Layer Architecture

Dynamics Layer: Atomic Operations + OWL-RL Reasoning

The foundation is Oxigraph, a pure-Rust SPARQL 1.1 engine used as the triple store. Built on top:

• ActionSchema: four core MCP tools with concurrent atomic operation support
• Causal rules: preconditions and postconditions for ontology actions
• OWL-RL closure: automatic reasoning closure computation after ontology changes

Causal Layer: Causal Identification

The onto_certify_action tool, with optional PyWhy backdoor identification (enabled via the causal-pywhy feature flag).

In healthcare, finance, and other regulated domains, causal relationships in ontologies require formal verification — this layer handles that.

Planner Layer: PDDL Compilation + Plan Validation

Compiles ontology operation sequences into PDDL (Planning Domain Definition Language), calls the Fast Downward planner, validates the change plan in a sandbox, then applies it to the live ontology.

70+ MCP Tools

AI agents call these via the MCP protocol. Grouped by function:

Core Operations

validate        Validate OWL ontology structural correctness
load / save     Load and save ontology files
query           SPARQL queries
diff            Compare two ontology versions
lint            Style and convention checking

Reasoning

reason          Run OWL-RL reasoning, expand implied triples
dl_explain      Explain the derivation path for a reasoning conclusion
dl_check        Consistency checking
classify_el     EL reasoner classification (lightweight, very fast)

Alignment

align           Class alignment between two ontologies
align_fuzzy     Fuzzy alignment (handles naming inconsistencies)
align_flora     Flora algorithm-based alignment
eval_alignment  Evaluate alignment quality (precision/recall/F1)

Lifecycle Governance

plan      Generate ontology change plan
apply     Apply a validated change plan
lock      Lock the ontology (prevent accidental modification)
drift     Detect how far the ontology has deviated from a baseline
enforce   Enforce policy constraints
monitor   Continuous ontology state monitoring

Policy Management (Terraform-style)

policy_register   Register governance policies
policy_list       List all active policies
policy_check      Check whether the ontology violates any policy

RAG Augmentation

segment_retrieve              TBox slice retrieval for ontology-driven RAG
graph_projection_lossy_check  Graph projection loss analysis
eval_rag / eval_rag_mmrag     RAG pipeline quality evaluation

Studio Desktop App

Built with Tauri 2. Three-process architecture:

Tauri shell (native window)
    ↓
Rust engine sidecar (localhost:8080)   ← core compute
    ↕
Node.js agent sidecar (MCP connection) ← Claude Opus 4.8

AI Chat Panel

Two build modes:

• /build: 13-step deep build pipeline generating IES-grade production ontologies
• /sketch: 3-step rapid prototype, initial structure in minutes

Virtualized Tree View

Renders ontologies with 1,500+ classes without lag — only visible DOM nodes are rendered, everything else stays virtualized. Protégé slows noticeably on large ontologies.

Lineage Panel

Full audit trail backed by SQLite: every ontology change recorded — who changed what, when.

Benchmarks

Pizza Ontology Construction

The Pizza ontology is the classic OWL learning exercise: 99 classes, several properties, named pizza definitions.

OntoAxiom: LLM Axiom Identification

This benchmark tests how well LLMs identify ontology axiom types — and in the process uncovered an error in the original paper:

The original paper reported "raw OWL files perform worse than name lists" — rerunning revealed that conclusion was an artifact of inconsistent scoring. Unified scoring reverses it entirely.

OAEI Anatomy Track Alignment (2025)

OAEI is the standard evaluation benchmark for ontology alignment:

High precision, lower recall: the matches it commits to are right, but coverage is incomplete.

Consistency Checking vs. HermiT

Ontology Marketplace: 33 Standard Ontologies

The built-in onto_marketplace command installs verified standard ontologies:

# IES Digital Twin Framework (UK NDTP)
onto_marketplace install ies-top   # Foundation layer, ~22 classes
onto_marketplace install ies-core  # Core layer, ~131 classes
onto_marketplace install ies       # Full, 511 classes, 206 properties
 
# Web standards
onto_marketplace install schema-org  # 1,032 classes, OWL-RL adds 14,236 triples
onto_marketplace install foaf
onto_marketplace install skos
onto_marketplace install prov-o
 
# Geospatial / temporal
onto_marketplace install geosparql
onto_marketplace install owl-time
 
# Finance
onto_marketplace install fibo

IES and the UK National Digital Twin Programme

IES (Information Exchange Standard) is the ontology framework for the UK National Digital Twin Programme (NDTP), describing the semantic information of buildings, infrastructure, and assets.

Open Ontologies implements IES more completely than the official NDTP tooling:

EPC (Energy Performance Certificate) is the UK building energy rating system. 100% column coverage means the tool is directly usable in UK building digital twin pipelines.

Connecting to MCP Clients

{
  "mcpServers": {
    "open-ontologies": {
      "command": "/path/to/open-ontologies",
      "args": ["serve"]
    }
  }
}

Works with Claude Code, Claude Desktop, Cursor, Windsurf, and any MCP-compatible tool.

Once connected, you can tell Claude Code: "Build a retail ontology with Product, Order, and Customer as core classes." The agent calls the tools to build, validate, run reasoning, and export — the full pipeline without manual steps.

Open Ontologies vs. Ontology Playground

Decision logic:

• New to ontology, want to understand the concepts → #183 Ontology Playground
• Already understand ontology, need an AI agent to build production ontologies → Open Ontologies

Project Links

• GitHub: fabio-rovai/open-ontologies
• Paper: arXiv:2605.09184 — Tool-augmented ontology engineering and stable matching alignment
• Causal paper: arXiv:2605.09168 — Causal intervention verification for language agents
• Publisher: The Tesseract Academy (Kampakis and Co Ltd, UK)

Summary

Open Ontologies addresses a specific gap: ontology engineering has always had a toolchain problem. Protégé is complete but was designed before AI agents existed — no API, JVM-dependent, not built for programmatic integration.

Rust + MCP turns the full ontology engineering toolchain into AI-callable tools. Five minutes to a Pizza ontology, 0.960 precision on OAEI, 3.1 million consistency checks per second — the benchmarks show this is engineered seriously, not a proof of concept.

Read alongside Ontology Playground, the two projects describe the two ends of the ontology toolchain: one lowers the entry barrier, the other raises the production ceiling.

Explore PrimeSkills — A marketplace for handpicked AI Agents and skills. Each is validated in real enterprise workflows, stripping away hype and keeping only what truly works.

Welcome to my Homepage for more useful insights and interesting products.