AutoOntic: Automatic Ontology Induction from Text for Knowledge Graph Construction

Alla Chepurova, Aydar Bulatov, Mikhail Burtsev, Yuri KuratovarXiv 2026 · arXiv

TL;DR

AutoOntic is a novel pipeline that automatically induces structured, hierarchical ontologies directly from raw text, moving beyond the "flat" knowledge graphs (KGs) typically produced by LLMs. By combining corpus-based statistical measures with LLM-adjudicated hierarchy checks, it creates KGs that are more semantically rich and achieve significantly higher retrieval accuracy for complex, multi-hop questions.

What Problem Does This Paper Address?

Graph-based Retrieval-Augmented Generation (GraphRAG) is a powerful tool for answering complex questions by connecting evidence across multiple documents. However, its effectiveness is bottlenecked by the quality of the underlying Knowledge Graph.

Most current "schema-free" extraction methods produce flat graphs: they identify entities and relations but lack a type hierarchy (e.g., knowing a documentary is a kind of film) and domain/range constraints (e.g., knowing the "director" relation should connect a person to a creative work). Without this structure, KGs suffer from poor entity deduplication and lack the semantic organization needed for high-precision retrieval. While manual ontologies exist, they are expensive to build and often fail to capture the specific vocabulary of a new, niche corpus.

Methods

The AutoOntic pipeline consists of six ordered stages designed to turn unstructured text into a canonicalized, typed KG:

  1. Typed Triplet Extraction: An LLM extracts raw (subject, relation, object) triplets, including initial free-text types and qualifiers.
  2. Relation & Type Canonicalization: Surface forms are clustered using embeddings and then verified by an LLM to merge synonyms while keeping distinct concepts separate.
  3. Hierarchy Induction: This is the core innovation. AutoOntic builds a single-parent "is-a" hierarchy. It uses a statistical measure called Weeds precision to rank types by generality (the "distributional inclusion principle"). It then performs a top-down traversal where an LLM makes local parent/child decisions. Crucially, the system can retroactively "repair" the hierarchy if a newly inserted type provides a more specific fit for existing nodes.
  4. Entity Canonicalization: The induced hierarchy acts as a "symbolic gate," preventing the system from merging entities with the same name but incompatible types (e.g., Paris the city vs. Paris the person).
  5. Constraint Induction: The system mines domain and range constraints for every relation by finding the Lowest Common Ancestor (LCA) of the types it connects in the hierarchy.
Figure 1: The AutoOntic pipeline. A schema-free LLM extractor (§2.1) produces a collection G of raw triplets g = (s, ts, r, o, to, Q). Their relation and type labels are canonicalized into a relation vocabulary R∗(§2.2) and a type vocabulary T ∗(§2.3) organized into a single- parent is-a hierarchy H∗(§2.4). Entity mentions are then deduplicated using that hierarchy as a symbolic gate (§2.5), and domain/range constraints are mined by re-resolving G against R∗, T ∗, and H∗(§2.6). Colored dashed arrows mark additional direct inputs beyond the sequential chain.

Datasets

The authors evaluated AutoOntic using two primary benchmarks:

  • Text2KGBench: Specifically the Wikidata-TekGen and DBpedia-WebNLG subsets. This was used for intrinsic evaluation to see how well the induced ontology aligns with human-curated reference ontologies.
  • MINE-1: A benchmark consisting of 100 essays and 1,500 factual queries, used to measure "information retention"—how much of the original text's meaning is preserved and retrievable from the constructed KG.

Key Insights and Ideas

  • Generality Ranking: By using Weeds precision, the system identifies that a "more general" type (like Animal) appears in a broader range of relational contexts than a "specific" type (like Golden Retriever), allowing for a logical top-down construction of the hierarchy.
  • LLM as a Local Judge: Instead of asking an LLM to organize a thousand types at once, AutoOntic breaks the problem into small, binary parent/child checks. This reduces context window issues and improves accuracy.
  • Dynamic Hierarchy Repair: The induction algorithm (shown in Figure 2) isn't just additive; it's corrective. If the system finds a new type that is a better parent for an existing node, it reparents that node automatically.
  • Granularity vs. Error: The evaluation revealed that most "mismatches" with gold-standard ontologies weren't outright errors, but rather differences in granularity (e.g., the system induced a type that was slightly broader or narrower than the reference).
Figure 2: Hierarchy induction algorithm. Canonical types in T ∗are processed in descending order of a generality score based on Weeds precision over their relation-argument profiles. Starting from the roots of H∗, an LLM first checks whether an existing candidate is a parent of the current type t ∈T ∗. Synonymous types are merged; otherwise, a parent match continues traversal through that candidate’s children. If no parent is found, a separate child check identifies existing can- didates to attach beneath t. If no match is found, t is added as a sibling at the current level. When the num- ber of nodes at a level exceeds threshold B, an LLM consolidates related siblings under a synthesized parent, limiting the context required for subsequent placement decisions. The procedure repeats until all types have been processed.

Key Results

AutoOntic demonstrated strong performance across both intrinsic and extrinsic metrics:

  • Semantic Alignment: On Text2KGBench, over 90% of the induced types were semantically aligned with reference classes. About half were exact matches, while the rest were mostly granularity differences (see Figure 3).
  • Retrieval Accuracy: On the MINE-1 benchmark, AutoOntic achieved 85.87% information-retention accuracy. When "seeded" with a few Wikidata classes, this rose to 88.00%, outperforming existing state-of-the-art methods like KGGen (82.37%) and Wikontic (82.93%) (see Figure 4).

Table 1: Per-triplet type match and Constraint plausibility Table 2: MINE-1 information retention scores

Limitations and Future Work

The authors acknowledge several areas for further exploration:

  • Extraction Precision: The current evaluation focuses on recall (recovering facts from a reference) and retrieval, but does not directly measure the precision of new facts extracted by the schema-free pipeline.
  • Language Support: The study was limited to English-language corpora; testing generalization to other languages remains a future task.
  • LLM Bias: The evaluation relies heavily on LLM-based judging, which may carry its own inherent biases regarding semantic similarity and hierarchy.

Summary updated

Abstract

Graph-based retrieval-augmented generation depends on the quality of the knowledge graph (KG) it retrieves over, yet schema-free LLM-based extraction pipelines typically produce flat graphs: deduplicated entities and relations with no type hierarchy and no domain/range constraints. We present AutoOntic, a pipeline that automatically constructs an ontology from text by canonicalizing open-vocabulary entity types and relations, inducing a hierarchy over the canonicalized types, and mining relation-level domain and range constraints. Its hierarchy induction procedure prioritizes types using corpus-derived relation-argument profiles and places them through local, LLM-adjudicated parent/child checks, allowing newly inserted types to trigger reassignment of existing parent-child links. The resulting hierarchy constrains entity deduplication and supports the induction of relation-level domain/range constraints. For intrinsic evaluation, we introduce a reference-based protocol that classifies induced ontology types as exact, broader, narrower, or unrelated to reference domain and range classes. On the Wikidata-TekGen and DBpedia-WebNLG subsets of Text2KGBench, over 90% of AutoOntic's induced endpoint types are semantically aligned with the reference classes across two LLM backbones: about half match exactly, while most remaining differences concern granularity. On MINE, knowledge graphs organized using an ontology built by AutoOntic achieve 88% retrieval accuracy. AutoOntic is available at https://github.com/screemix/AutoOntic.
BibTeX
@misc{chepurova2026autoontic,
  author = {Alla Chepurova and Aydar Bulatov and Mikhail Burtsev and Yuri Kuratov},
  title = {{AutoOntic: Automatic Ontology Induction from Text for Knowledge Graph Construction}},
  year = {2026},
  eprint = {2611.15467},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.15467},
}
Figure