A low-code development platform implementation method, device and medium

Abstract

The application discloses a low-code development platform implementation method, equipment and medium, and the method comprises the following steps: receiving requirements in the form of natural language, sketches and other non-programming languages, using a large language model to analyze and generate a structured design model; in the process of visual development, an intelligent recommendation engine is used to actively recommend components and arrangement schemes, and an AI auxiliary module is used to perform real-time verification and optimization on graphical logic; finally, a pre-trained code generation model is called to output target language source code conforming to enterprise-level specifications. The application realizes intelligent assistance for the whole process from requirement description to code generation, significantly reduces the development threshold, and improves the development efficiency and code quality.

Description

Technical Field

[0001] This application relates to the intersection of software development tools and artificial intelligence technology, and in particular to a method, device and medium for implementing a low-code development platform. Background Technology

[0002] With the accelerated pace of digital transformation, enterprises' demand for customized software has exploded, becoming a prominent bottleneck in their digital upgrades.

[0003] Low-code development platforms, by providing graphical interfaces and model-driven logic, enable users to quickly build applications by dragging and dropping components with minimal coding, effectively lowering the development threshold. However, existing low-code platforms largely rely on pre-built templates and component libraries, lacking the ability to proactively understand user intent, requiring manual component selection and logic configuration. Furthermore, they struggle to handle complex business rules and system integration needs, often necessitating extensive additional coding, thus deviating from the core purpose of low-code. The generated code is rigid, lacks maintainability and performance, and fails to meet the high standards of enterprise applications. Moreover, the generated application UIs are highly homogenized, making personalized adaptation impossible.

[0004] This makes it difficult for existing platforms to fully unleash the efficiency of software development. Summary of the Invention

[0005] To address the technical problems existing in the background art, embodiments of this application provide a low-code development platform implementation method, device, and medium. The method includes: receiving application development requirements in non-programming language form; the non-programming language form includes at least natural language text, sketches, or flowcharts; parsing the application development requirements through a preset large language model, and obtaining a structured design model based on the parsing results and preset framework rules; determining platform components and platform orchestration through a preset recommendation engine based on user drag-and-drop behavior and the structured design model; verifying the graphical logic orchestration through a preset artificial intelligence-assisted module when performing graphical logic orchestration based on the platform components and platform orchestration; and generating language source code by calling a pre-trained code generation model based on the structured design model after graphical logic orchestration when the verification is successful.

[0006] In one example, after generating language source code by calling a pre-trained code generation model based on a structured design model arranged with graphical logic, the method further includes: performing quality scanning, performance optimization, and security testing on the language source code to obtain optimized language source code; integrating the optimized language source code into the CI / CD pipeline for testing and deployment; and after deployment, collecting the running data of the optimized language source code through integrated operation and maintenance monitoring tools and feeding it back to the recommendation engine and code generation model.

[0007] In one example, the application development requirements are analyzed using a pre-defined large language model. Based on the analysis results and pre-defined framework rules, a structured design model is obtained. Specifically, this includes: if the application development requirements are natural language text, a pre-trained language model based on the Transformer architecture is invoked to perform semantic analysis, entity recognition, and intent recognition on the natural language text to extract data entities, user roles, and business process elements; based on the data entities, user roles, and business process elements, and the pre-defined framework rules, a structured design model is generated; if the application development requirements are sketches or flowcharts, an integrated computer vision model is invoked to recognize the images to obtain user interface elements, layout relationships, and process nodes; the user interface elements, layout relationships, and process nodes are mapped to corresponding front-end component trees and business logic flowcharts to form a structured design model.

[0008] In one example, based on user drag-and-drop behavior and the structured design model, a preset recommendation engine is used to determine platform components and platform orchestration. Specifically, this includes: using the recommendation engine to listen to user drag-and-drop behavior and the design context of the structured design model to determine the operation focus; using the recommendation engine to vectorize the UI components, backend API interfaces, and business logic blocks of the platform component library; and using the similarity between the operation focus and each vector representation to search the platform component library to determine the platform components and platform orchestration.

[0009] In one example, when performing graphical logic orchestration based on the platform components and platform orchestration, a preset artificial intelligence-assisted module verifies the graphical logic orchestration. Specifically, this includes: during the graphical logic orchestration process, performing semantic checks on the connection relationships, data flow, and state transitions of orchestrated nodes according to preset business rules and logical integrity constraints to identify logical conflicts; predicting performance bottlenecks of the graphical logic orchestration during runtime through simulated execution and static analysis; and matching the orchestration structure of the graphical logic orchestration according to a preset library of common error patterns to identify potential errors.

[0010] In one example, when the verification passes, the pre-trained code generation model is called based on the structured design model arranged by the graphical logic to generate language source code. Specifically, this includes: inputting the verified structured design model into the pre-trained code generation model, generating language source code according to the enterprise-level development specifications corresponding to the language source code, and generating corresponding unit test code and API interface documentation based on the business logic and interface definitions in the structured design model.

[0011] In one example, the method also includes: collecting user feedback on anomalies after optimizing the deployment of the language source code; and adjusting the recommendation engine and code generation model based on the feedback.

[0012] In one example, receiving application development requirements in non-programming language form specifically includes: receiving natural language text, interface sketch image files, or business process diagrams input by users through an interactive interface; performing format recognition and preprocessing on the received input, converting natural language text into text sequences, and converting sketch and flowchart images into digital image data.

[0013] On the other hand, embodiments of this application provide a low-code development platform implementation device, including: 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, the instructions being executed by the at least one processor to enable the at least one processor to perform any of the above-mentioned low-code development platform implementation methods.

[0014] On the other hand, embodiments of this application provide a low-code development platform implementation method that implements a non-volatile computer storage medium storing computer-executable instructions capable of executing any of the above-mentioned methods.

[0015] The above-described technical solutions adopted in the embodiments of this application can achieve the following beneficial effects: By integrating large language models with multimodal input understanding, users can express their needs intuitively through natural language descriptions, sketches, or flowcharts. Pre-trained large language models and computer vision models automatically parse user intent and convert it into a structured design model, enabling business personnel without programming backgrounds to directly participate in application development, effectively breaking down communication barriers between technology and business. Through an intelligent recommendation engine and context-aware technology, development efficiency and accuracy are significantly improved. While users are visually orchestrating, the system analyzes the current operational context in real time and proactively recommends the most suitable UI components, logic modules, and API interfaces based on vectorized retrieval and collaborative filtering algorithms. This mechanism reduces the time spent on manual searching and configuration, compressing the time-consuming component selection and logic design process in traditional development to minutes, resulting in an overall development efficiency improvement of several times. Attached Figure Description

[0016] To more clearly illustrate the technical solution of this application, some embodiments of this application will be described in detail below with reference to the accompanying drawings, in which: Figure 1 A flowchart illustrating a low-code development platform implementation method provided in this application embodiment; Figure 2 A phased process diagram of a low-code development platform implementation method provided in this application embodiment; Figure 3 This is a schematic diagram of the structure of a low-code development platform implementation device provided in an embodiment of this application. Detailed Implementation

[0017] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below in conjunction with specific embodiments and corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

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

[0019] Figure 1 This is a flowchart illustrating a low-code development platform implementation method provided in this application embodiment. This method can be applied to different business domains. Certain input parameters or intermediate results in this process allow for manual intervention and adjustment to help improve accuracy.

[0020] The analysis method involved in the embodiments of this application can be implemented by a terminal device or a server, and this application does not impose any special limitations on it. For ease of understanding and description, the following embodiments are all described in detail using a server as an example.

[0021] Based on this Figure 1 The process may include the following steps: S101: Receive application development requirements in non-programming language form; the non-programming language form includes at least natural language text, sketches, or flowcharts.

[0022] In some embodiments of this application, users first input their application development requirements through a multimodal interactive interface provided by the platform. This interface supports text input boxes, a sketching panel, and a flowchart editing area. Users can directly input natural language descriptions such as "Create an employee leave approval application that includes submission, department approval, and HR filing functions"; or upload hand-drawn or professionally crafted interface sketches; or draw or import business process diagrams.

[0023] Upon receiving the input, the system automatically performs format recognition and preprocessing: for natural language text, it converts it into a character sequence and performs word segmentation and standardization; for image input, it converts it into an RGB or grayscale digital image matrix, performs size normalization and noise filtering, so that the subsequent parsing module can process it. This step aims to unify the user's diverse intentions into a standardized data form that the machine can process, laying the foundation for subsequent intelligent parsing.

[0024] S102: The application development requirements are analyzed using a preset large language model, and a structured design model is obtained based on the analysis results and preset framework rules.

[0025] In some embodiments of this application, based on the standardized input data obtained in the previous step, the system calls the corresponding AI model for deep analysis to understand the user's intent. If the input is natural language text, a pre-trained large language model based on the Transformer architecture is called to perform semantic parsing, named entity recognition, and intent recognition on the text. For example, from the description of "employee leave approval application," the model will identify and extract entities such as "employee," "leave form," "department manager," and "HR," as well as operational intents such as "submit," "approval," and "filing," and then summarize the corresponding data model, user role system, and basic approval process elements.

[0026] Subsequently, the system combines and instantiates these extracted elements with preset framework rules to automatically generate an initial structured design model, which defines the application's business data, user interface framework, and core business process skeleton.

[0027] If the input is a sketch or flowchart image, the system then invokes an integrated computer vision model to recognize the image, extracting UI elements, layout relationships, or process nodes and connections. The recognition results are mapped to a front-end component tree or business logic flowchart within the platform, thus directly forming a structured design model describing the interface and process. The core of this step is to transform unstructured user requirements into a structured representation that the machine can accurately understand and process.

[0028] S103: Based on the user's drag-and-drop behavior and the structured design model, determine the platform components and platform orchestration through a preset recommendation engine.

[0029] In some embodiments of this application, after generating the design model, the user enters a visual development environment to refine and build it. During this interaction, the intelligent recommendation engine continues to run in the background. It monitors all of the user's drag-and-drop operations and the complete state of the current design context in real time (including placed components, data model fields being edited, and partially defined logic flows).

[0030] The engine first determines the current operational focus based on this information. Next, it employs a vector-based retrieval mechanism: it vectorizes all UI components, backend API modules, and pre-defined business logic blocks in the platform's component library. These vectors encode the component's function, attributes, and usage context. By calculating the cosine similarity between the current operational focus and all vectors in the component library, the engine can quickly retrieve and recommend a list of candidate components or logic modules most relevant to the current context and most likely to be needed from a massive library of components, displaying them intuitively to the user. For example, when a user is designing a data list interface, the engine might proactively recommend a "pagination component," a "search box," and an "export Excel" API. The user can select from the recommendation list to quickly determine the specific platform component needed and its placement within the application, significantly reducing manual browsing and searching time and achieving context-aware intelligent assisted development.

[0031] S104: When performing graphical logic orchestration based on the platform components and platform orchestration, the graphical logic orchestration is verified by a preset artificial intelligence auxiliary module.

[0032] In some embodiments of this application, when a user orchestrates specific business logic on a graphical interface using recommended components and connecting nodes, a pre-defined AI-assisted module is activated and provides real-time verification services. This module performs multiple analyses in parallel: First, based on a built-in domain business rule base and logical integrity constraints, it performs real-time semantic checks on the connection relationships, data flow, and state transitions of the orchestrated nodes, immediately highlighting any logical conflicts or missing links.

[0033] Secondly, the module uses lightweight simulation execution or static code analysis techniques to perform pre-execution analysis on the currently orchestrated logical chain, predicting potential performance bottlenecks during real-world runtime and providing early warnings. Furthermore, the module maintains a library of common error patterns, matching the currently orchestrated graphical logical structure with patterns in the library to identify potential logical errors or bad practices. All these verification results are provided to the user in real-time with visual feedback, ensuring the correctness, robustness, and efficiency of the logical orchestration are guaranteed during the development phase.

[0034] S105: When the verification is successful, the pre-trained code generation model is called to generate the language source code based on the structured design model arranged by the graphical logic.

[0035] In some embodiments of this application, the code generation stage can be triggered after the user completes all graphical design and logic arrangement and passes the verification by the AI-assisted module.

[0036] The system takes the finalized, structured design model, which includes a complete data model, UI design, and business logic, as input and passes it to an integrated, pre-trained large-scale code generation model. This code generation model not only learns the syntax and patterns of massive amounts of open-source code, but also incorporates development specifications and best practices for specific enterprise-level technology stacks.

[0037] Based on the input design model, the model automatically generates functional source code that is clearly structured, highly modular, and includes meaningful comments, covering the front-end interface, back-end business logic, data access layer, and API interfaces. More importantly, the generation process is not limited to functional implementation; the system simultaneously generates corresponding unit test code cases and standard-compliant API interface documentation based on the business rules and interface contracts defined in the structured design model. Thus, the final output is a complete source code project that is immediately readable, maintainable, testable, and meets enterprise-level quality requirements, achieving a direct transformation from visual design to high-quality output.

[0038] It should be noted that, although the embodiments in this application are based on... Figure 1 Steps S101 to S105 will be described sequentially, but this does not mean that steps S101 and S105 must be performed in a strict order. The reason this embodiment follows this order is... Figure 1 The order in which steps S101 to S105 are described is provided to facilitate understanding of the technical solutions of the embodiments of this application by those skilled in the art. In other words, in the embodiments of this application, the order of steps S101 to S105 can be appropriately adjusted according to actual needs.

[0039] pass Figure 1 This approach, by integrating a large language model with multimodal input understanding, allows users to express their needs intuitively through natural language descriptions, sketches, or flowcharts. Through pre-trained large language and computer vision models, it automatically parses user intent and converts it into a structured design model, enabling business personnel without programming backgrounds to directly participate in application development, effectively breaking down communication barriers between technology and business. Through an intelligent recommendation engine and context-aware technology, it significantly improves development efficiency and accuracy. While users are visually orchestrating, it analyzes the current operational context in real time and proactively recommends the most suitable UI components, logic modules, and API interfaces based on vectorized retrieval and collaborative filtering algorithms. This mechanism reduces the time spent on manual searching and configuration, compressing the time-consuming component selection and logic design process in traditional development to minutes, improving overall development efficiency several times over.

[0040] Figure 2 This is a process diagram illustrating the stages of a low-code development platform implementation method provided in an embodiment of this application.

[0041] Figure 3 A schematic diagram of a low-code development platform implementation device provided in this application embodiment includes: At least one processor; and, A memory that is communicatively connected to at least one processor; wherein, A low-code development platform implementation method in which the memory stores instructions that can be executed by at least one processor, such that the instructions are executed by at least one processor to enable at least one processor to perform any of the above.

[0042] Some embodiments of this application provide a low-code development platform implementation of a non-volatile computer storage medium storing computer-executable instructions, which can execute any of the above-described low-code development platform implementation methods.

[0043] The various embodiments in this application are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the device and medium embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the description of the method embodiments.

[0044] The devices and media provided in this application are one-to-one with the methods. Therefore, the devices and media also have similar beneficial technical effects as their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media will not be repeated here.

[0045] Those skilled in the art will understand that embodiments of the present invention can be provided as methods, systems, or computer program products. Therefore, the present invention can take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention can take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

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

[0047] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0048] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0049] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0050] Memory may include non-persistent storage in computer-readable media, random access memory (RAM), and non-volatile memory such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0051] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0052] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such process, method, article, or apparatus. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes that element.

[0053] The above are merely embodiments of this application and are not intended to limit this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, or improvements made within the technical principles of this application should fall within the protection scope of this application.

Claims

1. A method for implementing a low-code development platform, characterized in that, The method includes: Receive application development requirements in non-programming language formats; the non-programming language formats include at least natural language text, sketches, or flowcharts. The application development requirements are analyzed using a pre-defined large language model, and a structured design model is obtained based on the analysis results and pre-defined framework rules. Based on user drag-and-drop behavior and the structured design model, platform components and platform orchestration are determined through a preset recommendation engine; When performing graphical logic orchestration based on the platform components and platform orchestration, the graphical logic orchestration is verified by a preset artificial intelligence-assisted module; When the verification is successful, the pre-trained code generation model is invoked based on the structured design model arranged by the graphical logic to generate the language source code.

2. The method according to claim 1, characterized in that, After generating language source code by calling a pre-trained code generation model based on the structured design model arranged according to graphical logic, the method further includes: The source code of the language is subjected to quality scanning, performance optimization, and security testing to obtain optimized language source code. The optimized language source code is integrated into the CI / CD pipeline for testing and deployment. After deployment, the running data of the optimized language source code is collected through integrated operation and maintenance monitoring tools and fed back to the recommendation engine and code generation model.

3. The method according to claim 1, characterized in that, The process involves parsing the application development requirements using a pre-defined large language model, and obtaining a structured design model based on the parsing results and pre-defined framework rules. Specifically, this includes: If the application development requirement is natural language text, a pre-trained language model based on the Transformer architecture is invoked to perform semantic parsing, entity recognition, and intent recognition on the natural language text in order to extract data entities, user roles, and business process elements. Based on the data entities, user roles, and business process elements, as well as the preset framework rules, a structured design model is generated. If the application development requirements are a sketch or flowchart, the integrated computer vision model is called to recognize the image to obtain user interface elements, layout relationships and process nodes; The user interface elements, layout relationships, and process nodes are mapped to corresponding front-end component trees and business logic flowcharts to form the structured design model.

4. The method according to claim 1, characterized in that, The step of determining platform components and platform orchestration based on user drag-and-drop behavior and the structured design model using a preset recommendation engine specifically includes: The recommendation engine listens to user drag-and-drop behavior and the design context of the structured design model to determine the focus of the operation; The recommendation engine uses vectorized representations of UI components, backend API interfaces, and business logic blocks from the platform component library. By calculating the similarity between the operation focus and each vector representation, the platform component library is retrieved to determine the platform components and platform orchestration.

5. The method according to claim 1, characterized in that, When performing graphical logic orchestration based on the platform components and platform orchestration, the graphical logic orchestration is verified through a preset artificial intelligence-assisted module, specifically including: During the graphical logic orchestration process, semantic checks are performed on the connection relationships, data flow, and state transitions of the orchestrated nodes based on preset business rules and logical integrity constraints to identify logical conflicts. By simulating execution and static analysis, the performance bottleneck of the graphical logic orchestration at runtime is predicted; Based on a preset library of common error patterns, the arrangement structure of the graphical logic orchestration is matched to identify potential errors.

6. The method according to claim 1, characterized in that, When the verification is successful, the pre-trained code generation model is invoked based on the structured design model arranged by the graphical logic to generate language source code, specifically including: The validated structured design model is input into the pre-trained code generation model, which generates language source code based on the enterprise-level development specifications corresponding to the language source code; and generates corresponding unit test code and API interface documentation based on the business logic and interface definitions in the structured design model.

7. The method according to claim 1, characterized in that, The method further includes: After the optimized language source code is deployed, collect anomaly information reported by users; The recommendation engine and code generation model were adjusted based on the feedback information.

8. The method according to claim 1, characterized in that, The receiving of application development requirements in non-programming language formats specifically includes: Receive natural language text, interface sketch image files, or business process diagrams from users through an interactive interface. The received input is formatted and preprocessed, converting natural language text into text sequences and sketches and flowcharts into digital image data.

9. A low-code development platform implementation device, characterized in that, include: At least one processor; as well as, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform a low-code development platform implementation method as described in any one of claims 1-8.

10. A low-code development platform implementation storage medium storing computer-executable instructions, characterized in that, The computer-executable instructions are capable of executing the low-code development platform implementation method described in any one of claims 1-8.

Images