A micro application generation system and method based on natural language interaction

Abstract

The application relates to the technical field of software development tools, and discloses a micro application generation system and method based on natural language interaction, which comprises four core components of a natural language understanding module, a requirement modeling module, a code generation engine and a deployment and integration platform; the natural language understanding module generates a structured semantic representation through intent recognition, entity extraction and context analysis; the requirement modeling module constructs a data model, a process logic and an interface prototype based on the semantic representation, and optimizes model parameters by using reinforcement learning; the code generation engine generates cross-platform code of a micro service architecture through template matching and component assembly; and the deployment and integration platform realizes seamless integration of external systems and Internet of Things devices through standardized interfaces. The application can solve the problems of traditional low-code platforms, such as dependence on visual dragging operation, rough requirement analysis and insufficient cross-field adaptation.

Description

Technical Field

[0001] This invention relates to the field of software development tools technology, and in particular to a micro-application generation system and method based on natural language interaction. Background Technology

[0002] In the early days of software development, application development heavily relied on professional programmers manually writing code, requiring a lengthy process involving requirements analysis, architecture design, coding, and testing. This process was not only time-consuming and labor-intensive but also demanded extremely high technical skills from developers, resulting in long development cycles, high costs, and difficulty in meeting rapidly changing market demands. Furthermore, in the traditional model, discrepancies in understanding requirements between business and technical personnel led to a disconnect between development outcomes and actual needs, hindering rapid responses to dynamic business changes.

[0003] Over time, no-code development platforms have emerged, with some lowering the development threshold through visual drag-and-drop and template matching, allowing users to build basic applications with simple operations and improve development efficiency. However, existing no-code platforms still have many limitations when handling complex business logic and personalized requirements, and their capabilities in natural language interaction are relatively weak, failing to achieve true no-code automated development. Non-technical personnel need to learn the technical logic of interface component configuration, cannot directly describe requirements through natural language, and can only match templates based on keywords, requiring repeated manual adjustments to process nodes; built-in templates are difficult to cover various sub-scenarios, resulting in difficulties in multi-platform adaptation of generated applications, and requiring manual development of API interfaces to integrate with existing systems, increasing deployment costs.

[0004] Currently, there is no publicly available end-to-end automated micro-application generation system or method based on natural language semantic parsing, which covers everything from requirement capture to data modeling, component generation, and multi-terminal deployment.

[0005] Therefore, this invention proposes a micro-application generation system and method based on natural language interaction. Summary of the Invention

[0006] This invention provides a micro-application generation system and method based on natural language interaction to solve existing technical problems.

[0007] To solve the above-mentioned technical problems, the present invention provides the following technical solution:

[0008] This invention provides a micro-application generation system and method based on natural language interaction, comprising:

[0009] Natural Language Understanding Module, Requirements Modeling Module, Code Generation Engine, and Deployment and Integration Platform;

[0010] The natural language understanding module is used to parse the text or voice input from the user and generate a structured semantic representation through intent recognition, entity extraction and contextual analysis.

[0011] The requirement modeling module constructs a data model, business process logic, and interactive interface prototype based on the semantic representation, and iteratively optimizes the model parameters through reinforcement learning model;

[0012] The code generation engine is based on a requirement model and generates cross-platform executable code that conforms to a microservice architecture through template matching and componentized code assembly.

[0013] The deployment and integration platform is used to deploy the generated micro-applications to the target environment and achieve seamless integration with external systems and IoT devices through standardized interfaces.

[0014] The beneficial effects of the technical solution provided by this invention include at least the following:

[0015] This invention enables non-technical users to generate executable applications using natural language descriptions through multimodal input processing and domain knowledge graph disambiguation, significantly reducing the development threshold.

[0016] This invention automatically optimizes data association weights and process priorities through dynamic modeling based on reinforcement learning, thereby improving the accuracy of field matching and supporting the continuous evolution of complex business logic such as multi-level approval.

[0017] This invention decouples the core logic from the platform through AST conversion, and improves system integration efficiency and ensures data consistency by using standardized IoT interfaces. Attached Figure Description

[0018] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0019] Figure 1 This is a schematic diagram of the system architecture provided in an embodiment of the present invention. Detailed Implementation

[0020] To make the objectives, technical solutions, and advantages of the present invention clearer, the embodiments of the present invention will be described in further detail below with reference to the accompanying drawings.

[0021] Example

[0022] This embodiment provides a micro-application generation system and method based on natural language interaction, characterized in that it includes:

[0023] Natural Language Understanding Module, Requirements Modeling Module, Code Generation Engine, and Deployment and Integration Platform;

[0024] The natural language understanding module is used to parse the text or voice input from users and generate structured semantic representations through intent recognition, entity extraction, and contextual analysis.

[0025] The requirements modeling module constructs data models, business process logic, and interactive interface prototypes based on semantic representations, and iteratively optimizes model parameters through reinforcement learning models.

[0026] The code generation engine is based on a requirement model and generates cross-platform executable code that conforms to a microservice architecture through template matching and componentized code assembly.

[0027] The deployment and integration platform is used to deploy the generated micro-applications to the target environment and achieve seamless integration with external systems and IoT devices through standardized interfaces.

[0028] Please refer to Figure 1 This is a schematic diagram of the system architecture provided in an embodiment of the present invention.

[0029] For the micro-application generation system and method based on natural language interaction in this embodiment, its components should include a natural language understanding module, a requirement modeling module, a code generation engine, and a deployment and integration platform;

[0030] I. Natural Language Understanding Module:

[0031] The natural language understanding module includes:

[0032] The multimodal input processing unit eliminates ambiguous terms through speech denoising, text error correction, and semantic completion, combined with domain knowledge graphs. Specific steps include:

[0033] A noise reduction model based on deep neural networks processes speech signals and extracts text content.

[0034] Correcting spelling and grammatical errors in text content using the BERT-CRF error correction model;

[0035] By combining semantic matching algorithms based on domain knowledge graphs, semantic resolution is achieved for ambiguous terms.

[0036] The context management unit encodes the multi-turn dialogue history using a Transformer encoder, generates a context vector containing temporal relationships, and associates the current input with historical interaction information through an attention mechanism.

[0037] It should be noted that the speech denoising adopts a U-Net architecture deep model, which takes an 80-dimensional Mel spectrum as input and optimizes it by means of mean square error of spectral amplitude and multi-resolution STFT loss to output denoised speech features.

[0038] The code for the text correction process is as follows:

[0039] def text_correction(input_text):

[0040] token_vectors = pre-trained language model encoding(input_text) # Output 768-dimensional vectors

[0041] error_tags = Conditional Random Field Layer(token_vectors) #BIO Tagging

[0042] The `return` function replaces incorrect tags based on their labels (input_text, error_tags).

[0043] #Semantic Disambiguation Explanation

[0044] Combining semantic matching algorithms with domain knowledge graphs, cosine similarity between text entities and graph nodes is calculated, and semantic replacement is performed on ambiguous terms with similarity > 0.85. The domain knowledge graph extracts entities, relations, and attributes from industry standard documents using a triplet extraction algorithm.

[0045] The domain knowledge graph is constructed using publicly available industry standard documents and has undergone de-identification processing.

[0046] The unambiguous text sequence output by the multimodal input processing unit is encoded into a 768-dimensional context vector by the Transformer encoder of the context management unit. This vector is fused with the word embedding vector of the current input through a multi-head attention mechanism to generate an enhanced semantic representation containing historical dialogue information.

[0047] II. Requirements Modeling Module:

[0048] The requirements modeling module includes:

[0049] The data standard synchronization unit automatically aligns user-defined fields with the target system's data specifications through an entity-attribute mapping algorithm; it provides a visual interface for dynamically adjusting data model attributes and records version changes.

[0050] The compliance verification unit automatically checks the privacy data compliance and platform compatibility of business processes and generates a compliance report containing risk indicators.

[0051] The steps involved in iteratively optimizing the parameters of a reinforcement learning model include:

[0052] Construct a multidimensional state vector based on user feedback data and test metrics;

[0053] Dynamically adjust the data model association weights, business process node priorities, and interface layout parameters;

[0054] The reward value is calculated based on the functional completeness and performance indicators of the micro-application;

[0055] Employing a near-end strategy to optimize the algorithm iteratively reduces modeling errors;

[0056] The state vector includes the field matching accuracy of data standard synchronization; the field matching accuracy is calculated by cosine similarity to determine the semantic similarity between the user field and the target field.

[0057] The reward value calculation includes data alignment accuracy and compliance check pass rate.

[0058] The optimization process of reinforcement learning models includes:

[0059] Periodically collect user feedback to update model input;

[0060] Accelerate training convergence by using importance sampling to process sparse rewards;

[0061] When the standard deviation of the reward value is less than 5% for 5 consecutive iterations, the model is considered stable and the model parameters are automatically frozen.

[0062] It should be noted that the multi-dimensional feature extraction process includes:

[0063] Semantic features are generated using the BERT model, producing 768-dimensional semantic vectors for field names.

[0064] Structural features, extracting metadata such as field data type, length limit, and whether it is required;

[0065] Rule features are defined based on domain knowledge base to define mapping rules.

[0066] The formula for calculating mixed similarity is:

[0067] Matching degree = 0.6 × semantic cosine similarity + 0.3 × structural matching degree + 0.1

[0068] × Rule matching degree

[0069] The semantic cosine similarity range is calculated using the dot product of field vectors; the structural matching score is 1 if the data type matches, otherwise 0; and the rule matching score is 1 if the domain rules are met, otherwise 0.

[0070] Mapping decisions include:

[0071] When the matching degree is ≥80%, the mapping is completed automatically. The 80% threshold is determined by ROC curve analysis.

[0072] When the matching degree is 60%-80%, it is highlighted in the visual interface to prompt the user to confirm;

[0073] When the matching degree is less than 60%, a manual calibration process is triggered, which supports drag-and-drop field association or custom mapping expressions.

[0074] Visual interface design includes:

[0075] The model tree on the left displays the data model in the "Entity → Attribute" hierarchy, and supports creating entities by right-clicking;

[0076] The intermediate mapping panel displays the matching degree between user fields and target fields in real time, and provides "Autofill" and "Batch Calibration" buttons. Batch calibration supports regular expression matching of field names and can modify the mapping relationship of multiple fields at the same time.

[0077] The version bar on the right displays the history of changes, and supports one-click rollback to any version.

[0078] The core rule set for privacy data compliance checks is shown in Table 1:

[0079] Table 1

[0080]

[0081] The verification dimensions for platform compatibility include:

[0082] Interface compatibility: Verify whether the generated API parameters are compatible with the target system.

[0083] Performance compatibility: Simulate a weak network environment on a mobile device and check if the interface loading time is ≤5 seconds. If it exceeds the timeout, it is recommended to optimize the image compression strategy.

[0084] For device compatibility, check whether the control commands conform to the protocol specifications for IoT devices.

[0085] The dimensions of the multidimensional state vector of the reinforcement learning model are shown in Table 2:

[0086] Table 2

[0087]

[0088]

[0089] The reward function formula for a reinforcement learning model is:

[0090] R = 0.6A + 0.3C + 0.1(1-P)

[0091] Where A represents the field matching accuracy, C represents the compliance check pass rate, and P represents the business modeling accuracy.

[0092] Near-end policy optimization algorithms include:

[0093] Policy network, input state vector, output parameter adjustment action;

[0094] Value networks evaluate the long-term rewards of the current state and guide the optimization of policy networks;

[0095] The training frequency is such that a model update is triggered once after each micro-application is generated, and 50 historical samples are processed each time training is conducted.

[0096] When the standard deviation of the reward value is less than 5% for 5 consecutive iterations, the model is considered stable and the parameters are automatically frozen.

[0097] Importance sampling is implemented as follows:

[0098] old_policy=load_checkpoint("model_prev")

[0099] new_policy = current_model

[0100] ratio=new_policy.prob(action) / old_policy.prob(action)

[0101] clipped_ratio=clip(ratio,1-ε,1+ε)#ε=0.2

[0102] loss=-min(ratio*advantage,clipped_ratio*advantage)

[0103] III. Code Generation Engine:

[0104] Code generation engines include:

[0105] The template intelligent matching unit selects suitable code templates from the template library based on code complexity and template matching degree. When the template matching degree is lower than a preset threshold, it calls a deep learning-based code generation model to complete the missing business logic, inserts type annotations into the generated code, and verifies interface consistency through a static type checking tool.

[0106] The multi-platform adaptation unit is used to decouple core logic from platform features and achieve performance optimization; it transforms the core logic of microservices into a platform-independent implementation through abstract syntax tree transformation and injects local caching strategies for mobile devices.

[0107] It should be noted that the formula for calculating template matching degree is:

[0108] Matching degree = α·structural similarity + β·semantic similarity + γ·complexity fit

[0109] Structural similarity is calculated based on the edit distance of the abstract syntax tree; semantic similarity is generated through a pre-trained code semantic understanding model, which is based on the Transformer architecture and trained on a corpus containing function-level code snippets; complexity fit is evaluated based on Halstead complexity metric and Cyclomatic complexity calculation to assess the degree of complexity matching between the template and the requirements.

[0110] Deep learning model architectures include:

[0111] The encoder is a 12-layer Transformer with 768 hidden layers, processing code token sequences.

[0112] The decoder uses a 6-layer Transformer-CRF to ensure that the generated code conforms to syntax rules.

[0113] The training data consists of 1 million lines of code from 6 major fields, including finance and healthcare, and has been de-identified.

[0114] Type annotation insertion rules include:

[0115] Automatically insert function parameters based on the field types specified in the requirements;

[0116] Return values ​​are analyzed based on function semantics.

[0117] Class attributes are mapped using a domain knowledge graph.

[0118] The abstract syntax tree transformation process includes:

[0119] During the parsing phase, the core business logic code is parsed into an Abstract Syntax Tree (AST).

[0120] During the conversion phase, platform-specific code nodes are removed and abstract interface definitions are added;

[0121] During the generation phase, the AST is converted into corresponding code based on the target platform template.

[0122] The implementation of the caching strategy decision tree is as follows:

[0123] IF Data update frequency ≤ 1 time / day AND data size ≤ 10MB THEN

[0124] Employs local lightweight database full caching + daily scheduled updates

[0125] ELSE IF Data update frequency > 1 time / day AND data size ≤ 5MB THEN

[0126] Employs memory LRU caching + real-time push updates

[0127] ELSE

[0128] Adopting a hybrid caching strategy

[0129] IV. Deployment and Integration Platform:

[0130] The deployment and integration platform includes:

[0131] The IoT device control interface is used to parse natural language commands into device control parameters and send them to the target device through standardized IoT protocols; it supports command adaptation and status monitoring for multiple types of IoT terminals; the standardized IoT protocols include MQTT, CoAP and HTTP;

[0132] The bidirectional data synchronization interface converts business data into the target system's standard format through a data mapping engine; it achieves bidirectional synchronization between external system data tables and micro-application data based on a transaction consistency mechanism, and generates a data integrity verification report.

[0133] It should be noted that the instruction parsing engine adopts a three-level parsing architecture of intent recognition, entity extraction, and parameter validation. Intent recognition uses rule-based regular expression matching and a lightweight machine learning model; entity extraction uses a domain-specific named entity recognition model to extract device type, device identifier, and control parameters.

[0134] Parameter validation verifies the validity of parameters based on the device capability description file.

[0135] It uses a factory pattern to dynamically generate protocol processors, supporting MQTT, CoAP, and HTTP protocols.

[0136] For MQTT devices, status data is obtained by subscribing to the device / {device_id} / status topic;

[0137] For HTTP devices, the GET / device / {device_id} / status interface is called periodically (default interval 30 seconds).

[0138] Data mapping supports both visual configuration and script writing.

[0139] It supports multi-source data, including relational databases (MySQL, Oracle), NoSQL (MongoDB), files (CSV / Excel), and API data synchronization.

[0140] In distributed transaction solutions, a two-phase commit mechanism is used to ensure transaction consistency. Taking the synchronization of a micro-application and an ERP system as an example, the specific process is as follows:

[0141] During the preparation phase, the micro-application first marks the data as "to be synchronized" and locks the relevant records to ensure the integrity and consistency of the data during the synchronization process. After receiving the synchronization request, the ERP system pre-creates the data records and returns the pre-submission result to the micro-application, indicating that it is ready for formal submission.

[0142] During the submission phase, if both the micro-application and the ERP system successfully submit their pre-submissions, the micro-application will mark the data as "synchronized," and the ERP system will then formally submit the records, completing the entire synchronization operation. If a failure occurs at any stage, both parties will initiate a rollback operation to undo the pre-submission changes made. At the same time, the system will generate a compensation task.

[0143] The compensation mechanism uses Redis to store tasks that fail to synchronize and supports scheduled retry, with a default retry interval of 5 minutes.

[0144] The micro-application generation system and method based on natural language interaction in this embodiment.

[0145] Furthermore, it should be noted that the present invention can be provided as a method, apparatus, or computer program product. Therefore, embodiments of the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Moreover, embodiments of the present invention can take the form of a computer program product implemented on one or more computer-usable storage media containing computer-usable program code.

[0146] Embodiments of the present invention are described with reference to flowchart illustrations and / or block diagrams of methods, terminal devices (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, embedded processor, or other programmable data processing terminal device to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing terminal device, generate instructions for implementing the flowchart illustrations. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0147] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing terminal device to operate in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1The functions specified in one or more boxes. These computer program instructions may also be loaded onto a computer or other programmable data processing terminal equipment to cause a series of operational steps to be performed on the computer or other programmable terminal equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable terminal equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0148] It should also be noted that, in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. The terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or terminal device that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or terminal device. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or terminal device that includes said element.

[0149] Finally, it should be noted that the above description represents a preferred embodiment of the present invention. It should be pointed out that although preferred embodiments have been described, those skilled in the art, once they understand the basic inventive concept of the present invention, can make various improvements and modifications without departing from the principles described herein. These improvements and modifications should also be considered within the scope of protection of the present invention. Therefore, the appended claims are intended to be interpreted as including both the preferred embodiments and all changes and modifications falling within the scope of the embodiments of the present invention.

Claims

1. A micro-application generation system and method based on natural language interaction, characterized in that, include: Natural Language Understanding Module, Requirements Modeling Module, Code Generation Engine, and Deployment and Integration Platform; The natural language understanding module is used to parse the text or voice input from the user and generate a structured semantic representation through intent recognition, entity extraction and contextual analysis. The requirement modeling module constructs a data model, business process logic, and interactive interface prototype based on the semantic representation, and iteratively optimizes the model parameters through reinforcement learning model; The steps for iteratively optimizing the model parameters of the reinforcement learning model include: Construct a multidimensional state vector based on user feedback data and test metrics; Dynamically adjust the data model association weights, business process node priorities, and interface layout parameters; The reward value is calculated based on the functional completeness and performance indicators of the micro-application; Employing a near-end strategy to optimize the algorithm iteratively reduces modeling errors; The state vector includes field matching accuracy; the field matching accuracy is calculated by using cosine similarity to determine the semantic similarity between the user field and the target field. The reward value calculation includes data alignment accuracy and compliance check pass rate; The code generation engine, based on a requirement model, generates cross-platform executable code conforming to a microservice architecture through template matching and component-based code assembly; the code generation engine includes: The template intelligent matching unit selects suitable code templates from the template library based on code complexity and template matching degree. When the template matching degree is lower than a preset threshold, it calls a deep learning-based code generation model to complete the missing business logic, inserts type annotations into the generated code, and verifies interface consistency through a static type checking tool. The multi-platform adaptation unit is used to decouple core logic from platform features and achieve performance optimization; it transforms the core logic of microservices into a platform-independent implementation through abstract syntax tree transformation and injects local caching strategies for mobile devices. The deployment and integration platform is used to deploy the generated micro-applications to the target environment and achieve seamless integration with external systems and IoT devices through standardized interfaces.

2. The micro-application generation system and method based on natural language interaction according to claim 1, characterized in that, The natural language understanding module includes: The multimodal input processing unit eliminates ambiguous terms through speech denoising, text error correction, and semantic completion, combined with domain knowledge graphs. Specific steps include: A noise reduction model based on deep neural networks processes speech signals and extracts text content. The BERT-CRF error correction model was used to correct spelling and grammatical errors in the text content. By combining semantic matching algorithms based on domain knowledge graphs, semantic resolution is achieved for ambiguous terms. The context management unit encodes the multi-turn dialogue history using a Transformer encoder, generates a context vector containing temporal relationships, and associates the current input with historical interaction information through an attention mechanism.

3. The micro-application generation system and method based on natural language interaction according to claim 1, characterized in that, The requirement modeling module includes: The data standard synchronization unit automatically aligns user-defined fields with the target system's data specifications through an entity-attribute mapping algorithm; it provides a visual interface for dynamically adjusting data model attributes and records version changes. The compliance verification unit automatically checks the privacy data compliance and platform compatibility of business processes and generates a compliance report containing risk indicators.

4. The micro-application generation system and method based on natural language interaction according to claim 1, characterized in that, The deployment and integration platform includes: An IoT device control interface is used to parse natural language commands into device control parameters and send them to the target device via standardized IoT protocols; it supports command adaptation and status monitoring for multiple types of IoT terminals; the standardized IoT protocols include MQTT, CoAP, and HTTP; The bidirectional data synchronization interface converts business data into the target system's standard format through a data mapping engine; it achieves bidirectional synchronization between external system data tables and micro-application data based on a transaction consistency mechanism, and generates a data integrity verification report.

5. The micro-application generation system and method based on natural language interaction according to claim 1, characterized in that, The reinforcement learning model optimization process includes: Periodically collect user feedback to update model input; Accelerate training convergence by using importance sampling to process sparse rewards; When the volatility of the reward value is lower than the dynamic threshold for N consecutive iterations, the system is considered stable and the model parameters are automatically frozen.

Images