Application generation method, system, device, storage medium and program product based on low-code platform

Abstract

The application discloses a low-code platform-based application generation method, system, device, storage medium and program product, relates to the technical field of data processing, and the low-code platform-based application generation method comprises the following steps: obtaining the application generation requirement of a user, performing intention recognition based on the application generation requirement, and obtaining the intermediate representation of the application generation; performing configuration conversion of the low-code platform according to the intermediate representation, and obtaining the node configuration of the low-code platform; determining the application component configuration and the application logic configuration required by the application generation based on the node configuration; and generating the low-code platform application according to the application component configuration and the application logic configuration. Since the application generation is realized based on the application generation requirement of the user, the user does not need to divide time to learn and understand various components, attribute panels and logic arrangement rules of the platform, and the cognitive burden and efficiency bottleneck caused when low-code application generation is performed by using operations such as dragging, pulling, configuration and logic connection are avoided.

Description

Technical Field

[0001] This application relates to the field of data processing technology, and in particular to application generation methods, systems, devices, storage media, and program products based on low-code platforms. Background Technology

[0002] Low-code development platforms can significantly lower the technical barrier to application development by providing graphical interfaces and visual modeling tools, enabling business users or junior developers to quickly build applications.

[0003] Traditional low-code development platforms typically employ methods such as component drag-and-drop and property configuration, pre-built templates, and scaffolding to achieve low-code application development. When using these methods, users still need to spend time learning and understanding the platform's various components, property panels, and logic orchestration rules. For complex business logic, graphical orchestration can become lengthy, difficult to understand, and difficult to maintain. Summary of the Invention

[0004] The main purpose of this application is to provide an application generation method, system, device, storage medium and program product based on a low-code platform, which aims to solve the technical problems of the existing low-code application development methods for the lengthy, difficult-to-understand and maintain graphical orchestration under complex business logic.

[0005] To achieve the above objectives, this application proposes an application generation method based on a low-code platform, the application generation method based on a low-code platform comprising:

[0006] Obtain the user's application generation requirements, and perform intent recognition based on the application generation requirements to obtain an intermediate representation of the application generation;

[0007] Based on the intermediate representation, the configuration of the low-code platform is converted to obtain the node configuration of the low-code platform;

[0008] Based on the node configuration, the application component configuration and application logic configuration required for application generation are determined.

[0009] A low-code platform application is generated based on the application component configuration and the application logic configuration.

[0010] In some implementations, before the step of performing low-code platform configuration transformation based on the intermediate representation to obtain the node configuration of the low-code platform, the method further includes:

[0011] Obtain the metadata collection of the low-code platform;

[0012] The preset initial model is trained based on the metadata set to obtain the configuration conversion model;

[0013] Accordingly, the step of performing low-code platform configuration conversion based on the intermediate representation to obtain the node configuration of the low-code platform includes:

[0014] Based on the configuration transformation model, the intermediate representation is transformed to obtain the node configuration of the low-code platform.

[0015] In some implementations, the step of determining the application component configuration and application logic configuration required for application generation based on the node configuration includes:

[0016] Based on the node configuration and component semantic knowledge base, dynamic component mapping is performed to obtain the application components required for application generation.

[0017] Based on the node configuration, the logical action chain is identified to obtain the application logic configuration required for application generation.

[0018] In some implementations, before the step of performing dynamic component mapping based on the node configuration and component semantic knowledge base to obtain the application components required for application generation, the method further includes:

[0019] Obtain the technical attributes and semantic features corresponding to the components in the low-code platform;

[0020] Construct a semantic profile of the component based on the technical attributes and semantic features;

[0021] The component semantic knowledge base of the low-code platform is constructed based on the semantic archive.

[0022] In some implementations, the step of performing dynamic component mapping based on the node configuration and component semantic knowledge base to obtain the application components required for application generation includes:

[0023] Obtain the intent keywords from the node configuration;

[0024] Based on the intent keywords, vector matching is performed in the component semantic knowledge base to obtain candidate components;

[0025] The candidate component with the highest similarity to the intent keyword will be used as the application component required for application generation.

[0026] In some implementations, the step of identifying the logical action chain based on the node configuration to obtain the application logic configuration required for application generation includes:

[0027] Based on the node configuration, the trigger action chain is parsed to obtain the trigger source component and the trigger action;

[0028] The triggering event is determined based on the semantic profile of the triggering source component, and the triggering event is bound to the intent keyword to obtain a logical mapping relationship;

[0029] The application logic configuration required for application generation is obtained based on the logical mapping relationship.

[0030] Furthermore, to achieve the above objectives, this application also proposes an application generation system based on a low-code platform. This system is used to implement the application generation method based on a low-code platform as described above. The application generation system based on a low-code platform includes:

[0031] The user interaction layer is used to obtain the user's application generation requirements;

[0032] The large language model engine layer is used to perform intent recognition based on the application's generation requirements and obtain the intermediate representation generated by the application.

[0033] A configuration generation and assembly layer is used to perform low-code platform configuration transformation based on the intermediate representation to obtain the node configuration of the low-code platform;

[0034] The configuration generation and assembly layer is also used to determine the application component configuration and application logic configuration required for application generation based on the node configuration;

[0035] The platform core and integration layer are used to generate low-code platform applications based on the application component configuration and the application logic configuration.

[0036] Furthermore, to achieve the above objectives, this application also proposes an application generation device based on a low-code platform, the device comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the application generation method based on the low-code platform as described above.

[0037] In addition, to achieve the above objectives, this application also proposes a storage medium, which is a computer-readable storage medium, on which a computer program is stored, and when the computer program is executed by a processor, it implements the steps of the application generation method based on a low-code platform as described above.

[0038] In addition, to achieve the above objectives, this application also provides a computer program product, which includes a computer program that, when executed by a processor, implements the steps of the application generation method based on a low-code platform as described above.

[0039] One or more technical solutions proposed in this application have at least the following technical effects:

[0040] This application obtains the user's application generation requirements and performs intent recognition based on these requirements to obtain an intermediate representation for application generation. It then performs low-code platform configuration conversion based on this intermediate representation to obtain the low-code platform's node configuration. Based on the node configuration, it determines the application component configuration and application logic configuration required for application generation. Finally, it generates the low-code platform application based on these configurations. Since application generation is based on the user's application generation requirements, users do not need to allocate time to learn and understand the platform's various components, attribute panels, and logic orchestration rules. This avoids the cognitive burden and efficiency bottlenecks caused by drag-and-drop, configuration, and logic connection operations used in existing low-code application generation technologies. The low-code platform configuration conversion based on the intermediate representation yields the node configuration used for application generation within the low-code platform. Compared to traditional low-code solutions where users manually drag and drop configurations, and solutions that integrate AI-generated generic code into the platform, the node configuration generated in this application is the "native language" of the low-code platform. It can be directly parsed and executed by the low-code platform's core engine without any compilation, packaging, or adaptation processes. This fundamentally avoids integration failures or runtime errors caused by code version incompatibility, dependency conflicts, security vulnerabilities, etc., achieving true "build and use." Simultaneously, because it generates the platform's native configuration, applications can seamlessly enjoy all the advanced features provided by the platform, such as visual version management, one-click deployment, multi-platform adaptation, permission control, and performance monitoring. By treating components and their underlying logic as a whole and generating them synchronously, when a component is determined, its related application logic, such as filtering, pagination, and viewing details, is also generated and bound simultaneously. This end-to-end integrated generation ensures the integrity of functionality and the consistency of internal logic, reducing the cost of later debugging and repair. Attached Figure Description

[0041] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0042] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0043] Figure 1 This is a flowchart illustrating an embodiment of the application generation method based on a low-code platform provided in this application.

[0044] Figure 2 This is a flowchart illustrating Embodiment 2 of the application generation method based on a low-code platform in this application;

[0045] Figure 3 This is a flowchart illustrating Embodiment 3 of the application generation method based on a low-code platform in this application;

[0046] Figure 4 This is a schematic diagram of the module structure of the application generation system based on the low-code platform in an embodiment of this application;

[0047] Figure 5 This is a schematic diagram of the device structure of the hardware operating environment involved in the application generation method based on the low-code platform in the embodiments of this application.

[0048] The purpose, features, and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0049] It should be understood that the specific embodiments described herein are merely illustrative of the technical solutions of this application and are not intended to limit this application.

[0050] To better understand the technical solution of this application, a detailed description will be provided below in conjunction with the accompanying drawings and specific implementation methods.

[0051] The main solution of this application embodiment is: to obtain the user's application generation requirements, and to perform intent recognition based on the application generation requirements to obtain an intermediate representation of application generation; to perform low-code platform configuration conversion based on the intermediate representation to obtain the node configuration of the low-code platform; to determine the application component configuration and application logic configuration required for application generation based on the node configuration; and to generate a low-code platform application based on the application component configuration and application logic configuration.

[0052] This application provides a solution that achieves an intelligent application development experience of "description as generation" by recognizing intent based on user application generation requirements; by generating node configurations that are natively recognizable by the low-code platform, it maximizes the utilization of the low-code platform's native capabilities and ecosystem, avoiding potential logical vulnerabilities, performance bottlenecks, or security risks; and by generating low-code platform applications through application component configuration and application logic configuration, it achieves rapid and convenient application generation.

[0053] It should be noted that the executing entity in this embodiment can be a computing service device with data processing, network communication, and program execution functions, such as a computer or server, or an electronic device or virtual system capable of performing the above functions. The following description uses an application generation device based on a low-code platform (hereinafter referred to as the generation device) as an example to illustrate this embodiment and the subsequent embodiments.

[0054] Based on this, embodiments of this application provide an application generation method based on a low-code platform, referring to... Figure 1 , Figure 1 This is a flowchart illustrating an embodiment of the application generation method based on a low-code platform in this application.

[0055] In this embodiment, the application generation method based on the low-code platform includes steps S10 to S40:

[0056] Step S10: Obtain the user's application generation requirements, and perform intent recognition based on the application generation requirements to obtain an intermediate representation of the application generation.

[0057] Understandably, a low-code platform is a functional platform that allows users to generate applications through graphical interfaces, drag-and-drop components, and model-driven logic. When developing applications using a low-code platform, users can generate, deploy, and manage applications without writing large amounts of traditional code. Applications generated through a low-code platform are called low-code platform applications.

[0058] It should be noted that the aforementioned application generation requirements are functional requirements described by the user using natural language, which may include application functions, the business problems to be solved, and other related information. Users can input application generation requirements through voice input, text input, or other methods; this application embodiment does not impose any restrictions on this.

[0059] It is understood that intent recognition is a natural language processing method that analyzes and determines the user's purpose or intent from the application generation request input by the user. By analyzing the application generation request input by the user, an intermediate representation of the application generation can be obtained. The intent recognition method in this application embodiment can be implemented based on a large language model or other methods, and this application embodiment does not limit this.

[0060] It should be noted that the intermediate representation generated by the above application can be a structured, computer-readable data model, such as a structured file in JSON format.

[0061] In some embodiments of this application, the present application can specifically prompt the engineering and scheduling module to guide the large language model to perform deep parsing of the unstructured natural language (application generation requirements) input by the user, and identify the key elements therein to obtain the intermediate representation generated by the application. This structured intermediate representation may include, but is not limited to: data model (which data tables, fields and their types are needed), user interface (required pages, layouts and component types), business logic (data CRUD operations, validation rules, calculation logic, approval processes, etc.), and interaction logic (page navigation, button click events, etc.). By performing structured parsing through the structured intermediate representation, the node configuration of the low-code platform can be obtained.

[0062] In this embodiment, the user can input application generation requirements into the generation device, which can then perform intent recognition based on these requirements to obtain an intermediate representation of the generated application. Compared to traditional low-code platforms, this embodiment eliminates the need for users to allocate time to learn and understand the platform's various components, attribute panels, and logical orchestration rules. Users only need to describe their application requirements to generate the final application, avoiding the cognitive burden and efficiency bottlenecks caused by drag-and-drop, configuration, and logical connections used in existing low-code application generation technologies.

[0063] Step S20: Perform low-code platform configuration conversion based on the intermediate representation to obtain the node configuration of the low-code platform.

[0064] It should be noted that the above node configuration can be configured by setting attributes, adjusting parameters, and defining logic for each independent component or functional unit in the visual workflow or process design of a low-code platform.

[0065] In some embodiments of this application, in order to realize the configuration conversion of the intermediate representation, before the step of performing low-code platform configuration conversion based on the intermediate representation to obtain the node configuration of the low-code platform, the method further includes: obtaining a metadata set of the low-code platform; training a preset initial model based on the metadata set to obtain a configuration conversion model; correspondingly, the step of performing low-code platform configuration conversion based on the intermediate representation to obtain the node configuration of the low-code platform includes: performing configuration conversion on the intermediate representation based on the configuration conversion model to obtain the node configuration of the low-code platform.

[0066] It should be noted that the aforementioned metadata set can include metadata corresponding to various dimensions of the low-code platform. This metadata may include: component library definition files of the low-code platform, schema specifications of the data model, API interface documentation, rule definitions of the logic engine, and configuration instances of existing applications, etc., and this application embodiment does not impose any limitations on this. The metadata in the metadata set can be used to train a large language model. Compared to the traditional method of training a large language model using a general-purpose codebase, this application embodiment specifically uses metadata from the low-code platform to fine-tune the large language model, enabling the large language model to learn the "dialect" of a specific low-code platform.

[0067] It should be explained that the aforementioned preset initial model can be a large language model that has been fine-tuned. This embodiment does not limit the specific architecture used by this large language model, and it can be selected according to the needs of actual applications. By fine-tuning this preset initial model, the configuration conversion model can be generated.

[0068] In some embodiments of this application, the method for fine-tuning the preset initial model can be supervised fine-tuning. Specifically, this application can use a metadata set as a labeled dataset to perform supervised fine-tuning of the preset initial model, enabling the model to learn deeply and master the unique "syntax" and "vocabulary" of the low-code platform.

[0069] Understandably, the configuration transformation model obtained through training can perform configuration transformation based on intermediate representations to obtain the node configuration for generating applications in low-code platforms.

[0070] For example, the intermediate representation {"type": "DataTable", "dataSource": "Employee"} can be transformed through configuration to obtain the configuration {"component" "dt-001", "binding": {"data": "Employee"}, "props": { ...}} that the rendering engine of the low-code platform can directly parse.

[0071] It should be noted that by converting the intermediate representation into node configurations that the low-code platform can directly recognize, the generated configuration can directly call the low-code platform's built-in capabilities, such as data connectors, permission systems, and workflow engines, rather than attempting to reimplement these functions in external code.

[0072] In some implementations, the output of methods developed by developers using low-code platforms or generated by artificial intelligence models is often imperative code. This imperative code typically describes in detail each step of "how to do it," such as "create a div element, set its style to..., and then bind a click event function to it, with the function content being...". This type of code requires complex processes such as compilation, transpilation, and dependency management, and ultimately runs independently in the browser or on the server. It is a standalone "black box" decoupled from the low-code platform.

[0073] In its specific implementation, the generation device in this embodiment can perform low-code platform configuration conversion based on an intermediate representation, thereby obtaining the node configuration used for application generation within the low-code platform. Compared to the traditional low-code solution where users manually drag and drop configurations, and the solution where AI generates generic code and then integrates it into the platform, the node configuration generated in this embodiment is the "native language" of the low-code platform. It can be directly parsed and executed by the low-code platform's core engine without any compilation, packaging, or adaptation process. This fundamentally avoids integration failures or runtime errors caused by code version incompatibility, dependency conflicts, security vulnerabilities, etc., achieving true "generate and use immediately." Furthermore, because it generates the platform's native configuration, applications can seamlessly enjoy all the advanced features provided by the platform, such as visual version management, one-click deployment, multi-platform adaptation, permission control, and performance monitoring. Generic code, on the other hand, is often a "black box," making it difficult to deeply integrate with these platform-level capabilities.

[0074] Step S30: Determine the application component configuration and application logic configuration required for application generation based on the node configuration;

[0075] Step S40: Generate a low-code platform application based on the application component configuration and the application logic configuration.

[0076] It should be noted that the above application component configuration is a parameter that can characterize the component types and other component-related parameters required to generate the application, while the above application logic configuration is a parameter that can characterize the logical relationship between the components.

[0077] In some embodiments of this application, the component types in the generated application can be determined based on the node configuration, and these component types can correspond one-to-one with components in the low-code platform's component library. Simultaneously, the interaction logic between components can be automatically created based on the node configuration. For example, a routing rule can be created for the "View Details" action on the list page, pointing to the details page and passing the employee ID parameter; and logic for updating the data model can be bound to the "Submit" form action on the details page.

[0078] Understandably, upon obtaining the application component configuration and application logic configuration, a complete application configuration package can be generated based on these configurations. This application configuration package can then be used by the low-code platform's rendering engine to create a runnable application prototype in the visual designer. Based on this prototype, it can be fine-tuned using traditional low-code methods, or it can be directly released and used.

[0079] It should be understood that the embodiments of this application do not limit the specific method of generating the above application configuration package and other required parameters, which can be set according to the needs of actual application.

[0080] In its specific implementation, this application embodiment can determine the application component configuration and application logic configuration required for application generation based on node configuration, and then generate the low-code platform application through the low-code platform's rendering engine based on the application component configuration and application logic configuration. This application generates components and their underlying logical interactions as a whole, synchronously. When a component is determined, its related application logic, such as filtering, pagination, and viewing details, is also generated and bound together. This end-to-end integrated generation ensures the integrity of functionality and the consistency of internal logic, reducing the cost of later debugging and repair.

[0081] This application embodiment obtains the user's application generation requirements and performs intent recognition based on these requirements to obtain an intermediate representation for application generation. It then performs configuration conversion on the low-code platform based on this intermediate representation to obtain the node configuration of the low-code platform. Based on the node configuration, it determines the application component configuration and application logic configuration required for application generation. Finally, it generates the low-code platform application based on the application component configuration and application logic configuration. Since application generation is based on the user's application generation requirements, users do not need to allocate time to learn and understand the platform's various components, attribute panels, and logic orchestration rules. This avoids the cognitive burden and efficiency bottlenecks caused by drag-and-drop, configuration, and logic connection operations used in existing low-code application generation technologies. The low-code platform configuration conversion based on the intermediate representation yields the node configuration used for application generation within the low-code platform. Compared to traditional low-code solutions where users manually drag and drop configurations, and solutions that integrate AI-generated general code into the platform, the node configuration generated in this application embodiment is the "native language" of the low-code platform. It can be directly parsed and executed by the low-code platform's core engine without any compilation, packaging, or adaptation processes. This fundamentally avoids integration failures or runtime errors caused by code version incompatibility, dependency conflicts, security vulnerabilities, etc., achieving true "build and use." Simultaneously, because it generates the platform's native configuration, applications can seamlessly enjoy all the advanced features provided by the platform, such as visual version management, one-click deployment, multi-platform adaptation, permission control, and performance monitoring. By treating components and their underlying logic as a whole and generating them synchronously, when a component is determined, its related application logic, such as filtering, pagination, and viewing details, is also generated and bound simultaneously. This end-to-end integrated generation ensures the integrity of functionality and the consistency of internal logic, reducing the cost of later debugging and repair.

[0082] Based on the first embodiment of this application, in the second embodiment of this application, the content that is the same as or similar to that in the first embodiment described above can be referred to the above description, and will not be repeated hereafter. Based on this, please refer to... Figure 2 , Figure 2 This is a flowchart illustrating Embodiment 2 of the application generation method based on a low-code platform in this application.

[0083] like Figure 2 Fourth, in this embodiment of the application, the step of determining the application component configuration and application logic configuration required for application generation based on the node configuration includes:

[0084] Step S100: Based on the node configuration and component semantic knowledge base, perform dynamic component mapping to obtain the application components required for application generation;

[0085] Step S200: Based on the node configuration, identify the logical action chain to obtain the application logic configuration required for application generation.

[0086] It should be noted that for each component in the low-code platform, its corresponding component semantics can be determined. For example, the semantics of a button that triggers a save operation can be "save button". The aforementioned component semantic knowledge base can be a database containing the component semantics corresponding to all components in the low-code platform.

[0087] In some embodiments of this application, before the step of dynamically mapping components based on the node configuration and component semantic knowledge base to obtain the application components required for application generation, the method further includes: obtaining the technical attributes and semantic features corresponding to the components in the low-code platform; constructing the semantic profile of the components based on the technical attributes and semantic features; and constructing the component semantic knowledge base of the low-code platform based on the semantic profile.

[0088] It should be noted that, in order to achieve dynamic component mapping, this embodiment of the application can first build a component semantic knowledge base based on the components of the low-code platform, and design a mapping and assembly engine that works in conjunction with it. Specifically, this embodiment of the application can pre-build a semantic profile for each component (such as DataTable, Form, Chart) in the component library at the low-code platform level. This semantic profile can contain the component's technical attributes and semantic features.

[0089] It should be explained that the aforementioned technical attributes may include the component's input, output, and callable APIs, which can be used to define how the component is used. The aforementioned semantic features can be used to characterize the meaning carried by the component in a business context. Specifically, the semantic features reported in this application embodiment may include functional keywords (e.g., DataTable files contain "list," "table," "display," "view," and "filter"), applicable scenarios (e.g., data listing, multi-row comparison, batch operations), input / output intent, etc., which are not limited in this application embodiment.

[0090] Understandably, the above input / output intents can be used to define what data intents a component typically receives (such as displaying a data collection) and what interactive intents it can trigger (such as viewing the details of an event, editing an item, etc.).

[0091] It should be noted that the specific process of the above dynamic component mapping may include: intent vectorization matching, optimal component selection, and context-aware candidate selection. That is, the step of dynamically mapping components based on the node configuration and component semantic knowledge base to obtain the application components required for application generation includes: obtaining intent keywords in the node configuration; performing vectorization matching on the component semantic knowledge base according to the intent keywords to obtain candidate components; and selecting the candidate component with the highest similarity to the intent keywords as the application component required for application generation.

[0092] It should be noted that when obtaining the node configuration (such as the configuration fragment {"type": "list_view", "for": "Employee", "actions": ["filter"]}), the intent keywords (list_view, filter) in the fragment can be vectorized and matched with the semantic features of all components in the component semantic knowledge base to obtain candidate components in the component library.

[0093] Understandably, vectorized matching can identify components in the component semantic knowledge base that are similar to the intent keywords in the node configuration. Since there is a mapping relationship between component semantics and components in the component library, candidate components corresponding to the intent keywords can be determined based on the component name.

[0094] It should be understood that the aforementioned intent keywords are the keywords used in the node configuration to represent the user's intent.

[0095] In some embodiments of this application, when candidate components are determined, they can be filtered based on the semantics of the components and the semantics of the intent keywords. The candidate component whose semantic features are closest to the user's intent is selected as the application component required for application generation; that is, the candidate component with the highest similarity to the intent keywords is selected as the application component required for application generation. This dynamic semantic mapping avoids blind matching based directly on intent keywords.

[0096] This application embodiment obtains the technical attributes and semantic features corresponding to components in a low-code platform; constructs semantic profiles for the components based on these attributes and features; builds a component semantic knowledge base for the low-code platform based on the semantic profiles; performs dynamic component mapping based on node configuration and the component semantic knowledge base to obtain the application components required for application generation; and identifies logical action chains based on node configuration to obtain the application logic configuration required for application generation. Because automatic component matching is achieved through the establishment of semantic profiles and a semantic knowledge base, a shift from manual search to intelligent recommendation is realized, reducing the cognitive load on users. Users only need to describe their needs in natural language (e.g., "I need a list"), and the system can automatically recommend the most suitable components. Users do not need to care about the specific names and technical implementations of the components, eliminating the burden of learning and memorizing a component library.

[0097] Based on the first and / or second embodiments of this application, in the third embodiment of this application, the content that is the same as or similar to the first and / or second embodiments described above can be referred to the above description and will not be repeated hereafter. Based on this, please refer to... Figure 3 , Figure 3 This is a flowchart illustrating Embodiment 3 of the application generation method based on a low-code platform in this application.

[0098] like Figure 3 As shown in this embodiment, the step of identifying the logical action chain based on the node configuration to obtain the application logic configuration required for application generation includes:

[0099] Step S31: Based on the node configuration, perform trigger action chain parsing to obtain the trigger source component and trigger action;

[0100] Step S32: Determine the triggering event based on the semantic file of the triggering source component, and bind the triggering event with the intent keyword to obtain a logical mapping relationship;

[0101] Step S33: Obtain the application logic configuration required for application generation based on the logical mapping relationship.

[0102] It should be noted that the trigger action chain can be a causal relationship chain used to represent the functional requirements of a user application. The trigger source component is the starting component for implementing the function, such as a button, table, or input box; the trigger action is the action generated when the trigger source component is triggered, such as clicking a button to jump to a specific page.

[0103] For example, if the node configuration corresponding to the middle representation is {"from": "employeeList", "on": "viewDetail", "to": "employeeDetail"}, it can be identified that the triggering source is the employeeList component, the event is viewDetail, and the action is to navigate to employeeDetail.

[0104] It is understandable that the semantic profile of a component can include the events corresponding to that component. By examining the semantic profile of the triggering source component, its corresponding trigger time can be determined, and this triggering event can be bound to the intent keyword to obtain the logical mapping relationship between the triggering event and the intent keyword.

[0105] In some embodiments of this application, in the logic flow designer of a low-code platform, a "page navigation" node can be created, the target page can be set to employeeDetail, and parameters (such as employee ID) can be configured for transmission.

[0106] It is understandable that the above application logic configuration refers to the configuration parameters used to describe the logical relationships between the components. Application components can be chained together through application wheel configuration, thereby rendering a low-code platform application in the low-code platform.

[0107] This application embodiment parses the trigger action chain based on node configuration to obtain the trigger source component and trigger action; it determines the trigger event based on the semantic profile of the trigger source component and binds the trigger event with intent keywords to obtain a logical mapping relationship; and it obtains the application logic configuration required for application generation based on the logical mapping relationship. By constructing the logical mapping relationship, the creation of event normals, logical nodes, parameter configuration, and final connection can be completed automatically in one go. The entire process is transparent to the user, compressing the work that would normally take several minutes for the user to complete in seconds.

[0108] It should be noted that the above examples are only for understanding this application and do not constitute a limitation on the application generation method based on the low-code platform of this application. Any simple modifications based on this technical concept are within the protection scope of this application.

[0109] This application also provides an application generation system based on a low-code platform; please refer to [link / reference]. Figure 4 , Figure 4 This is a schematic diagram of the module structure of an application generation system based on a low-code platform according to an embodiment of this application. The application generation system based on a low-code platform includes:

[0110] User interaction layer 10 is used to obtain the user's application generation requirements;

[0111] The large language model engine layer 20 is used to perform intent recognition based on the application's generation requirements and obtain the intermediate representation generated by the application.

[0112] Configuration generation and assembly layer 30 is used to perform low-code platform configuration conversion based on the intermediate representation to obtain the node configuration of the low-code platform;

[0113] The configuration generation and assembly layer 30 is also used to determine the application component configuration and application logic configuration required for application generation based on the node configuration;

[0114] The platform core and integration layer 40 is used to generate low-code platform applications based on the application component configuration and the application logic configuration.

[0115] The application generation system based on a low-code platform provided in this application, employing the application generation method based on a low-code platform as described in the above embodiments, can solve the technical problem that existing low-code application development methods suffer from lengthy, difficult-to-understand, and difficult-to-maintain graphical orchestration for complex business logic. Compared with the prior art, the beneficial effects of the application generation system based on a low-code platform provided in this application are the same as those of the application generation method based on a low-code platform provided in the above embodiments, and other technical features of the application generation system based on a low-code platform are the same as those disclosed in the methods of the above embodiments, and will not be repeated here.

[0116] This application provides an application generation device based on a low-code platform. The application generation device based on a low-code platform includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to execute the application generation method based on the low-code platform in the first embodiment described above.

[0117] The following is for reference. Figure 5 This document illustrates a structural diagram of an application generation device based on a low-code platform suitable for implementing embodiments of this application. The application generation device based on a low-code platform in the embodiments of this application may include, but is not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Portable Application Descriptions), PMPs (Portable Media Players), in-vehicle terminals (e.g., in-vehicle navigation terminals), and fixed terminals such as digital TVs and desktop computers. Figure 5The application generation device based on the low-code platform shown is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of this application.

[0118] like Figure 5 As shown, the application generation device based on a low-code platform may include a processing unit 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes according to a program stored in read-only memory (ROM) 1002 or a program loaded from storage device 1003 into random access memory (RAM) 1004. The RAM 1004 also stores various programs and data required for the operation of the application generation device based on the low-code platform. The processing unit 1001, ROM 1002, and RAM 1004 are interconnected via a bus 1005. An input / output (I / O) interface 1006 is also connected to the bus. Typically, the following systems can be connected to I / O interface 1006: input devices 1007 including, for example, touchscreens, touchpads, keyboards, mice, image sensors, microphones, accelerometers, gyroscopes, etc.; output devices 1008 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 1003 including, for example, magnetic tapes, hard disks, etc.; and communication devices 1009. Communication device 1009 allows the low-code platform-based application generation device to wirelessly or wiredly communicate with other devices to exchange data. Although the figure shows a low-code platform-based application generation device with various systems, it should be understood that it is not required to implement or possess all the systems shown. More or fewer systems can be implemented alternatively.

[0119] Specifically, according to the embodiments disclosed in this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device, or installed from storage device 1003, or installed from ROM 1002. When the computer program is executed by processing device 1001, it performs the functions defined in the methods of the embodiments disclosed in this application.

[0120] The application generation device based on a low-code platform provided in this application, employing the application generation method based on a low-code platform as described in the above embodiments, can solve the technical problem that existing low-code application development methods suffer from lengthy, difficult-to-understand, and difficult-to-maintain graphical orchestration for complex business logic. Compared with the prior art, the beneficial effects of the application generation device based on a low-code platform provided in this application are the same as those of the application generation method based on a low-code platform provided in the above embodiments, and other technical features of this application generation device based on a low-code platform are the same as those disclosed in the method of the previous embodiment, and will not be repeated here.

[0121] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any suitable manner in one or more embodiments or examples.

[0122] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0123] This application provides a computer-readable storage medium having computer-readable program instructions (i.e., a computer program) stored thereon, the computer-readable program instructions being used to execute the application generation method based on a low-code platform in the above embodiments.

[0124] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems, devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM), or flash memory, optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, system, or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination thereof.

[0125] The aforementioned computer-readable storage medium may be included in an application generation device based on a low-code platform; or it may exist independently and not assembled into an application generation device based on a low-code platform.

[0126] The aforementioned computer-readable storage medium carries one or more programs, which, when executed by a low-code platform-based application generation device, cause the low-code platform-based application generation device to:

[0127] Obtain the user's application generation requirements, and perform intent recognition based on the application generation requirements to obtain an intermediate representation of the application generation;

[0128] Based on the intermediate representation, the configuration of the low-code platform is converted to obtain the node configuration of the low-code platform;

[0129] Based on the node configuration, the application component configuration and application logic configuration required for application generation are determined.

[0130] A low-code platform application is generated based on the application component configuration and the application logic configuration.

[0131] Computer program code for performing the operations of this application can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, as well as conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0132] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0133] The modules described in the embodiments of this application can be implemented in software or hardware. The names of the modules do not necessarily limit the functionality of the unit itself.

[0134] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., computer programs) for executing the application generation method based on the low-code platform described above. This solves the technical problem of existing low-code application development methods having lengthy, difficult-to-understand, and difficult-to-maintain graphical arrangements for complex business logic. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the application generation method based on the low-code platform provided in the above embodiments, and will not be repeated here.

[0135] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the application generation method based on a low-code platform as described above.

[0136] The computer program product provided in this application can solve the technical problem that existing low-code application development methods suffer from lengthy, difficult-to-understand, and difficult-to-maintain graphical orchestration for complex business logic. Compared with the prior art, the beneficial effects of the computer program product provided in this application are the same as those of the application generation method based on the low-code platform provided in the above embodiments, and will not be repeated here.

[0137] The above description is only a part of the embodiments of this application and does not limit the scope of protection of this application. All equivalent structural transformations made under the technical concept of this application and using the content of this application specification and drawings, or direct / indirect applications in other related technical fields, are included in the scope of protection of this application.

Claims

1. An application generation method based on a low-code platform, characterized in that, The method includes: Obtain the user's application generation requirements, and perform intent recognition based on the application generation requirements to obtain an intermediate representation of the application generation; Based on the intermediate representation, the configuration of the low-code platform is converted to obtain the node configuration of the low-code platform; Based on the node configuration, the application component configuration and application logic configuration required for application generation are determined. A low-code platform application is generated based on the application component configuration and the application logic configuration. The step of determining the application component configuration and application logic configuration required for application generation based on the node configuration includes: Based on the node configuration and component semantic knowledge base, dynamic component mapping is performed to obtain the application components required for application generation. Based on the node configuration, the logical action chain is identified to obtain the application logic configuration required for application generation. The step of dynamically mapping components based on the node configuration and component semantic knowledge base to obtain the application components required for application generation includes: Obtain the intent keywords from the node configuration; Based on the intent keywords, vector matching is performed in the component semantic knowledge base to obtain candidate components; The candidate component with the highest similarity to the intent keyword will be used as the application component required for application generation. The step of identifying the logical action chain based on the node configuration to obtain the application logic configuration required for application generation includes: Based on the node configuration, the trigger action chain is parsed to obtain the trigger source component and the trigger action; The triggering event is determined based on the semantic profile of the triggering source component, and the triggering event is bound to the intent keyword to obtain a logical mapping relationship; The application logic configuration required for application generation is obtained based on the logical mapping relationship.

2. The application generation method based on a low-code platform as described in claim 1, characterized in that, Before the step of performing low-code platform configuration conversion based on the intermediate representation to obtain the node configuration of the low-code platform, the method further includes: Obtain the metadata collection of the low-code platform; The preset initial model is trained based on the metadata set to obtain the configuration conversion model; Accordingly, the step of performing low-code platform configuration conversion based on the intermediate representation to obtain the node configuration of the low-code platform includes: Based on the configuration transformation model, the intermediate representation is transformed to obtain the node configuration of the low-code platform.

3. The application generation method based on a low-code platform as described in claim 1, characterized in that, Before the step of dynamically mapping components based on the node configuration and component semantic knowledge base to obtain the application components required for application generation, the method further includes: Obtain the technical attributes and semantic features corresponding to the components in the low-code platform; Construct a semantic profile of the component based on the technical attributes and semantic features; The component semantic knowledge base of the low-code platform is constructed based on the semantic archive.

4. An application generation system based on a low-code platform, characterized in that, The system is used to implement the application generation method based on a low-code platform as described in any one of claims 1-3, wherein the application generation system based on a low-code platform comprises: The user interaction layer is used to obtain the user's application generation requirements; The large language model engine layer is used to perform intent recognition based on the application's generation requirements and obtain the intermediate representation generated by the application. A configuration generation and assembly layer is used to perform low-code platform configuration transformation based on the intermediate representation to obtain the node configuration of the low-code platform; The configuration generation and assembly layer is also used to determine the application component configuration and application logic configuration required for application generation based on the node configuration; The platform core and integration layer are used to generate low-code platform applications based on the application component configuration and the application logic configuration. The process of determining the application component configuration and application logic configuration required for application generation based on the node configuration includes: Based on the node configuration and component semantic knowledge base, dynamic component mapping is performed to obtain the application components required for application generation. Based on the node configuration, the logical action chain is identified to obtain the application logic configuration required for application generation. The dynamic component mapping based on the node configuration and component semantic knowledge base to obtain the application components required for application generation includes: Obtain the intent keywords from the node configuration; Based on the intent keywords, vector matching is performed in the component semantic knowledge base to obtain candidate components; The candidate component with the highest similarity to the intent keyword will be used as the application component required for application generation. The step of identifying the logical action chain based on the node configuration to obtain the application logic configuration required for application generation includes: Based on the node configuration, the trigger action chain is parsed to obtain the trigger source component and the trigger action; The triggering event is determined based on the semantic profile of the triggering source component, and the triggering event is bound to the intent keyword to obtain a logical mapping relationship; The application logic configuration required for application generation is obtained based on the logical mapping relationship.

5. An application generation device based on a low-code platform, characterized in that, The device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the application generation method based on a low-code platform as described in any one of claims 1 to 3.

6. A storage medium, characterized in that, The storage medium is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by a processor, it implements the steps of the application generation method based on a low-code platform as described in any one of claims 1 to 3.

7. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, implements the steps of the application generation method based on a low-code platform as described in any one of claims 1 to 3.

Images