Method and Apparatus for Generating Document with Separated Structure and Content Using Generative Model

The method addresses document generation inefficiencies by separating structure and content, ensuring consistent format and style, and enhancing accuracy through vector space analysis, enabling high-quality, domain-specific document creation.

KR103044691B1Active Publication Date: 2026-11-11INFOGRAB LTD
View PDF 4 Cites 0 Cited by

Patent Information

Application Number
KR1020250188795
Authority / Receiving Office
KR · KR
Patent Type
Patents
Current Assignee / Owner
Filing Date
2025-12-03
Publication Date
2026-11-11
Estimated Expiration
2045-12-03

AI Technical Summary

Technical Problem

Conventional generative models struggle with maintaining document structure and format consistency, integrating multimodal data, and ensuring style portability across platforms, leading to inefficiencies and inaccuracies in document generation.

Method used

A method that separates structure and content generation using a generative model, analyzing multimodal input to define a layout and template, and generating content suitable for each structural component, with enforced styles and formats, while projecting context information into a vector space to enhance accuracy.

Benefits of technology

Ensures high-quality document generation with consistent format and style across platforms, reducing hallucination and errors, and enabling easy creation of domain-specific documents without manual post-processing.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 112025136077634-PAT00002_ABST
    Figure 112025136077634-PAT00002_ABST
Patent Text Reader

Abstract

A method for generating a structure-content separated document using a generative model according to one embodiment disclosed in this specification includes the steps of obtaining context information and multimodal input corresponding to a user, and inputting the information into a generative model to generate layout data defining the document creation intent and logical structure, and determining a structure template through user confirmation. Subsequently, each structural component within the structure template is identified, and a content generation prompt for each component is generated and input into the generative model to generate content to be mapped within structural constraints. Finally, the generated content is mapped to the structure template to create document data including inline style attributes and provide it to a user terminal. At this time, the content generation process is characterized by increasing accuracy by selectively utilizing only the information associated with each structural component through vector analysis of the context information.
Need to check novelty before this filing date? Find Prior Art

Description

Technology Field

[0001] The present invention relates to an artificial intelligence-based document creation technology, and more specifically, to a method for automatically generating a high-quality structured document that corresponds to user intent and multimodal input by utilizing a generative model to process the logical structure and content of a document separately, and to an apparatus for performing the same. Background Technology

[0002] In modern society, artificial intelligence (AI), particularly generative model technologies such as Large Language Models (LLMs), is driving innovative changes in various fields including text generation, summarization, translation, and code writing. These generative models learn from vast amounts of text data to construct fluent sentences comparable to those of humans, and recently, their capabilities have expanded to include multimodal functions that process not only text but also various forms of data such as images and charts. Consequently, it has become commonplace for companies and individuals to rely on AI assistance when drafting various business documents, such as reports, proposals, and emails.

[0003] However, conventional document creation technologies using generative models focus primarily on generating 'text content' itself, so there are clear technical limitations in producing a completed 'structured document'.

[0004] First, because conventional generative models follow an autoregressive approach that predicts and generates text sequentially, they are weak at maintaining consistency in the overall layout or hierarchical structure of a document. For example, if a user requests, "Please write a business plan," the model can plausibly generate text for the introduction, body, and conclusion, but it cannot perfectly control visual and structural formatting, such as the size of titles, indentation of body text, merging of table cells, and placement of images. In most cases, the output produced by the model is unstructured plain text or merely a simple tag format like Markdown. Consequently, users faced the inconvenience of having to go through manual post-processing steps, such as copying and pasting the generated text into a separate word processor or editing tool, and then setting the font and layout.

[0005] Second, conflicts between the 'content' and 'format' of documents frequently occur. In existing technologies, models are requested to generate content and form structure simultaneously; however, as the length of the text to be generated increases or the content becomes more complex, the model exhibits a phenomenon known as "Hallucination of Structure," where it forgets or violates predefined structural constraints. Conversely, enforcing strict templates or formats degrades the model's creative text generation ability, leading to awkward contextuality or the omission of information as content is forcibly fitted into designated cells. This is a major obstacle to the adoption of AI in domains requiring strict formats, such as technical specifications, legal documents, and administrative notices.

[0006] Third, there is a deficiency in the integration and rendering of multimodal data. Modern documents are not merely a simple sequence of text, but are composed of a mixture of structured data (databases, Excel sheets, etc.) and unstructured data (memos, images, etc.). When integrating such heterogeneous data into a single document, conventional technology lacks the ability to automatically select and place appropriate visual components (charts, tables, highlight boxes, etc.) suited to the nature of the data. In particular, it is difficult to guarantee data integrity because even for data where accuracy is paramount, such as code blocks or quantitative indicators, the generative model sometimes arbitrarily modifies or transforms them based on the context before outputting them.

[0007] Fourth is the issue of style attribute portability. When documents generated on web-based or specific platforms are transmitted to user devices (PCs, mobile devices, etc.), Cascading Style Sheets (CSS), which define the document's style, are often managed as separate files or processed in a platform-dependent manner. This leads to problems where styles break or the document appears different from the original when a user downloads it or opens it in a different environment. In other words, there is a technical barrier preventing the document's intended 'Look and Feel' from being fully conveyed to the end user.

[0008] Therefore, there is a growing need for a new type of document generation architecture that can leverage the powerful language generation capabilities of generative models while maintaining the logical structure and visual style of documents, particularly a technology capable of effectively separating and recombining content generation and structure control.

[0009] The aforementioned background technology is technical information that the inventor possessed for the derivation of the present invention or acquired during the process of deriving the present invention, and it cannot be considered technology that was disclosed to the general public prior to the filing of the present invention. The problem to be solved

[0010] The present invention was devised to solve the problems of the prior art as described above, and aims to provide a process for separating and processing the structural framework (layout and template) of a document and the content to be filled therein using a generative model.

[0011] Specifically, the present invention aims to provide a complete document that can be used immediately without separate post-editing by analyzing multimodal input to first define an optimal layout suitable for the document's creation intent and domain, generating a structural template with enforced styles and formats based on this, and then generating and injecting content suitable for each structural component.

[0012] In addition, the present invention aims to reduce hallucination in generative models and increase the accuracy of content by projecting context information into a vector space and selectively injecting only information highly associated with structural components into the prompt. means of solving the problem

[0014] A method for generating a structure-content separated document using a generative model in one embodiment of the present specification for achieving the above-described objective may include: acquiring context information and multimodal input corresponding to a user; inputting the context information and the multimodal input into a generative model to generate layout data defining a document creation intent and a logical structure of a document and transmitting it to a user terminal; acquiring user response information regarding the layout data from the user terminal and determining a structure template based on the user response information and the layout data; identifying each structural component within the structure template and generating a content creation prompt for each structural component by referring to the document creation intent and the multimodal input; setting the structure template as a structural constraint and inputting the content creation prompt into the generative model to generate content to be mapped within the area of ​​each structural component; and generating document data mapped to the content in the structure template and providing it to the user terminal.

[0015] The above multimodal input is composed of a plurality of heterogeneous data entities including structured data and unstructured data, and the step of generating the layout data may include the step of analyzing the attribute vector of each of the heterogeneous data entities to identify a target domain among technical specifications, analytical research, or administrative notices, and the step of determining a document ontology having a predefined logical topology corresponding to the target domain.

[0016] The above layout data is defined as a hierarchical node structure that controls the logical flow of the document to be generated, and each node within the hierarchical node structure functions as a discrete generation partition that occupies an independent rendering area within the structure template, and the step of determining the structure template may include a step of performing logic to map style attributes and data representation formats corresponding to each node.

[0017] The above structural template is composed of a set of syntactic markup elements based on a document object model, and each of the markup elements encapsulates style definition data in the form of inline attributes that enforce visual rendering attributes corresponding to the document creation intent, so that when text is generated by the generation model, the structural constraints of the corresponding markup elements are dependently followed.

[0018] The step of generating the content generation prompt may include inferring the semantic type of data to be mapped to each structural component, verifying the compatibility between the inferred type and the markup container within the structural template, and, if the source data includes code logic or a quantitative matrix, injecting a directive into the prompt to cause the generation model to place the data within a preformat container having rendering invariance.

[0019] Additionally, the step of generating the content generation prompt may further include the steps of projecting the entire acquired context information onto a vector space and calculating the degree of association of the semantic range of each structural component of the structural template, and selectively extracting only the information with an degree of association greater than or equal to a threshold to form a local context segment, and combining this with the generation constraint of the corresponding structural component to inject it into the inference window of the generation model.

[0020] The step of determining the above structural template can be performed by cross-referencing and synthesizing a natural language-based style descriptor that defines the tone and rhetoric permeating the entire document and structural topological data that defines the visual skeleton of each section. At this time, the generative model can synchronously perform a natural language generation process that generates text content based on the style descriptor and a structuring process that injects the generated content into tag syntax defined by the structural topological data.

[0021] The step of generating the document data may include encapsulating individual content blocks derived from a plurality of structural components into a single document object having a specified root identifier, and serializing a markup stream containing header information, metadata, and a body section within the encapsulated document object and transmitting it to a user terminal, wherein the user terminal renders the document through inline style attributes inherent in the serialized markup stream itself without loading a separate style sheet.

[0022] A computer device according to another embodiment of the present specification includes a processor and a memory for storing instructions to be executed by the processor, wherein the instructions may be configured to perform the steps of: acquiring context information and multimodal input corresponding to a user; inputting the context information and the multimodal input into a generation model to generate layout data defining a document creation intent and a logical structure of a document and transmitting it to a user terminal; acquiring user response information regarding the layout data from the user terminal and determining a structural template based on the user response information and the layout data; identifying each structural component within the structural template and generating a content creation prompt for each structural component by referring to the document creation intent and the multimodal input; setting the structural template as a structural constraint and inputting the content creation prompt into the generation model to generate content to be mapped within the area of ​​each structural component; and generating document data mapped to the content in the structural template and providing it to the user terminal.

[0023] Another embodiment of the present specification may provide a computer-readable recording medium that stores instructions for executing the methods described above when executed by a computer. Effects of the invention

[0024] According to one embodiment of the present invention, by separating the structure (layout) and content generation of a document, the text generation capability of a generative model and the visual / logical completeness of the document can be simultaneously secured. In other words, a document can be generated that is rich in content without compromising its format.

[0025] According to one embodiment of the present invention, by analyzing a user's multimodal input (structured / unstructured data) and automatically determining a document ontology suitable for a target domain (technical specifications, research, administrative notices, etc.), even a user without specialized knowledge can easily create high-quality documents that meet the purpose.

[0026] According to one embodiment of the present invention, style definition data is encapsulated as inline attributes within a structural template, thereby providing portability that allows a document to be rendered immediately with a consistent style on a user terminal without the need for a separate style sheet file.

[0027] According to one embodiment of the present invention, by selecting only the local context associated with each structural component and injecting it into the prompt, information dilution or errors that may occur during long context processing can be prevented, and rendering invariance can be maintained even for special data such as code or matrices.

[0028] The effects of the present invention are not limited to those mentioned above. Brief explanation of the drawing

[0029] FIG. 1 is a schematic diagram illustrating the overall system configuration for providing a structure-content separated document generation service using a generative model according to one embodiment of the present invention. FIG. 2 is a flowchart illustrating the overall flow of a document generation method according to one embodiment of the present invention in chronological order. FIG. 3 is a flowchart illustrating the process of identifying a target domain and determining a document ontology by analyzing heterogeneous data objects of multimodal input in one embodiment of the present invention. FIG. 4 illustrates the structure of layout data according to an embodiment of the present invention and is an example diagram for explaining the concepts of a hierarchical node structure and a discrete generated partition. FIG. 5 illustrates the configuration of a structural template according to an embodiment of the present invention and is a conceptual diagram showing the structure of a markup element in which style definition data is encapsulated as an inline attribute. FIG. 6 is a flowchart illustrating detailed logic for inferring the type of data to be mapped to a structural component and determining whether to process a free format container in one embodiment of the present invention. FIG. 7 is a conceptual diagram illustrating the process of projecting context information into a vector space to calculate the degree of association with structural components and extracting local context segments in one embodiment of the present invention. FIG. 8 illustrates the operation process of a generative model according to an embodiment of the present invention, and is a diagram showing the process in which a natural language generation process and a structuring process are performed synchronously to inject content. FIG. 9 is a data conceptual diagram illustrating the process of encapsulating generated content blocks into a single document object and serializing them to generate a markup stream in one embodiment of the present invention. FIG. 10 illustrates an example screen when an embodiment of the present invention is implemented in a user terminal, and is an example of a multimodal input screen, a layout selection screen, and a final document rendering screen. FIG. 11 is a block diagram schematically illustrating a computer device according to one embodiment of the present invention. Specific details for implementing the invention

[0030] The terms used in this invention are used merely to describe specific embodiments and are not intended to limit the scope of other embodiments. A singular expression may include a plural expression unless the context clearly indicates otherwise. Terms used herein, including technical or scientific terms, may have the same meaning as generally understood by those skilled in the art as described in this invention. Terms used in this invention that are defined in a general dictionary may be interpreted as having the same or similar meaning as they have in the context of the relevant technology, and are not interpreted in an ideal or overly formal sense unless explicitly defined in this invention. In some cases, even terms defined in this invention may not be interpreted to exclude embodiments of this invention.

[0031] Below, various embodiments are described in detail with reference to the attached drawings so that those skilled in the art can easily implement the present invention. However, since the technical concept of the present invention can be modified and implemented in various forms, it is not limited to the embodiments described in this specification. In describing the embodiments disclosed in this specification, if it is determined that specifically describing related known technologies may obscure the essence of the technical concept of the present invention, such specific description of known technologies is omitted. Identical or similar components are assigned the same reference numerals, and redundant descriptions thereof are omitted.

[0032] In this embodiment, the term "~part" refers to a component that performs a specific function performed by software or hardware such as an FPGA (Field Programmable Gate Array) or an ASIC (Application Specific Integrated Circuit). However, "~part" is not limited to being performed by software or hardware. "~part" may exist in the form of data stored on an addressable storage medium, or it may be implemented by instructions and configured so that one or more processors execute a specific function.

[0033] Software may include computer programs, code, instructions, or a combination of one or more of these, and may configure a processing unit to operate as desired or instruct the processing unit independently or collectively. Software and / or data may be permanently or temporarily embodied in any type of machine, component, physical device, virtual equipment, computer storage medium or device, or transmitted signal wave in order to be interpreted by the processing unit or to provide instructions or data to the processing unit. Software may be distributed over networked computer systems and may be stored or executed in a distributed manner. Software and data may be stored on one or more computer-readable recording media. Software may be read into main memory from other computer-readable media, such as data storage devices, or from other devices via communication interfaces. Software instructions stored in main memory may cause the processor to perform processes or steps, which will be described in detail below. Alternatively, processes consistent with the principles of the present invention may be executed using a fixed wiring circuit instead of or in combination with software instructions. Accordingly, embodiments consistent with the principles of the present invention are not limited to any specific combination of hardware circuits and software.

[0034] The terms used in this application are used merely to describe specific embodiments and are not intended to limit the invention. Singular expressions include plural expressions unless the context clearly indicates otherwise. In this application, terms such as “comprising” or “having” are intended to indicate the presence of the features, numbers, steps, actions, components, parts, or combinations thereof described in the specification, and should be understood as not precluding the existence or addition of one or more other features, numbers, steps, actions, components, parts, or combinations thereof. Terms such as “first,” “second,” etc., may be used to describe various components, but the components should not be limited by these terms. These terms are used solely for the purpose of distinguishing one component from another.

[0035] FIG. 1 is a schematic diagram illustrating the overall system configuration for providing a structure-content separated document generation service using a generative model according to one embodiment of the present invention.

[0036] Referring to FIG. 1, a document generation system (100) may be configured to include a user terminal (120), a network (130), and a server (110). The user terminal (120) and the server (110) may be connected to transmit and receive data to and from each other through the network (130).

[0037] A user terminal (120) is an electronic device used by a user requesting document creation, and can perform the function of acquiring context information and multimodal input corresponding to the user. The user terminal (120) can be implemented as various computing devices equipped with wired and wireless communication capabilities, such as a desktop computer, a laptop computer, a smartphone, a tablet PC, or a wearable device. The user terminal (120) may be equipped with an input / output interface for receiving multimodal input including various forms of unstructured data and structured data, such as text, images, voice, or files.

[0038] Additionally, the user terminal (120) can provide layout data or intermediate results received from the server (110) to the user by displaying them on a display screen. The user terminal (120) can obtain user feedback, i.e., user response information regarding the displayed layout data, and transmit it back to the server (110). Finally, the user terminal (120) receives structure-content separated document data generated by the server (110) and can render the completed document using style attributes inherent in the data itself without a separate style sheet loading process.

[0039] The network (130) may refer to a communication path that relays data packets between a user terminal (120) and a server (110). The network (130) may include a local area network, a wide area network, a value-added network, a mobile network, a satellite network, or a combination thereof. The network (130) may be constructed using wired internet technology or wireless internet technology.

[0040] The server (110) may be a core computing device that runs a generative model to automatically generate a document corresponding to the user's intent. The server (110) includes at least one processor and memory and may be programmed to perform each step of the document generation method described in claims 1 through 8.

[0041] Specifically, the server (110) can provide context information and multimodal input received from the user terminal (120) as input values ​​to a generative model. Here, the generative model is a large-scale language model (LLM) or a multimodal generative model and may include an artificial intelligence algorithm capable of analyzing the meaning of input data and generating text and code.

[0042] The server (110) can primarily generate layout data that defines the intention to create a document and the logical structure of the document through a generation model and transmit it to a user terminal (120). In this process, the server (110) can analyze the attribute vectors of heterogeneous data objects included in the multimodal input to identify target domains such as technical specifications, analytical research, or administrative notices, and determine a document ontology suitable for them.

[0043] The server (110) can determine a final structure template by reflecting user response information received from the user terminal (120). The structure template consists of a set of syntactic markup elements based on a document object model, and each element may include style definition data that enforces visual rendering attributes.

[0044] The server (110) can identify each structural component within a determined structural template and generate content creation prompts for each component to generate content to be filled in the area of ​​each component. At this time, the server (110) can include local context segments in the prompts, which are extracted by projecting context information into a vector space and extracting only information that is highly associated with the corresponding component.

[0045] The server (110) can input a content creation prompt into the creation model while the structural template is set as a structural constraint. Through this, the server (110) can generate text or data content to be mapped within each structural component area, and at the same time, control the placement of the content according to the format of the structural template.

[0046] The server (110) can map the generated content to a structural template to encapsulate it into a single document object, convert it into document data in the form of a serialized markup stream, and provide it to a user terminal (120). Through this, the system (100) can efficiently provide a high-quality document combining a logical structure and a sophisticated style with only simple input from the user.

[0047] FIG. 2 is a flowchart illustrating the overall flow of a document generation method according to one embodiment of the present invention in chronological order.

[0048] Referring to FIG. 2, the server (110) can obtain context information and multimodal input corresponding to the user at step S210. The server (110) can receive data packets through a network interface connected to the user terminal (120). The context information may include identity information of the subject creating the document, job roles within the organization, style history of previously created documents, or project metadata at the time of creation. The server (110) can use the context information to set the tone and manner of speech of the document to be created in a personalized form.

[0049] Additionally, the server (110) can receive multimodal input that serves as the basic material for creating a document. The multimodal input may consist of multiple heterogeneous data objects, including structured data in the form of a text file or spreadsheet, images, voice recording files, or unstructured data such as PDF documents. The server (110) can perform a preprocessing process on the received heterogeneous data objects to perform text extraction, image caption generation, or speech-to-text conversion (STT), and convert them into machine-readable embedding vectors and store them in memory.

[0050] In step S220, the server (110) inputs context information and multimodal input into a generative model to generate layout data that defines the document creation intent and the logical structure of the document, and transmits this to the user terminal (120). The server (110) can semantically analyze the user's natural language instructions and the content of the input data by utilizing a generative model based on a large-scale language model (LLM). The server (110) can identify the target domain to which the document belongs by analyzing the attribute vector of the data included in the multimodal input. The target domain may include categories such as business plans, technical specifications, meeting minutes, research reports, or marketing proposals.

[0051] The server (110) can construct the skeleton of a document by referencing a predefined document ontology corresponding to the identified target domain. The layout data can be generated as a hierarchical node structure that controls the logical flow of the entire document. Each node within the hierarchical node structure can be defined as a discrete generated partition that occupies an independent rendering area within the document, such as a title, subtitle, body text, bulleted list, table, or image area. The server (110) can generate tree-structured layout data using JSON (JavaScript Object Notation) or XML format and transmit it to a user terminal (120).

[0052] In step S230, the server (110) obtains user response information regarding layout data from the user terminal (120) and can determine a structure template based on the user response information and the layout data. The user terminal (120) renders the received layout data into a visual interface and presents it to the user, and the user can input feedback such as changing the order of nodes, adding or deleting specific sections, or modifying the hierarchical structure. The server (110) can update the layout data by receiving this user response information.

[0053] Next, the server (110) can generate a structural template by performing logic to map specific style attributes and data representation formats to each node of the finalized layout data. The structural template may consist of a set of syntactic markup elements based on the Document Object Model (DOM). The server (110) can inject style data defining visual rendering attributes, such as font size, margins, alignment, and color codes, into each markup element by encapsulating it in the form of inline attributes. Through this, the structural template can serve as an empty template that perfectly maintains the visual form of the document even when it is not filled with content.

[0054] In step S240, the server (110) can identify each structural component within the structural template, generate a content generation prompt for each structural component, and input this into a generation model to generate content to be mapped within the area of ​​each structural component. This step may include an advanced inference process to ensure consistency between structure and content, rather than simple text generation.

[0055] First, the server (110) can project the entire context information and multimodal input obtained for prompt optimization onto a high-dimensional vector space. The server (110) can calculate the semantic relevance between the subject required by the structural component (specific paragraph or section) currently to be processed and the data within the vector space. The server (110) can construct a local context segment by selectively extracting only the information where the relevance is greater than or equal to a preset threshold.

[0056] The server (110) can construct a content creation prompt by combining the extracted local context segment and the role definition (directive) of the corresponding component. At this time, the server (110) can input the markup structure of the structure template determined in step S230 itself as a constraint on the creation model. For example, the server (110) can inject a system prompt into the creation model in the form of "Generate the following text, but place it appropriately within the provided HTML tag structure."

[0057] Additionally, if the server (110) determines that the data to be mapped to the component includes code logic, formulas, or quantitative matrices, the generating model renders the data into a freeformat container having rendering immutability (e.g., <pre>, <code>Instructions that force placement within a , or a Markdown table) can be included in the prompt. This allows the server (110) to generate text, numeric data, or code that maps exactly within the area of ​​each structural component.

[0058] In step S250, the server (110) can generate document data that maps the generated content to a structure template and provide it to the user terminal (120). In step S240, the server (110) can inject multiple content blocks that are individually generated into the corresponding locations of the structure template and encapsulate them into a single document object having a specified root identifier. The server (110) can serialize the encapsulated document object to generate a markup stream in which header information, metadata, style definitions, and body content are integrated.

[0059] The server (110) can transmit a serialized markup stream to a user terminal (120) via a network (130). The user terminal (120) can interpret the received data through a web browser or a dedicated viewer. At this time, since style information is included inline in each element within the document data, the user terminal (120) can immediately render and display the completed document on the screen without the process of loading or referencing a separate CSS file or style sheet.

[0060] FIG. 3 is a flowchart illustrating the process of identifying a target domain and determining a document ontology by analyzing heterogeneous data objects of multimodal input in one embodiment of the present invention.

[0061] Referring to FIG. 3, the server (110) can analyze the attribute vectors of each heterogeneous data object included in the multimodal input at step S310. The server (110) can identify the format of the input data including text, images, audio, and structured data, and remove noise by applying a preprocessing module suitable for each format. The server (110) can extract semantic features from the preprocessed data and generate numerical embedding vectors by projecting the extracted features into a high-dimensional vector space.

[0062] Specifically, the server (110) can perform morphological analysis and syntactic analysis on text data and generate a dense vector containing contextual information using a Transformer-based language model. The server (110) can perform object detection and optical character recognition (OCR) on image data to convert visual objects within the image and included text information into text-based metadata and then vectorize it. The server (110) can analyze column and row header information on structured data to extract the schemamatic meaning of the data and reflect it in an attribute vector. The server (110) can concatenate or weighted sum the generated heterogeneous data vectors to produce an integrated attribute vector representing the entire input data.

[0063] The server (110) can identify a target domain that defines the nature of the document to be generated based on the attribute vector analyzed in step S320. The server (110) can calculate the similarity between a plurality of reference domain vectors stored in a database and the calculated integrated attribute vector. The server (110) can search for the nearest domain cluster in vector space using cosine similarity or Euclidean distance.

[0064] The server (110) can classify the target domain as analytical research, financial reports, or market trend reports if the input data contains numerical tables, charts, or financial terms in a threshold ratio or higher. The server (110) can classify the target domain as technical specifications, development guides, or architecture design documents if the input data contains programming code, API endpoints, or system configuration diagrams. The server (110) can classify the target domain as meeting minutes, work logs, or administrative notices if the input data contains interactive text, date information, or a list of participants. In this case, the server (110) can correct the accuracy of domain identification by utilizing context information, including the user's job information or past document creation history, as a weight.

[0065] The server (110) can determine a document ontology having a predefined logical topology corresponding to the target domain identified in step S330. The document ontology may be a knowledge graph structure that defines essential components, hierarchical inclusion relationships between each element, and a narrative development sequence to ensure the logical completeness that the documents of the domain must possess.

[0066] The server (110) can retrieve and load a standard ontology model mapped to the identified target domain. Based on the loaded ontology model, the server (110) can form a tree structure extending from the top node to the end node of the document. If the target domain is a technical specification, the server (110) can determine an ontology that includes nodes such as the purpose of the document, system architecture, interface definition, data model, exception handling, and security requirements. If the target domain is a business proposal, the server (110) can determine an ontology that connects nodes such as proposal background, market analysis, proposal content, expected effects, and execution schedule in a sequential flow.

[0067] Additionally, the server (110) can dynamically modify the document ontology determined according to the specific content of the input multimodal data. If the input data contains multiple specific statistical indicators, the server (110) can additionally create and assign a 'statistical analysis details' node within the body section of the standard ontology. Through this process, the server (110) can determine a flexible layout structure that fully accommodates the characteristics of the input data while adhering to a domain-specific standard format.

[0069] FIG. 4 illustrates the structure of layout data according to an embodiment of the present invention and is an illustrative diagram for explaining the concepts of a hierarchical node structure and discrete generated partitions. With reference to FIG. 4, the process of a server structuring a document will be described in detail.

[0070] When the server receives a document creation request, it may generate layout data (400) to control the logical flow of the entire document. The layout data (400) may include top-level nodes that define major subject units, such as the introduction, body, and conclusion of the document. As illustrated in FIG. 4, the layout data (400) may consist of a first section node (411), a second section node (413), and a third section node (415) having a sequential flow. Each section node represents a semantic chunk distinguished within the document.

[0071] The second section node (413) is not composed of a single text block and can be branched into lower layers for more detailed content development. The server can analyze the second section node (413) to generate multiple lower nodes, namely the first discrete generated partition (421) and the second discrete generated partition (423).

[0072] A discrete generation partition refers to an independent unit of work in which a generation model performs a single text generation inference. Instead of generating a vast document as a whole, the server can generate content in parallel or sequentially by dividing it into manageable small units, such as a first discrete generation partition (421) and a second discrete generation partition (423). This prevents performance degradation of the generation model that may occur during long context processing.

[0073] Each discrete generated partition can correspond one-to-one with a specific visual area on the user terminal screen. The first discrete generated partition (421) can be mapped to and displayed in the first rendering area (431). The second discrete generated partition (423) can be mapped to and displayed in the second rendering area (433). The first rendering area (431) and the second rendering area (433) may have different styles or formats, and the server can improve the quality of the output by individually applying prompts suitable for the nature of each partition.

[0074] FIG. 5 illustrates the configuration of a structural template according to an embodiment of the present invention and is a conceptual diagram showing the structure of a markup element in which style definition data is encapsulated as an inline attribute. With reference to FIG. 5, the principle of combining content and style will be explained.

[0075] The structural template (510) serves as a container for the generated content and can follow the structure of the Document Object Model (DOM), which is a web standard technology. The structural template (510) may include one or more syntactic markup elements (520). The syntactic markup elements (520) serve as containers such as HTML div tags, p tags, or span tags.

[0076] A syntactic markup element (520) may contain an inline style definition (530) within it. An inline style definition (530) is a set of visual rules that must be applied immediately when the element is rendered without a separate CSS file reference. The inline style definition (530) may encapsulate and store specific design attribute information, such as font type, margin size, and layout method, in the form of key-value pairs.

[0077] When the server generates text content through the generative model, it can target content mapping slots within syntactic markup elements (520). As illustrated by the arrow in FIG. 5, inline style definitions (530) act as strong constraints on the output of the generative model.

[0078] Regardless of the length of the text generated by the generative model, the syntactic markup elements (520) wrap or align the text according to the layout rules set in the inline style definition (530). This provides the effect that the server can completely separate the text content generated by the model from the visual structure of the document, while allowing the user terminal to view the combined complete document.

[0079] FIG. 6 is a flowchart illustrating detailed logic for inferring the type of data to be mapped to a structural component and determining whether to process a free format container in one embodiment of the present invention.

[0080] Referring to FIG. 6, the server (110) can perform a procedure to determine the nature of the data to be filled into a specific structural component in the process of preparing to create content for that specific structural component within the structural template.

[0081] In step (S610), the server (110) can analyze multimodal input and context information to infer the semantic type of data to be mapped to the structural component currently being processed. The server (110) can identify whether the input data is general descriptive text, a tabular format containing numerical data, or a programming code block. At this time, the server (110) can predict the expected data type by referring to the node attributes of the layout data generated in the previous step.

[0082] In step (S620), the server (110) can verify the compatibility between the inferred semantic type and the markup container of the corresponding component within the structure template. If the data type requires a table structure and the assigned container is a simple text paragraph tag, the server (110) can decide to dynamically modify the structure template or convert the data representation method into a text summary form.

[0083] In step (S630), the server (110) can determine whether the source data to be mapped to the structural component corresponds to a special data type. The special data type may include code logic, expressions, or quantitative matrix data where the alignment of rows and columns is important.

[0084] If, as a result of the judgment in step (S630), the data corresponds to a special data type (Y), the server (110) can proceed to step (S650) and inject a directive into the prompt to have the generating model place the data within a freeformat container that has rendering immutability. A freeformat container may refer to a markup element that displays the original content as is, such as HTML's pre tag or code tag, without the browser arbitrarily interpreting whitespace and line breaks of the internal content. Through this, the server (110) can enforce that indentation or alignment is not broken when the generating model generates Python code or complex financial statement data.

[0085] On the other hand, if the result of the judgment in step (S630) is that the data is general text (N), the server (110) can proceed to step (S640) to perform a natural language generation process. The server (110) can control the generation model to generate fluent sentences that match the overall tone and context of the document.

[0086] FIG. 7 is a conceptual diagram illustrating the process of projecting context information into a vector space to calculate the degree of association with structural components and extracting local context segments in one embodiment of the present invention.

[0087] Referring to FIG. 7, the server (110) can perform an information retrieval and extraction process using a vector space (710) to increase the accuracy and relevance of text generation. The server (110) can embed and project the entire acquired context information and multimodal input data onto a high-dimensional vector space (710). Each point within the vector space (710) can represent an individual piece of information, a sentence, or a data object.

[0088] The server (110) can set a structural component range (720) by defining the semantic range covered by the structural component that intends to generate content. The structural component range (720) can be represented as an area centered on specific coordinates within a vector space (710) based on the title, intent, and content of the section and adjacent sections.

[0089] The server (110) can calculate the degree of association between the structural component range (720) and the projected information in the vector space (710). The degree of association can be calculated through Cosine Similarity or Euclidean Distance calculations. The server (110) can selectively filter only the information for which the calculated degree of association is greater than or equal to a preset threshold.

[0090] The server (110) can form a local context segment (730) by combining filtered information. The local context segment (730) may refer to a data block containing only information, numbers, or supporting materials directly related to the section currently being written within the entire document data. By combining the local context segment (730) with the generation constraints of the corresponding structural component and injecting it into the inference window of the generation model, the server (110) can induce the model to generate text that is specific and free of hallucination without losing the overall context.

[0091] FIG. 8 illustrates the operation process of a generative model according to an embodiment of the present invention, and is a diagram showing the process in which a natural language generation process and a structuring process are performed synchronously to inject content.

[0092] Referring to Fig. 8, the generative model can receive two main input streams to generate a document. The first input is a natural language-based style descriptor that defines the tone and speech that run through the entire document, and the second input is structural topological data that defines the visual skeleton of each section.

[0093] The generative model can synchronously perform a natural language generation process (810) and a structuring process (820) based on input data. The natural language generation process (810) is a process of generating human-readable meaningful text content based on style descriptors. The structuring process (820) is a process of generating grammatically correct markup code by complying with tag syntax or format rules defined by structural topological data.

[0094] The server (110) can control the generative model to determine in real time the logical structure where the text should be located at the same time as the model generates the text. For example, at the time the generative model generates the text "Project Overview" (natural language generation), it determines this as a title tag <h1>Can recognize and process the need to place (structure) within.

[0095] As a result of this synchronous execution, the server (110) can perform the content injection and synthesis (830) process. Content injection and synthesis (830) means that the generated natural language text is injected precisely at a specified node location of a structural template. In this process, the text content functions not as a simple string, but as part of a document object model (DOM) with style attributes applied.

[0096] Finally, the server (110) can generate completed document data by integrating the results produced from multiple structural components. The document data may consist of a serialized markup stream that includes header information, metadata, and a body section. Through this, the user terminal (120) can transmit the data to a rendering engine without separate post-processing to immediately visualize the completed document.

[0097] FIG. 9 is a data conceptual diagram illustrating the process of encapsulating generated content blocks into a single document object and serializing them to generate a markup stream in an embodiment of the present invention. FIG. 10 illustrates an example screen when an embodiment of the present invention is implemented on a user terminal, and is an example diagram of a multimodal input screen, a layout selection screen, and a final document rendering screen.

[0098] Hereinafter, the process of document data structuring and user interface operation according to an embodiment of the present invention will be described in detail with reference to FIGS. 9 and FIGS. 10.

[0099] Referring to FIG. 9, the server can obtain individual content blocks (910) generated through a generation model. The individual content blocks (910) may contain discrete units of information, such as text, image paths, table data, or code snippets, separated according to the logical structure of the document. For example, the individual content blocks (910) may be data pieces corresponding to each node of a structural template, such as an introduction, each paragraph of the body, a conclusion, or a bibliography.

[0100] The processor of the server can perform an encapsulation process that aggregates multiple individual content blocks (910) and integrates them into a single document object (920). The single document object (920) has a root identifier that encompasses the entire document and can form a tree structure arranged according to a logical hierarchy. The single document object (920) can be divided into a header and metadata area containing attribute information such as the document's title, author, creation date and time, or security level, and a body section area where the actual content of the document is placed. The processor can inject the individual content blocks (910) into the corresponding coordinates or tags of the body section according to the markup location information of the previously determined structure template.

[0101] Next, the processor can convert the encapsulated single document object (920) into a serialized stream (930) that is suitable for network transmission. Serialization may refer to the process of converting object data existing in memory into a series of byte streams or strings. The serialized stream (930) may be composed of a markup language format and may include tags defining the structure of the document, text data representing the content, and style attributes visually representing the elements.

[0102] In particular, each markup element within the serialized stream (930) may include inline style attributes. Inline style attributes may refer to a method of describing rendering information, such as font, color, margin, or alignment, directly within the tag without referencing a separate CSS (Cascading Style Sheets) file or external resources. Through this, the user terminal can immediately render the completed document without any additional style sheet loading waiting time upon receiving the serialized stream (930).

[0103] Referring to FIG. 10, the user terminal may display an application or web interface on the display for providing a document creation service.

[0104] The input screen (1010) may provide an interface for a user to input basic information for document creation. The input screen (1010) may include a field for text input and an area for file upload. The user may input the purpose or intention of document creation in natural language form in the corresponding field, and may input multimodal data such as structured data files, image files, or audio files that serve as reference materials through the file upload area. The user terminal may request initial analysis by transmitting the information obtained through the input screen (1010) to a server.

[0105] The layout confirmation screen (1020) may be an interface that visualizes layout data received from a server and provides it to the user. The server analyzes the domain of the input information and proposes a suitable document structure, and the user terminal may display this on the layout confirmation screen (1020) in the form of a thumbnail or a skeletal diagram. As illustrated in FIG. 10, multiple layout options may be presented, and the user may select a preferred structure using touch input or a pointing device. The user's selection information is fed back to the server and may serve as a criterion for determining the final structure template.

[0106] The document viewer screen (1030) may be an interface that receives document data generated from a server and displays the final rendered result. The user terminal may parse the serialized stream (930) described in FIG. 9 and display it on the screen. The document displayed on the document viewer screen (1030) may be output with the title, separator, body text, table, etc., all styled. Since the style definition is encapsulated within the data itself, the document can maintain consistent visual quality regardless of the type or environment of the user terminal's viewer. Additionally, the user can view the generated document on the document viewer screen (1030) and perform subsequent actions such as saving or sharing it.

[0107] FIG. 11 is a block diagram schematically illustrating a computer device according to one embodiment of the present invention.

[0109] Referring to FIG. 11, the computer device (1200) may include a communication unit (1120), memory (1130), and a processor (1110). The components shown in FIG. 11 are exemplary, and the computer device (1200) may include additional components not shown, or some of the shown components may be omitted.

[0110] The memory (1130) is a recording medium readable by the processor (1110) and can store instructions and logic for controlling the operation of the processor (1110). The memory (1130) may include volatile memory or non-volatile memory and can store program code for performing a document generation algorithm according to an embodiment of the present invention. Additionally, the memory (1130) can temporarily or permanently store multimodal input received from a user, context information, generated layout data, structural template, and final document data.

[0111] The communication unit (1120) may provide a wired or wireless interface for transmitting and receiving data with an external device. The communication unit (1120) may receive multimodal input and user response information from a user terminal and transmit it to the processor (1110). Additionally, the communication unit (1120) may transmit layout data and final document data generated by the processor (1110) to the user terminal.

[0112] The processor (1110) can control the overall operation of the computer device (1200) by executing instructions stored in memory (1130). The processor (1110) may include a central processing unit (CPU), a graphics processing unit (GPU), or a neural network processing unit (NPU) specialized for artificial intelligence computation.

[0113] The processor (1110) can obtain context information and multimodal input corresponding to the user through the communication unit (1120). If the obtained multimodal input consists of multiple heterogeneous data objects, such as text, images, and structured data, the processor (1110) can analyze the attribute vector of each heterogeneous data object. Based on the analysis results, the processor (1110) can identify a target domain, such as technical specifications, analytical research, or administrative notices, and determine a document ontology having a predefined logical position corresponding to the target domain.

[0114] The processor (1110) can input context information and multimodal input into a generation model to generate layout data that defines the document creation intent and the logical structure of the document. The processor (1110) can define the layout data as a hierarchical node structure that controls the logical flow of the document to be generated. At this time, the processor (1110) can set each node within the hierarchical node structure as a discrete generation partition that occupies an independent rendering area within a structure template. The processor (1110) can transmit the generated layout data to a user terminal by controlling the communication unit (1120).

[0115] The processor (1110) can obtain user response information regarding layout data from a user terminal. The processor (1110) can determine a final structural template based on the user response information and the generated layout data. In this process, the processor (1110) can cross-reference and synthesize a natural language-based style descriptor that defines the tone and speech style that permeates the entire document, and structural topological data that defines the visual skeleton of each section. Additionally, the processor (1110) can perform logic to map style attributes and data representation formats corresponding to each node. The processor (1110) can compose the structural template as a set of syntactic markup elements based on a document object model, and encapsulate style definition data in the form of inline attributes that enforce visual rendering attributes corresponding to the document creation intent for each markup element.

[0116] The processor (1110) can identify each structural component within the structural template and generate content creation prompts for each structural component by referring to document creation intent and multimodal input. Specifically, the processor (1110) can project the entire acquired context information onto a vector space and calculate the degree of association with the semantic range of each structural component of the structural template. The processor (1110) can selectively extract only the information whose degree of association is greater than or equal to a preset threshold to form local context segments, and can inject the extracted local context segments into the inference window of the generation model by combining them with the generation constraints of the corresponding structural component.

[0117] Additionally, the processor (1110) can infer the semantic type of data to be mapped to each structural component and verify compatibility between the inferred type and the markup container within the structural template. If the processor (1110) determines that the source data contains code logic or a quantitative matrix, it can inject a directive into the prompt that causes the generating model to place the data within a preformat container having rendering immutability.

[0118] The processor (1110) can set a structural template as a structural constraint and input a generated content generation prompt into a generation model to generate content to be mapped within the area of ​​each structural component. In this process, the processor (1110) can synchronously perform a natural language generation process that generates text content based on style descriptors and a structuring process that injects the generated content into tag syntax defined by structural topological data.

[0119] The processor (1110) can generate document data that maps the generated content to a structural template. The processor (1110) can encapsulate individual content blocks derived from a plurality of structural components into a single document object having a specified root identifier. Subsequently, the processor (1110) can serialize a markup stream containing header information, metadata, and a body section within the encapsulated document object. By transmitting the serialized markup stream to a user terminal via the communication unit (1120), the processor (1110) can enable the user terminal to render the document using inline style attributes inherent in the serialized markup stream itself without loading a separate style sheet.

[0120] Although the embodiments have been described above with reference to limited examples and drawings, those skilled in the art can make various modifications and variations from the description above. For example, suitable results can be achieved even if the described techniques are performed in a different order than described, and / or the components of the described system, structure, device, circuit, etc. are combined or assembled in a form different from described, or replaced or substituted by other components or equivalents.

[0121] Therefore, other implementations, other embodiments, and equivalents to the claims also fall within the scope of the claims set forth below. Explanation of the symbols

[0122] 100: System 110: Server 120: User terminal 130: Network 400: Layout data 411: Section 1 Node 413: Section 2 Node 415: Section 3 Node 421: 1st Discretely Generated Partition 423: Second discrete generated partition 431: 1st Rendering Area 433: Second rendering area 510: Structure Template 520: Syntactic Markup Elements 530: Inline Style Definition 710: Vector space 720: Structural component scope 730: Local context segment 810: Natural Language Generation Process 820: Structured Process 830: Synthesis 910: Individual content block 920: Single document object 930: Stream 1010: Input screen 1020: Layout verification screen 1030: Document Viewer Screen 1110: Processor 1120: Communications Department 1130: Memory< / h1> < / code> < / pre>

Claims

Claim 1 A method performed by a server comprises: a step of obtaining context information and multimodal input corresponding to a user; a step of inputting the context information and the multimodal input into a generation model to generate layout data defining a document creation intent and a logical structure of a document, and transmitting the layout data to a user terminal; a step of obtaining user response information regarding the layout data from the user terminal, wherein the user response information includes at least one of selecting one of a plurality of layout options, changing the order of nodes included in the layout data, adding or deleting a specific section, and modifying a hierarchical structure; a step of updating the layout data according to the user response information and determining a structural template that maintains the visual form of a document based on the updated layout data, wherein the structural template is composed of a set of syntactic markup elements based on a document object model and each markup element includes inline style attributes; a step of, after the structural template is determined, identifying each structural component within the structural template and generating a content creation prompt for each structural component by referring to the document creation intent and the multimodal input; and a structural constraint including the markup tag syntax and inline style attributes of the structural template. A document generation method comprising: a step of setting, inputting the content generation prompt into the generation model, and generating content to be mapped within the area of ​​each structural component; and a step of inserting individual content blocks generated from a plurality of structural components into corresponding positions of the structural template to generate document data mapped to the content in the structural template and transmitting the document data to the user terminal. Claim 2 A document generation method according to claim 1, wherein the multimodal input comprises a plurality of heterogeneous data entities including structured structured data and unstructured data, and the step of generating the layout data comprises: a step of analyzing the attribute vector of each of the heterogeneous data entities to identify a target domain among technical specifications, analytical research, or administrative notices; and a step of determining a document ontology having a predefined logical topology corresponding to the target domain. Claim 3 A document generation method according to claim 1, wherein the layout data is defined as a hierarchical node structure that controls the logical flow of a document to be generated, and each node within the hierarchical node structure functions as a discrete generation partition that occupies an independent rendering area within the structure template, and the step of determining the structure template includes the step of performing logic to map style attributes and data representation formats corresponding to each node. Claim 4 A document generation method according to claim 1, wherein the structural template is composed of a set of syntactic markup elements based on a document object model, and each of the markup elements includes style definition data in the form of inline attributes that enforce visual rendering attributes corresponding to the document creation intent, and is configured to dependently follow structural constraints including the markup tag syntax and inline style attributes when generating content by the generation model. Claim 5 A document generation method according to claim 1, wherein the step of generating the content generation prompt comprises: inferring the semantic type of data to be mapped to each structural component; verifying the compatibility between the inferred type and the markup container within the structural template; and, if the heterogeneous data object included in the multimodal input or the data extracted from the heterogeneous data object includes code logic or a quantitative matrix, injecting a directive into the prompt to cause the generation model to place the data within a preformat container having rendering invariance. Claim 6 A document generation method according to claim 1, wherein the step of generating the content generation prompt comprises: projecting the entire acquired context information onto a vector space; calculating the degree of association with the semantic range of each structural component of the structural template; and selectively extracting only the information having a degree of association greater than or equal to a threshold to form a local context segment, and combining this with the generation constraint of the corresponding structural component to inject it into the inference window of the generation model. Claim 7 A document generation method according to claim 1, wherein the step of determining the structural template is performed by cross-referencing and synthesizing a natural language-based style descriptor that defines the tone and speech style permeating the entire document and structural topological data that defines the visual skeleton of each section, wherein the generation model synchronously performs a natural language generation process that generates text content based on the style descriptor and a structuring process that injects the generated content into the markup tag syntax defined by the structural topological data. Claim 8 A method for generating a document according to claim 1, wherein the step of generating the document data and transmitting it to the user terminal comprises: encapsulating individual content blocks derived from a plurality of structural components into a single document object having a specified root identifier; and serializing a markup stream containing header information, metadata, and a body section within the encapsulated single document object and transmitting it to the user terminal, wherein the user terminal renders the document by means of inline style attributes included in the serialized markup stream itself without loading a separate style sheet. Claim 9 In a computer device, a processor; and a memory storing instructions to be executed by the processor; wherein the instructions include: a step of causing the processor to obtain context information and multimodal input corresponding to a user; a step of inputting the context information and the multimodal input into a generation model to generate layout data defining a document creation intent and a logical structure of a document, and transmitting the layout data to a user terminal; a step of obtaining user response information regarding the layout data from the user terminal, wherein the user response information includes at least one of selecting one of a plurality of layout options, changing the order of nodes included in the layout data, adding or deleting a specific section, and modifying a hierarchical structure; a step of updating the layout data according to the user response information and determining a structural template that maintains a visual form based on the updated layout data, wherein the structural template is composed of a set of syntactic markup elements based on a document object model and each markup element includes an inline style attribute; a step of, after the structural template is determined, identifying each structural component within the structural template and generating a content creation prompt for each structural component by referring to the document creation intent and the multimodal input; and the structure A computer device configured to perform the steps of: setting a structure including markup tag syntax and inline style attributes of a template as a structural constraint, inputting the content creation prompt into the creation model, and creating content to be mapped within the area of ​​each structural component; and inserting individual content blocks created from a plurality of structural components into corresponding locations of the structural template to create document data mapped to the content of the structural template and transmitting the document data to the user terminal. Claim 10 A computer-readable recording medium that stores instructions for executing the method of any one of claims 1 through 8 when executed by a computer.

Citation Information

Patent Citations

  • Computer-implemented systems and methods for managing an electronic document

    KR1020220002213A

  • Apparatus and method for automatic report generation

    KR1020250155489A

  • A System for Generating Documents by Integrating Word-Processor and Database and a Method Therefore

    KR102253751B1

  • Method for generating structured report through generative ai and the table of contents creation process

    KR102790504B1