DKSE: Automated Extraction of Structured Domain Ontologies from Software Requirement Documents via Large Language Models
This paper presents DKSE, a Rust-based tool that leverages large language models to automatically convert unstructured software requirement documents from the Chinese banking sector into machine-readable, provenance-tracked ontologies, demonstrating high accuracy and practical utility for downstream tasks like test generation and knowledge graph construction.
Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you are walking into a massive, ancient library where every single book is written in a language that only humans can understand. You can read the stories, the rules, and the instructions, but if you try to ask a robot to find a specific fact, build a new machine based on those instructions, or check if a rule was followed, the robot just stares blankly. It sees paragraphs of text, not the structured data it needs to work its magic. This is the daily reality for the world of software engineering. For decades, the "source code" of how businesses run—their requirements, rules, and processes—has been locked inside unstructured documents like Word files and PDFs. While Artificial Intelligence has gotten incredibly good at reading and writing code, it has struggled to understand the messy, natural-language documents that tell it what to build in the first place. The big question has been: How do we turn these human stories into a format that machines can actually use to think, build, and verify?
Enter DKSE (Domain Knowledge Structuring Engine), a new tool that acts like a super-powered translator and librarian. Think of it as a magical scanner that doesn't just read a requirement document; it understands the story inside it and instantly rewrites it into a perfectly organized, machine-readable blueprint. Instead of leaving the information as a wall of text, DKSE breaks it down into six specific, useful categories: Entities (the characters in the story, like "Customer" or "Account"), Relations (how they connect, like "Customer owns Account"), Rules (the laws of the universe, like "If balance is low, block transaction"), Processes (the step-by-step dances, like "How to approve a loan"), APIs (the doors and windows for data to enter or leave), and Dictionaries (the official lists of allowed words and codes).
The researchers tested this tool on a massive pile of real-world banking documents—about 800,000 Chinese characters worth of complex financial rules. The result was impressive: DKSE automatically pulled out 3,439 distinct pieces of structured knowledge, including over 1,200 rules and nearly 600 data interfaces. When human experts checked the work, they found it was 96% accurate, with zero "hallucinations" (where an AI makes things up). But the real magic isn't just the extraction; it's what happens next. Because the information is now structured, the team used it to instantly generate 1,214 test questions to check other AI models, built a massive training dataset of about 2 million tokens to teach new AI brains, and even fed it into a knowledge graph system to help computers retrieve precise facts without making things up. The paper presents this as a successful proof-of-concept specifically for the banking industry, showing that we can finally turn those dusty requirement documents into the living, breathing "brain" that drives modern software development.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.