Low-code application development method and device based on large model and storage medium

Abstract

The invention discloses a low-code application development method and device based on a large model and a storage medium, and the method comprises the steps: inputting a received application development request into a pre-trained low-code generation large model, and obtaining an application development intention corresponding to the application development request; retrieving corresponding low-code development knowledge from a pre-constructed low-code development knowledge base according to the application development intention; generating a page layout cue word according to the low-code development knowledge and the application development intention; inputting the page layout cue word into a pre-trained low-code evaluation large model to obtain a layout evaluation result of the page layout cue word; and determining the application page layout according to the page layout cue word in response to the situation that the layout evaluation result represents that the page layout cue word conforms to the application development intention. According to the scheme, the application development efficiency can be improved.

Description

Technical Field

[0001] This application relates to the field of large model technology, and in particular to a low-code application development method, device, and storage medium based on large models. Background Technology

[0002] Low-code technology, as a significant innovation in modern software development, stems from the industry's continuous exploration of efficient and agile development models. At its core are visual programming, rapid application development, and model-driven architecture. Through features such as pre-built component libraries, reusable templates, and graphical interfaces, this technology significantly improves the efficiency, flexibility, and scalability of application development.

[0003] While low-code platforms offer advantages such as fast development speed and cost-effectiveness, they still have several technical limitations: for example, the platform faces technical challenges in terms of feature expansion and deep customization; secondly, developers need to invest in learning to master the platform's unique interface operations, toolchain, and domain-specific language (DSL); in addition, the "black box effect" caused by the closed architecture increases the difficulty of troubleshooting, which affects both development efficiency and the technical growth of developers.

[0004] Therefore, how to effectively utilize the advantages of low-code and solve the pain points of low-code platforms such as high usage threshold and difficulty in building them has become one of the important research directions of low-code technology. Summary of the Invention

[0005] This application provides at least one method, apparatus, device, and computer-readable storage medium for developing low-code applications based on a large model.

[0006] The first aspect of this application provides a low-code application development method based on a large model, comprising: inputting a received application development request into a pre-trained low-code generation large model to obtain an application development intent corresponding to the application development request; retrieving corresponding low-code development knowledge from a pre-built low-code development knowledge base according to the application development intent; generating page layout prompts based on the low-code development knowledge and the application development intent; inputting the page layout prompts into a pre-trained low-code evaluation large model to obtain a layout evaluation result of the page layout prompts; and determining the application page layout based on the page layout prompts in response to the layout evaluation result indicating that the page layout prompts conform to the application development intent.

[0007] In one embodiment, after inputting the page layout tooltip into a pre-trained low-code evaluation model and obtaining the layout evaluation result of the page layout tooltip, the process includes: In response to the layout evaluation result indicating that the page layout prompt does not conform to the application development intent, the low-code evaluation model is used to obtain the prompt optimization scheme for the page layout prompt; the page layout prompt and the prompt optimization scheme are input into the low-code generation model to obtain the optimized page layout prompt; the application page layout is determined based on the optimized page layout prompt.

[0008] In one embodiment, the low-code development knowledge base includes a component knowledge base and an interface knowledge base. The step of retrieving corresponding low-code development knowledge from the pre-built low-code development knowledge base according to the application development intention includes: obtaining component knowledge from the component knowledge base and obtaining interface knowledge from the interface knowledge base according to the application development intention; and determining the component knowledge and the interface knowledge as the low-code development knowledge.

[0009] In one embodiment, the step of inputting the received application development request into a pre-trained low-code generation model to obtain the application development intent corresponding to the application development request includes: retrieving corresponding intent recognition knowledge from a preset intent recognition knowledge base based on the application development request; generating intent prompt words based on the intent recognition knowledge and the application development request; recognizing the intent prompt words and generating the application development intent corresponding to the intent prompt words.

[0010] In one embodiment, after retrieving corresponding low-code development knowledge from a pre-built low-code development knowledge base according to the application development intent, the method further includes: generating corresponding component attribute prompts and component interaction prompts based on the low-code development knowledge and the application development intent; generating component attribute configurations based on the component attribute prompts and the application page layout, and generating component interaction configurations based on the component interaction prompts and the application page layout; integrating the application page layout, the component attribute configurations, and the component interaction configurations to obtain page description information; and rendering the page description information to obtain the target application page.

[0011] In one embodiment, the application page layout includes a component tree. Integrating the application page layout, the component attribute configuration, and the component interaction configuration to obtain page description information includes: traversing the page components to be set in the component tree to obtain the currently traversed component; querying the component description information corresponding to the currently traversed component in a preset component library; creating a new component instance based on the component description information; setting the component description information of the component instance based on the component attribute configuration and the component interaction configuration, until all page components to be set in the component tree are set, thereby obtaining the page description information.

[0012] In one embodiment, after integrating the application page layout, the component attribute configuration, and the component interaction configuration to obtain page description information, the method further includes: inputting the page description information into the low-code evaluation model to obtain a page evaluation result; in response to the page evaluation result indicating that the page description information conforms to the application development intent, storing the page description information into a pre-built page template library; and inputting the page description information into a renderer for page rendering processing to obtain the target application page.

[0013] In one embodiment, after inputting the received application development request into a pre-trained low-code generation model to obtain the application development intent corresponding to the application development request, the method further includes: responding to the application development intent as a page template generation strategy, searching for a corresponding page template in a pre-built page template library according to the application development intent; inputting the page description information of the page template into a renderer for page rendering processing to obtain a target application page; and responding to the application development intent as a page description generation strategy, retrieving corresponding low-code development knowledge from the low-code development knowledge base according to the application development intent.

[0014] A second aspect of this application provides a low-code application development apparatus based on a large model, comprising: an intent recognition module, configured to input a received application development request into a pre-trained low-code generation large model to obtain an application development intent corresponding to the application development request; a knowledge retrieval module, configured to retrieve corresponding low-code development knowledge from a pre-built low-code development knowledge base according to the application development intent; a prompt word generation module, configured to generate page layout prompt words according to the low-code development knowledge and the application development intent; a prompt word evaluation module, configured to input the page layout prompt words into a pre-trained low-code evaluation large model to obtain a layout evaluation result of the page layout prompt words; and a page generation module, configured to determine the application page layout according to the page layout prompt words in response to the layout evaluation result indicating that the page layout prompt words conform to the application development intent.

[0015] A third aspect of this application provides an electronic device including a memory and a processor, the processor being used to execute program instructions stored in the memory to implement the aforementioned low-code application development method based on a large model.

[0016] The fourth aspect of this application provides a computer-readable storage medium having program instructions stored thereon, which, when executed by a processor, implement the aforementioned low-code application development method based on a large model.

[0017] The above scheme involves inputting received application development requests into a pre-trained low-code generation model for development intent recognition, thereby obtaining the application development intent corresponding to the request. The application development intent reflects the developer's development needs. After obtaining the intent, corresponding low-code development knowledge can be retrieved from a pre-built low-code development knowledge base. This allows for the analysis and refinement of development needs based on low-code development knowledge such as component knowledge and UI specification knowledge, and the low-code generation model generates corresponding page layout prompts. These prompts are then input into a pre-trained low-code evaluation model, which evaluates them and provides optimization suggestions to guide the low-code generation model in iterative optimization until the evaluation results indicate that the prompts align with the application development intent. Finally, the corresponding domain-specific language (DSL) is found based on the evaluated prompts for rendering, resulting in the application page layout corresponding to the prompts. This enables rapid application page development and improves development efficiency.

[0018] It should be understood that the above general description and the following detailed description are exemplary and explanatory only, and are not intended to limit this application. Attached Figure Description

[0019] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with this application and, together with the specification, serve to explain the technical solutions of this application.

[0020] Figure 1 This is a flowchart illustrating an exemplary embodiment of the low-code application development method based on a large model according to this application; Figure 2 This is an exemplary intent recognition diagram in the low-code application development method based on a large model of this application; Figure 3 This is an exemplary overall application development flowchart in the low-code application development method based on a large model of this application; Figure 4 This is an exemplary flowchart of page description information assembly in the low-code application development method based on a large model of this application; Figure 5 This is a block diagram illustrating a low-code application development apparatus based on a large model, as shown in an exemplary embodiment of this application; Figure 6 This is a schematic diagram of the structure of an embodiment of the electronic device of this application; Figure 7 This is a schematic diagram of the structure of an embodiment of the computer-readable storage medium of this application. Detailed Implementation

[0021] The embodiments of this application will now be described in detail with reference to the accompanying drawings.

[0022] In the following description, specific details such as particular system architectures, interfaces, and technologies are presented for illustrative purposes rather than for limiting purposes, in order to provide a thorough understanding of this application.

[0023] In this document, the term "and / or" is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, and B existing alone. Additionally, the character " / " generally indicates that the preceding and following related objects have an "or" relationship. Furthermore, "many" in this document means two or more. Moreover, the term "at least one" in this document means any combination of at least two of any one or more of a plurality of objects. For example, including at least one of A, B, and C can mean including any one or more elements selected from the set consisting of A, B, and C.

[0024] To facilitate understanding, one of the applicable scenarios of this application will be illustrated by example.

[0025] Low-code technology, as a significant innovation in modern software development, stems from the industry's continuous exploration of efficient and agile development models. At its core are visual programming, rapid application development, and model-driven architecture. Through features such as pre-built component libraries, reusable templates, and graphical interfaces, this technology significantly improves the efficiency, flexibility, and scalability of application development.

[0026] Its core value lies not only in simplifying the development process, but also in effectively lowering the technical threshold, enabling non-professional developers such as business personnel to participate in application building, thereby promoting cross-team collaborative innovation and shortening the product iteration cycle.

[0027] While low-code platforms offer advantages such as rapid development and cost-effectiveness, they still face several technical limitations. For example, they present technical challenges in terms of feature expansion and deep customization. Secondly, developers need to invest time and effort to master the platform's unique interface, toolchain, and domain-specific languages ​​(DSLs). Furthermore, the "black box effect" caused by a closed architecture increases the difficulty of troubleshooting, impacting both development efficiency and hindering developers' technical growth. These factors limit the application of low-code technology in complex system development scenarios.

[0028] Therefore, this application proposes a low-code application development method based on large models. Large model technology is rapidly developing in the field of artificial intelligence, achieving significant results in natural language processing, image recognition, and intelligent coding, and giving rise to numerous native applications. Therefore, this application introduces large model technology into traditional low-code platforms. Through the complementary advantages of both, it can solve the pain points of high usage barriers and difficult setup faced by low-code platforms, thereby improving application development efficiency.

[0029] Please see Figure 1 , Figure 1 This is a flowchart illustrating an exemplary embodiment of the low-code application development method based on a large model according to this application. The low-code application development method of this application can be applied to low-code application development. Specifically, it may include the following steps: Step S110: Input the received application development request into the pre-trained low-code generation model to obtain the application development intent corresponding to the application development request.

[0030] Application development requests are typically received by the low-code application development system from developers (users), but can also be sent from other devices. Developers can submit application development requests to raise development issues, which the low-code generation model can then interpret as application development intent. Alternatively, developers can directly send specific application development intents to the low-code generation model, etc., without further limitations.

[0031] For example, upon receiving an application development request, the system can determine whether the developer has specified an intent to develop the application (if so, subsequent processing can proceed directly). Otherwise, it combines Retrieval-augmented Generation (RAG) technology with a low-code generation model to identify the intent of the application development request. RAG technology combines language modeling and information retrieval techniques. Simply put, when the model needs to generate text or answer questions, it first retrieves relevant information from a large document collection and then uses this retrieved information to guide text generation, thereby improving the quality and accuracy of predictions. For a detailed explanation of this technology, please refer to relevant documentation; it will not be elaborated upon here.

[0032] For example, let's take a user submitting a development question (without specifying an application development intent) as an illustration. After receiving an application development request, the low-code generation model retrieves corresponding domain knowledge from a pre-built intent recognition knowledge base based on the user's development question. This intent recognition knowledge base may include a template knowledge base (knowledge related to application development templates), a component knowledge base (knowledge related to application development components), etc. Then, it assembles prompt words based on the development question and the retrieved domain knowledge, thereby generating the user's application development intent. It can also determine whether the application development intent falls within the preset business scope supported by the low-code application development system (e.g., pre-constraining certain compliant and legal business scopes). If so, a corresponding development workflow can be generated based on the application development intent. If not, an exception message is sent to inform the developer that the current application development intent is not within the business scope supported by the low-code application development system.

[0033] Therefore, when processing application development requests, the system can first check whether an application development intent within the specified business scope has been defined. If it has, the intent recognition step is skipped, and the corresponding subsequent processing path is directly selected to improve processing efficiency. If it has not been defined, the original application development request is parsed, domain knowledge is retrieved from the knowledge base, and prompt words are assembled and fed into a large model for learning to accurately identify the application development intent. Subsequently, the system can select the corresponding subsequent processing path to execute the workflow based on the application development intent, generate the page DSL, and finally return the DSL for low-code renderer to complete the application page rendering.

[0034] Step S120: Retrieve the corresponding low-code development knowledge from the pre-built low-code development knowledge base according to the application development intent.

[0035] The low-code development knowledge base and the intent recognition knowledge base mentioned in the previous steps may contain the same or different knowledge; this is not limited here. For example, the intent recognition knowledge base is mainly used for intent understanding and may include a template knowledge base and a component knowledge base. The low-code development knowledge base is mainly used for low-code development and may include a component knowledge base and a UI (User Interface) specification knowledge base (referred to as the interface knowledge base).

[0036] For example, after obtaining the application development intent, the corresponding page generation workflow can be selected based on the application development intent. The page generation workflow can include a workflow based on a page template generation strategy (referring to finding the corresponding DSL in the page template to generate the page) and a workflow based on a page description generation strategy (referring to determining the corresponding DSL through the intent description to generate the page).

[0037] For example, if analyzing the developer's application development intent determines that the intended workflow is based on a page template generation strategy, then a target page template matching the application development intent can be retrieved from a pre-built page template library. The target page template's DSL can then be obtained and input into the renderer for rendering. Conversely, if analyzing the developer's application development intent determines that the intended workflow is based on a page description generation strategy, then low-code development knowledge can be retrieved from the low-code development knowledge base based on the application development intent (or the original application development request) to assist in understanding and analyzing the application development intent. Therefore, compared to page template generation strategies, page description generation strategies support the rapid construction of diverse application pages through natural language commands, significantly lowering the barrier to entry for low-code application development and also meeting personalized needs.

[0038] Step S130: Generate page layout prompts based on low-code development knowledge and application development intent.

[0039] To illustrate this in conjunction with the preceding steps, after retrieving low-code development knowledge, the developer's application development needs can be analyzed and refined based on this knowledge, extracting key requirements and expanding upon them. For example, if a developer's application development request (development problem) is "Please help me build a user registration page," after refinement, the specific requirements might be "Please design a mobile user registration page that includes a mobile phone number and verification code, password settings (with strong hints), an agreement checkbox, a simple page style, a blue main color, supports WeChat quick login, and redirects to the homepage after registration." Thus, the low-code generation model assembles prompts (such as page layout prompts) based on the application development intent and low-code development knowledge.

[0040] Page layout tooltips refer to the tooltips used to generate the application's page layout. Other development processes may also exist during application development, such as setting page component attributes and page component interactions. Therefore, in some application scenarios, component tooltips and interaction tooltips may also be included, which will not be elaborated upon here.

[0041] Step S140: Input the page layout prompts into the pre-trained low-code evaluation model to obtain the layout evaluation results of the page layout prompts.

[0042] Based on the preceding steps, after obtaining the page layout hints, these hints can be input into a pre-trained low-code evaluation model for hint evaluation. This process determines whether the page layout hints align with the application development intent and provides evaluation feedback. The low-code evaluation model is an evaluation-type model, distinct from the low-code generation model (generation-type model) in the previous embodiments. The low-code evaluation model is primarily used to evaluate the low-code application development process, such as evaluating hints and / or the final generated application, which will not be elaborated upon here.

[0043] For example, the layout evaluation result may include whether the page layout hints conform to the application development intent or not. The low-code evaluation model essentially acts as a teacher model for the low-code generation model. When the page layout hints do not conform to the application development intent, it can provide feedback and guidance to the teacher model of the low-code generation model, guiding the low-code generation model to iteratively optimize the page layout hints until the evaluation is reasonable or the iteration count threshold is exceeded, at which point it exits the iteration optimization process. If the page layout hints conform to the application development intent, the application page layout can be determined based on the page layout hints.

[0044] Step S150: In response to the layout evaluation result indicating that the page layout prompts conform to the application development intent, determine the application page layout based on the page layout prompts.

[0045] Based on the steps described above, after obtaining the layout evaluation result indicating that the page layout hints match the application development intent, the corresponding DSL can be found based on the page layout hints and then handed over to the renderer to render the page, resulting in the completed application page.

[0046] As can be seen, this application obtains the application development intent corresponding to the received application development request by inputting it into a pre-trained low-code generation model for development intent recognition. The application development intent reflects the developer's development needs. After obtaining the application development intent, corresponding low-code development knowledge can be retrieved from a pre-built low-code development knowledge base. This allows for the analysis and refinement of development needs based on low-code development knowledge such as component knowledge and UI specification knowledge, and the low-code generation model generates corresponding page layout prompts. Inputting the page layout prompts into a pre-trained low-code evaluation model allows the model to evaluate the prompts, obtain layout evaluation results, and output optimization suggestions to guide the low-code generation model in iterative optimization until the layout evaluation results indicate that the page layout prompts conform to the application development intent. Then, based on the evaluated page layout prompts, the corresponding domain-specific language (DSL) can be found for rendering, resulting in the application page layout corresponding to the page layout prompts. This enables rapid application page development and improves application development efficiency.

[0047] Based on the above embodiments, this application embodiment describes the steps following the process of obtaining the layout evaluation result of the page layout prompts after inputting them into a pre-trained low-code evaluation model. Specifically, the method of this embodiment includes the following steps: In response to the layout evaluation results indicating that the page layout hints do not conform to the application development intent, the low-code evaluation model is used to obtain the hint optimization scheme for the page layout hints; the page layout hints and the hint optimization scheme are input into the low-code generation model to obtain the optimized page layout hints; the application page layout is determined based on the optimized page layout hints.

[0048] In conjunction with the aforementioned embodiments, if the layout evaluation result indicates that the page layout prompt does not conform to the application development intent, the low-code evaluation model will output an optimization scheme for the page layout prompt and feed it back to the low-code generation model, which will then guide the low-code generation model to iteratively optimize the page layout prompt until the evaluation is reasonable or the iteration number threshold is exceeded, at which point the iteration can be exited.

[0049] If the number of iterations exceeds the iteration threshold and the resulting layout evaluation result still indicates that the page layout hints do not conform to the application development intent, an error message can be generated, and the application development process can be paused or stopped. If, after iterations within the iteration threshold, the resulting layout evaluation result indicates that the page layout hints conform to the application development intent, the application page layout can be determined based on the currently optimized page layout hints.

[0050] Based on the above embodiments, this application embodiment describes the steps of retrieving corresponding low-code development knowledge from a pre-built low-code development knowledge base according to application development intent. The low-code development knowledge base includes a component knowledge base and a UI knowledge base. Specifically, the method of this embodiment includes the following steps: Based on the application development intent, component knowledge is obtained from the component knowledge base, and interface knowledge is obtained from the interface knowledge base; the component knowledge and interface knowledge are identified as low-code development knowledge.

[0051] Referring to the foregoing embodiments, after analyzing the developer's application development request to obtain the application development intent, if the application development intent representation determines the page DSL based on the page description generation strategy, then the requirements of the application development intent are refined through low-code generation of a large model, and prompt words are generated in combination with the domain knowledge retrieved from the low-code development knowledge base.

[0052] The low-code development knowledge base can include a component knowledge base (which stores knowledge related to page development components) and a UI knowledge base (a UI interface specification knowledge base, which stores knowledge related to UI interface design specifications). Therefore, component knowledge obtained from the component knowledge base and UI knowledge (also known as interaction knowledge) obtained from the UI knowledge base can be used as low-code development knowledge and combined with the application development intent to generate prompts.

[0053] Based on the above embodiments, this application embodiment describes the steps of inputting a received application development request into a pre-trained low-code generation model to obtain the application development intent corresponding to the application development request. Specifically, the method of this embodiment includes the following steps: Based on the application development request, retrieve the corresponding intent recognition knowledge from the preset intent recognition knowledge base; generate intent prompt words based on the intent recognition knowledge and the application development request; recognize the intent prompt words and generate the application development intent corresponding to the intent prompt words.

[0054] Referring to the foregoing embodiments, developers can specify the application development intent in the application development request, allowing the low-code to large-scale model to directly select the corresponding workflow based on that intent. Alternatively, developers can declare application development problems in the application development request, requiring the low-code to large-scale model to use RAG technology to identify and understand the application development intent expressed in the request, and then select the corresponding workflow based on that intent.

[0055] Among them, you can refer to, such as Figure 2 As shown, Figure 2This is an exemplary intent recognition diagram in the low-code application development method based on a large model according to this application. The process of the low-code generation large model combined with RAG technology to understand the application development intent may include, but is not limited to: retrieving corresponding intent recognition knowledge (domain knowledge used for intent recognition) from a preset intent recognition knowledge base (including component knowledge base and template knowledge base) according to the application development request; generating intent prompt words based on the intent recognition knowledge and the application development request; then, the low-code generation large model can combine the intent recognition knowledge to recognize the intent prompt words, generate the application development intent corresponding to the intent prompt words, and then output the subsequent intent processing module. The intent processing module can select the corresponding workflow module according to the application development intent, as in the aforementioned embodiments.

[0056] Based on the above embodiments, this application embodiment describes the steps following the retrieval of corresponding low-code development knowledge from a pre-built low-code development knowledge base according to the application development intent. Specifically, the method of this embodiment includes the following steps: Based on low-code development knowledge and application development intent, generate corresponding component attribute prompts and component interaction prompts; generate component attribute configurations based on component attribute prompts and application page layout, and generate component interaction configurations based on component interaction prompts and application page layout; integrate the application page layout, component attribute configurations, and component interaction configurations to obtain page description information; render the page description information to obtain the target application page.

[0057] Referring to the foregoing embodiments, in addition to setting the application page layout, application development typically requires setting page components within the application page and configuring the interaction logic between these components. Methods for setting component attributes and interactions within the application page layout can include, but are not limited to, receiving user-issued component editing instructions for the application page layout, or automatically generating them through the application development intent analysis using the low-code generation model of this application. Therefore, in addition to generating page layout prompts using a low-code generation model, this application can also generate component attribute prompts and component interaction prompts for page components using the low-code generation model.

[0058] Among them, component attribute hints are mainly used to describe component attributes and styles (such as width, height, color, font, etc.). Component interaction hints are mainly used to describe the response actions of each component when it is triggered.

[0059] For example, reference can be made to, such as Figure 3 , Figure 3This is an exemplary overall application development flowchart of the low-code application development method based on a large model in this application. After determining the application development intent as a page description-based generation strategy, the development requirements are refined, and corresponding low-code development knowledge is retrieved from the low-code development knowledge base. Then, the low-code development knowledge and the development requirements represented by the application development intent are combined to assemble three types of prompts (page layout prompts, component attribute prompts, and component interaction prompts). For an explanation of page layout prompts, please refer to the aforementioned example; it will not be repeated here. For component attribute prompts and component interaction prompts, component attribute configuration information can be generated based on the component attribute prompts and the application page layout, and component interaction configuration can be generated based on the component interaction prompts and the application page layout, respectively. Then, the application page layout, component attribute configuration, and component interaction configuration are integrated to obtain a complete page description information DSL including the application page, page components, and the interactions of each component. Rendering the page description information yields the complete target application page.

[0060] It's important to note that in low-code development platforms, pages are like blueprints for building applications, while components are the core modules that construct those applications, representing reusable functional units or UI elements. By encapsulating specific functionalities or interface designs, they allow developers to quickly build applications through drag-and-drop, configuration, and other operations rather than traditional coding. For example, basic components include, but are not limited to: buttons, input boxes, dropdown menus, etc.; container components include, but are not limited to: layout grids, tabs, cards (used to organize other components), etc.; and there may also be advanced components, including, but not limited to: data tables, charts, maps, etc.

[0061] Key characteristics of a component typically include: Attributes: Configurable parameters (such as title, style, data binding).

[0062] Event: Triggers an action (such as submitting a form when a button is clicked).

[0063] Data binding: Dynamically associate components with data sources (such as displaying database query results in a table).

[0064] Responsive behavior: Automatically updates based on received user actions or data changes (such as real-time search filter lists).

[0065] At the code level, a component can be described using a JSON-formatted data structure. This JSON data can be called the component's Domain-Specific Language (DSL). For example, the DSL of a button can be represented as:

[0066] Compared to basic components, container components typically have an additional `components` array property in their Domain-Specific Language (DSL) structure, such as:

[0067] In application development, several components are often nested and combined to form a more complex JSON. This nested JSON is called the application's Domain Specific Language (DSL) or the application's metadata.

[0068] Therefore, an application may correspond to a very complex DSL, and it is very difficult to directly generate this complex DSL using traditional methods with a large model. However, this application utilizes Retrieval-Augmented Generation (RAG) technology to pre-build a component knowledge base. The knowledge base documentation can describe in detail the applicable scenarios for each type of component, helping the large model in this application select appropriate components based on the problem description (application development intent). The knowledge base documentation can also describe in detail the component's attributes, styles, events, and interactive behavior information, which helps the large model understand each component and generate specific attribute, style, and interactive configuration items. Furthermore, when a user issues an application development request, the component knowledge base can be retrieved based on the question to obtain component domain knowledge and fully understand the application development intent contained in the application development request.

[0069] Based on the above embodiments, this application embodiment describes the steps of integrating application page layout, component attribute configuration, and component interaction configuration to obtain page description information. The application page layout includes a component tree. Specifically, the method of this embodiment includes the following steps: Traverse the page components to be set in the component tree to obtain the currently traversed component; query the component description information corresponding to the currently traversed component in the preset component library; create a new component instance based on the component description information; set the component description information of the component instance based on the component attribute configuration and component interaction configuration, until all page components to be set in the component tree are set and the page description information is obtained.

[0070] Referring to the foregoing embodiments, the application page layout can be expressed through a page component tree structure. Tree nodes represent components, and the tree hierarchy represents the component layout relationships. Thus, each component has a unique ID in the component tree, and different page components can be associated within the tree. Integrating the application page layout, component attribute configurations, and component interaction configurations is equivalent to having application components to be configured within the application page layout. By integrating the obtained component attribute configurations and component interaction configurations into the application page layout, the component settings for the application page layout can be completed.

[0071] For example, the page layout tooltip used to generate the page component tree can be as follows:

[0072] Among them, {context} and {user_input} can be used to populate component domain knowledge (such as low-code development knowledge in the previous example) and developer questions, respectively.

[0073] Another example is that the component attribute hints used to generate the component attribute configuration for each component in the page component tree can be as follows:

[0074] The {context}, {app_tree}, and {user_input} can be used to populate component domain knowledge, component tree, and development issues, respectively.

[0075] As another example, the component interaction prompts used to generate the component interaction configurations between components in the page component tree can be as follows:

[0076] The {context}, {app_tree}, and {user_input} can be used to populate component domain knowledge, component tree, and development issues, respectively.

[0077] Furthermore, after obtaining the prompts, they can be input into the low-code generation model to generate a DSL. For example, inputting page layout prompts into the low-code generation model will produce a page component tree generated by the model. The model will learn component domain knowledge, understand user development needs, and identify which components are needed to implement the page and the appropriate page layout to meet those needs. It will then provide specific page layout configuration requirements and output a component tree represented using a JSON data structure, for example:

[0078] The result indicates that the generated application page contains a container component, which in turn nests a button component and a dialog component. The `analysis` field also provides the page layout configuration requirements.

[0079] It should be noted that, as can be seen from the foregoing embodiments, this process is an iterative optimization process. First, the generative large model outputs the initial page layout. Then, the evaluation large model, which has been trained according to a specified method, evaluates the initial page layout and outputs feedback guidance to guide the generative large model to iteratively optimize the initial page layout until the evaluation is reasonable or exceeds the iteration threshold, at which point the iteration exits and proceeds to subsequent processing.

[0080] Then, on the one hand, the application page layout and component attribute hints can be integrated, and the generated page component tree can be filled into the {app_tree} of the component attribute hints to obtain more complete hints. This is then input into the large generation model, which generates the attribute and style configurations for each component in the component tree. The output format strictly follows the output requirements agreed upon in the component attribute hints, that is, it is output in JSON array format. Each object in the array contains the component's unique ID, the JSON path of the configuration item to be modified, and the value to be configured, etc. For example:

[0081] The example above indicates that the button component with the id "button_1" in the component tree needs to be configured with a background color of "#1c79f4".

[0082] On the other hand, the application page layout and component interaction prompts can be integrated, and the generated page component tree can be populated into the {app_tree} of the component interaction prompts to obtain more complete prompts. This is then input into the large generation model, which generates the interaction relationship configuration between each component in the component tree. The output format strictly follows the output requirements agreed upon in the component interaction prompts, that is, it is output in JSON array format. Each object in the array contains the component's unique ID and the interaction events and reactive behaviors that need to be configured, for example:

[0083] The example above shows that when the button component with the id "button_1" in the component tree is clicked, it will trigger the dialog component with the id "dialog_3" and execute the open action. In short, it implements the event of "clicking the button opens a dialog".

[0084] Examples are available for reference. Figure 4 , Figure 4This is an exemplary flowchart of page description information assembly in the low-code application development method based on a large model of this application. Based on the above-mentioned generation of page component tree, component attribute configuration, and component interaction configuration, using the component tree as a blueprint, each component in the component tree is traversed and parsed. Based on the component name, the metadata of that type of component (i.e., the complete DSL of the component, including default attributes and style configurations) can be queried from the component base library. A new component instance is created and initialized with the default attributes and style configurations in the DSL. Then, the component attributes and style configurations generated in the example above are assembled, mainly by finding the attribute items of the component instance through the JSON path and setting them to the attribute values ​​generated in the example (that is, equivalent to replacing the default values ​​of the newly created component instance according to development needs). The interaction relationship configuration of each component instance is assembled in the same way. Then, according to the topology of the component tree, all component instances can be integrated to generate the complete metadata (i.e., page description information DSL) of the low-code application page.

[0085] Additionally, the final assembled page description information DSL can be evaluated using a large evaluation model (low-code evaluation of large models) to verify whether it meets the development requirements (application development intent). If it does not meet the requirements, iterative optimization is required; if it does meet the requirements, the DSL is returned and then handed over to the renderer to complete the interface rendering, resulting in the application page.

[0086] Based on the above embodiments, this application embodiment describes the steps after integrating the application page layout, component attribute configuration, and component interaction configuration to obtain page description information. Specifically, the method of this embodiment includes the following steps: The page description information is input into the low-code evaluation model to obtain the page evaluation result; in response to the page evaluation result indicating that the page description information conforms to the application development intent, the page description information is stored in the pre-built page template library; the page description information is input into the renderer for page rendering processing to obtain the target application page.

[0087] Referring to the foregoing embodiments, the final generated Page Description Information (DSL) can be input into a low-code evaluation system to assess whether it meets the requirements of the large model. The evaluated and verified DSL can be saved as a template in a pre-built page template library for use in applications where the development intent is based on a page template-based generation strategy. For example, when receiving a requirement for a similar development problem, generation based on a page template can be directly selected, reducing the interaction with the large model, improving system response speed, and saving token costs.

[0088] Based on the above embodiments, this application embodiment describes the steps after obtaining the application development intent corresponding to the received application development request by inputting it into a pre-trained low-code generation model. Specifically, the method of this embodiment includes the following steps: In response to the application development intent, a page template generation strategy is implemented. The corresponding page template is searched in the pre-built page template library according to the application development intent. The page description information of the page template is input into the renderer for page rendering processing to obtain the target application page. In response to the application development intent, a page description generation strategy is implemented. The corresponding low-code development knowledge is retrieved from the low-code development knowledge base according to the application development intent.

[0089] As illustrated in the foregoing embodiments, after obtaining the application development intent, a workflow that selects the corresponding strategy can be selected based on the application development intent.

[0090] For example, if the application development intent is a page template generation strategy, in this strategy, the system can search for the corresponding page template in a pre-built page template library according to the application development intent, obtain the DSL (Page Description Information) of the found page template, and return it to the requesting end. Subsequently, the low-code platform renderer can perform page rendering to obtain the target application page. This method utilizes the mature page templates pre-built in the low-code platform (which can be pre-built on the low-code platform through visual drag-and-drop according to specific needs, details of which will not be elaborated here), eliminating the need for development from scratch. It is suitable for standardized scenarios and can significantly improve the development efficiency of building low-code applications from large models.

[0091] If the application development intent is a page description generation strategy, the system can retrieve low-code development knowledge (such as component knowledge, UI specification knowledge, etc.) from the knowledge base based on the user's original development questions. The development requirements are then analyzed and refined using this low-code development knowledge. Subsequent processes can be referenced in the aforementioned examples and will not be elaborated upon here.

[0092] In summary, the low-code application development method based on large models proposed in this application can generate domain-specific low-code languages ​​(DSLs) from natural language. It not only supports the automatic generation of static low-code components and their attribute configurations, but also generates flexible interface layouts and component interaction relationships to meet the needs of dynamic application pages. Compared with traditional technical solutions, it has higher flexibility and broader adaptability to business scenarios. By integrating large model generation technology into traditional low-code development platforms, an intelligent upgrade of the development process is achieved. Users only need to input a natural language description of their development requirements to quickly build applications, replacing complex visual drag-and-drop arrangement and configuration operations. This significantly improves the usability of low-code platforms, greatly lowers the development threshold, and allows non-professional developers to efficiently complete application building.

[0093] It should be further noted that the execution entity of the large-model-based low-code application development method can be a large-model-based low-code application development device. For example, the large-model-based low-code application development method can be executed by a terminal device, server, or other processing device. The terminal device can be a user equipment (UE), computer, mobile device, user terminal, terminal, cellular phone, cordless phone, personal digital assistant (PDA), handheld device, computing device, in-vehicle device, wearable device, etc. In some possible implementations, this large-model-based low-code application development method can be implemented by the processor calling computer-readable instructions stored in memory.

[0094] Figure 5 This is a block diagram illustrating a low-code application development apparatus based on a large model, as shown in an exemplary embodiment of this application. Figure 5 As shown, this exemplary low-code application development apparatus 500 based on a large model includes: an intent recognition module 510, a knowledge retrieval module 520, a prompt word generation module 530, a prompt word evaluation module 540, and a page generation module 550. Specifically: The intent recognition module 510 is used to input the received application development request into the pre-trained low-code generation large model to obtain the application development intent corresponding to the application development request.

[0095] The knowledge retrieval module 520 is used to retrieve corresponding low-code development knowledge from a pre-built low-code development knowledge base based on the application development intent.

[0096] The prompt generation module 530 is used to generate page layout prompts based on low-code development knowledge and application development intent.

[0097] The prompt evaluation module 540 is used to input page layout prompts into a pre-trained low-code evaluation model to obtain the layout evaluation results of the page layout prompts.

[0098] The page generation module 550 is used to determine the application page layout based on the layout evaluation results indicating that the page layout prompts conform to the application development intent.

[0099] In this exemplary low-code application development device based on a large model, the received application development request is input into a pre-trained low-code generation large model for development intent recognition, thus obtaining the application development intent corresponding to the request. The application development intent reflects the developer's development needs. After obtaining the intent, corresponding low-code development knowledge can be retrieved from a pre-built low-code development knowledge base. This allows for the analysis and refinement of development needs based on low-code development knowledge such as component knowledge and UI specification knowledge, and the low-code generation large model generates corresponding page layout prompts. Inputting these prompts into a pre-trained low-code evaluation large model allows it to evaluate the prompts, obtaining layout evaluation results. It can also output optimization suggestions to guide the low-code generation large model in iterative optimization until the layout evaluation results indicate that the prompts conform to the application development intent. Then, the corresponding domain-specific language (DSL) can be found based on the evaluated prompts for rendering, resulting in the application page layout corresponding to the prompts. This enables rapid application page development and improves application development efficiency.

[0100] It should be noted that the apparatus and method provided in the above embodiments belong to the same concept, and the specific ways in which each module and unit performs operations have been described in detail in the method embodiments, and will not be repeated here. In practical applications, the apparatus provided in the above embodiments can be assigned to different functional modules as needed, that is, the internal structure of the apparatus can be divided into different functional modules to complete all or part of the functions described above, and this is not a limitation.

[0101] The functions of each module can be found in the implementation examples of the low-code application development method based on a large model, and will not be repeated here.

[0102] Please see Figure 6 , Figure 6 This is a schematic diagram of the structure of an embodiment of the electronic device of this application. The electronic device 100 includes a memory 101 and a processor 102. The processor 102 is used to execute program instructions stored in the memory 101 to implement the steps in any of the above embodiments of the low-code application development method based on a large model. In a specific implementation scenario, the electronic device 100 may include, but is not limited to, a microcomputer or a server. In addition, the electronic device 100 may also include mobile devices such as laptops and tablets, which are not limited here.

[0103] Specifically, processor 102 controls itself and memory 101 to implement the steps in any of the above embodiments of the low-code application development method based on a large model. Processor 102 can also be referred to as a CPU (Central Processing Unit). Processor 102 may be an integrated circuit chip with signal processing capabilities. Processor 102 can also be a general-purpose processor, digital signal processor (DSP), application-specific integrated circuit (ASIC), field-programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. A general-purpose processor can be a microprocessor or any conventional processor. Furthermore, processor 102 can be implemented using integrated circuit chips.

[0104] In this exemplary electronic device, the received application development request is input into a pre-trained low-code generation model for development intent recognition, thus obtaining the application development intent corresponding to the request. The application development intent reflects the developer's development needs. After obtaining the intent, corresponding low-code development knowledge can be retrieved from a pre-built low-code development knowledge base. This allows for the analysis and refinement of development needs based on low-code development knowledge such as component knowledge and UI specification knowledge, and the low-code generation model generates corresponding page layout prompts. Inputting these prompts into a pre-trained low-code evaluation model allows the model to evaluate them, obtaining layout evaluation results. The model can also output optimization suggestions to guide iterative optimization until the layout evaluation results indicate that the prompts align with the application development intent. Then, the corresponding domain-specific language (DSL) can be found based on the evaluated prompts for rendering, resulting in the application page layout corresponding to the prompts. This enables rapid application page development and improves development efficiency.

[0105] Please see Figure 7 , Figure 7 This is a schematic diagram of a computer-readable storage medium according to an embodiment of the present application. The computer-readable storage medium 110 stores program instructions 111 that can be executed by a processor. The program instructions 111 are used to implement the steps in any of the above embodiments of the low-code application development method based on a large model.

[0106] In this exemplary storage medium, by running the program instructions stored in the storage medium, the received application development request is input into a pre-trained low-code generation model for development intent recognition, thus obtaining the application development intent corresponding to the application development request. The application development intent reflects the developer's development needs. After obtaining the application development intent, corresponding low-code development knowledge can be retrieved from a pre-built low-code development knowledge base. This allows for the analysis and refinement of development needs based on low-code development knowledge such as component knowledge and UI specification knowledge, and the low-code generation model generates corresponding page layout prompts. Inputting the page layout prompts into a pre-trained low-code evaluation model allows the model to evaluate the prompts, obtaining layout evaluation results. It can also output prompt optimization suggestions to guide the low-code generation model in iterative optimization of the page layout prompts until the layout evaluation results indicate that the page layout prompts conform to the application development intent. Then, based on the evaluated page layout prompts, the corresponding domain-specific language (DSL) can be found for rendering, resulting in the application page layout corresponding to the page layout prompts. This enables rapid application page development and improves application development efficiency.

[0107] In some embodiments, the functions or modules of the apparatus provided in this disclosure can be used to perform the methods described in the above method embodiments. The specific implementation can be referred to the description of the above method embodiments, and for the sake of brevity, it will not be repeated here.

[0108] The description of the various embodiments above tends to emphasize the differences between the various embodiments. The similarities or similarities between them can be referred to, and for the sake of brevity, they will not be repeated here.

[0109] In the several embodiments provided in this application, it should be understood that the disclosed methods and apparatus can be implemented in other ways. For example, the apparatus implementations described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection of devices or units may be electrical, mechanical, or other forms.

[0110] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) or processor to execute all or part of the steps of the methods in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

Claims

1. A low-code application development method based on a large model, characterized in that, The method includes: The received application development request is input into a pre-trained low-code generation model to obtain the application development intent corresponding to the application development request. Based on the application development intent, retrieve the corresponding low-code development knowledge from the pre-built low-code development knowledge base; Generate page layout prompts based on the low-code development knowledge and the application development intent; The page layout prompts are input into a pre-trained low-code evaluation model to obtain the layout evaluation results of the page layout prompts. In response to the layout evaluation result indicating that the page layout prompts conform to the application development intent, the application page layout is determined based on the page layout prompts.

2. The method according to claim 1, characterized in that, After inputting the page layout tooltip into the pre-trained low-code evaluation model and obtaining the layout evaluation result of the page layout tooltip, the process includes: In response to the layout evaluation result indicating that the page layout prompt does not conform to the application development intent, the low-code evaluation model is used to obtain the prompt optimization scheme for the page layout prompt. The page layout prompts and the prompt optimization scheme are input into the low-code generation large model to obtain the optimized page layout prompts. The application page layout is determined based on the optimized page layout prompts.

3. The method according to claim 1, characterized in that, The low-code development knowledge base includes a component knowledge base and a UI knowledge base. The step of retrieving corresponding low-code development knowledge from the pre-built low-code development knowledge base according to the application development intent includes: According to the application development intent, component knowledge is obtained from the component knowledge base, and interface knowledge is obtained from the interface knowledge base; The component knowledge and the interface knowledge are defined as the low-code development knowledge.

4. The method according to claim 1, characterized in that, The step of inputting the received application development request into a pre-trained low-code generation model to obtain the application development intent corresponding to the application development request includes: According to the application development request, the corresponding intent recognition knowledge is retrieved from the preset intent recognition knowledge base; Generate intent prompt words based on the intent recognition knowledge and the application development request; Identify the intent prompt words and generate the application development intent corresponding to the intent prompt words.

5. The method according to claim 1, characterized in that, After retrieving the corresponding low-code development knowledge from the pre-built low-code development knowledge base according to the application development intent, the method further includes: Based on the low-code development knowledge and the application development intent, generate corresponding component attribute prompts and component interaction prompts; Component attribute configuration is generated based on the component attribute prompts and the application page layout, and component interaction configuration is generated based on the component interaction prompts and the application page layout; The application page layout, component attribute configuration, and component interaction configuration are integrated to obtain page description information; The page description information is rendered to obtain the target application page.

6. The method according to claim 5, characterized in that, The application page layout includes a component tree. The integration of the application page layout, component attribute configurations, and component interaction configurations yields page description information, including: Traverse the page components to be set in the component tree to obtain the currently traversed component; Query the component description information corresponding to the currently traversed component in the preset component library; Create a new component instance based on the component description information; The component description information of the component instance is set according to the component attribute configuration and the component interaction configuration until all page components to be set in the component tree are set, and the page description information is obtained.

7. The method according to claim 5, characterized in that, After integrating the application page layout, the component attribute configuration, and the component interaction configuration to obtain page description information, the method further includes: The page description information is input into the low-code evaluation model to obtain the page evaluation result; In response to the page evaluation result indicating that the page description information conforms to the application development intent, the page description information is stored in a pre-built page template library; The page description information is input into the renderer for page rendering to obtain the target application page.

8. The method according to claim 1, characterized in that, After obtaining the application development intent corresponding to the received application development request by inputting it into a pre-trained low-code generation model, the method further includes: In response to the application development intent being a page template generation strategy, the corresponding page template is searched in a pre-built page template library according to the application development intent; The page description information of the page template is input into the renderer for page rendering to obtain the target application page; In response to the application development intent, a page description generation strategy is implemented, and corresponding low-code development knowledge is retrieved from the low-code development knowledge base based on the application development intent.

9. An electronic device, characterized in that, The method includes a memory and a processor, the processor being configured to execute program instructions stored in the memory to implement the method according to any one of claims 1 to 8.

10. A computer-readable storage medium having program instructions stored thereon, characterized in that, When the program instructions are executed by the processor, they implement the method described in any one of claims 1 to 8.

Images