KnowledgeGraph Explorer: Exploring the SimpleModeling Knowledge Graph
This article introduces the prototype version of the KnowledgeGraph Explorer, a tool designed to visualize the knowledge contained in the content published on SimpleModeling.org.
KnowledgeGraph Explorer
The web content provided by SimpleModeling.org as a Body of Knowledge (BoK) becomes explicit knowledge shared between humans and AI.
Humans read HTML documents, but a key question is how to convey this knowledge effectively to AI systems.
SimpleModeling.org describes its BoK as a knowledge graph using RDF (JSON-LD, Turtle), a knowledge representation format that AI can directly interpret.
By consuming this knowledge graph, AI systems can understand explicit knowledge with significantly higher accuracy.
The tool used to visualize the RDF-based knowledge structure is the KnowledgeGraph Explorer.
Knowledge Graph
A knowledge graph is a graph-structured knowledge base that represents real-world entities, concepts, and events as nodes, and the relationships among them as edges. By connecting these nodes with semantically meaningful links (vocabularies), both humans and computers can more easily search, associate, reason over, and visualize knowledge across domains.
RDF is a standard data-modeling framework for describing knowledge graphs, originally recommended by the W3C in 2004 and revised as RDF 1.1 in 2014. It expresses all information as “subject–predicate–object” triples, enabling semantic connections among any resources on the Web.
JSON-LD is an official RDF 1.1 serialization format, allowing semantic data to be expressed in a JSON structure familiar to web developers, making it essential for web-based BoKs such as SimpleModeling.org.
RDF is a core technology of the Semantic Web, which aims to treat the entire Web as a single, interconnected knowledge base. It forms the foundation for sharing SmartDox and SimpleModeling content as explicit knowledge interpretable by AI.
In SimpleModeling, the vocabularies used to describe knowledge are referred to as knowledge vocabularies.
When constructing a BoK with SmartDox, the following knowledge vocabularies are used.
-
Standard knowledge vocabulary
-
SimpleModeling knowledge vocabulary
Standard knowledge vocabulary
Standard knowledge vocabularies are the foundational vocabularies provided by the RDF ecosystem. In SimpleModeling, the following vocabularies are treated as standard knowledge vocabularies.
- RDF
-
The most fundamental meta-model for expressing data as subject–predicate–object triples, providing the basic structure for resource identifiers, predicates, and literals.
- RDFS
-
A vocabulary defining “lightweight semantics,” such as classes, properties, and hierarchical relations (subClassOf / subPropertyOf), giving RDF its basic semantic structure.
- OWL
-
A vocabulary enabling richer “logical semantics,” allowing strict modeling of constraints, inference, equivalence, and classification.
- SKOS
-
A vocabulary for describing concept systems, thesauri, and classification schemes. It standardizes broader/narrower relations, alternative labels, and label management, making it ideal for glossaries and BoK structuring.
- DCTERMS
-
A vocabulary standardizing metadata description—titles, creation dates, authors, subjects, coverage, licenses, and more—providing widely reusable metadata properties for documents, web pages, and data assets.
- Schema
-
A general-purpose vocabulary for sharing structured data across the Web, providing common types such as Article, Person, Event, and WebSite.
By describing information in the knowledge graph using standard vocabularies, it becomes accessible to general knowledge applications that do not know the SimpleModeling-specific vocabularies.
Basic Vocabularies
RDF, RDFS, and OWL form a three-layered architecture with clear role separation: RDF provides the “data structure,” RDFS provides “basic semantic classification,” and OWL enables “advanced logical inference.” This structure allows a knowledge graph to function not merely as a collection of links but as a semantically integrated body of knowledge.
Applied Vocabularies
While RDF, RDFS, and OWL form the foundational layers that support the “semantics of knowledge,” SKOS, DCTERMS, and Schema.org function as application-level vocabularies that support structured representations for specific purposes.
- SKOS
-
A vocabulary for describing concept schemes, handling hierarchical structuring, labeling, and synonym management of human-centered concepts such as glossaries, classification systems, and knowledge systems. Unlike OWL, it focuses on organizing and labeling knowledge rather than logical inference.
- DCTERMS
-
A vocabulary for describing document-level metadata—titles, authors, creation dates, subjects, licenses, and more—allowing SmartDox documents, articles, and external references to be managed in a consistent metadata structure.
- Schema.org
-
A widely used general-purpose schema for web-published documents, standardizing common Web structures such as Article, Person, Event, and WebSite. Its high compatibility with search engines makes it a “shared vocabulary of the Web” easily interpretable by external services and AI.
By combining these vocabularies on top of the RDF foundation, the knowledge graph of SimpleModeling.org becomes a multi-layered semantic knowledge space:
-
Semantics (RDF / RDFS / OWL)
-
Concept Schemes (SKOS)
-
Document Metadata (DCTERMS)
-
Web Structure (Schema.org)
This integration enables the system to operate as a multi-layered semantic knowledge space.
SimpleModeling Knowledge Vocabularies
SimpleModeling knowledge vocabularies are the vocabularies defined within the SimpleModeling framework.
By leveraging the SimpleModeling knowledge vocabularies, it becomes possible to build more precise knowledge-based applications and provide higher-quality knowledge to generative AI systems.
The following vocabularies are defined as part of the SimpleModeling knowledge vocabulary set.
- https://www.simplemodeling.org/ontology/simplemodelingorg#
-
The core vocabulary for SimpleModeling.org as a whole. It defines the central schema for site structure, including Article, GlossaryTerm, Category, and Site. Prefix: smorg.
- https://www.simplemodeling.org/bok/ontology/0.1-SNAPSHOT#
-
The vocabulary representing the SimpleModeling Body of Knowledge. It models BoK topics, knowledge areas, and reference relationships. Prefix: smbok.
- https://www.simplemodeling.org/category/ontology/0.1-SNAPSHOT#
-
The vocabulary for category classification (domains and themes). It provides models for category hierarchies associated with articles and glossary terms. Prefix: smcat.
- https://www.simplemodeling.org/docmodel/ontology/0.1-SNAPSHOT#
-
The vocabulary describing the structure of SmartDox documents, including documents, sections, paragraphs, figures, and code blocks. Prefix: smdoc.
- https://www.simplemodeling.org/glossary/ontology/0.1-SNAPSHOT#
-
The vocabulary representing glossary concepts, defining Term, Definition, Alias, and relations such as broader/narrower. Prefix: smglo.
- https://www.simplemodeling.org/bibliography/ontology/0.1-SNAPSHOT#
-
The vocabulary modeling bibliographic information (books, papers, URLs, etc.), including authors, publication year, publisher, ISBN, and citation relationships. Prefix: smbib.
- https://www.simplemodeling.org/project/ontology/0.1-SNAPSHOT#
-
The vocabulary describing projects associated with SimpleModeling (e.g., smart tools, research lines), defining project names, deliverables, and related components. Prefix: smproj.
- https://www.simplemodeling.org/simplemodel/ontology/0.1-SNAPSHOT#
-
The vocabulary expressing SimpleModeling “modeling elements” such as Entity, Value, Event, and Rule—forming the core schema for meta-level model structure. Prefix: smodel.
- https://www.simplemodeling.org/componentRepository/ontology/0.1-SNAPSHOT#
-
The vocabulary representing the component repository—a collection of reusable components—defining components, interfaces, and dependencies. Prefix: smcompr.
At present, SimpleModeling.org constructs its knowledge graph using smorg, smbok, smdoc, and smglo.
Why SimpleModeling Adopts RDF
SimpleModeling aims to integrate diverse forms of explicit knowledge—documents, models, terms, design knowledge, and process knowledge—and reconstruct them into a unified knowledge base that can be shared with AI. To achieve this, SimpleModeling adopts RDF as its foundational technology.
RDF is the technology that enables this integration with the highest level of semantic consistency, and therefore serves as a core component of SimpleModeling.
The reasons for adopting RDF are as follows:
-
It enables Literate Models to be transformed into machine-readable knowledge.
-
It aligns naturally with Web-based Bodies of Knowledge (BoKs).
-
It is the only standard that allows precise semantic sharing with AI.
-
It dramatically improves accuracy when integrated with RAG (Retrieval-Augmented Generation).
-
It can unify multiple knowledge systems, including SmartDox, CML, BoK, and process models.
-
Toward Semantic AI: RDF as the Future Standard
Converting Literate Models into Machine-Readable Knowledge
SmartDox constructs “Literate Models,” which integrate both narrative text and formal models.
RDF can formalize this content into the following structures:
-
Explicit concepts (Glossary Terms)
-
Document structures such as articles, chapters, and sections
-
Model elements (Entity, Value, Event, Rule, etc.)
-
Cross-references (mentions, refersTo)
This allows human-readable documents to be directly transformed into AI-ready knowledge resources.
High Affinity with Web-Based BoKs
SimpleModeling.org treats the Web itself as its Body of Knowledge (BoK).
RDF and JSON-LD align extremely well with Web-based BoKs for the following reasons:
-
JSON-LD is the standard structured-data format of the Web
-
It can be embedded directly into HTML
-
URLs naturally serve as resource identifiers
-
It simplifies the integration of distributed knowledge sources
The design philosophy of turning the entire Web into a massive knowledge graph aligns strongly with the architecture of SimpleModeling.
The Only Standard That Enables Precise Semantic Sharing with AI
Generative AI excels at understanding natural language text, but it is not good at reconstructing conceptual structures or relationships.
By using RDF, we can provide AI with:
-
Concept hierarchies (broader / narrower)
-
Model structures (Entity → Attribute)
-
Correspondence between articles and terms (article → mentions → term)
These can be provided to AI explicitly.
To convey “precise meaning” to AI, a structural knowledge representation such as RDF is indispensable.
High Compatibility with RAG (Retrieval-Augmented Generation)
-
semantic retrieval (meaning-based search)
-
graph expansion (automatic chaining: article → term → category …)
-
use of SmartDox section structure as an index
-
extraction of only the necessary knowledge (context packing)
These capabilities offer significant advantages.
Integration of Multiple Knowledge Systems (SmartDox / CML / BoK / Process Models)
The knowledge model of SimpleModeling is multi-layered:
RDF can integrate all of these into a single unified graph space.
Furthermore, by adopting RDF:
-
External open knowledge such as Wikipedia, Wikidata, and DBpedia
-
Bibliographic information for books, papers, and web resources (DOI, ISBN, CrossRef, etc.)
can be connected on the same graph, enabling the SimpleModeling knowledge system to link with global standard open knowledge spaces.
This enables:
-
Documents → Models → Terms → Design → Implementation
-
→ (External Knowledge) Wikipedia / Wikidata / Book and Paper Metadata
Thus, knowledge becomes linked across layers, allowing AI agents to semantically and horizontally integrate knowledge both inside and outside SimpleModeling.
By enabling access to large-scale external open knowledge, AI achieves significant improvements in recognition accuracy, answer coverage, and term disambiguation. The SimpleModeling BoK serves as the central hub for this integration.
Toward Semantic AI: RDF as the Future Standard
With the rapid evolution of generative AI, the importance of AI systems that consume “knowledge graphs with semantic structure” is increasing rapidly.
In fact, both industry and academia have already begun adopting “Graph × AI” approaches widely.
-
Google’s Knowledge Graph A large-scale knowledge graph behind web search(Google Knowledge Graph)
-
GraphRAG (Graph-based Retrieval-Augmented Generation)A technique that improves RAG accuracy using knowledge graphs(Microsoft: GraphRAG in Semantic Kernel,Document GraphRAG: Knowledge Graph Enhanced RAG)
-
Semantic / KG-enhanced LLM (Academic Research)A survey that systematizes approaches to integrating LLMs and knowledge graphs(Unifying LLMs and Knowledge Graphs)
-
Applications of KG × LLM (Medical Domain)Diagnostic-support research combining medical knowledge graphs and LLMs(KG + LLM (Nature Digital Medicine))
As these examples demonstrate, Semantic AI—built on knowledge graphs—is rapidly becoming mainstream, and adopting RDF as a foundation ensures strong alignment with future AI ecosystems.
SimpleModeling is moving ahead of this trend by organizing its Body of Knowledge (BoK) using RDF.
RDF Summary
SimpleModeling adopts RDF in order to transform Literate Models into knowledge that can be directly shared with AI, and RDF is the most consistent and standardized technology for achieving this.
RDF unifies:
into a single semantic space and provides AI with explicit, structured, and machine-readable knowledge.
RDF is an essential technology forming the foundation of knowledge-driven development that SimpleModeling aims to achieve.
Try the KnowledgeGraph Explorer
KnowledgeGraph Explorer is a simple JavaScript-based application.
You can launch it by clicking the link below.
You can open it from the menu via Lexicon → KnowledgeGraph on the top page or any category page.
Initial State
This is the initial screen displayed immediately after launching the application.
The interface consists of an operation bar at the top, a graph display area in the center, and a property display panel on the right.
Overview
Pressing the Load button loads the specified knowledge graph in JSON-LD or Turtle format and displays it on the screen.
When you click a node, its properties are shown in the property panel on the right.
Purpose of the KnowledgeGraph Explorer
SimpleModeling.org is a website designed to support Literate Model-Driven Development using SimpleModeling. The knowledge graph is used to share accurate information with generative AI.
Users of Literate Model-Driven Development do not need to know the internal structure of the knowledge graph, but understanding the mechanism for applying generative AI to the development process is beneficial.
When building a Body of Knowledge (BoK) for knowledge-driven development, it is useful to organize content with the knowledge graph in mind.
The more easily content can be structured as a knowledge graph, the more accurately generative AI can understand it, increasing its value as explicit knowledge shared between developers and AI.
For this reason, the ability to visualize the knowledge graphs of content published on SimpleModeling.org and within project-specific BoKs is essential.
Visualizing the knowledge graph provides the following benefits:
-
Domain structure becomes visible at a glance
-
Relationships between articles can be understood visually
-
Vocabulary drift becomes easier to detect
-
A “knowledge map” of the entire SimpleModeling.org ecosystem can be built
For these purposes, the KnowledgeGraph Explorer has been developed and provided.
Perspective
Knowledge graph development in SimpleModeling.org is not merely an experiment in visualization, but a foundational effort aimed at enabling knowledge-driven development.
The idea of treating documents, models, terminology, design knowledge, processes, and external knowledge as a unified space is expected to become essential in future development environments.
The greatest value of knowledge graphs lies in their role as a “knowledge interface” that allows AI and humans to share the same semantic structures and collaborate effectively in development.
Knowledge Graphs as a Foundation for Knowledge-Driven Development
Modern generative AI can infer information from text, but it is difficult for it to accurately reconstruct complex domain structures or modeling semantics solely from unstructured text.
In knowledge-driven development, the following elements are provided to AI as “structured knowledge”:
-
SmartDox (document knowledge)
-
CML / SimpleModel (model knowledge)
-
Glossary / Category (concept systems)
-
Bibliography (reference information)
RDF is what enables the integration of all these elements, and the KnowledgeGraph Explorer provides a visual interface to observe this integrated knowledge space.
Deeper Integration of GraphRAG and RDF
In text-centric RAG systems, it is difficult to pass hierarchical structures, dependencies, and semantic groupings of knowledge to AI, leading to limitations in retrieval accuracy and answer consistency.
By combining GraphRAG with RDF:
-
Semantic proximity between concepts
-
Automatic traversal of broader/narrower concepts
-
Relationships among model elements
-
SmartDox document structure
-
Integration with external knowledge (e.g., Wikidata)
can be passed to AI “as-is,” enabling:
AI to truly use knowledge in a meaningful way to support development.
Knowledge-driven development is directly connected to the foundations of Semantic AI.
SmartDox → RDF → Knowledge Applications: An Integrated Pipeline
In knowledge-driven development, writing documentation directly updates the knowledge system.
-
Write SmartDox
-
→ Converted into RDF
-
→ Integrated into the knowledge graph
-
→ Referenced by GraphRAG or MCP agents
-
→ AI assists with design, explanation, and code generation
forming a complete knowledge creation loop.
The KnowledgeGraph Explorer functions as the “visualization layer” of this knowledge loop.
Extensibility Through Integration with External Open Knowledge
By adopting an RDF-based foundation, the SimpleModeling knowledge system becomes capable of integrating with:
-
Wikipedia / Wikidata
-
DBpedia
-
CrossRef (DOI)
-
Academic papers and books (ISBN, publication metadata)
thus enabling integration with global open knowledge ecosystems.
As a result, knowledge-driven development evolves beyond depending solely on the internal understanding of developers, forming a reusable knowledge structure aligned with external global knowledge.
For AI systems, the ability to reference both internal and external knowledge significantly improves answer accuracy, explanatory completeness, and term disambiguation.
Foundation for the Future of Knowledge-Driven Development
In the future, software development is expected to shift from “writing code” to “building knowledge.”
SimpleModeling is gradually building the full stack required for that future:
By combining these layers, SimpleModeling aims to create a knowledge-centered development platform optimized for the AI era.
Within this broader ecosystem, the KnowledgeGraph Explorer is the first tool that allows users to interact with the system in a visible and tangible way.
Summary
Knowledge-driven development is a methodology that enables a new development cycle: “human knowledge → structuring → semantic enrichment → AI utilization → feedback into development.”
SimpleModeling.org integrates RDF, SmartDox, CML, GraphRAG, and Semantic AI to build a knowledge-centered development foundation for the AI era.
We invite you to try the KnowledgeGraph Explorer and experience how the knowledge within SimpleModeling.org is semantically structured.
References
Glossary
- KnowledgeGraph Explorer
-
An application that visualizes knowledge graphs generated from SimpleModeling.org’s RDF/JSON-LD/Turtle data, allowing exploration of articles, terms, categories, and semantic relationships.
- BoK (Body of Knowledge)
-
At SimpleModeling, the core knowledge system for contextual sharing is called the BoK (Body of Knowledge). The goal of building a BoK is to enable knowledge sharing, education, AI support, automation, and decision-making assistance.
- RDF
-
A W3C-standardized data model that represents information as subject–predicate–object triples.
- knowledge graph
-
A semantic graph-based knowledge base where nodes represent entities or concepts and edges represent their relationships.
- knowledge vocabulary
-
A vocabulary system used to structure knowledge and enable humans and AI to share concepts, relations, and attributes.
- standard knowledge vocabulary
-
Undefined
- SimpleModeling knowledge vocabulary
-
A vocabulary system defined uniquely by SimpleModeling to describe structures such as SmartDox, BoK, Glossary, Category, and SimpleModel.
- Component
-
A software construct that encapsulates well-defined responsibilities, contracts, and dependencies as a reusable and replaceable unit. In the logical model, it serves as an abstract structural unit; in the physical model, it corresponds to an implementation or deployment unit.
- literate model
-
A Literate Model is a “readable model” that integrates model structure with natural-language narrative (structured documentation). It extends the idea of literate programming into the modeling domain, unifying structure (model) and narrative (structured text) into a single intelligible artifact interpretable by both humans and AI. The concept of “Literate Modeling” has been explored previously by some researchers and developers, mostly as an approach to improve documentation or code comprehension. However, those attempts did not establish a systematic modeling methodology that integrates models, narrative, and AI assistance as a unified framework. The Literate Model is a modeling concept newly systematized and proposed by SimpleModeling for the AI era. Building upon the ideas of literate modeling, it redefines them as an intelligent modeling foundation that enables AI-collaborative knowledge circulation and model generation. It is not merely a modeling technique but a framework that embeds human reasoning and design intent as narrative within the model, enabling AI to analyze and reconstruct them to assist in design and generation.
- Retrieval-Augmented Generation (RAG)
-
A generation technique that supplements a language model’s internal (parametric) knowledge by retrieving relevant external information before generation. RAG systems first search knowledge sources such as databases or knowledge graphs and then use the retrieved context as input for text generation.
- CML (Cozy Modeling Language)
-
CML is a literate modeling language for describing Cozy models. It is designed as a domain-specific language (DSL) that forms the core of analysis modeling in SimpleModeling. CML allows model elements and their relationships to be described in a narrative style close to natural language, ensuring strong compatibility with AI support and automated generation. Literate models written in CML function as intermediate representations that can be transformed into design models, program code, or technical documentation.
- semantic ai
-
An approach in which AI systems leverage knowledge graphs (RDF/OWL) to understand, reason, and generate information while preserving semantic structures.
- Development Process
-
A development process is the entire set of activities involved in building, deploying, and maintaining software systems. It encompasses planning, modeling, implementation, testing, and delivery as a systematic flow of development activities.
- term disambiguation
-
The process of determining the exact concept (term) referred to when a word has multiple possible meanings, using context, knowledge graphs, and controlled vocabularies. Disambiguation is achieved through explicit identifiers (URIs) in RDF/OWL.
- Knowledge-Driven Development
-
A development paradigm that centers on knowledge, integrating AI assistance and modeling for continuous evolution.
- Literate Model-Driven Development (LMDD)
-
Literate Model–Driven Development (LMDD) is a software development methodology that integrates natural-language narrative and formal model structure within a unified text-based framework. It extends conventional Model–Driven Development (MDD) by treating documentation and models as a single, consistent source of truth. In LMDD, the descriptive and structural elements of development artifacts are expressed together using the SmartDox language. From this unified representation, ModelDox extracts structural data, CML (Cozy Modeling Language) defines domain-specific models, and Cozy generates executable code, documentation, and configuration artifacts. Artificial intelligence participates in the LMDD process by analyzing the narrative context, validating structural consistency, and supporting the refinement of models and generated artifacts. All artifacts are represented in text form, ensuring traceability, version control, and interoperability within standard development environments. By defining a formally connected and machine-interpretable relationship between documentation, design, and implementation, LMDD provides a foundation for AI-assisted model–driven engineering where human authorship and automated reasoning operate on the same representational layer.
- knowledge creation loop
-
A cyclical knowledge-updating process in the AI era, in which documents (SmartDox), models (CML/SimpleModel), vocabularies (Glossary/Category), and design knowledge (BoK) are integrated through RDF, enabling AI to reference, generate, and improve knowledge, which is then reflected back into documentation.