Integration between the Semantic Integration Engine and ChatGPT

SIE Startup

For the Semantic Integration Engine, use the one described in 📄 Semantic Integration Engine: A BoK Integration Demo for the AI Era. You can start it using Docker by following the same procedure.

ChatGPT Session Realization Method

Unfortunately, MCP registration has not yet been enabled for the author’s ChatGPT account. For this reason, this article is based on a simulated session conducted within the ChatGPT chat interface, with assistance from ChatGPT itself.

The simulated session is composed as follows.

The behavior on the ChatGPT side is based on explanations provided within the ChatGPT chat.
The behavior on the SIE side is realized by issuing, via the WebSocket protocol, the operations explained by ChatGPT to the SIE demo environment published using docker compose, and retrieving the responses.

As a result, we believe that this setup reproduces a session state that is as close as possible to an actual MCP-based connection.

Figure 1. Semantic Integration Engine Architecture

Initial Setup

In the initial setup of ChatGPT, you register the MCP server URL with ChatGPT.

Although this could not be tested in the author’s environment, the procedure presented by ChatGPT is summarized here.

In the SIE demo environment, McpWebSocketServer provides the following URL as the endpoint for the MCP WebSocket protocol.

ws://localhost:9050/mcp

Registering this URL with ChatGPT is sufficient.

Enter the following information in the ChatGPT settings.

Name: Semantic Integration Engine
URL: ws://localhost:9050/mcp

From this point onward, we will simulate how ChatGPT and the MCP server actually exchange messages during communication, using websocat.

Simulated Session

Communication between ChatGPT and MCP is performed over WebSocket using a ChatGPT-specific protocol that is similar to JSON-RPC.

In this article, we construct this simulated session using the websocat command.

The websocat command is launched as follows.

$ websocat ws://localhost:9050/mcp | jq .

By connecting the jq command in a pipeline after the websocat command, the output JSON is formatted for readability.

When the websocat command is started, it waits for input from standard input. When you enter JSON here, it is sent to SIE, and the execution result is returned as JSON.

Initialization

MCP initialization in ChatGPT is performed using the following two requests.ChatGPTでのMCPの初期化は以下の2つのリクエストで行われます。

initialize
get_manifest

initialize

Once MCP registration is completed in ChatGPT, it retrieves MCP initialization information using the following initialize request.

{"type":"initialize","protocolVersion":"1.0","client":{"name":"chatgpt","version":"1.0"}}

As a result of the input, the following response is returned.

{
  "type": "initialized",
  "protocolVersion": "1.0",
  "server": {
    "name": "semantic-integration-engine",
    "version": "0.0.4"
  },
  "capabilities": {
    "tools": {
      "enabled": true
    }
  },
  "version": null,
  "name": "semantic-integration-engine",
  "metadata": {
    "author": "SimpleModeling Team",
    "homepage": "https://www.simplemodeling.org"
  }
}

type: initialized

This indicates that the MCP session has been formally established.

protocolVersion: 1.0

This is the version of the MCP interaction protocol. It is not an API version, but the version of the conversational grammar (DSL).

server

The server field identifies the communication peer and its version.

  "server": {
    "name": "semantic-integration-engine",
    "version": "0.0.4"
  },

capability

The capability field declares that tools are available for use in this session.

  "capabilities": {
    "tools": {
      "enabled": true
    }
  },

This is the core of MCP: the presence of this declaration provides the basis for ChatGPT to decide, “then I should call tools/list.”

Meta Information

This section contains meta-information for MCP. For AI systems, this serves as a hint of background knowledge.

  "version": null,
  "name": "semantic-integration-engine",
  "metadata": {
    "author": "SimpleModeling Team",
    "homepage": "https://www.simplemodeling.org"
  }
}

get_manifest

After the initialize request, the following get_manifest request is used to retrieve the capabilities of MCP.

{"type":"get_manifest"}

As a result, the following JSON is returned from SIE.

{
  "type": "manifest",
  "manifest": {
    "schema_version": "v1",
    "name": "semantic-integration-engine",
    "version": "0.0.4",
    "description": "Semantic Integration Engine for SimpleModeling.org. Provides unified semantic search across SmartDox, RDF, SKOS, ontology graphs, and the SimpleModeling Knowledge Graph.",
    "interfaces": {
      "websocket": {
        "url": "ws://localhost:9050/mcp",
        "protocol": "mcp"
      }
    },
    "capabilities": {
      "tools": {
        "enabled": true
      }
    },
    "tools": [
      {
        "name": "tools.sie.query",
        "description": "Semantic search across SmartDox, RDF, ontology, and vector embeddings. Returns unified SemanticRAG results: concept matches, passages, summaries, and knowledge graph snippets.",
        "input_schema": {
          "type": "object",
          "properties": {
            "query": {
              "type": "string",
              "description": "Natural language query, glossary term, page title, or concept name. Example: 'What is SimpleModelObject?'"
            },
            "limit": {
              "type": "integer",
              "minimum": 1,
              "maximum": 20,
              "default": 5,
              "description": "Maximum number of passages to retrieve."
            },
            "include_graph": {
              "type": "boolean",
              "default": true,
              "description": "If true, include graph-neighborhood results for related concepts."
            }
          },
          "required": [
            "query"
          ]
        }
      },
      {
        "name": "tools.sie.explainConcept",
        "description": "Explain a single concept identified by its URI. Returns label, definitions, SKOS relations, and its local RDF neighborhood.",
        "input_schema": {
          "type": "object",
          "properties": {
            "uri": {
              "type": "string",
              "description": "Fully qualified concept URI. Example: 'https://www.simplemodeling.org/simplemodelingorg/ontology/0.1-SNAPSHOT#SimpleModelObject'"
            },
            "locale": {
              "type": "string",
              "description": "Optional locale for explanation (IETF BCP47). Example: 'en', 'ja'. Default is 'en'."
            }
          },
          "required": [
            "uri"
          ]
        }
      },
      {
        "name": "tools.sie.getNeighbors",
        "description": "Retrieve the local RDF/SKOS neighborhood of a concept: broader, narrower, related, domain-specific relationships, state-machine transitions, component relations, and more.",
        "input_schema": {
          "type": "object",
          "properties": {
            "uri": {
              "type": "string",
              "description": "Concept URI from the SimpleModeling Knowledge Graph."
            },
            "limit": {
              "type": "integer",
              "minimum": 1,
              "maximum": 50,
              "default": 20,
              "description": "Maximum number of neighbor nodes to return."
            }
          },
          "required": [
            "uri"
          ]
        }
      }
    ],
    "metadata": {
      "author": "SimpleModeling Team",
      "homepage": "https://www.simplemodeling.org",
      "license": "Apache-2.0",
      "description_long": "This MCP manifest describes the SimpleModeling Semantic Integration Engine (SIE), capable of hybrid semantic retrieval combining RDF, SKOS, SPARQL, ontology reasoning, SmartDox semantic index, and vector search. It provides a unified interface for ChatGPT-based knowledge exploration, conceptual explanation, and semantic graph traversal.",
      "description_long_ja": "本MCPマニフェストは、SimpleModeling Semantic Integration Engine (SIE) が提供する機能を ChatGPT に正しく伝えるための自己記述ファイルです。SIE は RDF・SKOS・SPARQL・オントロジー推論・SmartDox セマンティックインデックス・ベクトル検索を統合したハイブリッド検索を提供しており、本マニフェストにより ChatGPT はこれらの機能を理解し、適切なツール呼び出しを自律的に行えるようになります。SemanticRAG の構造や概念説明、近傍探索といった高度な知識処理を利用者に代わって実行するため、manifest の情報量は推論精度と操作性を大きく向上させます。",
      "keywords": [
        "SimpleModeling",
        "Semantic Search",
        "Knowledge Graph",
        "RDF",
        "SKOS",
        "SmartDox",
        "Ontology",
        "Semantic RAG",
        "MCP"
      ]
    },
    "protocolVersion": "1.0"
  }
}

This JSON is not merely a list of tools. It serves as a contract (a DSL definition) that allows ChatGPT to learn how it should use this server in order to reason.

ChatGPT determines its actions by reading the manifest.

interface

The interface field indicates the communication protocol.

"interfaces": {
  "websocket": {
    "url": "ws://localhost:9050/mcp",
    "protocol": "mcp"
  }
}

By examining this URL, ChatGPT understands that the endpoint is not a “pre-known API” like a typical REST interface.

tools

The tools section defines the following tools provided by SIE.

tools.sie.query: Query execution
tools.sie.explainConcept: Concept explanation
tools.sie.getNeighbors: Retrieval of neighboring information

Each tool defines the following properties.

name: The name of the tool
description: A description of the tool
input_schema: The schema of input parameters

From this information, ChatGPT understands each tool’s functionality and usage, and reasons about which tools can be used and how during its inference process.

While the tool name and input parameters are obviously important, the description field is also critically important because it directly informs ChatGPT’s decision-making.

The fact that the content of the description influences ChatGPT’s behavior is a fundamental difference from traditional program-oriented interfaces.

metadata

The metadata field provides meta-information for the entire MCP. Although it mainly consists of language-based descriptions, this information is critically important because ChatGPT understands these linguistic cues and uses them as part of its decision-making process when utilizing MCP.

Session Start

The session between ChatGPT and SIE (MCP) has now started.

Starting from the user’s question below, let us walk through how ChatGPT leverages SIE’s knowledge base to generate its response.

What is SimpleObject?

ChatGPT Processing

Here, we examine how ChatGPT processes the input “What is SimpleObject?” when it is entered via the ChatGPT console.

The following explanation is based on information provided by ChatGPT itself, and the actual session behavior is expected to be very similar.

ChatGPT Internal Analysis

ChatGPT makes the following judgments and decides to use SIE.

“SimpleObject” is a technical term specific to SimpleModeling.
SIE provides a complete set of Glossary, BoK, and SmartDox resources.
Therefore, external knowledge should be consulted.
→ MCP tools (sie.query or sie.explainConcept) should be invoked.

This decision is made autonomously within the ChatGPT model.

ChatGPT → MCP: Tool Invocation Decision and call_tool Message Generation

ChatGPT uses the tools.sie.query function provided by SIE (MCP).

{"type":"call","tool":{"name":"tools.sie.query","arguments":{"query":"SimpleModeling"}}}

As a result of the request, the following information related to the queried term is returned.

concepts: A list of related concepts.
passages: A list of related articles with descriptive text.
graph: The knowledge graph.

The graph (knowledge graph) contains a list of nodes that make up the knowledge graph in nodes, and a list of knowledge triples in edges.

{
  "type": "toolResult",
  "tool": "tools.sie.query",
  "result": {
    "concepts": [
      {
        "uri": "https://www.simplemodeling.org/glossary/knowledge-development/socialization",
        "label": "共同化",
        "lang": "en"
      },
      {
        "uri": "https://www.simplemodeling.org/glossary/development-process/alpha-state",
        "label": "アルファ状態",
        "lang": "en"
      },
      {
        "uri": "https://www.simplemodeling.org/glossary/development-process/activity",
        "label": "活動",
        "lang": "en"
      }
    ],
    "passages": [
      {
        "id": "https://www.simplemodeling.org/ja/glossary/development-process/kernel.html#chunk-0",
        "text": "カーネル 浅海 智晴 用語 カーネル 用語(英) Kernel 別名 - 定義 任意のソフトウェア開発活動を定義・理解するために必要最小限の概念を含むEssenceの中核要素群。アルファ、アクティビティスペース、能力などで構成される。 SimpleModeling SimpleModelingのメタ開発フレームワークを表現するための参照基盤を形成する。",
        "score": 0.8439708948135376
      },
      {
        "id": "https://www.simplemodeling.org/ja/glossary/development-process/simplemodeling-reference-profile.html#chunk-0",
        "text": "SimpleModelingリファレンス・プロファイル 浅海 智晴 用語 SimpleModelingリファレンス・プロファイル 用語(英) SimpleModeling Reference Profile 別名 - 略語 SMRP 定義 SimpleModelingのリファレンス・プロファイルです。 SimpleModelingによる文芸モデル駆動開発の説明を具体的にするために、リファレンス・プロファイルを定義しています。",
        "score": 0.8891597986221313
      },
      {
        "id": "https://www.simplemodeling.org/ja/glossary/knowledge-development/knowledge-promotion.html#chunk-0",
        "text": "知識昇格 浅海 智晴 用語 知識昇格 用語(英) Knowledge Promotion 別名 - 定義 BoKの構造化知識を再学習・ファインチューニングによりAIモデルのパラメトリック知識（PPK）へ恒久的に統合するプロセス。 SimpleModeling SimpleModelingにおける知識昇格は、文芸モデリング・知識体系化・モデル再学習を結ぶ知識生態系の持続的進化段階を意味する。",
        "score": 0.8909172415733337
      },
      {
        "id": "https://www.simplemodeling.org/en/domain-modeling/concept-analysis-design.html#chunk-1",
        "text": "ed with domain experts Establish it as a mechanism that can be implemented in software There are various options for modeling the problem domain, such as granularity and perspective, but it must fit within a structure that operates in software. Therefore, it is practical to proceed with modeling according to a predefined model framework template that works in software. Model Layers in SimpleModeling In SimpleModeling, domain models are implemented in the following three layers. Conceptual Model Analysis Model Design Model The diagram below shows the types of model elements used in the conceptual, analysis, and design models within SimpleModeling. Details will be explained in another article, but the types of model elements used increase dramatically as the level of concreteness rises from ",
        "score": 0.9439836144447327
      },
      {
        "id": "https://www.simplemodeling.org/en/domain-modeling/simple-object.html#chunk-0",
        "text": "SimpleObject ASAMI, Tomoharu Created: 2025-09-15 In the SimpleModeling Reference Profile, the abstract class SimpleEntity is defined as the base class for all entity objects. Except for special cases, all entity objects are expected to derive from SimpleEntity. SimpleEntity provides a comprehensive set of attributes commonly needed by entity objects, allowing designers to define entity objects by simply adding domain-specific attributes. SimpleObject is defined as the base class of SimpleEntity. SimpleObject is an abstract object in SimpleModeling that defines the common attributes of domain objects. Value objects can optionally use SimpleObject as their base class. SimpleObject is composed by delegating various generic attribute groups, each of which can also be reused individually as com",
        "score": 0.9511008262634277
      }
    ],
    "graph": {
      "nodes": [
        {
          "id": "https://www.simplemodeling.org/glossary/knowledge-development/socialization",
          "label": "共同化",
          "kind": "concept"
        },
        {
          "id": "https://www.simplemodeling.org/glossary/development-process/alpha-state",
          "label": "アルファ状態",
          "kind": "concept"
        },
        {
          "id": "https://www.simplemodeling.org/glossary/development-process/activity",
          "label": "活動",
          "kind": "concept"
        },
        {
          "id": "https://www.simplemodeling.org/ja/glossary/development-process/kernel.html#chunk-0",
          "label": "カーネル 浅海 智晴 用語 カーネル 用語(英) Kernel 別名 - 定義 任意のソフトウェア開発活動を定義・理解するために必要最小限の概念を含むEssen",
          "kind": "passage"
        },
        {
          "id": "https://www.simplemodeling.org/ja/glossary/development-process/simplemodeling-reference-profile.html#chunk-0",
          "label": "SimpleModelingリファレンス・プロファイル 浅海 智晴 用語 SimpleModelingリファレンス・プロファイル 用語(英) SimpleMod",
          "kind": "passage"
        },
        {
          "id": "https://www.simplemodeling.org/ja/glossary/knowledge-development/knowledge-promotion.html#chunk-0",
          "label": "知識昇格 浅海 智晴 用語 知識昇格 用語(英) Knowledge Promotion 別名 - 定義 BoKの構造化知識を再学習・ファインチューニングにより",
          "kind": "passage"
        },
        {
          "id": "https://www.simplemodeling.org/en/domain-modeling/concept-analysis-design.html#chunk-1",
          "label": "ed with domain experts Establish it as a mechanism that can be implemented in so",
          "kind": "passage"
        },
        {
          "id": "https://www.simplemodeling.org/en/domain-modeling/simple-object.html#chunk-0",
          "label": "SimpleObject ASAMI, Tomoharu Created: 2025-09-15 In the SimpleModeling Reference",
          "kind": "passage"
        }
      ],
      "edges": [
        {
          "source": "https://www.simplemodeling.org/glossary/knowledge-development/socialization",
          "target": "https://www.simplemodeling.org/ja/glossary/development-process/kernel.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/knowledge-development/socialization",
          "target": "https://www.simplemodeling.org/ja/glossary/development-process/simplemodeling-reference-profile.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/knowledge-development/socialization",
          "target": "https://www.simplemodeling.org/ja/glossary/knowledge-development/knowledge-promotion.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/knowledge-development/socialization",
          "target": "https://www.simplemodeling.org/en/domain-modeling/concept-analysis-design.html#chunk-1",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/knowledge-development/socialization",
          "target": "https://www.simplemodeling.org/en/domain-modeling/simple-object.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/development-process/alpha-state",
          "target": "https://www.simplemodeling.org/ja/glossary/development-process/kernel.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/development-process/alpha-state",
          "target": "https://www.simplemodeling.org/ja/glossary/development-process/simplemodeling-reference-profile.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/development-process/alpha-state",
          "target": "https://www.simplemodeling.org/ja/glossary/knowledge-development/knowledge-promotion.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/development-process/alpha-state",
          "target": "https://www.simplemodeling.org/en/domain-modeling/concept-analysis-design.html#chunk-1",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/development-process/alpha-state",
          "target": "https://www.simplemodeling.org/en/domain-modeling/simple-object.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/development-process/activity",
          "target": "https://www.simplemodeling.org/ja/glossary/development-process/kernel.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/development-process/activity",
          "target": "https://www.simplemodeling.org/ja/glossary/development-process/simplemodeling-reference-profile.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/development-process/activity",
          "target": "https://www.simplemodeling.org/ja/glossary/knowledge-development/knowledge-promotion.html#chunk-0",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/development-process/activity",
          "target": "https://www.simplemodeling.org/en/domain-modeling/concept-analysis-design.html#chunk-1",
          "relation": "related"
        },
        {
          "source": "https://www.simplemodeling.org/glossary/development-process/activity",
          "target": "https://www.simplemodeling.org/en/domain-modeling/simple-object.html#chunk-0",
          "relation": "related"
        }
      ]
    }
  }
}

Concepts Define the Central Axes of Reasoning

The concepts field contains data such as the following.

"concepts": [
  { "uri": ".../socialization", "label": "共同化" },
  { "uri": "...#hasService", "label": "hasService" },
  { "uri": ".../development-system-reference-profile", "label": "開発システム・リファレンス・プロファイル" }
]

By inspecting this field, ChatGPT understands which set of concepts the question has been mapped to. It then uses these concepts as anchors for term explanations, associations, and context selection in subsequent reasoning.

In other words, the ambiguous term “SimpleObject” is interpreted as being decomposed into three semantic centers.

Passages as “Speakable Knowledge Material”

The passages field contains text related to the concepts along with relevance scores.

"passages": [
  { "text": "...", "score": 0.95 },
  ...
]

Because passages provide textual information, they are directly tied to the generation process.

ChatGPT evaluates passages in score order, summarizes and restructures their content, and re-edits them so that they connect naturally as prose.

Importantly, these scores are not absolute values but relative rankings. ChatGPT prioritizes higher scores while also using lower-scored passages in a supporting role.

Through this process, concepts derived from the GraphDB and explanatory texts derived from the VectorDB (documents) are naturally integrated.

Graph Ensures “Semantic Consistency Checks”

The graph field contains the knowledge graph related to the query.

"graph": {
  "nodes": [...],
  "edges": [...]
}

ChatGPT uses this part not for visualization, but for validating internal consistency.

Specifically, ChatGPT checks the following points.

Whether multiple passages originate from the same concept.
Whether the passages are not unrelated to each other.
Whether the explanatory flow does not make unjustified leaps.

The structure of the GraphDB functions as a “guardrail” that prevents logical jumps in the generated text.

ChatGPT Integrated Processing: Answer Generation

ChatGPT internally integrates the returned data and performs the following steps.

Extract definitions (Glossary / BoK).
Interpret the relevant sections of explanatory documents.
Reinforce context using semantic structures from RDF.
Adjust tone and context based on conversation history (sessionMemory).
Finalize the output into natural language that is easy for the user to understand.

As a result, an answer such as the following is generated.

SimpleObject is a fundamental abstraction of entities in SimpleModeling.
It has an identifier (id) and, in addition to NameAttributes such as name, title, and description,
it holds lifecycle information such as creation and update timestamps,
as well as delegated state machines like PostStatus and Aliveness.
SimpleModelObject (or SimpleEntity) functions as a standardized base type shared across the entire application,
serving as the foundation for all business entities.

ChatGPT is not answering based on its own internal knowledge, but by using the content provided by SIE.

Why This Structure Fits ChatGPT

Regarding the query functionality provided by SIE, we received the following comments from ChatGPT.

Your response structure is extremely easy for ChatGPT to work with.
The reasons are as follows:
- Semantic units (concepts) are explicitly defined.
- Explanatory units (passages) are clearly separated.
- Relational structures (graph) are explicitly represented.
- Each item is associated with a rank (score).
👉 As a result, ChatGPT can decide by itself what to use, in what order, and with what level of emphasis.

What ChatGPT’s comment indicates is that ChatGPT is not asking MCP for “the answer itself,” but rather for the “materials” and “evidence” needed to perform its own reasoning.

The reasons why SIE’s response structure is evaluated as easy for ChatGPT to handle are clear.

Semantic units (concepts) are explicitly defined.
Explanatory units (passages) are separated.
Relational structures (graph) are explicitly represented.
Importance is indicated by rank (score).

With this structure, ChatGPT can decide within its own reasoning process what to reference, in what order, and with what level of emphasis.

In other words, for ChatGPT, an MCP server functions not as a “machine that generates answers,” but as a “system that supplies the grounds for reasoning.”

From this perspective, the knowledge provision approach adopted by SIE—combining knowledge graphs (semantic relationships between concepts) with vectorized textual information (semantic proximity)—can be said to align directly with the reasoning model and objectives of ChatGPT.

Summary

When advancing software development in collaboration with generative AI such as ChatGPT, a crucial question is how to enable the AI to understand domain knowledge.

Even for relatively small systems, domain knowledge tends to grow larger than expected. Providing all of this knowledge as a prompt at the beginning of a chat session is not a practical approach.

To address this issue, as demonstrated in this article, it is effective to organize domain knowledge as a structured knowledge base and query it as needed.

SIE is positioned not as a simple search engine, but as a foundation that provides a knowledge environment enabling generative AI to perform autonomous reasoning.

References

In Site

📄 Semantic Integration Engine: A BoK Integration Demo for the AI Era

Glossary

Semantic Integration Engine (SIE): An integration engine that unifies structured knowledge (RDF) and document knowledge (SmartDox) derived from the BoK, making them directly accessible to AI.
DSL (Domain Specific Language): A DSL (Domain-Specific Language) is a language designed for a particular domain, enabling direct and concise expression of the domain’s concepts and structures. Compared to general-purpose programming languages (GPLs), DSLs offer a higher level of abstraction tailored for domain-specific problem solving and automation.
SimpleObject: SimpleObject is an abstract object defined in the SimpleModeling Reference Profile that specifies common attributes for domain objects. It delegates generic attribute groups—such as NameAttributes and LifecycleAttributes—as value objects, making it reusable as a base class for both entity objects and value objects. SimpleEntity inherits from SimpleObject and adds attributes such as the identifier (id) required for persistence, forming the foundation of entity objects.
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.
knowledge graph: A semantic graph-based knowledge base where nodes represent entities or concepts and edges represent their relationships.
RDF: A W3C-standardized data model that represents information as subject–predicate–object triples.
Prompt: A structured instruction or contextual representation that bridges retrieved knowledge (RAG) and the AI model’s reasoning process. It transforms the structured knowledge from the BoK into a narrative or directive form that the model can interpret, act upon, and internalize.