Context-based multilingual text conversion AI keyboard system and its operation method

Abstract

This invention provides a context-based multilingual text conversion AI keyboard system and its operating method that enable efficient use of computing resources. [Solution] The method involves the terminal's buffer monitoring input events including at least one of text input, deletion, cursor movement, and selection change; the terminal's buffer updating the current state of the text stored in the buffer based on the input events; the terminal's core receiving conversion events and analyzing the current state of the text, determining at least one of the presence or absence of a sentence boundary, paragraph boundary, cursor movement, contextual change, and sentence completion; and if it determines that the sentence is complete, the core storing the sentence as completed sentence data and transmitting the completed sentence to the server; the server's AI engine performing text conversion based on the completed sentence to generate a result; the server's AI engine sending the result to the terminal; and the terminal's display unit displaying the result in the UI or automatically reflecting it.

Description

Technical Field

[0001] The present invention relates to a context-based multilingual text conversion AI keyboard system and its operating method, which can not only analyze the text input by the user in real time to understand the context and automatically perform multilingual text conversion such as translation, proofreading, summarization, or recreation of the text on an artificial intelligence basis, but also apply an artificial intelligence model in text units without interrupting the user input flow, select an appropriate artificial intelligence model according to the length, request type, and context information of the input text, or generate and process a summary text, so as to relate to a context-based multilingual text conversion AI keyboard system and its operating method that can use computing resources efficiently.

Background Art

[0002] The present invention relates to a context-based multilingual text conversion AI keyboard system and its operating method, which can not only analyze the text input by the user in real time to understand the context and automatically perform multilingual text conversion such as translation, proofreading, summarization, or recreation of the text on an artificial intelligence basis, but also apply an artificial intelligence model in text units without interrupting the user input flow, select an appropriate artificial intelligence model according to the length, request type, and context information of the input text, or generate and process a summary text, so as to relate to a context-based multilingual text conversion AI keyboard system and its operating method that can use computing resources efficiently.

[0003] In typical text input environments, various software and services are provided for performing linguistic transformation tasks such as translation, proofreading, and summarization based on user-generated text or paragraphs. In one embodiment, conventional machine translation services, grammar proofreading tools, document summarization tools, etc., operate in a way that does not provide results until the user has entered the entire text and then either copied and pasted it separately or switched to the service and made a request. Such methods disrupt the user's input flow and can only process a single sentence or paragraph, making it difficult to automatically transform text during the real-time input process or to provide results that reflect the context.

[0004] Furthermore, keyboard input systems (Input Method Editors, IMEs) provided on mobile devices or computer operating systems primarily focus on word-by-word input assistance and therefore cannot provide advanced artificial intelligence processing such as multilingual translation, proofreading, and rewriting based on the meaning and context of the entire text. In particular, in mobile environments, input speeds are fast and various editing operations such as cursor changes, text corrections, and intermediate insertions occur frequently, creating structural constraints for performing AI-based language conversion work in real time while accurately maintaining the user input state. In addition, with the recent development of AI processing technology based on large language models (LLMs), the quality of context-based translation and text conversion has greatly improved. However, such models are computationally expensive, and if all inputs are processed using the same method, unnecessary resource waste and response delays may occur. Especially when texts are long or when many conversion requests occur consecutively, efficient model selection and optimization of requirements are necessary in keyboard environments where immediate input responsiveness is required.

[0005] Prior to this, there is Patent Document 1 (Automatic Translation by Keyboard), but the method merely includes the steps of: outputting a graphic user interface including a graphic keyboard and an editing area for a display using a computing device; the graphic keyboard including a plurality of keys and a translation area, and the computing device determining one or more candidate words from a source language based on the selection of one or more keys from the plurality of keys; and the computing device outputting a display of at least one candidate word from the one or more candidate words for a display in the editing area. [Prior art documents] [Patent Documents]

[0006] [Patent Document 1] Korean Registered Patent No. 10-2204888 [Overview of the Initiative] [Problems that the invention aims to solve]

[0007] To solve the aforementioned problems, the present invention aims to provide a context-based multilingual text conversion AI keyboard system and its operation method that can analyze input text in real time without interrupting the user's input flow, automatically perform context-based multilingual text conversion such as translation, proofreading, summarizing, or rewriting, and efficiently process the input text by selecting an appropriate artificial intelligence model or generating a summary text according to the length of the input text, the processing type, and the required computational complexity. [Means for solving the problem]

[0008] A method for operating the context-based multilingual text conversion AI keyboard system of the present invention, comprising: a step of a buffer engine of a user terminal monitoring input event data including at least one of text input, deletion, cursor movement, and selection change; a step of the buffer engine of the user terminal updating the current state of text stored in an internal buffer based on the input event data; a step of the core engine of the user terminal monitoring text conversion event data, analyzing the current state of text stored in an internal buffer, and determining at least one of text boundaries, paragraph boundaries, cursor movement, context changes, and text completion; a step of the core engine storing the text as completed text data and sending the completed text data to a service provider server if it is determined that the text is complete; a step of the AI ​​engine of the service provider server performing text conversion work based on the completed text data to generate result data; a step of the AI ​​engine of the service provider server sending the result data to the user terminal; and a step of the display unit of the user terminal displaying the result data on the user interface or automatically reflecting it.

[0009] The present invention relates to an operating system for a context-based multilingual text conversion AI keyboard system, comprising: a buffer engine that monitors input event data including at least one of text input, deletion, cursor movement, and selection change, and updates the current state of text stored in an internal buffer based on the input event data; a core engine that monitors text conversion event data, analyzes the current state of text stored in an internal buffer, determines at least one of text boundaries, paragraph boundaries, cursor movement, contextual changes, and text completion, and if it is determined that the text is complete, stores the text as completed text data and transmits the completed text data to a service provider server; a user terminal including a display unit that displays the result data on a user interface or automatically reflects it; and a service provider server that performs text conversion work based on the completed text data to generate result data and transmits the result data to the user terminal. [Effects of the Invention]

[0010] According to one embodiment of the present invention, real-time text analysis is possible without interfering with the user's input, and a natural flow of input can be maintained.

[0011] Furthermore, by applying a context-based processing method, the quality of results such as translation, summarization, proofreading, and rewriting can be improved compared to the conventional keyboard-based automatic completion method.

[0012] Furthermore, since the AI ​​model can be selected according to the length or processing difficulty of the input text, computational costs and response delays can be minimized.

[0013] Furthermore, by generating a text summary and switching to lightweight model-based processing, the frequency of high-cost model calls can be reduced, thereby lowering system operating costs.

[0014] Furthermore, by providing diverse work modes according to user-specific settings, language environment, or execution purpose, a personalized AI keyboard service can be realized. [Brief explanation of the drawing]

[0015] [Figure 1] This is a flowchart illustrating the operation method of the context-based multilingual text conversion AI keyboard system according to an embodiment of the present invention. [Figure 2] This is a flowchart illustrating how an AI engine according to an embodiment of the present invention performs text conversion work and generates result data. [Figure 3] This is a diagram showing the configuration of a context-based multilingual text conversion AI keyboard system according to an embodiment of the present invention. [Best Mode for Carrying Out the Invention]

[0016] Specific structural or functional descriptions of embodiments according to the concepts of the present invention disclosed in this specification are merely exemplified for the purpose of explaining embodiments according to the concepts of the present invention, and embodiments according to the concepts of the present invention can be implemented in various forms and are not limited to the embodiments described in this specification.

[0017] Embodiments according to the concepts of the present invention can be subject to various modifications and can have various forms. Therefore, embodiments will be illustrated in the drawings and described in detail herein. However, this is not intended to limit embodiments according to the concepts of the present invention to a specific disclosed form, and it should be understood to include all modifications, equivalents, or alternatives included in the spirit and technical scope of the present invention.

[0018] The terms used herein are merely used to explain specific embodiments and are not intended to limit the present invention. Singular expressions shall include plural expressions unless the context clearly indicates a different meaning. In this specification, terms such as "comprising" or "having" indicate the existence of features, numerical values, steps, operations, components, parts, or combinations thereof described herein, and it should be understood that they do not preclude the possibility of the existence or addition of one or more other features, numerical values, steps, operations, components, parts, or combinations thereof.

[0019] Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings attached hereto.

[0020] FIG. 1 is a flowchart for explaining an operation method of a context-based multilingual sentence conversion AI keyboard system according to an embodiment of the present invention.

[0021] Referring to Figure 1, the buffer engine 110 of the user terminal 100 monitors input event data including at least one of text input, deletion, cursor movement, and selection change (S101). The user terminal 100 may include a display unit 130 which is a text input interface (UI), and the user can perform editing operations such as character input, deletion, cursor movement, selection area change, and paste through the UI. When an input event occurs, the user terminal 100 can convert it into input event data in event data format, and the input event data may include, but is not limited to, at least one of the input string, deletion command, cursor position, selection area information, presence or absence of automatic correction, and IME synthesis status.

[0022] The buffer engine 110 of the user terminal 100 updates the current state of the text stored in the internal buffer based on the input event data (S103). In one embodiment, the input event data may include UI interactions such as character input (text insertion), deletion (backspace / delete), copy (cut), paste, selection range change, and cursor position change (caret movement), and can occur in various forms depending on the operating system (iOS, Android, etc.) and input method (basic keyboard, third-party keyboard, IME-based character combination input, etc.). The buffer engine 110 can process input events while maintaining the order in which they occur by applying a serial execution processing method (First In First Out; FIFO-based processing), and for this purpose, it can be configured to sequentially transmit input events through a separate dedicated queue such as a Serial DispatchQueue in the Swift or Java layer. If the input processing order is reversed, damage to the text state or overlapping reflection of context may occur, so the serial execution processing method can be applied, but is not necessarily limited to this. The buffer engine 110 can integrate differences in the format of input event data transmitted from the operating system, input source, and language-specific input engine through its input event standardization function, and convert them into standardized input commands. Furthermore, the buffer engine 110 can update and maintain the current state of text in an internal buffer based on the standardized input commands. The current state of text may be stored in buffer form, and the buffer may contain input state information such as text strings, cursor position, and selected area. By updating and maintaining the buffer in real time, the buffer engine 110 can save the latest text state that accurately reflects changes during the input process.

[0023] The core engine 120 of the user terminal 100 monitors the text conversion event data, analyzes the current state of the text stored in the internal buffer, and determines at least one of the text boundary, paragraph boundary, presence or absence of cursor movement, context change, and presence or absence of text completion (S105). The core engine 120 can determine whether the input text is in a completed state by analyzing at least one of the text string, cursor position, selection area, type of input data, and text change pattern, thereby distinguishing between the text during simple input and the text unit independent in meaning. The core engine 120 can detect a text boundary determination signal such as an end element of a sentence such as a period, question mark, exclamation mark, line break, continuous blank, auto-completion confirmation signal, or a change in the input combination state displayed by the operating system (OS) and IME engine. In addition, the core engine 120 analyzes the semantic flow of the user input based on the determined text unit, input pattern, cursor movement history, and text change history, and can determine whether the current input is the generation of a new text, the correction of an existing text, or a context conversion has occurred. The core engine 120 can interpret the input intention by combining various factors such as not only simple string differences but also text history, input motion pattern, input cancellation operation, and system automatic correction event. In addition, when the user moves the cursor to a text or paragraph area that has already been completed, the core engine 120 can distinguish whether the movement is a simple search operation or an intention for semantic correction (Re-entry).

[0024] When the core engine 120 determines that a sentence is complete, it stores the sentence as completed sentence data and transmits the completed sentence data to the service server 200 (S107). The core engine 120 operates by selectively extracting information on a sentence-by-sentence basis without reprocessing the entire text or initializing the existing state, thereby providing a non-interruptive sentence processing structure that does not interrupt the input flow even in a continuous input environment. When a sentence is completed, the core engine 120 can store the string corresponding to the sentence within the text range inside the buffer, along with cursor position information, the sentence confirmation time, and related contextual elements. Furthermore, after storing the completed sentence data in the storage unit 140, the core engine 120 can generate and issue a sentence completion event to notify that the sentence is ready for AI processing or use by an external system. Immediately after the sentence confirmation conditions are met, the core engine 120 records the completed sentence data in the storage unit 140 along with a tag (sentence parsed), allowing for traceable management of the sentence processing history.

[0025] The AI ​​engine 210 of the service provision server 200 performs a text conversion operation based on the completed document data to generate result data (S109), and the AI ​​engine 210 of the service provision server 200 transmits the result data to the user terminal 100 (S111). The process of generating and transmitting the result data by the AI ​​engine 210 will be described in detail later in Figure 2. The display unit 130 of the user terminal 100 displays the result data on the user interface or automatically reflects it (S113).

[0026] Figure 2 is a flowchart illustrating how an AI engine according to an embodiment of the present invention performs text conversion work and generates result data.

[0027] Referring to Figure 2, the AI ​​engine 210 classifies the completed document data into at least one request type from proofreading, summarizing, translation, or rewriting (S201). By analyzing the document conversion event data received from the user terminal 100, the AI ​​engine 210 can automatically classify which type of user request it is—proofreading, summarizing, translation, rewriting, or the performance of multiple functions. Because the AI ​​engine 210 determines the request type based on the document conversion event data, which is a function trigger containing at least one of the following inputs from the user terminal 100: a tap of the translation button, a tone change request, a proofreading command, or a document style conversion request, it can interpret the request intent in a consistent manner regardless of the user input method, language environment, or platform. The AI ​​engine 210 can derive which function type the request corresponds to by interpreting the request parameters, such as option settings, output format conditions, and target language information, included in the document conversion event data, and comparing them with an internal request table or rule-based classification mapping logic.

[0028] The AI ​​engine 210 determines whether the request type is proofreading or summarizing (S203). If it determines that the request type is neither proofreading nor summarizing, it determines whether the length of the completed document data is greater than or equal to a pre-set threshold (S205). If it is greater than or equal to the threshold, the AI ​​engine 210 generates a summary based on the completed document data (S207). In one embodiment, the AI ​​engine 210 can operate within the Service Layer of the AI ​​delegator system structure and generate a summary through SummaryService. The AI ​​engine 210 selects an AI model based on the completed document data if the request type is proofreading or summarizing, or if the request type is translation or rewriting instead of proofreading or summarizing, but the length of the completed document data is less than a pre-set threshold (S209). The AI ​​engine 210 also selects an AI model based on the summary if the request type is translation or rewriting, and the length of the completed document data is greater than or equal to a pre-set threshold (S209). The AI ​​engine 210 can perform model selection logic considering at least one of the following: request type (proofreading, summarizing, translation, rewriting), length of completed document data, presence or absence of a summary, user function options, system policy, and cost strategy. Internally, the AI ​​engine 210 applies a hierarchical model application policy and can select either an efficient model or a frontier model according to the computational difficulty and desired result quality required for request processing. In one embodiment, for simple proofreading or conversion of short single sentences, a cost-effective model may be preferentially selected, while conversely, for long-text translation, style rewriting, or advanced contextual transformation, a higher-quality frontier model may be selected. If a summary is generated for a request, the AI ​​engine 210 can configure the input prompt to include the summary in the form of a context_summary field, enabling the AI ​​model to perform context-dependent tasks such as tone application, deep semantic rewriting, and multi-stage language transformation more efficiently.Conversely, if the completed text data is short and below the threshold, or if sufficient contextual interpretation is possible in a single request step, the original completed text data can be used directly as model input without using a summary.

[0029] The AI ​​engine 210 performs text conversion work based on the selected AI model and generates result data (S211). The AI ​​engine 210 may also include the role of a Model Adapter, which configures a call path that can make actual requests to the selected model and connects to external AI services or on-device models. The AI ​​engine 210 can perform text conversion work by making at least one of the following: REST API calls, WebSocket connections, FFI calls, or internal AI acceleration engine calls, according to the selected model type and the input format, security policies, and connection methods required by the model. After completing the calls to the selected model, the AI ​​engine 210 can convert the original result data received from the model into a user-applicable result format to generate final result data (result data). The AI ​​engine 210 verifies whether the model response result conforms to at least one of the following: request type (proofreading, summarizing, translation, rewriting, etc.), output language, output format, user-specified options, and system policies, and can refine, structure, or transform the result as necessary.

[0030] Figure 3 is a diagram illustrating the configuration of a context-based multilingual text conversion AI keyboard system according to an embodiment of the present invention.

[0031] Referring to Figure 3, the context-based multilingual text conversion AI keyboard system 10 (hereinafter referred to as "this system") consists of a user terminal 100 and a service provision server 200.

[0032] The user terminal 100 is an interface device that allows the user to input text, request text conversion, determine whether the text is complete, check the results, and perform subsequent editing. It can handle the main interactions of the system 10 while communicating with the service server 200. The user terminal 100 can be embodied by at least one of the following: a smartphone, tablet, PC, wearable device, or other input-based user interface device. It can interact with the system 10 regardless of the operating system, such as iOS, Android, Windows, or macOS®, or the input method, such as a basic keyboard, a third-party keyboard, voice input, or stylus-based input. The user terminal 100 consists of a buffer engine 110, a core engine 120, a display unit 130, a storage unit 140, a communication unit 150, and a control unit 160.

[0033] The buffer engine 110 can monitor input event data, including at least one of text input, deletion, cursor movement, and selection change, and update the current state of the text based on the input event data. It also consists of an input processing module 111, a text synchronization module 112, an integrity verification module 113, and a buffer management module 114.

[0034] The input processing module 111 can monitor input event data including at least one of text input, deletion, cursor movement, and selection change, and can convert the input event data into standardized input processing units. By integrating and processing events occurring in various input methods such as virtual keyboard, auto-completion input, system input, and IME (Input Method Editor) based combination input in a single format, the input processing module 111 enables input state management that is independent of the platform, operating system, and language environment. Depending on the embodiment, the input processing module 111 may include multiple detailed components, and in one embodiment, it may be divided into an input event data monitoring function and an input event standardization function.

[0035] First, the input event data monitoring function of the input processing module 111 can monitor various input event data occurring on the user terminal 100 in real time. In one embodiment, the input event data can include UI interactions such as text insertion, deletion (backspace / delete), copy (cut), paste, selection change, and cursor movement, and can occur in various forms depending on the operating system (iOS, Android, etc.) and input method (basic keyboard, third-party keyboard, IME-based character combination input, etc.). The input processing module 111 can apply a First In First Out (FIFO) processing method to save and process the order in which input events occur. For this purpose, the Swift or Java layer can be configured to sequentially transmit input events through a separate dedicated queue such as a Serial DispatchQueue. While the serial processing method can be applied because reversing the input processing order may result in damage to the text state or overlapping context, it is not necessarily limited to this. Furthermore, the input processing module 111 needs to be controlled to prevent data races or multithreaded collisions even when input events occur simultaneously in an asynchronous processing environment. For this purpose, internal locking or atomic arithmetic processing methods may be applied.

[0036] Furthermore, the input processing module 111 can use an input event standardization function to integrate format differences in input event data transmitted from the operating system, input source, and language-specific input engine, and convert them into standardized input commands. In one embodiment, in iOS, the deleteBackward event means single cursor deletion, while in situations where a selection area exists, the same event can mean range deletion. In IME-based Korean input, a single input can be classified as either a "combining state" or a "completed word" depending on the letter combination state, requiring a process to convert the input into a single rule base. The input processing module 111 can convert input event data into a normalized input command system such as Insert, Delete, Replace, and Update Selection. The standardized input commands can also include additional information such as the text state change range, the changed string, and the applied cursor or selection area position.

[0037] The text synchronization module 112 can update and maintain the current state of text in an internal buffer based on the standardized input command. The current state of text may be stored in a buffer, which may contain input state information such as the text string, cursor position, and selected area. By updating and maintaining the buffer in real time, the text synchronization module 112 can save the latest text state that accurately reflects changes during the input process. Furthermore, the text synchronization module 112 can maintain the latest state of the creation area during input by maintaining the final state that reflects the event processing results without storing a cumulative log of input event data. In addition, the text synchronization module 112 can reflect the text state in the same manner regardless of differences in the input method used by the user (character input, auto-completion, paste, input after selection, IME-based combination input, etc.). To this end, the text synchronization module 112 can interpret the text change range, applicable string, cursor position, and selected area information included in the standardized input command and selectively update the content data and cursor metadata stored in the buffer. The text synchronization module 112 can operate in an incremental update mode that updates only the range that has been changed from the existing state in the smallest possible units through such selective updates, thereby preventing unnecessary reprocessing of the entire string in a high-speed continuous input processing environment.

[0038] Furthermore, the text synchronization module 112 may be designed to prevent the generation of different system states for the same input due to asynchronous processing delays or differences in platform input processing methods that may occur in intermediate steps of input processing. In one embodiment, the text synchronization module 112 can operate so that the buffer state is consistently maintained as the latest state, even when the user switches to another input field during input or when the operating system performs an automatic text proofreading function. In addition, the text synchronization module 112 can distinguish and process inputs with a finalized text state from inputs with an incomplete state, taking into account that the result of text changes may be in the form of a draft that exists before the document boundary, rather than simply word by word.

[0039] The consistency verification module 113 verifies the consistency between the state of the text input field displayed on the display unit 130 (text state) and the internal buffer state stored by the text synchronization module 112. If the two states do not match, it can automatically adjust them to maintain a consistent input state. The consistency verification module 113 can receive text state information such as the currently displayed string, cursor position, and selected area through a text state inquiry interface (API). In one embodiment, the UI base state can be obtained through interfaces such as UITextInput, selectedTextRange, and documentContextBeforeInput in an iOS environment, and through interfaces such as InputConnection, getExtractedText(), and getTextBeforeCursor() in an Android environment. The consistency verification module 113 can perform a text state inquiry when at least one system event from onSelectionChanged, onTextChanged, and compositionUpdated occurs, or when predefined operating conditions such as input interruption (idle), input field switching, or automatic correction execution are met, but is not necessarily limited to these.

[0040] The consistency verification module 113 can compare the queried text state with the internal buffer state stored by the text synchronization module 112 to determine whether the two states are identical. If a mismatch is detected as a result of the consistency verification, the consistency verification module 113 can determine which value of the text state or internal buffer state represents the latest state and synchronize the state based on the latest state. In one embodiment, if the operating system or input engine has the latest state from the buffer through at least one of the processes of automatic combination confirmation, automatic completion, or proofreading, the buffer state can be updated with the text state value. Conversely, if the internal buffer maintains the latest state but the reflection is delayed, the text state can be updated based on the internal buffer state. Furthermore, the consistency verification module 113 can apply the consistency judgment criteria differently, taking into account cases where the input state is divided into a "combining state" and a "confirmed state," such as Korean IME combination input, multilingual combination character input, and predictive text input. This prevents problems such as misrecognition of input during combination or duplicate reflection of text changes, and minimizes abnormal processing phenomena such as cursor jumps, missing text, and loss of selection range. Therefore, the consistency verification module 113 can ensure stability and reliability in the overall input processing flow by maintaining real-time state consistency between the text state and the internal buffer state.

[0041] The buffer management module 114 efficiently manages the internal buffer structure maintained by the text synchronization module 112 and can control the buffer storage policy to maintain the persistence, stability, and memory efficiency of the input state. The buffer management module 114 can manage the lifecycle of the internal buffer. In one embodiment, when a new input session is started, when an input field is changed, or after existing input is finalized and transmitted to the core engine 120, the existing buffer can be initialized or stored as a separate history buffer. The buffer management module 114 can also apply buffer initialization or session partitioning policies when input interruption (idle state) is maintained for a preset time or when the focus of the input area changes. This prevents the continuous accumulation of unnecessary state data and enables buffer maintenance synchronized with the user's input context flow. Furthermore, the buffer management module 114 can perform buffer optimization functions for memory efficiency. In the process by which the text synchronization module 112 updates and maintains the current state of text based on standardized input processing instructions, if the text state is updated repeatedly, previously stored state information may be duplicated or multiple temporary string data may be generated. The buffer management module 114 can minimize the amount of storage space used by applying optimization techniques such as duplicate data removal, range-unit data reduction, and string compression. In one embodiment, the text synchronization module 112 can improve processing stability by normalizing the buffer into a single structure when a specific input pattern is detected, but is not necessarily limited to this. Furthermore, the buffer management module 114 can determine whether the internal buffer state is in a stable state that can be used for AI processing or contextual analysis before the internal buffer state is transmitted to the core engine 120.The buffer management module 114 can distinguish whether a buffer is in a combination state, a confirmed input state, or an input completion state. If the input is not confirmed, such as in the Korean IME combination state, it can prevent unnecessary AI calls by not setting the buffer as a target for transmission. On the other hand, if a sentence boundary is detected or if it is determined that the user input pattern is complete, it can perform flag processing or state switching so that the buffer can be transmitted to the core engine 120. Furthermore, if the buffer is not used for a long time, the buffer management module 114 can implement a TTL (Time-To-Live) based automatic cleanup policy to prevent memory accumulation and accumulation of residual state data. In one embodiment, an internal buffer may be determined to be in an expired state when a predetermined time (e.g., about 20 minutes) has elapsed based on the update time, and may be automatically deleted by a background thread or a periodic check scheduler.

[0042] The core engine 120 can monitor text conversion event data, and when it detects text conversion event data, it analyzes the current state of the text stored in the internal buffer to determine at least one of the following: text boundary, paragraph boundary, cursor movement, context change, and text completion. If it determines that the text is complete, the core engine 120 can store the text as completed text data and transmit it to the service provider server 200. The core engine 120 can consist of a boundary determination module 121, a context interpretation module 122, a text extraction module 123, and a simultaneity control module 124.

[0043] Furthermore, the boundary determination module 121 can monitor and detect text conversion event data, and if detected, determine input boundaries at the sentence and paragraph levels based on the current state of the text stored in the internal buffer. The text conversion event data may be generated based on interactions including, but are not limited to, at least one of the following: translation request button input, tone change (recreation) request, proofreading request, summary execution, style conversion option selection, or target language change. The text conversion event data may include not only function selection information, but also request type, option value, target language, selected text range, and request timestamp information. The boundary determination module 121 can determine whether the input text is in a completed state by analyzing at least one of the following: text string, cursor position, selection area, input data type, and text change pattern, thereby distinguishing between text being simply entered and semantically independent sentence units. The boundary determination module 121 can detect text boundary determination signals such as sentence ending elements like periods, question marks, and exclamation marks, line breaks, consecutive spaces, auto-completion confirmation signals, or input combination state changes displayed by the operating system (OS) and IME engine. In one embodiment, the boundary determination module 121 does not determine that a sentence is complete based solely on the input of a single closing character, but can determine a clear sentence completion state by applying at least one additional condition from cursor position movement, deselection of a selection area, and input interruption for a predetermined time or longer. Furthermore, the boundary determination module 121 can apply separate criteria for determining paragraph structure. In one embodiment, a paragraph boundary may be determined when line breaks are entered consecutively, when a specific punctuation pattern is combined at the end of a sentence, when the semantic context is separated from previous input, or when the input field is changed. When a paragraph boundary is detected, the boundary determination module 121 can treat the sentence as an independent semantic unit. In addition, the boundary determination module 121 can improve the accuracy of sentence boundary determination by analyzing cursor movement patterns.In one embodiment, if a user moves the cursor to the end of a text or deselects a text area and then resumes input while in the middle of text input, it can be determined that the text is in a state of ongoing creation. On the other hand, if input occurs after the cursor has moved to the end of the text or the start of the next line, the existing input content can be processed as a completed text, and this text can then be generated as completed text data by the text extraction module 123. In other words, the boundary determination module 121 can determine text boundaries and paragraph boundaries by comprehensively analyzing at least one of the following: input patterns, interaction flow, selection area behavior, cursor movement, and OS and IME state changes, rather than using a simple punctuation-based string processing method. This makes it possible to distinguish at least one input step from temporary input state, modification input state, text completion state, and paragraph transition state.

[0044] The context interpretation module 122 analyzes the semantic flow of user input based on the sentence units, input patterns, cursor movement history, and text modification history determined by the boundary determination module 121, and can determine whether the current input is the generation of a new sentence, the modification of an existing sentence, or whether a contextual shift has occurred. The context interpretation module 122 can interpret the input intent by combining various factors such as not only simple string differences, but also sentence history, input motion patterns, input cancel operations, and system automatic correction events. Furthermore, when the user moves the cursor to a sentence or paragraph area that has already been completed, the context interpretation module 122 can distinguish whether the movement is merely a search operation or an intention to make a semantic modification (Re-entry). In one embodiment, when the cursor moves to an area ahead of the current input range (completed sentence storage area), the context interpretation module 122 can determine this as a sentence re-entry (Re-entry) and restore the sentence again to make it editable. Furthermore, the context interpretation module 122 can distinguish whether the input state is in a temporary creation state, a confirmed input state, or a modification state, depending on the input method, language structure, presence or absence of auto-completion, IME combination state, and presence or absence of proofreading. Based on such changes in input state, the context interpretation module 122 can interpret the input flow step by step and classify the same text content into different semantic states according to the user's intent. In one embodiment, even when a user re-enters the same sentence, it can determine whether it is an overwrite of an existing sentence, generation of a new version, or user approval of auto-completion, based on at least one contextual clue. In addition, the context interpretation module 122 can determine whether a context shift has occurred by analyzing the relationships between semantic units of the sentence. If the user's input is determined to have a new subject, sentence structure, or utterance intent, the context interpretation module 122 can classify the input state as a new sentence flow and divide it into a higher-level paragraph, a lower-level syntax, or an independent sentence depending on the degree of relevance to the existing context.

[0045] If the text extraction module 123 determines that a text is complete based on the determination results of the boundary determination module 121 and the context interpretation module 122, it can extract the text from the text stored in the internal buffer and store it in the storage unit 140 as completed text data. The text extraction module 123 can also match and store the completed text data together with the text conversion event data. Therefore, when transmitting completed text data to the service provision server 200, both the completed text data and the text conversion event data can be transmitted together. The text extraction module 123 operates in a manner that selectively extracts text on a text-by-text basis without reprocessing the entire text or initializing the existing state, thereby providing a non-interruptive text processing structure that does not interrupt the input flow even in a continuous input environment. When a text is completed, the text extraction module 123 can store the text range within the buffer that corresponds to the text, along with cursor position information, the text confirmation time, and related context elements. In one embodiment, the text extraction module 123 can record text unit data that includes not only the text string but also at least one metadata item from the following: the paragraph structure constituting the text, contextual linking relationships, whether or not automatic proofreading is performed, whether or not an IME combination is confirmed, or whether or not the user has re-entered the system. Furthermore, to ensure input persistence, the text extraction module 123 can perform a trim operation on a variable memory buffer that stores the incomplete paragraph currently being entered by the user after text extraction. In one embodiment, after the completed text is extracted from the buffer, the string corresponding to the text is deleted from the buffer or moved to a separate recording area, and the cursor position can be automatically aligned to a position where the next input is possible. Furthermore, the text extraction module 123 can apply different processing strategies according to the method of transmitting the completed text.In one embodiment, if the text is to be used immediately for AI processing, the text can be transmitted to the service provider server 200 in the form of an event. Conversely, if the text is for storage purposes or for reflecting the user interface, the text extraction module 123 can store the text in the storage unit 140 and use it for context maintenance and subsequent input determination.

[0046] Furthermore, after storing the completed sentence data in the storage unit 140, the sentence extraction module 123 can generate and issue a sentence completion event to indicate that the sentence is ready for AI processing or use by an external system. Immediately after the sentence confirmation conditions are met, the sentence extraction module 123 can record the completed sentence data in the storage unit 140 along with a tag (sentence parsed) to enable tracking of the sentence processing history. Subsequently, the sentence extraction module 123 can generate a structure (SentenceCompletionEvent) that includes the completed sentence data and at least one of the following: context information, text position information, and user input session identifier. The sentence extraction module 123 can, but is not limited to, using at least one of the following to transmit the generated structure asynchronously to an external or internal processing layer: a message queue, an event bus channel infrastructure transmission interface, or a Publish-Subscribe infrastructure interface. In one embodiment, the structure can be transmitted directly to the service provision server 200, and in other embodiments, it can be transmitted to the user interface layer, the control unit 160, or a subsequent processing engine linked to an external server. This event-based transmission method separates the input flow from the AI ​​processing flow, ensuring an uninterrupted input experience where user input is not delayed while AI calls are being executed.

[0047] Furthermore, the text extraction module 123 can define an event receiving structure so that the generated text completion event can be utilized by an external processing engine or a higher-level application layer, and can request that an external module implement this structure. In one embodiment, the text extraction module 123 can define a Rust-based Trait interface so that an external module or application layer that processes the event implements a SentenceCompletionListener-type callback handler. The Rust-based implementation example is merely one embodiment of a particular implementation method, and the present invention is not limited to Rust. Each component of the system 10 can be implemented as a system programming language or other native language-based core module that guarantees memory safety, and Rust can be used as one embodiment. The Trait can be defined as a structure that can be shared and transmitted in a multithreaded environment, and an external module can implement an on_sentence_completed() method that is called when an event is received. The callback structure can be provided through JNI (FFI) or a platform bridge layer for interaction with different application environments such as Java, Kotlin, and Swift. Furthermore, since the text extraction module 123 executes the text completion event independently of the main input processing thread, the event issuance process can be performed asynchronously. In one embodiment, the event can be sent to a worker thread via an asynchronous message channel (tokio::sync::mpsc::channel) or a Publish-Subscribe base event dispatcher, and event reception and callback execution can be performed in a dedicated thread separated from the input processing loop.

[0048] The simultaneity control module 124 is a component that maintains data integrity and ensures the stability of the input processing flow by controlling concurrent access that may occur during the process in which the core engine 120 queries or processes the text state stored in the internal buffer. In environments where user input event processing, document processing, buffer querying, and document completion event generation are performed in parallel, the simultaneity control module 124 can apply mutual exclusion, read / write access control, and asynchronous communication policies to prevent buffer data from being corrupted or duplicated. When querying the internal buffer state, the simultaneity control module 124 can secure a buffer snapshot even when the text state is changing by temporarily acquiring a read lock. In one embodiment, the simultaneity control module 124 can prevent input event processing delays by immediately releasing the lock when the buffer query is completed. This minimizes the lock holding time, preventing a decrease in responsiveness and maintaining system processing efficiency, even in real-time environments where input events such as cursor movement, character input, or automatic proofreading occur continuously. Furthermore, the simultaneity control module 124 can apply an asynchronous event isolation policy to ensure that subsequent calculations performed at the time of text extraction and AI processing requests do not conflict with the flow of input events. In one embodiment, when a text completion event occurs, the simultaneity control module 124 can isolate and process the event using a message queue or a publish-subscribe (Pub / Sub) method, thereby preventing delays that may occur in the AI ​​engine 210 or the external service call process from affecting the user input experience. In addition, the simultaneity control module 124 can dynamically adjust the lock policy according to the execution environment, input pattern, and system load.In one embodiment, when input events occur frequently, the simultaneity control module 124 can minimize the lock duration and apply a reentrant lock or a lock-free cache-based read strategy. Conversely, when operations with large data fluctuations, such as IME composition states, large text modifications, or paste operations, are detected, a write lock or a temporary buffer sweep policy for buffer state protection can be applied.

[0049] The display unit 130 may include a text input interface (UI), through which the user can perform editing operations such as character input, deletion, cursor movement, selection area modification, and pasting. The display unit 130 can convert an input event into event data format and send it to the buffer engine 110 when an input event occurs, and the input event data includes the entered string, deletion The results may include, but are not limited to, at least one of the following: delete command, cursor position, selected area information, presence or absence of automatic proofreading, and IME combination status. In one embodiment, the display unit 130 can convert input signals such as system input events (onTextChange), selection change events (onSelectionchanged), and automatic completion confirmation events (IME commit) into a standardized data structure and transmit them. The display unit 130 can also display the result data returned from the service server 200 on the UI (User Interface) and provide an interface that allows the results to be automatically reflected in the existing input content according to the result application method, or to be selectively reflected by the user. In one embodiment, if the result data is proofreading or fine-tuning result, the automatic application method can be used, and if the result is a replacement for the original text, such as translation or recreation, the user can apply it via the preview and apply button. The user terminal 100 may include Undo / Redo, version-based text restoration function, or document-unit result comparison function, and can recall previous input records or AI results on a session basis in conjunction with the service server 200. Furthermore, the user terminal 100 can display system status such as network status, user plan level, request status, whether or not a model is waiting to run, and token consumption on the UI, and can provide upgrade or payment guidance messages when necessary.

[0050] The storage unit 140 can store, query, and manage data generated or modified during the processing of the buffer engine 110, core engine 120, display unit 130, and communication unit 150. Internally, the storage unit 140 can store at least one of the following: session data, text input history, completed document data, AI generation result data, user setting information, and model execution log. The storage unit 140 can be divided into a short-term cache area and a persistent storage area, and the storage method can be determined according to the nature of the data, the purpose of use, and the system policy. By storing the internal buffer state maintained by the buffer engine 110 and the input state determined during the consistency verification process on a session basis, the storage unit 140 can support input re-entry, undo / redo, multi-field editing, and session restoration functions. Furthermore, by storing the completed document data extracted by the core engine 120 in a structured record format, the storage unit 140 can be used for context-based AI processing, subsequent document determination, translation target identification, and user input pattern analysis.

[0051] The communication unit 150 can perform secure communication with the service provider server 200 in accordance with data transmission encryption, authentication token issuance, session maintenance policies, or regional data processing regulations, and can interact with the service provider server 200 using at least one of the following: REST API, WebSocket, message bridge, or native platform-based FFI calling method. The communication unit 150 can also transmit and receive at least one of the following: input event data, completed document data, request execution context, model call request, or result data. To ensure the reliability and efficiency of the communication structure, the communication unit 150 can selectively apply at least one of the following: REST API, WebSocket, gRPC, FFI (External Function Interface), message queue-based calling, or Publish-Subscribe method, depending on the transmission method. Furthermore, the communication unit 150 can convert messages into predefined formats such as JSON, Protobuf, or CBOR by performing serialization / deserialization processes during data transmission, and can apply retransmission policies or QoS (Quality of Service) based transmission priorities in the event of network delay or packet loss. In one embodiment, input event-based messages may have a real-time transmission priority, and non-blocking response messages such as AI result data may be subject to a waiting queue-based transmission policy. The communication unit 150 may include security authentication and session management functions. In one embodiment, a security header including a user access token, model call API authentication key, encrypted user account information, and session identifier may be automatically attached, or HTTPS / TLS-based encrypted communication, signature-based request validity verification, or regional data transmission regulation compliance policies may be applied.

[0052] The control unit 160 can control all the configurations of the user terminal 100.

[0053] The service provision server 200 consists of an AI engine 210, a storage unit 220, a communication unit 230, and a control unit 240.

[0054] The AI ​​engine 210 can generate result data by performing text conversion work based on completed document data, and consists of a request type classification module 211, a summary text generation module 212, a model router 213, and a result data generation unit 214.

[0055] The request type classification module 211 receives completed document data from the user terminal 100 and can classify the completed document data into at least one request type from proofreading, summarizing, translation, or rewriting. At this time, the request type classification module 211 can receive document conversion event data along with the completed document data. The request type classification module 211 can analyze the document conversion event data and automatically classify which type the user's request falls under: proofreading, summarizing, translation, rewriting, or multiple function execution. Because the request type classification module 211 determines the request type based on document conversion event data which is a function trigger including at least one of the following inputs from the user terminal 100: a translation button tap, a tone change request, a proofreading execution command, or a document style conversion request, it can interpret the request intent in a consistent manner regardless of the user input method, language environment, or platform. The request type classification module 211 can derive which function type a request corresponds to by interpreting request parameters such as option settings, output format conditions, and target language information included in the text conversion event data and comparing them with an internal request table or rule-based classification mapping logic. In one embodiment, if the text conversion event data contains the values ​​"action": "translate" and "target_lang": "en", the request can be classified as a translation function, and conversely, if it contains the values ​​"action": "rewrite" and "tone": "formal", it can be classified as a rewrite function. The request type classification module 211 can apply a multi-stage classification strategy by referring to the user's selection options, language settings, previous processing records, cursor position, or the presence or absence of incomplete input. The request type classification module 211 can convert the classified request type into structured instruction data (RequestExecutionContext). If the request type is summarization or proofreading, the request type classification module 211 can transmit this information to the model router 213, and if the request type is translation or rewrite, it can transmit this information to the summary generation module 212.

[0056] The summary generation module 212 can receive the completed document data and generate a summary if the request type classified by the request type classification module 211 requires post-processing by the translation or rewriting infrastructure. The summary generation module 212 determines whether the request type is translation or rewriting and whether the length of the completed document data is greater than or equal to a preset threshold, and if it is greater than or equal to the threshold, it can generate a summary of the completed document data. In one embodiment, the summary generation module 212 operates within the Service Layer of the AI ​​delegator system structure and can transmit the summary generated through SummaryService to subsequent processing steps according to the request type. In one embodiment, in the case of a translation or rewriting request, the summary generation module 212 can transmit the generated summary to the model router 213 and configure it so that the summary is used as at least one of a prompt context system message or auxiliary input data. If the length of the completed document data is less than a preset threshold, the summary generation module 212 can transmit this information to the model router 213. Furthermore, the summary generation module 212 may include a Fail-Open strategy. In one embodiment, if an error occurs during summary execution, or if the model availability or latency condition exceeds a threshold, the summary generation result may be not used and the original text may be preserved and transmitted to the model router 213.

[0057] The model router 213 can receive information from the request type classification module 211 if the request type is summarization or proofreading, and can receive a generated summary from the summary generation module 212 if the request type is translation or rewriting and the completed document data is above a set threshold, and can receive information from the summary generation module 212 if the request type is translation or rewriting and the completed document data is below a set threshold. The model router 213 can perform model selection logic considering at least one of the following: request type (proofreading, summarization, translation, rewriting), length of completed document data, presence or absence of a summary, user function options, system policy, and cost strategy. The model router 213 can internally apply a hierarchical model application policy to select either an efficient model or a frontier model depending on the computational difficulty and result quality required for request processing. In one embodiment, for simple proofreading or short single-document conversion, a cost-effective model can be preferentially selected, while conversely, for long-text translation, style rewriting, or high-difficulty contextual conversion, a higher-quality frontier model can be selected. The model router 213, in the case of a request for which a summary has been generated, can configure the input prompt by including the summary in the form of a context_summary field, enabling the AI ​​model to perform context-dependent tasks such as tone application, deep semantic reconstruction, and multi-stage language translation more efficiently. Conversely, if the completed text data is short and below a threshold, or if sufficient contextual interpretation is possible in a single request step, the completed text data can be used as model input without a summary. Furthermore, the model router 213 can optimize the number of input tokens by inserting the summary not as simple auxiliary input data, but as part of the prompt template or system context (System Prompt or Context Message) of the selected AI model.This reduces the model input size, lowers the computational load, and reduces response delay, API costs, or token consumption. Furthermore, if requests based on the same context are repeated, the system can be designed to continuously reuse the summary text or cache it in the session context to prevent duplicate calculations in the same text transformation step.

[0058] Furthermore, the model router 213 can differentially apply models during the request execution process, taking into account user credit unit price, token consumption, processing cost per model, user plan level, availability of free services, and upsell incentive policies. In one embodiment, the model hierarchy can be automatically switched based on the user level or feature options, according to the model usage policy of the uploaded file. The model router 213 can determine the range of available models based on user credits and token consumption, and can be designed to automatically switch to the Efficient Model if the amount of tokens or cost required for request processing exceeds the user's credit limit, or conversely, to preferentially apply the Frontier Model if the user activates a paid plan or premium features. In one embodiment, the user credit unit can be linked to a predefined token unit price system, where 1 credit corresponds to 10,000 to 100,000 tokens, or a policy can be applied where 20,000 tokens are provided per dollar. Furthermore, while an efficiency model may be preferentially selected when a user performs single-sentence processing such as a general proofreading request, it can be automatically routed to a frontier model if the request involves translation, long-text reconstruction, or high-difficulty semantic transformation. In addition, the model router 213 can implement feature restrictions, model switching, upgrade restrictions, or additional payment incentive policies according to user types such as free users, basic users, and premium users, or usage criteria such as cumulative AI request volume, token balance, and previous usage history. In one embodiment, free users may be provided with only a certain amount of tokens or a certain number of requests for free, after which they may be required to pay or upgrade when using a premium model. Such policy-based routing can be configured according to a token-credit mapping structure and differential pricing policies.

[0059] Furthermore, the model router 213 may also include the role of a model adapter that configures a call path to make actual requests to the selected model and connects to an external AI service or on-device model. The model router 213 can perform text conversion work by making at least one of the following: a REST API call, a WebSocket connection, an FFI call, or an internal AI acceleration engine call, according to the selected model type, the input format requested by the model, security policy, and connection method. After completing the call to the selected model, the model router 213 can transmit the original result data received from the model to the result data generation unit 214.

[0060] The result data generation unit 214 receives the original result data received from the model router 213 and can convert the original result data into a user-applicable result format to generate final result data (result data). The result data generation unit 214 verifies whether the model response result conforms to at least one of the request type (proofreading, summarizing, translation, rewriting, etc.), output language, output format, user-specified options, and system policy, and can refine, structure, or transform the result as necessary. The result data generation unit 214 can remove or organize unnecessary whitespace, control characters, metatokens, text boundary errors, IME-based integration residual symbols, or excessive contextual information generated by model characteristics that are included in the string result returned by the AI ​​model. In addition, the result data generation unit 214 can improve the readability of the result by performing at least one of the following tasks: text symbol normalization, custom unit notation according to the user language environment, style consistency organization, or expression naturalization. Furthermore, to ensure the accuracy of the semantic transformations included in the model response, post-validation logic can be performed to compare the semantic consistency between the completed text data or summary text and the result, or, in the case of a re-creation request, to determine whether the request options (tone, purpose, field, frame style) are appropriately reflected. In one embodiment, the result data generation unit 214 can generate and include quality indicators such as Confidence Score, Consistency Index, and Context Retention Ratio in the result. The result data generation unit 214 can apply different output structures depending on whether the result format is for user interface display, storage, or subsequent AI processing. In one embodiment, the result for user interface display can be transmitted in single-string form, while the result for storage or subsequent AI processing can consist of a structured result object (ResultPayload) including the source text, transformed text, quality indicators, time information, processed request type, and context metadata.Furthermore, the result data generation unit 214 can store the processed result data in the storage unit 220 of the service provision server 200 or send it to the user terminal 100, and can transmit the results to a subsequent event pipeline or an external service linkage interface depending on the system settings. In one embodiment, the result data generation unit 214 can record the results in a version control format so that they can be linked with prompt relay (Replay), Undo / Redo history recording, and text editing restoration functions before the AI ​​results are stored or reflected on the user screen.

[0061] The storage unit 220 can store, query, and manage data generated or modified during the processing of the AI ​​engine 210. The storage unit 220 can store original result data and final result data (result data) separately from the AI ​​engine 210, and can classify and manage the results for use in the user interface, user records, or subsequent model calculations according to the storage policy. In one embodiment, the storage unit 220 can apply a reusable caching infrastructure processing strategy to the same request by storing metadata such as tone options, translation language, model used, quality score, and generation time in the AI ​​results. The storage unit 220 can differentiate the data access scope and storage period according to at least one criterion, such as the user account level, device level, or session level. In one embodiment, for free users, only recently processed results are stored, while for paid plans or premium user tiers, long-term storage, AI result version control, and search infrastructure document reuse functions can be provided. The storage unit 220 can apply at least one of the following technologies for such policy-based access control: indexing, encrypted storage, compressed storage, and deduplication.

[0062] The communication unit 230 can control and manage data transmission and reception between the user terminal 100, the AI ​​engine 210, and external AI services, and can play a role in maintaining the overall system communication flow as a single interface. The communication unit 230 can transmit and receive at least one of the following: input event data, completed document data, request execution context, model call request, and result data. To ensure the reliability and efficiency of the communication structure, the communication unit 230 can selectively apply at least one of the following according to the transmission method: REST API, WebSocket, gRPC, FFI (External Function Interface), Message Queue infrastructure call, or Publish-Subscribe method. In addition, the communication unit 230 can support the transmission strategy of the asynchronous processing infrastructure and operate the input flow and AI processing flow on separate channels so that user input events are not delayed even before the processing results of the AI ​​engine 210 are returned. Furthermore, the communication unit 230 can perform serialization / deserialization processing during data transmission to convert messages into predefined formats such as JSON, Protobuf, and CBOR, and can apply a retransmission policy or a QoS (Quality of Service) based transmission priority in the event of network delay or packet loss. In one embodiment, input event-based messages may have a real-time transmission priority, and non-blocking response messages such as AI result data may be subject to a waiting queue-based transmission policy. The communication unit 230 can include security authentication and session management functions. In one embodiment, it may automatically attach a security header including a user access token, model call API authentication key, encrypted user account information, and session identifier, or it may apply an HTTPS / TLS based encrypted communication, signature-based request validity verification, or regional data transmission regulation compliance policy.If necessary, the communication unit 230 can perform state tracking on model call requests and responses, and if a transmission failure, response time exceeding limit, or response format error occurs, it can execute error handling, automatic recovery, or retry logic.

[0063] The control unit 240 can control each component of the service provision server 200.

[0064] Although the present invention has been described with reference to embodiments shown in the drawings, these are merely illustrative, and a person with ordinary skill in the art will understand that various modifications and equivalent other embodiments are possible based thereon. Therefore, the true scope of technical protection of the present invention should be determined by the technical idea set forth in the appended claims. [Explanation of Symbols]

[0065] 10: Context-Based Multilingual Text Conversion AI Keyboard System 100: User terminal 110: Buffer Engine 111: Input Processing Module 112: Text synchronization module 113: Integrity Verification Module 114: Buffer Management Module 120: Core Engine 121: Boundary Determination Module 122: Contextual Analysis Module 123: Text Extraction Module 124: Simultaneous control module 200: Service Provider Server 210: AI Engine 211: Request Type Classification Module 212: Summary generation module 213: Model Router 214: Result Data Generation Unit 220: Storage Unit 230: Communications Department 240: Control Unit

Claims

1. A method for operating a context-based multilingual text conversion AI keyboard system, The user terminal's buffer engine monitors input event data that includes at least one of the following: text input, deletion, cursor movement, and selection change. The user terminal's buffer engine updates the current state of the text stored in the internal buffer based on the input event data. The user terminal's core engine monitors text conversion event data, analyzes the current state of the text stored in the internal buffer, and determines at least one of the following: text boundary, paragraph boundary, cursor movement, context change, and text completion. If it is determined that the text is complete, the core engine stores the text as completed text data and sends the completed text data to the service provider server. The AI ​​engine of the service provider server performs text conversion work based on the completed text data to generate result data, The AI ​​engine of the service provider server sends the result data to the user terminal. The user terminal's display unit includes the step of displaying the result data on the user interface or automatically reflecting it, The step in which the AI ​​engine of the service provider server performs text conversion work based on the completed text data to generate result data is: The AI ​​engine classifies the completed document data into at least one request type: proofreading, summarizing, translating, or rewriting. If the request type is summarization or proofreading, the AI ​​engine selects an AI model based on the completed document data. If the request type is translation or rewriting, the AI ​​engine determines whether the length of the completed document data is greater than or equal to a preset threshold, and if it is greater than or equal to the threshold, it generates a summary of the completed document data and selects an AI model based on the summary. The process further includes the step of an AI engine performing a text conversion operation based on a selected AI model to generate result data, The AI ​​engine selects an AI model based on the summary text and performs text conversion work, and by injecting the summary text as the system context of the prompt, it optimizes the number of input tokens for the AI ​​model and reduces the computational load. How a context-based multilingual text conversion AI keyboard system operates.

2. The aforementioned buffer engine, An input processing module that monitors input event data including at least one of text input, deletion, cursor movement, and selection change, and converts the input event data into standardized input commands, A text synchronization module that updates and maintains the current state of text stored in an internal buffer based on the standardized input processing instructions, A consistency verification module that verifies the consistency between the current state of the text and the state of the text input field, and performs automatic synchronization based on the latest state, A buffer management module that maintains and optimizes the internal buffer and manages the transmission conditions is included. A method for operating the context-based multilingual text conversion AI keyboard system described in claim 1.

3. A buffer engine that monitors input event data including at least one of text input, deletion, cursor movement, and selection change, and updates the current state of text stored in an internal buffer based on the input event data, A core engine that monitors text conversion event data, analyzes the current state of the text stored in an internal buffer, determines at least one of the following: text boundary, paragraph boundary, cursor movement, context change, and text completion. If it is determined that the text is complete, it stores the text as completed text data and sends the completed text data to the service provider server. A user terminal including a display unit that displays or automatically reflects result data on the user interface, This includes a service provider server that performs text conversion based on completed document data to generate result data and sends the result data to the user terminal, When the aforementioned service provider server performs text conversion work based on the completed document data to generate result data, The completed document data is classified into at least one request type: proofreading, summarizing, translation, or rewriting. If the request type is summarization or proofreading, the steps include selecting an AI model based on the completed document data, If the request type is translation or rewriting, it is determined whether the length of the completed document data is greater than or equal to a predetermined threshold. If it is greater than or equal to the threshold, a summary of the completed document data is generated, and an AI model is selected based on the summary. Based on the selected AI model, the text conversion process is performed to generate the resulting data. When the service provider server selects an AI model based on the summary text and performs text conversion, it is characterized by optimizing the number of input tokens for the AI ​​model and reducing the computational load by injecting the summary text as the system context of the prompt. Context-based multilingual text conversion AI keyboard system.

4. The aforementioned buffer engine, An input processing module that monitors input event data including at least one of text input, deletion, cursor movement, and selection change, and converts the input event data into standardized input commands, A text synchronization module that updates and maintains the current state of text stored in an internal buffer based on the standardized input processing instructions, A consistency verification module that verifies the consistency between the current state of the text and the state of the text input field, and performs automatic synchronization based on the latest state, A buffer management module that maintains and optimizes the internal buffer and manages the transmission conditions is included. The context-based multilingual text conversion AI keyboard system according to claim 3.

Images