OntoExtend: A Framework for Requirement-driven and Scalable Ontology Extension with LLMs

Technical Summary: OntoExtend: A Framework for Requirement-driven and Scalable Ontology Extension with LLMs

Problem Statement
Ontology extension—the process of enriching an existing ontology to satisfy emerging functional requirements—is traditionally a resource-intensive and error-prone task. While Large Language Models (LLMs) have demonstrated promise in generating ontologies from scratch, current approaches rarely explicitly tie extension tasks to specific requirements or reusable core models. Furthermore, existing methods often lack systematic evaluation of LLM outputs. A significant technical challenge arises from the scale of input ontologies; they frequently contain hundreds of classes and properties that exceed the context window limitations of current LLMs. Even when ontologies fit within large context windows, LLMs may be misled by irrelevant details, producing off-target or inconsistent outputs. There is a gap in the literature regarding how LLMs can extend mature input ontologies by reusing existing elements while modeling additional requirements provided as Competency Questions (CQs).

Methodology: The OntoExtend Framework
The authors propose OntoExtend, a retrieval-augmented generation (RAG) framework designed to extend ontologies based on new requirements. The system operates through three primary subsystems:

1. Ontology Retriever: To address context limitations, this module constructs a semantic index of the input ontology. It parses OWL entities (classes, properties, annotations) and serializes them into pipe-delimited strings containing URIs, labels, comments, and structural relations (e.g., domain/range). These elements are embedded into dense vectors using a configurable sentence embedding model (specifically text-embedding-ada-002 in the main experiments) and stored in a FAISS index. When a user provides a CQ, it is embedded into the same vector space, and the retriever returns the top-k most relevant ontology elements. This ensures the generation is grounded in the existing terminology and modeling patterns.
2. Ontology Extender: This module assembles the prompt for the LLM. It groups retrieved elements by source, renders them as Turtle snippets, and constructs a unified prefix block to resolve namespace conflicts. Crucially, the prompt includes the CQ and the retrieved context, along with specific modeling constraints (e.g., requiring SHACL shapes for industrial use or OWL restrictions for EU-project use). The LLM generates a candidate TBox fragment. A two-stage validator checks for syntactic correctness (Turtle parser) and adherence to modeling conventions (e.g., explicit domain/range declarations).
3. Ontology Integrator: This module incorporates the validated fragment into the input ontology. It performs deduplication (removing repeated axioms, classes, and prefixes) and concatenates the cleaned fragment. Optionally, generated fragments can be re-indexed to serve as context for subsequent CQs, though this was disabled in the evaluation to ensure independent assessment.

Experimental Setup
The framework was evaluated on two real-world use cases:

• Onto-DESIDE: A public EU-project ontology network focusing on circular economy data interoperability (20 CQs).
• Bosch Industrial Ontology: An internal ontology following a manufacturing profile (19 CQs).

The dataset was created by systematically removing classes and properties from the original ontologies and formulating CQs to probe these missing components. The study compared retrieval configurations (embedding models and text separators) and LLMs (o1-preview and GPT-5). Evaluation metrics included structural validity (OOPS! pitfall scanner, Pellet reasoner, syntax checking), functional adequacy (CQ verification via SPARQL, counting superfluous elements), and a user-based survey by six ontology engineers rating Correctness and Completeness on a 5-point Likert scale.

Key Results

• Structural Quality: Generated fragments exhibited almost no syntax errors. Integration with OOPS! revealed that OntoExtend introduced very few new modeling pitfalls compared to existing work, which often reports critical or important pitfalls. Minor issues (e.g., missing annotations in the industrial case due to input style replication) were observed but were straightforward to fix.
• Functional Adequacy: Both LLMs achieved 100% CQ verification, meaning all generated extensions correctly modeled the requirements. The rate of superfluous elements (unnecessary classes or properties) was extremely low (<2%), a significant improvement over previous studies reporting ~30%.
• Human Evaluation: Ontology engineers rated the fragments highly. For the industrial ontology, fragments required only minor to no changes (Mean Completeness ~4.5). For the EU-project, scores were slightly lower (Mean Completeness ~3.1), attributed to the open-ended nature of the CQs which required more modeling decisions from the tool. Engineers noted that while the output was generally syntactically and semantically correct, it sometimes required moderate revision regarding naming conventions, domain/range declarations, or linking to existing elements.

Significance and Claims
The paper claims that OntoExtend offers a practically useful level of automation for real-world ontology extension. Its primary significance lies in shifting the ontology engineer's role from manual axiom authoring to reviewing and lightly editing drafts, thereby lowering the barrier to entry for domain experts. The authors posit that OntoExtend functions effectively as a "drafting assistant" that is sensitive to the specificity of the input CQs and the modeling profile.

The study further suggests that LLM performance can serve as a proxy indicator for the quality of requirements and ontological artifacts; when CQs are precise and well-structured, the resulting extensions are of higher quality with fewer modeling errors. Conversely, ambiguity in requirements leads to lower scores, highlighting that the framework's success is dependent on the quality of the input specifications. The authors conclude that while the framework is effective for precise requirements, it remains sensitive to the formulation of the input CQs and requires human oversight for integration.