Real-time graph retrieval-augmented generation system using tag-based metamodel

Abstract

The present invention relates to a real-time graph search augmentation generation system using a tag-based metamodel, comprising: a metamodel generation unit that generates a tag-based metamodel from natural language requirements; and a dual storage unit that stores transaction data in a relational database (RDBMS) and a knowledge graph based on the tag-based metamodel and generates a deterministic graph structure. and includes an answer generation unit that generates an answer to a user query based on the above deterministic graph structure, wherein the metamodel generation unit includes an entity extraction module that extracts entities from the above natural language requirements and a tag assignment module that generates the tag-based metamodel by assigning semantic tags to the entities, wherein the semantic tags define data processing rules and include a structure tag, a retrieval tag, a logic tag, and a security tag, wherein the dual storage unit includes a command generation module that generates a first storage command for storing the transaction data in the relational database based on the semantic tags and a second storage command for storing the transaction data in the knowledge graph, and an execution module that synchronously executes the first storage command and the second storage command, maintains the integrity of the transaction data according to the first storage command, and converts the transaction data into nodes and edges according to the second storage command to generate the deterministic graph structure, and wherein the answer generation unit searches the deterministic graph structure based on the tag-based metamodel and It includes a graph navigation module that generates a subgraph, and an answer generation module that inputs the subgraph into a language model to generate an answer to a user query.

Description

Technology Field

[0001] The present invention relates to a real-time graph search augmentation generation system using a tag-based metamodel. Background Technology

[0002] With the recent surge in demand for information retrieval and decision support utilizing Large Language Models (LLMs) in the corporate environment, Retrieval-Augmented Generation (RAG) technology is being introduced to improve the response quality of language models by retrieving relevant information from external knowledge bases.

[0003] However, existing Vector-based Search Augmented Generative (Vector RAG) technology has a structural limitation in that the process of dividing documents into fixed sizes and vectorizing them results in the loss of the logical context running through the entire document or the connections between different documents, making it impossible to infer causal relationships between data. Additionally, since vector similarity judges only semantic proximity, it is vulnerable to structured data queries that require satisfying specific conditions.

[0004] To overcome the limitations of such vector-based search augmentation technologies, Graph Retrieval-Augmented Generation (GAG) technology has been proposed, which represents structural relationships between data as a Knowledge Graph and utilizes it for search. However, existing GAG technologies suffer from the problem of relying on a method that inputs unstructured text documents into a language model to probabilistically extract entities and relationships and construct a Knowledge Graph.

[0005] This method can generate different graph structures for the same text each time it is executed and carries the problem of so-called graph hallucination, where non-existent relationships are created.

[0006] In addition, there is a structural limitation in that it is difficult to apply to real-time enterprise environments where analysis must be performed immediately after data is generated, as the graph construction process requires repeatedly calling a language model, which results in indexing delays ranging from hours to days. Furthermore, even though most corporate data is already structured and stored in relational database management systems (RDBMS), existing graph search augmentation generation technologies take the approach of converting this back into unstructured text and then re-extracting the graph using a language model, which not only wastes unnecessary computing resources but also causes problems that compromise the integrity of the original data.

[0007] Therefore, there is a need to develop an intelligent data storage and graph search augmented generation system that fundamentally resolves the problems of graph illusion and indexing delay caused by probabilistic graph construction methods relying on unstructured text analysis, and synchronizes corporate data structured in relational databases with a knowledge graph in real time so that language models can utilize it immediately. Prior art literature

[0008] Republic of Korea Registered Patent Publication No. 10-2845839 The problem to be solved

[0009] The present invention is devised to solve the aforementioned conventional problems and provides a real-time graph search augmentation generation system using a tag-based metamodel that can resolve the graph illusion and indexing delay problems caused by language model-based probabilistic graph extraction methods by simultaneously generating and storing deterministic graph structures in a relational database and a knowledge graph at the time of transaction data generation according to the rules of a predefined tag-based metamodel, and utilizing the knowledge graph for real-time search augmentation generation. means of solving the problem

[0010] The above objective is achieved, according to the present invention, by a metamodel generation unit that generates a tag-based metamodel from natural language requirements; and a dual storage unit that stores transaction data in a relational database (RDBMS) and a knowledge graph based on the tag-based metamodel and generates a deterministic graph structure. and includes an answer generation unit that generates an answer to a user query based on the above deterministic graph structure, wherein the metamodel generation unit includes an entity extraction module that extracts entities from the above natural language requirements and a tag assignment module that generates the tag-based metamodel by assigning semantic tags to the entities, wherein the semantic tags define data processing rules and include a structure tag, a retrieval tag, a logic tag, and a security tag, wherein the dual storage unit includes a command generation module that generates a first storage command for storing the transaction data in the relational database based on the semantic tags and a second storage command for storing the transaction data in the knowledge graph, and an execution module that synchronously executes the first storage command and the second storage command, maintains the integrity of the transaction data according to the first storage command, and converts the transaction data into nodes and edges according to the second storage command to generate the deterministic graph structure, and wherein the answer generation unit searches the deterministic graph structure based on the tag-based metamodel and This is achieved by a real-time graph search augmentation generation system using a tag-based metamodel, comprising a graph search module that generates a subgraph and an answer generation module that inputs the subgraph into a language model to generate an answer to a user query.

[0011] In addition, the tag assignment module defines rules for converting transaction data into nodes and edges through the structure tag, defines the search entry points and search priorities of the graph search module through the search tag, defines allowed search paths of the graph search module through the logic tag, and controls the scope of exposure of sensitive information during the search of the knowledge graph through the security tag.

[0012] Additionally, when the second save command is executed, the execution module converts the attribute field value of the entity designated as the search entry point by the search tag into an embedding vector and stores it as a node attribute of the knowledge graph.

[0013] In addition, the graph search module determines a search entry point through a similarity search using the embedding vector, and generates the subgraph by searching the deterministic graph structure along the allowed search path defined in the logic tag.

[0014] In addition, the above answer generation module masks the attributes of the above subgraph to which the security tag is specified, and inputs the masked above subgraph into the language model. Effects of the invention

[0015] According to the present invention, since a knowledge graph is deterministically generated according to the rules of a tag-based metamodel at the time transaction data is generated, immediate graph inference for the just-input data is possible without a separate indexing process, thereby enabling the establishment of a real-time decision support environment.

[0016] Furthermore, since the graph structure is generated according to predefined metamodel rules without undergoing the probabilistic extraction process of the language model, it can provide a deterministic graph structure with guaranteed data integrity without graph illusions, making it applicable to fields requiring high data reliability, such as finance, healthcare, and law.

[0017] In addition, by precisely extracting only the subgraphs related to the user query based on the allowed navigation paths and priorities defined in semantic tags and inputting them into the language model, unnecessary node traversal is excluded, thereby reducing the token cost of the language model and improving response speed.

[0018] Meanwhile, the effects of the present invention are not limited to those mentioned above, and various effects may be included within the scope obvious to a person skilled in the art from the contents described below. Brief explanation of the drawing

[0019] FIG. 1 illustrates a real-time graph search augmentation generation system using a tag-based metamodel according to an embodiment of the present invention. FIG. 2 illustrates the connections between the components of a metamodel generation unit of a real-time graph search augmentation generation system using a tag-based metamodel according to an embodiment of the present invention, and FIG. 3 illustrates the connection between the components of a dual storage unit of a real-time graph search augmentation generation system using a tag-based metamodel according to an embodiment of the present invention, and Figure 4 illustrates the connections between the components of the answer generation unit of a real-time graph search augmentation generation system using a tag-based metamodel according to an embodiment of the present invention. Specific details for implementing the invention

[0020] Hereinafter, some embodiments of the present invention will be described in detail with reference to the exemplary drawings. It should be noted that in assigning reference numerals to the components of each drawing, the same components are given the same reference numeral whenever possible, even if they are shown in different drawings.

[0021] In addition, when describing embodiments of the present invention, if it is determined that a detailed description of related known configurations or functions would hinder understanding of the embodiments of the present invention, such detailed description is omitted.

[0022] In addition, terms such as first, second, A, B, (a), (b), etc., may be used when describing the components of the embodiments of the present invention. These terms are used merely to distinguish the components from other components, and the essence, order, or sequence of the components is not limited by the terms used.

[0023] Additionally, in the specification, the singular form includes the plural form unless specifically stated otherwise in the text. The terms “comprising” and / or “comprising” as used in the specification do not exclude the presence or addition of one or more other components in addition to the mentioned components.

[0024] In addition, in describing embodiments of the present invention, a “part,” “module,” or “step” as each component may be implemented using one or more processors and memory. Here, a processor may be interpreted to include a general-purpose processor, a central processing unit (CPU), a microprocessor, a microcontroller (MCU), a digital signal processor (DSP), a controller, or a state machine, etc.

[0025] The processor may be composed of a single processor or a processor including multiple processing cores, and may include various forms of processing devices, such as, for example, a combination of multiple microprocessors, a combination of a microprocessor and a DSP, or a single processor including multiple processing cores having different characteristics. Additionally, depending on the specific implementation environment, the processor may be configured to include an Application-Specific Integrated Circuit (ASIC), a Programmable Logic Device (PLD), a Field Programmable Gate Array (FPGA), or similar hardware logic circuits.

[0026] Additionally, memory may be interpreted as including any electronic storage means capable of storing electronic information, and may include various forms of processor-readable media including random access memory (RAM), read-only memory (ROM), non-volatile random access memory (NVRAM), programmable read-only memory (PROM), eraseable programmable read-only memory (EPROM), electrically eraseable read-only memory (EEPROM), flash memory, magnetic or optical storage devices, registers, etc.

[0027] When a processor can read information from memory or write information to memory, the processor and memory are interpreted as being in a state where they can communicate electronically, and each “part,” “module,” or “step” according to an embodiment of the present invention may be implemented by a program, firmware, or application stored in the processor and memory in such an electronically communicable state.

[0028] Furthermore, in the present invention, Artificial Intelligence (AI) refers to a technology that imitates human learning ability, reasoning ability, and perceptual ability, and implements them on a computer, and may include concepts such as machine learning and symbolic logic. Machine Learning (ML) is an algorithmic technology that classifies or learns the characteristics of input information on its own. AI technology can analyze input information as a machine learning algorithm, learn from the results of that analysis, and make judgments or predictions based on the results of that learning. Additionally, technologies that mimic the functions of the human brain, such as cognition and judgment, by utilizing machine learning algorithms can also be understood as falling within the category of AI. For example, technological fields such as linguistic understanding, visual understanding, reasoning / prediction, knowledge representation, and motion control may be included.

[0029] Artificial intelligence learning models or neural network models can be designed to implement the structure of the human brain on a computer and may include multiple network nodes that simulate neurons of a human neural network and have weights. These multiple network nodes can have interconnected relationships by simulating the synaptic activity of neurons, where they exchange signals through synapses. In an artificial intelligence learning model, multiple network nodes can be located in layers of different depths and exchange information according to convolutional connections. An artificial intelligence learning model may be, for example, an Artificial Neural Network (ANN) or a Convolutional Neural Network (CNN). An artificial intelligence learning model can be machine learned according to methods such as supervised learning, unsupervised learning, and reinforcement learning. Machine learning algorithms that can be used to perform machine learning include Decision Trees, Bayesian Networks, Support Vector Machines, Perceptrons, and Clustering.

[0031] From now on, a real-time graph search augmentation generation system (100) using a tag-based metamodel according to an embodiment of the present invention will be described in detail with reference to the attached drawings.

[0032] As illustrated in FIG. 1, a real-time graph search augmentation generation system (100) using a tag-based metamodel according to one embodiment of the present invention includes a metamodel generation unit (110), a dual storage unit (120), and / or an answer generation unit (130).

[0033] The metamodel generation unit (110) generates a tag-based metamodel from natural language requirements and is electrically connected to the dual storage unit (120) and / or answer generation unit (130).

[0034] The metamodel generation unit (110) can generate a tag-based metamodel by receiving requirements described in natural language, extracting entities, and assigning semantic tags that define data processing rules to the extracted entities.

[0035] A tag-based metamodel refers to a metadata structure that includes entities extracted from natural language requirements and semantic tags assigned to those entities, representing the storage structure of transaction data, knowledge graph structure creation rules, and knowledge graph traversal rules through a structured representation.

[0036] An entity is a concept representing a type of data object processed by a system, signifying a unit of data that is independently identifiable within transaction data. Transaction data may consist of a set of actual data values ​​corresponding to entities and serves as the target for data storage, updating, and retrieval operations performed by the system.

[0037] A tag-based metamodel can be represented as structured definition information that includes both a data structure containing entities and relationships between entities, and semantic tag information assigned to the entities. This definition information can formalize and describe the data structures and data processing rules handled by the system.

[0038] A tag-based metamodel can describe the storage structure and data processing standards of transaction data in a consistent manner by representing the structure of transaction data processed by the system and data processing rules as a single metadata structure.

[0039] In addition, a tag-based metamodel can be managed as a metadata structure generated at build time and referenced at runtime. The tag-based metamodel generated at build time can be used as reference information that predefines data structures and data processing rules processed by the system.

[0040] Tag-based metamodels can be managed as structured data representations in JSON or YAML formats and can be automatically generated by natural language processing-based compilers that analyze natural language requirements.

[0041] As illustrated in FIG. 2, the metamodel generation unit (110) includes an entity extraction module (111) and / or a tag assignment module (112).

[0042] The entity extraction module (111) is configured to extract entities from natural language requirements and is electrically connected to the tag assignment module (112).

[0043] The entity extraction module (111) can analyze requirements described in natural language to identify and extract entities, which are data objects handled by the system.

[0044] An entity refers to a data object that can be independently identified within a system and may include conceptual units that have meaning in a business domain, such as an order, a supplier, or a product.

[0045] The entity extraction module (111) can extract noun phrases from natural language requirements through natural language processing (NLP) technology and select data objects among the extracted noun phrases that can be independently identified and managed within the system as entities.

[0046] For example, from the requirement that the inventory is updated when a supplier delivers raw materials, you can extract the Supplier, Material, and Inventory entities.

[0047] The entity extraction module (111) can standardize the extracted entities by mapping them to tables of a relational database (RDBMS) and define a unique identifier (ID) field that identifies each entity and an attribute field that specifically describes each entity.

[0048] An attribute field is a unit of individual data items that constitute an entity, and it is a concept corresponding to a column in a relational database.

[0049] Attribute fields are data items that specifically describe the state or characteristics of an entity; for example, items such as the order date and time, order amount, and order description of an Order entity correspond to attribute fields.

[0050] The attribute field can be a target for being assigned a semantic tag by the tag assignment module (112) described later, and depending on the type of semantic tag assigned, it can be processed in different ways, such as being stored as a node attribute of the knowledge graph or converted into an embedding vector and used as a search entry point.

[0051] In this way, the entity extracted through the entity extraction module (111) can be used as a data object that constitutes transaction data.

[0052] Next, the tag assignment module (112) generates a tag-based metamodel by assigning a semantic tag to an entity received from the entity extraction module (111), and is electrically connected to the entity extraction module (111).

[0053] Semantic tags define data processing rules and include structure tags, retrieval tags, logic tags, and / or security tags.

[0054] The tag assignment module (112) can define rules for converting transaction data into a structure of nodes and edges of a knowledge graph through a structure tag.

[0055] Structure tags are applied to entities or relationships between entities to describe how transaction data is transformed into a graph structure.

[0056] For example, you can assign the graph:node tag to an entity unit to instruct it to be created as a node in the knowledge graph, assign the graph:edge tag to foreign key relationships between entities to instruct them to be converted into edges between nodes, and assign the graph:property tag to fields to be stored as attributes of nodes or edges.

[0057] For example, if a graph:node tag is assigned to the Order entity and a graph:edge tag is assigned to the foreign key relationship between Order and Supplier, the dual storage unit (120) described later can create an Order node and a Supplier node at the time an order transaction occurs and automatically create an edge between the two nodes.

[0058] Additionally, the tag assignment module (112) can define the search entry point and search priority of the graph search module (131) described later through the retrieval tag.

[0059] Search tags can be used to express the search criteria applied during the knowledge graph exploration process, and can describe the starting criteria for graph exploration, the data referenced during the exploration process, and information regarding exploration priority.

[0060] For example, a field to be used as an entry point for vector search can be given a rag:anchor tag, a field to be used as context information to be provided to the language model can be given a rag:context tag, and a field to be used to control search priority can be given a rag:weight tag to set a weight value between 0.0 and 1.0.

[0061] Additionally, the tag assignment module (112) can define the allowed paths for the graph search module (131) described later through the logic tag.

[0062] Logic tags can be used to express search rules or data constraints applied during the knowledge graph traversal process, and can describe paths or data validity conditions for which graph traversal is permitted.

[0063] For example, tags such as `logic:constraint` can express validation conditions applied to data values, while tags such as `logic:path` can express movement paths between nodes allowed during graph traversal. Additionally, the `logic:path` tag can be used to set path constraints that allow navigation only from a specific node to a specific node, such as `allow:Order->Item`, and the `logic:constraint` tag can be used to define data validation rules.

[0064] In addition, the tag assignment module (112) can control the exposure range of sensitive information when exploring the knowledge graph through a security tag.

[0065] For example, attribute fields corresponding to personally identifiable information can be tagged with `security:pii` to instruct them to be hashed or excluded from storage when saving to the knowledge graph, and can be designated as targets for masking during exploration so that the corresponding attribute value is not exposed to the language model even if it is included in the subgraph. Additionally, nodes or edges accessible only to users with specific permissions can be tagged with `security:role` to configure access control rules to be applied during exploration.

[0066] The tag assignment module (112) can generate a tag-based metamodel by assigning semantic tags to entities received from the entity extraction module (111).

[0067] For example, when a structure tag is assigned to a specific entity, criteria for converting that entity into a node of the knowledge graph can be defined, and when a structure tag is assigned to relationships between entities, criteria for creating connection relationships between nodes can be defined.

[0068] The tag-based metamodel generated through the tag assignment module (112) can block the graph hallucination problem that occurs when a large-scale language model (LLM) probabilistically extracts nodes and edges from unstructured text.

[0069] The tag-based metamodel projects transaction data into a knowledge graph structure according to predefined semantic tags and data transformation rules, thereby enabling the generation of a deterministic graph structure in which consistency between the input data and the output graph is guaranteed in the dual storage unit (120) described later.

[0070] In this way, the metamodel generation unit (110) can derive entities from natural language requirements and generate a tag-based metamodel by assigning semantic tags to the derived entities.

[0071] The tag-based metamodel generated from the metamodel generation unit (110) can be used as reference information to describe the data structure and data processing rules processed by the system in a consistent form, and the transaction data can be stored in a relational database and a knowledge graph according to the rules defined in the tag-based metamodel in the dual storage unit (120) to be described later.

[0073] The dual storage unit (120) stores transaction data in a relational database (RDBMS) and a knowledge graph based on a tag-based metamodel and generates a deterministic graph structure, and is electrically connected to the metamodel generation unit (110) and / or the answer generation unit (130).

[0074] The dual storage unit (120) can intercept data processing requests occurring at the application layer in real time and synchronously record data in storages of different natures, such as a relational database and a knowledge graph. This synchronous storage method can ensure data consistency between the two storages within a single transaction and can provide an environment for building a knowledge graph simultaneously with the generation of data without a separate post-processing process.

[0075] The dual storage unit (120) can maintain data integrity by converting transaction data into commands that match the format of each storage unit by referring to rules defined in the tag-based metamodel and executing them in batches.

[0076] As illustrated in FIG. 3, the dual storage unit (120) includes a command generation module (121) and / or an execution module (122).

[0077] The command generation module (121) is configured to generate a first storage command for storing transaction data in a relational database based on semantic tags and a second storage command for storing transaction data in a knowledge graph, and is electrically connected to the execution module (122).

[0078] The command generation module (121) can individually generate storage commands for each heterogeneous repository having a different data structure, such as a relational database and a knowledge graph, by analyzing semantic tags defined in a tag-based metamodel for transaction data occurring in real time at the application layer.

[0079] The first save command refers to a data storage command for recording transaction data into the table structure of a relational database, and a relational database management system (RDBMS) can be configured as a data storage system that manages data in a table format consisting of rows and columns and maintains referential integrity between data.

[0080] The command generation module (121) can generate a first storage command so that transaction data is recorded in a table structure corresponding to each entity of the relational database according to the entities defined in the tag-based metamodel.

[0081] For example, the first save command may be generated as an SQL statement in the form of a Data Manipulation Language executed in a relational database, and may include a data insertion command to insert new transaction data into a table or a data update command to update existing stored records.

[0082] The command generation module (121) can generate a first storage command to be stored in a table structure of a relational database according to the structure of an entity defined in a tag-based metamodel.

[0083] The second save command refers to a graph data save command for converting transaction data into a node and edge structure of a knowledge graph and storing it, and the knowledge graph can be composed of a graph-based data representation structure in which data objects are represented as nodes and relationships between data objects are represented as edges.

[0084] The command generation module (121) can generate a second storage command to convert transaction data into a node and edge structure of a knowledge graph by referencing semantic tags defined in a tag-based metamodel.

[0085] The second storage command may include a command configuration that converts entities into nodes according to structural tags included in semantic tags, and may include a command configuration that converts relationships between entities into edges.

[0086] In addition, for entities to which search tags have been assigned, information for storing the corresponding data as node attributes of the knowledge graph so that it can be utilized for graph exploration may be included in the second storage command.

[0087] For example, the second storage command may be generated in the form of a Graph Query Language used in a graph database and may include a node processing command to create a node or update an existing node, or a relationship creation command to create directed edges between nodes.

[0088] The command generation module (121) can generate a first storage command and a second storage command based on the same transaction data, thereby enabling the transaction data recorded in the relational database and the node and edge structures recorded in the knowledge graph to maintain the same transaction standard.

[0089] Additionally, the command generation module (121) can generate two storage commands according to the rules defined in the tag-based metamodel, thereby ensuring that the data recording criteria applied to the relational database and the graph representation criteria applied to the knowledge graph follow the same rule system.

[0090] Next, the execution module (122) synchronously executes the first storage command and the second storage command, maintains the integrity of the transaction data according to the first storage command, and converts the transaction data into nodes and edges according to the second storage command to generate a deterministic graph structure, and is electrically connected to the command generation module (121).

[0091] The execution module (122) is configured to synchronously execute the first save command and the second save command received from the command generation module (121), wherein synchronous execution means an execution method in which the first save command and the second save command are executed within a single transaction processing flow so that the transaction data recorded in the relational database and the nodes and edges recorded in the knowledge graph maintain the same transaction criteria.

[0092] Additionally, the execution module (122) can maintain data consistency between the relational database and the knowledge graph by rolling back the execution results of the remaining commands together if the execution of either the first save command or the second save command fails.

[0093] The execution module (122) executes the first save command to store transaction data in the table structure of the relational database and can maintain the integrity of the transaction data according to the integrity constraints of the relational database.

[0094] A relational database can be configured as a storage structure that ensures the consistency of stored transaction data through integrity constraints such as primary keys, foreign keys, and / or unique constraints.

[0095] For example, when a transaction occurs in which a user creates a new order, the execution module (122) may execute a data insertion command to record order data, including an order number, a supplier identifier, an order amount, and an order date and time, into an order table of a relational database. In this case, the supplier identifier is a foreign key that references the primary key of the supplier table, and can ensure that order data for a non-existent supplier is not recorded according to the referential integrity constraint of the relational database.

[0096] The execution module (122) can maintain data consistency in the relational database by stopping the execution of the transaction and treating it as an execution error if an integrity constraint is violated during the execution of the first save command.

[0097] Additionally, the execution module (122) can execute a second storage command to convert transaction data into nodes and edges of the knowledge graph and store them.

[0098] The execution of the second storage command can be performed based on transformation rules defined in the structure tag, and the execution module (122) can apply a deterministic transformation algorithm that transforms each entity included in the transaction data and the relationships between entities into nodes and edges of the knowledge graph.

[0099] The execution module (122) can execute a command to create or update the entity as a node in the knowledge graph when a structure tag is assigned to the entity.

[0100] Here, a node is a unit representing a data object that can be independently identified in a knowledge graph, and can be created based on the unique identifier of an entity. For example, if a structure tag is assigned to an Order entity, the execution module (122) can create an Order node in the knowledge graph with the order number as its unique identifier. In this case, if a node with the same unique identifier already exists, the existing node can be updated instead of creating a new node to prevent the creation of duplicate nodes.

[0101] Additionally, the execution module (122) can execute a command to generate directed edges between nodes after querying each node when a structure tag is assigned to a foreign key relationship between entities.

[0102] Here, an edge is a connection structure that represents the semantic relationship between two nodes in a knowledge graph, and refers to the result of projecting the foreign key relationship of a relational database onto a graph structure. For example, if a structure tag is assigned to the foreign key relationship between an Order entity and a Supplier entity, the execution module (122) can query the Order node and the Supplier node respectively and then create a directed edge between the two nodes indicating that the order is processed by the corresponding supplier.

[0103] Through this edge generation, the knowledge graph represents the reference relationships between tables of the relational database as a graph connection structure, and the answer generation unit (130) described later can secure a search path capable of multi-stage inference by following this connection structure.

[0104] Additionally, the execution module (122) can execute a command to save the value of the field as the attribute value of the node or edge when a structure tag is assigned to the attribute field.

[0105] The attributes of a node or edge are data in the form of key-value pairs that specifically describe the corresponding graph element, and for example, fields such as the order amount and order date and time of an order node can be stored as node attributes. Through this, each node and edge of the knowledge graph does not remain merely a simple connection structure but also possesses detailed data of the business domain, so that when the answer generation unit (130), which will be described later, inputs the graph search results into the language model, it can provide rich contextual information.

[0106] The execution module (122) can generate a deterministic graph structure based on the structure of nodes and edges stored in the knowledge graph after the execution of the second storage command is completed.

[0107] A Deterministic Graph Structure refers to a graph representation structure that is generated according to predefined transformation rules for semantic tags in a tag-based metamodel, possessing the property that the same graph structure is always generated for the same transaction data.

[0108] These deterministic characteristics can block the graph hallucination problem that occurs in graph structures generated through the probabilistic inference process of language models, and can guarantee consistency between transaction data and graph structures.

[0109] Additionally, when executing the second save command, the execution module (122) can convert the value of the attribute field of the entity designated as the search entry point by the search tag into an embedding vector and store it as a node attribute of the knowledge graph.

[0110] An embedding vector is a vector that numerically represents text data in a high-dimensional real vector space. It possesses the property that semantically similar text is placed in close positions within the vector space, enabling the rapid identification of nodes semantically similar to user queries through numerical calculations alone.

[0111] For example, if a search tag is assigned to the order description field of an Order entity, the execution module (122) can convert the order description text into a high-dimensional real number vector and store it as an attribute of the order node.

[0112] The execution module (122) generates an embedding vector at the time of storage and stores it in advance as a node attribute, so that the graph search module (131), which will be described later, can immediately utilize the stored embedding vector without a separate vectorization process at the time of processing a user query to quickly determine the search entry point.

[0113] Meanwhile, the execution module (122) may apply a distributed transaction technique to prevent data inconsistency between the relational database and the knowledge graph during the process of synchronously executing the first save command and the second save command.

[0114] A distributed transaction refers to a transaction processing technique that treats transactions performed across different repositories as a single logical unit of execution, guaranteeing atomicity where data writing to all repositories either succeeds or all fails.

[0115] Additionally, the execution module (122) can apply an eventual consistency method that utilizes a message queue in environments where high throughput is required, such as with large amounts of log data.

[0116] The Eventual Consistency method can be configured to synchronously process the first save command to immediately write to a relational database, and to asynchronously write the second save command to a knowledge graph while ensuring order through a message queue, thereby ensuring data consistency between the two repositories even if temporary processing delays occur.

[0117] As described above, by the execution module (122) synchronously executing the first save command and the second save command, the data integrity of the Online Transaction Processing (OLTP) handled by the relational database and the multi-level reasoning capability handled by the knowledge graph are integrated at a single point in time.

[0118] Furthermore, by establishing an environment where the knowledge graph is completed simultaneously with data generation without a separate asynchronous data transformation (ETL) process, immediate graph-based search augmentation generation for input transaction data is possible.

[0119] The execution module (122) generates a graph structure deterministically according to rules defined in the tag-based metamodel, so it can provide a reliable graph structure with graph illusions excluded in fields where data accuracy is required, such as finance, medical and legal fields.

[0120] In this way, the dual storage unit (120) performs a series of processing flows based on the tag-based metamodel received from the metamodel generation unit (110), wherein the command generation module (121) generates a first storage command and a second storage command at the time of occurrence of transaction data, and the execution module (122) synchronously executes them to store transaction data in a relational database and a knowledge graph and to create a deterministic graph structure.

[0121] The dual storage unit (120) can immediately construct a knowledge graph without undergoing the inference process of the language model at the time transaction data occurs by referencing the semantic tags of the tag-based metamodel generated by the metamodel generation unit (110) at build time as execution rules at runtime. This fundamentally resolves the indexing delay problem in conventional graph search augmented generation technology, where graph construction takes hours to days, and enables the construction of a real-time environment where immediate graph-based inference on transaction data that has just occurred is possible.

[0122] In addition, the dual storage unit (120) deterministically converts transaction data into nodes and edges according to the transformation rules defined in the structure tags of the metamodel generation unit (110), so that the same graph structure can always be generated for the same transaction data. This blocks the graph illusion problem caused by the probabilistic extraction method of the language model and guarantees consistency between the transaction data and the knowledge graph structure, thereby providing a reliable graph-based inference environment even in fields requiring data accuracy, such as finance, medicine, and law.

[0123] In addition, the dual storage unit (120) converts the value of the attribute field specified by the search tag into an embedding vector and stores it as a node attribute at the time when the execution module (122) executes the second storage command, thereby enabling the answer generation unit (130) to immediately determine the search entry point without a separate vectorization process at the time of processing the user query, thereby establishing an environment in advance.

[0124] The deterministic graph structure generated through the dual storage unit (120) is transmitted to the graph search module (131) of the answer generation unit (130) and used for generating graph-based search augmentations for user queries.

[0126] The answer generation unit (130) generates an answer to a user query based on a deterministic graph structure received from the dual storage unit (120) and is electrically connected to the metamodel generation unit (110) and / or the dual storage unit (120).

[0127] The answer generation unit (130) can generate an answer by referencing semantic tags defined in a tag-based metamodel received from the metamodel generation unit (110) as search rules, and by searching the deterministic graph structure constructed by the execution module (122) of the binary storage unit (120) to extract a subgraph related to the user query, and inputting the extracted subgraph into a language model.

[0128] The answer generation unit (130) can provide inference results based on multi-level connection relationships between transaction data to a language model by utilizing the subgraph generated by the graph search module (131) searching for a deterministic graph structure as contextual information. For example, for a query that requires tracking relationships between multiple entities, such as "Which supplier has repeatedly caused delivery delays?", the answer generation unit (130) can generate an accurate answer by extracting relevant subgraphs along a multi-level search path leading from an order node to a delivery node, and from a delivery node to a supplier node, and inputting them into a language model.

[0129] The answer generation unit (130) can implement an integrated inference environment in which the storage rules and search rules of transaction data are consistently controlled by the same tag-based metamodel by utilizing the tag-based metamodel received from the metamodel generation unit (110) and the deterministic graph structure received from the dual storage unit (120). Through this, the rule system of the tag-based metamodel is consistently applied from the data storage stage to the answer generation stage, thereby enabling the generation of reliable answers based on transaction data.

[0130] As illustrated in FIG. 4, the answer generation unit (130) includes a graph search module (131) and / or an answer generation module (132).

[0131] First, the graph search module (131) is configured to search for a deterministic graph structure based on a tag-based metamodel and generate a subgraph, and is electrically connected to the answer generation module.

[0132] The graph search module (131) can search for a deterministic graph structure built by the execution module (122) of the dual storage unit (120) and generate a subgraph related to the user query by referencing search tags and logic tags defined in the tag-based metamodel received from the metamodel generation unit (110) as search rules.

[0133] Here, a subgraph refers to a partial graph formed by selecting only the nodes and edges necessary to generate an answer to a user query from the entire deterministic graph structure.

[0134] Since deterministic graph structures include nodes and edges generated from all transaction data processed by the system, inputting the entire graph into a language model can lead to wasted context windows and inference errors.

[0135] Accordingly, the graph search module (131) can generate a subgraph by precisely extracting only the nodes and edges related to the query according to the search rules defined in the tag-based metamodel.

[0136] The graph search module (131) operates in the order of, when a user query is entered, performing a similarity search based on the search entry point information defined in the search tag to determine the search entry point, and then searching a deterministic graph structure along the search allowed path defined in the logic tag to create a subgraph.

[0137] Additionally, the graph search module (131) can determine a search entry point through a similarity search using an embedding vector stored as a node attribute of the knowledge graph in the execution module (122), and generate a subgraph by searching a deterministic graph structure along a search allowed path defined in a logic tag.

[0138] Similarity Search refers to a search method that identifies the most semantically similar node by converting a user query text into an embedding vector and calculating the numerical distance between that vector and the embedding vector stored as a node attribute in a knowledge graph.

[0139] The similarity between vectors can be measured by numerical calculations such as cosine similarity or Euclidean distance, and search entry points can be determined based on the order of high similarity values.

[0140] Additionally, the search entry point is a node where the graph search module (131) starts searching the deterministic graph structure, and refers to the node that is most semantically similar to the user query.

[0141] When a user query is input, the graph search module (131) converts the query text into an embedding vector, and the execution module (122) can determine the search entry point by calculating the similarity with the embedding vector that was previously created and stored as a node attribute at the time of saving the transaction data.

[0142] Since the execution module (122) has pre-generated an embedding vector at the time of storage and stored it as a node attribute, the graph search module (131) can immediately utilize the stored embedding vector without a separate vectorization process to determine the search entry point and quickly determine the search entry point. For example, if a query such as "Which supplier has repeatedly caused delivery delays?" is entered, the graph search module (131) can determine the Order node or Delivery node that has the highest similarity to the embedding vector of the query as the search entry point.

[0143] An Allowed Path refers to a path between nodes predefined in logic tags that restricts the range of nodes and edges reachable from a search entry point.

[0144] The graph search module (131) can sequentially search the deterministic graph structure along the allowed search paths defined in the logic tag once the search entry point is determined.

[0145] The graph search module (131) can generate a subgraph composed only of nodes and edges related to the user query by performing a pruning process that excludes nodes and edges not included in the allowed search paths from the search target during the search process.

[0146] For example, if a path constraint is defined in the logic tag that allows only navigation from an Order node to a Delivery node and from a Delivery node to a Supplier node, the graph navigation module (131) can perform navigation along the path and, as a result, generate a subgraph consisting of Order, Delivery, and Supplier nodes and edges between them.

[0147] Additionally, the graph search module (131) can adjust the search order of nodes and edges constituting the subgraph by reflecting the search priority defined in the search tag.

[0148] For example, the search priority can be defined by a weight value between 0.0 and 1.0 in the rag:weight tag, and nodes and edges with higher weight values ​​can be searched first and included in the subgraph.

[0149] Through this, the graph search module (131) can generate a subgraph that includes nodes and edges that have a high contribution to generating an answer to a user query within the constraints of the context window.

[0150] The subgraph generated by the graph search module (131) is structured relational data extracted from a deterministic graph structure, and may include contextual information necessary for generating an answer to a user query in a structured form, and the generated subgraph can be transmitted to the answer generation module (132).

[0151] Next, the answer generation module (132) is configured to generate an answer to a user query by inputting the received subgraph into a language model, and is electrically connected to the graph search module (131).

[0152] The answer generation module (132) can convert the subgraph received from the graph search module (131) into a natural language format prompt that a language model can process, and input the converted prompt into the language model to generate an answer to a user query.

[0153] Here, a prompt refers to instruction information in text format input into a language model, which can include structured contextual information extracted from user queries and subgraphs.

[0154] The answer generation module (132) can serialize the attribute values ​​and edges of the nodes included in the subgraph into a natural language format to construct a prompt, and input the constructed prompt into a language model.

[0155] Additionally, the answer generation module (132) can include the value of the attribute field with the rag:context tag of the search tag in the prompt first during the process of converting the subgraph into a prompt.

[0156] Since the rag:context tag is pre-assigned to an attribute field that will be used as context information to be provided to the language model at build time by the tag assignment module (112), the answer generation module (132) includes only the value of the attribute field with the tag assigned to it in the prompt without a separate judgment process at runtime.

[0157] This allows for the accurate provision of key contextual information necessary for answer generation while minimizing the amount of information input into the language model's context window, and enables the reduction of token costs and improvement of response speed.

[0158] A language model generates an answer to a user query based on an input prompt; for example, it can be implemented as a Large Language Model (LLM) and can be provided in a manner where it is called externally in the form of an Application Programming Interface (API) or directly installed within the system.

[0159] Since the language model generates answers to user queries based on structured contextual information extracted from subgraphs, it can generate answers based on deterministic graph structures generated from actual transaction data, without relying on parametric knowledge acquired during the learning process.

[0160] Parametric knowledge refers to the knowledge that a language model internalizes into model parameters from large-scale text data during the pre-training process; however, it has limitations in that it cannot reflect biases in the training data or changes in information since the training point.

[0161] The answer generation module (132) provides a subgraph extracted from a deterministic graph structure built in real-time by the dual storage unit (120) at the time of transaction data occurrence as context information, thereby enabling the language model to generate a realistic answer based on the latest transaction data.

[0162] This suppresses the hallucinations that occur when relying solely on the parametric knowledge of language models, and enables the generation of reliable answers based on real-time updated transaction data.

[0163] Additionally, the answer generation module (132) can mask the attributes of the security-tagged subgraph and input the masked subgraph into the language model.

[0164] Masking refers to a processing method in which attributes of nodes or edges included in a subgraph that are tagged with security are de-identified or replaced with alternative values ​​so that such attributes are not exposed to the language model.

[0165] Security tags are predefined at build time by the tag assignment module (112) of the metamodel generation unit (110) and may include, for example, a security:pii tag assigned to an attribute field designated as Personally Identifiable Information (PII) and a security:role tag assigned to a node or edge accessible only to users with specific authority.

[0166] The answer generation module (132) can sequentially examine the attribute values ​​of nodes and edges included in the subgraph after receiving the subgraph from the graph search module (131) and before inputting it into the language model to identify attributes with security tags and perform masking processing.

[0167] For attributes tagged with security:pii, the attribute value can be replaced with a predefined alternative value or the attribute itself can be excluded from the prompt.

[0168] For nodes or edges tagged with `security:role`, the process can be handled by checking the current user's role information and excluding nodes or edges that are not allowed access from the prompt.

[0169] By applying access control rules defined in security tags at the prompt stage where the answer generation module (132) is input into the language model, sensitive information can be prevented from being exposed during the inference process of the language model and an answer generation environment that complies with personal information protection laws and data security policies can be provided.

[0170] Since masking is performed at the prompt stage input to the language model, it is possible to block sensitive information from being utilized or exposed in the generated answers during the language model's inference process itself. This provides an environment where graph-based search augmentation generative technology can be safely applied even in fields where personal information protection regulations are strictly enforced, such as healthcare, finance, and law.

[0171] The answer generation module (132) can convert the masked subgraph into a prompt and input it into a language model, and return the answer generated by the language model to the user.

[0172] Since the answer generation module (132) utilizes subgraphs extracted from a deterministic graph structure as contextual information, only information controlled by security tags and navigation allowed paths defined in the tag-based metamodel can be used for inference in the language model.

[0173] Thus, the answer generation module (132) can generate a controlled inference environment that generates answers based only on information that corresponds to the scope and authority of the user query, suppress the hallucination phenomenon that occurs when relying only on the parametric knowledge of the language model, and generate a realistic and reliable answer based on transaction data.

[0174] In this way, the answer generation unit (130) can perform a series of processing flows to generate an answer to a user query by referencing search tags and logic tags defined in a tag-based metamodel received from the metamodel generation unit (110) as search rules, extracting a subgraph from a deterministic graph structure, and applying access control rules defined in a security tag in the prompt configuration step to input them into a language model.

[0175] The answer generated through the answer generation unit (130) is based on a deterministic graph structure built in real time by the dual storage unit (120) at the time of transaction data occurrence, so it can suppress hallucinations that rely on parametric knowledge of the language model and provide a realistic and reliable answer based on the latest transaction data.

[0176] As described above, according to the real-time graph search augmentation generation system (100) using a tag-based metamodel according to one embodiment of the present invention, since a knowledge graph is deterministically generated according to the rules of the tag-based metamodel at the time transaction data is generated, immediate graph inference for the data just entered is possible without a separate indexing process, thereby enabling the establishment of a real-time decision support environment.

[0177] Furthermore, since the graph structure is generated according to predefined metamodel rules without undergoing the probabilistic extraction process of the language model, it can provide a deterministic graph structure with guaranteed data integrity without graph illusions, making it applicable to fields requiring high data reliability, such as finance, healthcare, and law.

[0178] In addition, by precisely extracting only the subgraphs related to the user query based on the allowed navigation paths and priorities defined in semantic tags and inputting them into the language model, unnecessary node traversal is excluded, thereby reducing the token cost of the language model and improving response speed.

[0180] The operation and effects of the invention will be explained in more detail below through specific embodiments. However, these are presented merely as examples of the invention and do not limit the scope of the invention in any way.

[0181] Examples

[0182] In this embodiment, a real-time graph search augmentation generation system using a tag-based metamodel was implemented for the Supply Chain Management domain.

[0183] From natural language requirements, five entities (Order, Supplier, Material, ProductionLine, and Delivery), 23 attribute fields, and eight relationships between entities were extracted, and a tag-based metamodel was created in YAML format with 17 structure tags, 4 search tags, 6 logic tags, and 3 security tags assigned.

[0184] PostgreSQL 16.2 was used for the relational database, and Neo4j 5.18 was used for the knowledge graph database.

[0185] In addition, OpenAI text-embedding-3-small (1,536 dimensions) was used as the embedding model, Neo4j HNSW index as the vector index, and GPT-4o (gpt-4o-2024-08-06) as the response generation language model.

[0186] The experimental environment was configured with an AWS EC2 m6i.4xlarge instance (16 vCPU, 64GB RAM) and the Ubuntu 22.04 LTS operating system.

[0187] Comparative Example 1

[0188] In Comparative Example 1, a Vector-based Search Augmentation Generative (Vector-based RAG) system was implemented targeting the same domain as the Example.

[0189] After converting transaction data into a natural language document format, a vector index was created by splitting it into chunks of 512 tokens.

[0190] The embedding model used was OpenAI text-embedding-3-small, the vector repository was FAISS, and the index update cycle was set to 70 minutes. The response generation language model used was GPT-4o (gpt-4o-2024-08-06).

[0191] The experimental environment was configured with an AWS EC2 m6i.4xlarge instance (16 vCPU, 64GB RAM) and Ubuntu 22.04 LTS, identical to the example.

[0192] Comparative Example 2

[0193] In Comparative Example 2, a GraphRAG (Graph Search Augmentation) system based on an LLM graph extraction method was implemented for the same domain as the example.

[0194] It was configured to convert transaction data into natural language document form, extract entities and relationships using a large-scale language model, and generate a knowledge graph.

[0195] Microsoft GraphRAG (v0.3.6) was used as the graph construction framework, GPT-4o was used as the graph extraction model, and graph generation was configured to be performed using a batch processing method.

[0196] The answer generation language model used was GPT-4o (gpt-4o-2024-08-06).

[0197] The experimental environment was configured with an AWS EC2 m6i.4xlarge instance (16 vCPU, 64GB RAM) and Ubuntu 22.04 LTS, identical to the example.

[0199] Experimental Example 1 - Measurement of latency from data generation to the point where querying becomes possible

[0200] For the systems of Example, Comparative Example 1 and Comparative Example 2, the delay time (Data-to-Query Latency) from the generation of transaction data until a query response based on said data becomes possible was measured.

[0201] A total of 50,000 order transaction data were injected under throughput conditions of 100 transactions per second (100 TPS), 500 transactions (500 TPS), 1,000 transactions (1,000 TPS), and 5,000 transactions (5,000 TPS), respectively.

[0202] The difference between the time of occurrence of each transaction and the time when a response to a query containing the corresponding transaction data became available for the first time was measured, and the average value was calculated by applying the measurement to 1,000 transactions per condition. The measurement results are shown in Table 1 below.

[0203] TPS condition (TPS) Examples (ms) Comparative Example 1 (ms) Comparative Example 2 (ms) 100 450 4,200,000 17,400,000 500 780 4,200,000 19,800,000 1,000 1,200 4,200,000 23,100,000 5,000 5,800 4,200,000 31,600,000

[0204] As shown in Table 1, in Comparative Example 1, since the FAISS index update is performed in a batch processing method with a 70-minute cycle, a constant delay of approximately 4,200,000 ms occurred regardless of the TPS condition. In Comparative Example 2, since LLM-based graph extraction is performed in a batch processing method, a delay of approximately 17,400,000 ms occurred under the 100 TPS condition, and as the TPS increased, the batch processing waiting time increased to approximately 31,600,000 ms under the 5,000 TPS condition.

[0205] In the example, save commands for PostgreSQL and Neo4j were executed synchronously at the time of transaction occurrence, showing an average of 450 ms under 100 TPS conditions, and increased to 780 ms under 5,000 TPS conditions due to the accumulation of synchronous processing load as TPS increased, but maintained a lower level compared to the 100 TPS conditions of Comparative Example 1 and Comparative Example 2.

[0206] Through Experimental Example 1, it was confirmed that the system of the embodiment achieved significantly lower latency compared to Comparative Examples 1 and 2, which are based on batch processing, through a real-time construction environment in which the knowledge graph is updated simultaneously with the occurrence of transaction data. In particular, it was confirmed that real-time performance in a large-scale transaction processing environment is stably maintained, as the increase in latency was minimal even in a high-load environment where throughput increased.

[0208] Experimental Example 2 - Measurement of the Accuracy of Knowledge Graph Structure

[0209] The accuracy of the knowledge graph generated for the systems of Example and Comparative Example 2 was evaluated. Comparative Example 1 was excluded from the evaluation of this experimental example because it does not use a knowledge graph.

[0210] Based on 50,000 transaction records stored in PostgreSQL, a Ground Truth Graph consisting of 12,847 nodes and 31,204 edges was constructed.

[0211] The knowledge graphs and ground truth graphs generated by the Example and Comparative Example 2 were compared to measure the Graph Hallucination Rate, Graph Omission Rate, Node Precision, and Edge Precision. For Comparative Example 2, the process was repeated 10 times on the same dataset to reflect the probabilistic characteristics of LLM-based extraction, and the average value was calculated. The measurement results are shown in Table 2 below.

[0212] Measurement indicators Examples Comparative Example 2 Graph Hallucination Rate (%) 0.05 14.7 Graph Omission Rate (%) 1.50 11.3 Node precision (%) 99.8 85.3 Edge precision (%) 99.5 76.8 Graph structure match rate (%) between 10 iterations 100.0 61.4

[0213] As shown in Table 2, Comparative Example 2, which relies on probabilistic inference of LLM, had a hallucination rate of 14.7%, generating relationships that do not exist in the ground truth graph, and a structural match rate of 61.4%, as the results varied each time it was run on the same dataset. Since the Example uses a deterministic projection algorithm through a tag-based metamodel, the graph hallucination rate was measured to be less than 0.05%, confirming that the hallucination problem was resolved.

[0214] In addition, the example demonstrated high reproducibility and reliability by showing a 100% match rate even after 10 iterations. However, the 1.5% graph omission rate was determined to be due to some attributes for which tags were not explicitly assigned in the natural language requirements, and it was confirmed to be within a controllable range through metamodel definition.

[0215] Through Experimental Example 2, it was confirmed that the system of the example achieved significantly superior performance in terms of graph illusion rate, omission rate, and reproducibility compared to the LLM-based graph extraction method through a deterministic transformation algorithm of a tag-based metamodel.

[0217] Experimental Example 3 - Measurement of Answer Accuracy and Processing Efficiency for Multi-stage Inference Queries

[0218] For the systems of Example, Comparative Example 1 and Comparative Example 2, the answer accuracy and processing efficiency were measured for queries requiring multi-stage inference.

[0219] The evaluation queries consisted of a total of 100 queries, comprising 30 single-entity queries, 40 two-level inference queries, and 30 multi-level inference queries. The answers for each query were written based on results retrieved directly from PostgreSQL.

[0220] Answer accuracy was measured by the Exact Match rate, F1 Score, and Faithfulness rate; the Faithfulness rate was calculated as the proportion of factual claims included in the generated answers that matched the correct answers based on PostgreSQL standards.

[0221] Processing efficiency was measured by the average number of prompt tokens input into the language model and the Query Response Time. The measurement results are shown in Tables 3 and 4 below.

[0222] Query Types Measurement indicators Examples Comparative Example 1 Comparative Example 2 Single entity lookup Correct Answer Match Rate (%) 91.3 79.4 82.7 Single entity lookup F1 Score 0.93 0.82 0.85 2-step inference Correct Answer Match Rate (%) 86.4 54.3 72.8 2-step inference F1 Score 0.88 0.59 0.76 Multi-step reasoning of 3 or more steps Correct Answer Match Rate (%) 81.7 42.1 59.4 Multi-step reasoning of 3 or more steps F1 Score 0.84 0.46 0.63 entire Fact-based response rate (%) 89.6 73.1 80.4

[0223] Measurement indicators Examples Comparative Example 1 Comparative Example 2 Average number of prompt tokens 2,614 3,184 6,879 Average question response time (ms) 1,836 2,913 6,487

[0224] As shown in Table 3, in a single entity lookup query, Comparative Example 1, Comparative Example 2, and Example showed correct answer rates of 79.4%, 82.7%, and 91.3%, respectively, indicating that the performance difference between the three systems was relatively small. As the inference stage increased, the performance gap between the systems widened significantly, and in a multi-stage inference query with three or more stages, Comparative Example 1 showed a correct answer rate of 42.1% and Comparative Example 2 showed a rate of 59.4%, while Example maintained 81.7%.

[0225] This is analyzed as a result of Comparative Example 1, a chunk-unit search method, having structural limitations in inferring connection relationships between entities, and Comparative Example 2, where hallucinatory nodes and edges in the LLM-based graph extraction process cumulatively affect the multi-stage inference path.

[0226] In particular, in the case of Comparative Example 1, the drop in the correct answer match rate due to the increase in the inference step reached 37.3%p compared to a single entity lookup, confirming that there are limitations in restoring relationships between chunks without a graph structure.

[0227] The fact-based response rates for all inquiries were 73.2% for Comparative Example 1, 80.4% for Comparative Example 2, and 89.6% for the Example.

[0228] In addition, as shown in Table 4, the average number of prompt tokens in the example was 2,614 tokens, which is 61.9% less than the 6,873 tokens in Comparative Example 2, and the average question response time in the example was 1,836 ms, which is 71.7% less than the 6,487 ms in Comparative Example 2. This is analyzed as a result of the size of the subgraph being limited to nodes and edges related to the query through pruning processing by the allowed path of search.

[0229] Through Experimental Example 3, it was confirmed that the system of the example shows an increased advantage in accuracy compared to the comparative example as the query requires multi-stage reasoning, and that both answer accuracy and processing efficiency are improved simultaneously.

[0231] Although all components constituting the embodiments of the present invention have been described above as being combined or operating in combination, the present invention is not necessarily limited to such embodiments. That is, within the scope of the purpose of the present invention, all components may be selectively combined in one or more ways to operate.

[0232] Furthermore, terms such as "include," "compose," or "have" as described above, unless specifically stated otherwise, mean that the relevant component may be inherent; therefore, they should be interpreted as allowing for the inclusion of additional components rather than excluding them. All terms, including technical or scientific terms, have the same meaning as generally understood by those skilled in the art to which the present invention pertains, unless otherwise defined. Commonly used terms, such as those defined in advance, should be interpreted in accordance with their meaning in the context of the relevant technology and should not be interpreted in an ideal or overly formal sense unless explicitly defined in the present invention.

[0233] Furthermore, the above description is merely an illustrative explanation of the technical concept of the present invention, and those skilled in the art to which the present invention pertains will be able to make various modifications and variations within the scope of the essential characteristics of the present invention.

[0234] Accordingly, the embodiments disclosed in this invention are intended to illustrate, not limit, the technical concept of the invention, and the scope of the technical concept of the invention is not limited by these embodiments. The scope of protection of this invention shall be interpreted by the claims below, and all technical concepts within an equivalent scope shall be interpreted as being included within the scope of rights of this invention. Explanation of the symbols

[0235] 100: Real-time graph search augmentation generation system using a tag-based metamodel according to an embodiment of the present invention 110: Metamodel generation section 111: Entity Extraction Module 112: Tagging Module 120: Dual storage unit 121: Command generation module 122: Execution module 130: Answer generation section 131: Graph Search Module 132: Answer generation module

Claims

Claim 1 A metamodel generation unit that generates a tag-based metamodel from natural language requirements; a dual storage unit that stores transaction data in a relational database (RDBMS) and a knowledge graph based on the tag-based metamodel and generates a deterministic graph structure; The system includes an answer generation unit that generates an answer to a user query based on the above deterministic graph structure, and the metamodel generation unit includes an entity extraction module that extracts entities from the above natural language requirements and a tag assignment module that generates the tag-based metamodel by assigning semantic tags to the entities, wherein the semantic tags define data processing rules and include a structure tag, a retrieval tag, a logic tag, and a security tag; the dual storage unit includes a command generation module that generates a first storage command for storing the transaction data in the relational database based on the semantic tags and a second storage command for storing the transaction data in the knowledge graph, and an execution module that synchronously executes the first storage command and the second storage command, maintains the integrity of the transaction data according to the first storage command, and converts the transaction data into nodes and edges according to the second storage command to generate the deterministic graph structure, and the answer generation unit searches the deterministic graph structure based on the tag-based metamodel. A real-time graph search augmentation generation system using a tag-based metamodel, comprising a graph search module that generates a subgraph and an answer generation module that inputs the subgraph into a language model to generate an answer to a user query. Claim 2 A real-time graph search augmentation generation system using a tag-based metamodel according to claim 1, wherein the tag assignment module defines rules for converting transaction data into the node and the edge through the structure tag, defines the search entry point and search priority of the graph search module through the search tag, defines the allowed search path of the graph search module through the logic tag, and controls the exposure range of sensitive information during the search of the knowledge graph through the security tag. Claim 3 The real-time graph search augmentation generation system using a tag-based metamodel according to claim 1, wherein the execution module converts the attribute field value of the entity designated as a search entry point by the search tag into an embedding vector and stores it as a node attribute of the knowledge graph when the second storage command is executed. Claim 4 In claim 3, the graph search module determines a search entry point through a similarity search using the embedding vector, and generates the subgraph by searching the deterministic graph structure along a search allowance path defined in the logic tag, thereby creating a real-time graph search augmentation generation system using a tag-based metamodel. Claim 5 In claim 1, the answer generation module processes the attributes of the subgraph to which the security tag is specified, and inputs the masked subgraph into the language model, thereby creating a real-time graph search augmentation generation system using a tag-based metamodel.

Images