Low code development system

Abstract

The invention provides a low-code development system, which comprises an agent module, an expandable low-code platform, a tool platform and a low-code working module, and is characterized in that the agent module is used for processing initial demand information input by a user based on a large language model and generating an execution command according to target demand information; the expandable low-code platform is used for analyzing the execution command to obtain a self-defined code and packaging the self-defined code to generate a reusable visual component; the tool platform is used for analyzing the execution command to obtain a target tool calling instruction and calling a target tool according to the target tool calling instruction; the agent module is further used for generating a target code according to the reusable visual component, the target tool and the execution command; and the low-code working module comprises a working platform, and the working platform is used for displaying the target code. Therefore, automatic generation, testing and delivery from natural language requirements to reliable application codes can be realized, and the development efficiency is greatly improved.

Description

Technical Field

[0001] This application relates to the field of program development technology, and in particular to a low-code development system. Background Technology

[0002] Low-code platforms, through visual interfaces and pre-built components, improve software development efficiency through abstraction and encapsulation, and are widely used in data visualization and IoT fields to meet the needs of enterprise digitalization and agile development. However, existing platforms lack the ability to express complex logic, and when large language models are introduced to assist in code generation, the complex component relationships and excessively long required contexts can easily exceed the model context window limit, thus restricting the quality of the generated code. In addition, the platform lacks an efficient integration and collaboration mechanism for custom code and visual components, making it difficult to guarantee the reliability of the output, and it lacks built-in verification and debugging capabilities to identify and correct errors. Summary of the Invention

[0003] This application aims to at least partially address the technical problems in the aforementioned technologies.

[0004] Therefore, the purpose of this application is to propose a low-code development system that can automate the generation, testing, and delivery of reliable application code from natural language requirements, thereby significantly improving development efficiency.

[0005] To achieve the above objectives, this application proposes a low-code development system, comprising: an agent module for generating target requirement information based on a large language model and initial requirement information input by the user, and generating execution commands based on the target requirement information; an extensible low-code platform connected to the agent module for parsing the execution commands to obtain custom code, and encapsulating the custom code to generate reusable visual components; a tool platform connected to the agent module for parsing the execution commands to obtain target tool invocation instructions, and invoking the target tool based on the target tool invocation instructions; the agent module is also used to generate target code based on the reusable visual components, the target tool, and the execution commands; and a low-code working module connected to the agent module, wherein the low-code working module includes a working platform for displaying the target code.

[0006] The low-code development system according to embodiments of this application generates target requirement information based on a large language model and initial user input requirements through an intelligent agent module. It then generates execution commands based on the target requirement information. An extensible low-code platform parses the execution commands to obtain custom code, which is then encapsulated to generate reusable visual components. A tool platform parses the execution commands to obtain target tool invocation instructions and invokes the target tool based on these instructions. The intelligent agent module then generates target code based on the reusable visual components, the target tool, and the execution commands. Finally, the target code is displayed through a working platform within the low-code working module. This enables automated generation, testing, and delivery of reliable application code from natural language requirements, significantly improving development efficiency.

[0007] In addition, the low-code development system according to the above embodiments of this application may also have the following additional technical features: According to one embodiment of this application, the intelligent agent module is specifically used to receive initial requirement information input by the user, preprocess the initial requirement information to generate requirement description information; call a large language model to process the requirement description information to generate target requirement information; and call a task decomposition engine to decompose and analyze the target requirement information to generate execution commands.

[0008] According to one embodiment of this application, an extensible low-code platform includes: a component module for obtaining a target component from a component library based on custom code, wherein the component library includes basic UI components and business logic components; a metaprogramming module for encapsulating the target component to obtain a target meta-template; and a meta-module engine for rendering and logically binding the target meta-template to generate a reusable visual component.

[0009] According to one embodiment of this application, the component module is further configured to: generate the target component based on custom code if the component library does not have the target component.

[0010] According to one embodiment of this application, the extensible low-code platform further includes: a component wrapper for template-encapsulating and storing reusable visual components.

[0011] According to one embodiment of this application, the tool platform includes a local tool container, a cloud service adapter, and a tool registry.

[0012] According to one embodiment of this application, the tool platform is also used to test the target tool.

[0013] According to one embodiment of this application, the low-code working module further includes: a logging platform for collecting log data generated during the operation of the low-code development system and storing the log data.

[0014] According to one embodiment of this application, the low-code development system further includes: a large language model module, which is connected to an intelligent agent module. The large language model module includes a model repository and a parameter control console. The model repository is used to deploy the large language model, and the deployment method includes local deployment and cloud deployment. The parameter control console is used to receive input information from the administrator to adjust the parameters of the large language model.

[0015] According to one embodiment of this application, the extended low-code platform is further configured to: if a reusable visual component is confirmed to exist in the template component database based on custom code, then directly obtain it.

[0016] Additional aspects and advantages of this application will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of this application. Attached Figure Description

[0017] The above and / or additional aspects and advantages of this application will become apparent and readily understood from the following description of the embodiments taken in conjunction with the accompanying drawings, wherein: Figure 1 This is a block diagram of a low-code development system according to an embodiment of this application; Figure 2 This is a flowchart illustrating the task planning and command generation of an intelligent agent module according to an embodiment of this application; Figure 3 A block diagram of an extensible low-code platform according to an embodiment of this application; Figure 4 A flowchart illustrating the generation of a reusable visual component for an extensible low-code platform according to one embodiment of this application; Figure 5 This is a block diagram of a tool platform according to an embodiment of this application; Figure 6 This is a schematic diagram illustrating the process of a tool platform invoking a tool according to an embodiment of this application; Figure 7 A block diagram of a low-code working module according to an embodiment of this application; and Figure 8 This is a block diagram of a low-code development system according to an embodiment of this application. Detailed Implementation

[0018] The embodiments of this application are described in detail below. Examples of these embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and intended to explain this application, and should not be construed as limiting this application.

[0019] The low-code development system of this application embodiment is described below with reference to the accompanying drawings.

[0020] Figure 1 This is a block diagram of a low-code development system according to an embodiment of this application.

[0021] like Figure 1 As shown, the low-code development system 100 of this application embodiment may include: an agent module 110, an extensible low-code platform 120, a tool platform 130, and a low-code working module 140, wherein the agent module 110 is connected to the extensible low-code platform 120, the tool platform 130, and the low-code working module 140, and the low-code working module 140 includes a working platform 141.

[0022] Among them, the intelligent agent module 110 is used to generate target requirement information based on the large language model and the initial requirement information input by the user, and to generate execution commands based on the target requirement information.

[0023] Specifically, in this embodiment, the core architecture of the agent module 110 may include a task decomposition engine and a prompt word factory. The task decomposition engine parses the structured task plan after user confirmation. After the user confirms the structured task plan generated by the agent, it parses and transforms the plan into execution commands that can be directly recognized and executed by downstream platforms. Downstream platforms include an extensible low-code platform 120 and a tool platform 130. The prompt word factory stores system instructions set by the administrator during system deployment. These instructions shape the behavior patterns of the large language model. When the agent module 110 makes a request to the large language model module, the system instructions are always sent as the primary context to shape and constrain the behavior of the large language model, ensuring that the model always reasones within the preset roles, rules, and capabilities. The content typically includes role definitions and operating specifications.

[0024] In one embodiment of this application, the intelligent agent module 110 can be specifically used to receive initial requirement information input by the user, preprocess the initial requirement information to generate requirement description information; call a large language model to process the requirement description information to generate target requirement information; and call a task decomposition engine to decompose and analyze the target requirement information to generate execution commands.

[0025] In the embodiments of this application, such as Figure 2As shown, the agent module first receives the initial natural language requirement information input by the user through the interactive interface. It then calls the prompt word factory to obtain pre-set system instructions, combines these instructions with the user's requirements to generate requirement description information, and submits it to the large language model. Next, the large language model, under the constraints and guidance of this context, performs deep semantic understanding and logical reasoning, outputting a structured task plan, i.e., the target requirement information, and returns it to the user interface for confirmation. Once the user confirms the task plan, the agent module calls the task decomposition engine, which transforms the task plan into a sequence of execution commands that can be directly executed by downstream platforms. If the user does not confirm or suggests modifications, the agent module, based on the user's feedback, will again call the large language model to integrate and understand the requirements and feedback information, iteratively optimize the structured task plan, and resubmit it for user confirmation until final confirmation is obtained. Finally, the task decomposition engine is called to decompose and analyze the target requirement information to generate execution commands. The execution command sequence contains standardized instruction units, whose structure clearly indicates the target platform, operation type, and key parameters.

[0026] The scalable low-code platform 120 is connected to the intelligent agent module 110 and is used to parse the executed commands to obtain custom code and encapsulate the custom code to generate reusable visual components.

[0027] In one embodiment of this application, such as Figure 3 As shown, the extensible low-code platform 120 includes: a component module 210, used to obtain target components from a component library based on custom code, wherein the component library includes basic UI components and business logic components; a metaprogramming module, used to encapsulate the target components to obtain a target meta template; and a meta module engine, used to render and logically bind the target meta template to generate reusable visual components.

[0028] Specifically, component module 210 is used to parse and execute commands to obtain the custom code contained therein, and thereby obtain or dynamically generate target components from the component library. The component library provides basic UI components and business logic components.

[0029] Metaprogramming module 220 is the core of the platform's capability encapsulation and abstraction. It is used to standardize and encapsulate the target components provided by component module 121 to obtain machine-readable target meta-templates. A meta-template is a structured description file whose structure includes metadata, fields, and events. Metadata describes non-business management attributes such as the component's name, owner, version, and access permissions. Fields describe the characteristics of the business data held and managed by the component, such as the field's name, data type, display method on the user interface, and its relationship with other components. Events describe the internal or external stimuli that the component can respond to, and the specific actions or function references that need to be executed after triggering them.

[0030] The meta-module engine 230 is a renderer and logic binder for meta templates. It is used to parse the target meta templates generated by the meta-programming module 122 and render them into reusable visual components that are visible at design time and can be dragged and dropped. In this process, it binds the events defined in the meta templates to the corresponding business logic code.

[0031] In one embodiment of this application, the component module is further configured to generate the target component based on custom code if the component library does not have the target component.

[0032] In one embodiment of this application, the extendable low-code platform is also used to directly obtain a reusable visual component if it is confirmed from the template component database based on custom code.

[0033] Specifically, such as Figure 4 As shown, the extensible low-code platform receives execution commands from the agent module. The execution command first enters the component module, which parses the custom code carried in the command and searches the platform's component library accordingly. If a matching component exists in the library, the component module directly acquires that component as the target component. If no existing component exists, the component module executes its core dynamic generation function, creating a new, matching target component based on the logic of the custom code. The metaprogramming module standardizes and encapsulates the target component according to predefined metatemplate specifications, outputting a complete, structured target metatemplate. The target metatemplate is then fed into the metamodule engine. The engine parses and renders it into a visual component, binds it with business logic, and ultimately generates a ready-to-use, reusable visual component.

[0034] In one embodiment of this application, the extensible low-code platform 120 may also include a component wrapper. The component wrapper is used to template and store reusable visual components.

[0035] Specifically, the reusable visual components output by the meta-module engine 230 are template-encapsulated by the component encapsulator to generate a component package in the platform standard format, and the component package is stored in the component library of the extensible low-code platform.

[0036] The tool platform 130 is connected to the intelligent agent module and is used to parse the execution command to obtain the target tool invocation instruction, and to invoke the target tool according to the target tool invocation instruction.

[0037] In one embodiment of this application, the tool platform 130 includes a local tool container, a cloud service adapter, and a tool registry.

[0038] Specifically, such as Figure 5 As shown, the core architecture of the tool platform 130 includes a local tool container 510, a cloud service adapter 520, and a tool registry center 530, which are used to receive and execute execution commands related to tool invocation from the agent module 110, provide a secure and manageable tool invocation layer, and provide external capability support for the automated testing of the agent module and the entire system.

[0039] Local tool containers, typically based on containerization technologies such as Docker, are used to encapsulate various tools that need to run in an isolated environment, such as Python script execution environments, file processors, database query tools, testing tools, and data simulation interfaces. They provide a secure and isolated execution environment for tools, avoiding pollution and dependency conflicts to the main system environment.

[0040] The Cloud Service Adapter 520 is used to integrate various third-party cloud services and APIs, such as SMS sending services, payment interfaces, map services, and identity authentication services. This adapter encapsulates the diverse API interfaces of different cloud service providers into a unified calling format within the system, simplifying the complexity of intelligent agents calling external services.

[0041] Tool Registry 530 is a catalog system and unified gateway for tool assets. It registers and describes all available tools in a standard format, including the tool's unique name, functional description, input parameter structure, and output result type.

[0042] In one embodiment of this application, the tool platform is also used to test the target tool.

[0043] Specifically, the isolated execution environment provided by tool platform 130 is not only used for regular tool execution, but also provides a secure sandbox for automated testing in the code workspace of low-code working module 140. The sandbox is used to execute test cases containing simulated interfaces and test data, ensuring that code and tool verification does not affect formal production data and system stability.

[0044] Specifically, such as Figure 6 As shown, in one embodiment of this application, the tool platform receives an execution command from the agent module requesting the invocation of a specific tool. The command is first sent to the tool registry for parsing and routing. Based on the tool name or function description specified in the command, the tool registry searches its tool directory and confirms the tool's detailed information and access endpoint. When the target tool is a local tool, the tool registry routes the request to the local tool container, which loads and executes the tool in a separate Docker container instance and returns the execution result. When the target tool is a cloud service, the tool registry routes the request to the cloud service adapter. The cloud service adapter converts its internally unified call format into a specific API request required by the target cloud service provider, processes the response, and ultimately returns the unified result. All tool call requests, responses, and performance metrics are encapsulated into standardized logs and sent to the low-code working module's log platform for centralized storage and analysis.

[0045] The low-code working module 140 is connected to the intelligent agent module. The low-code working module includes a working platform 141, which is used to display the target code.

[0046] In one embodiment of this application, the low-code working module further includes: a log platform 710, used to collect log data generated by the low-code development system during operation and to store the log data.

[0047] Specifically, low-code working module 140, such as Figure 7 As shown, its core architecture includes a working platform 141 and a log platform 710, which provide users with an integrated development interface and serve as the core coordination environment for code integration, test scheduling and process monitoring.

[0048] The working platform 141 is the main interface for interaction between the system and the user. It receives initial requirement information input by the user, displays the structured task plan generated by the intelligent agent for confirmation, and finally displays the target code generated by the system. The core sub-module of the working platform 141 is the code workspace, which is a virtual creation space based on an integrated development environment. In this virtual creation space, the intelligent agent module 110 writes code and integrates various components, and acts as a client to send commands to the tool platform 130, calling its isolated sandbox environment to execute automated testing processes.

[0049] Log platform 710 serves as the system's data awareness and diagnostic center, comprehensively and continuously collecting all log data generated by the low-code development system 100 during operation, and storing and visualizing the log data. The data it collects includes, but is not limited to, user's raw input, the reasoning process and intermediate results of the intelligent agent module, call requests and responses to various platforms, code change history in the code workspace, and detailed automated test reports returned by tool platform 130.

[0050] Specifically, users input their natural language requirements through the interactive interface provided by the work platform. The intelligent agent module returns a generated structured task plan, which is displayed by the work platform and awaits user confirmation. Driven by the intelligent agent module, the generated target code and the code of each component are integrated in the workspace. Subsequently, the low-code tool module calls the sandbox environment of the tool platform through instructions to run tests and receives the returned test reports. From the moment the user inputs their requirements to the generation and display of the target code, the log platform continuously collects and stores logs generated at each stage. All this data is categorized and stored in the log database for easy querying.

[0051] In some embodiments of this application, the low-code development system 100, such as Figure 8 As shown, it also includes a large language model module 150, which is connected to the agent module 110 and is used to provide the agent module with core intelligent computing capabilities. The core architecture of the large language model module 150 includes a model repository 910 and a parameter control console 920.

[0052] Specifically, Model Repository 910 is used to deploy and manage one or more large language models, providing model inference services for the system. Deployment methods include local deployment and cloud deployment. Local deployment refers to deploying the model on the user's own server cluster to ensure data privacy and service stability; cloud deployment refers to calling large language models provided by third-party cloud service providers through API interfaces to obtain cutting-edge model capabilities and reduce local operation and maintenance costs.

[0053] The Parameter Control Console 920 is a platform for system administrators to fine-tune and optimize model behavior. It receives input from administrators to visually adjust and configure core operating parameters of large language models. These parameters include, but are not limited to: Temperature (to control the randomness and creativity of model output); Top-p (to control the probability distribution range of candidate words during sampling); and Maximum Output Length (to limit the maximum number of tokens the model can generate in a single inference, preventing excessively long or unterminated responses and ensuring the efficiency and controllability of system responses). By adjusting these parameters, administrators can finely control the quality, style, and stability of the content generated by the agent, making it more suitable for specific development scenarios.

[0054] Specifically, based on project requirements, the administrator pre-configures the single-target large language model and its global runtime parameters for use in the system within the model repository. When the agent module performs inference tasks such as natural language understanding, task planning, or code generation, it sends a request to the large language model module. Upon receiving the request, the model repository routes it to the enabled target large language model according to the administrator's preset configuration. This model runs under preset parameters, performing inference calculations. The inference results generated by the model are received by the model repository and returned to the agent module. Throughout this process, all key data from the agent's request to the model's return of results, including request content, model response, computation latency, and other performance metrics, are synchronously recorded in the log platform, providing data support for system auditing and performance optimization.

[0055] As a specific embodiment of this application, the workflow of the low-code development system may include: A user inputs initial requirements in natural language form through the interactive interface provided by the low-code working module's platform. The agent module receives this requirements and retrieves pre-set system instructions from its internal prompt word factory. These system instructions include role definitions, platform capability descriptions, and operating specifications. The agent module combines the system instructions with the user's requirements into a command and initiates the first inference request to the large language model module. The large language model module's model repository, based on system configuration, calls a specified single-target model. This model performs inference under preset parameters, parsing the command sent by the agent module into a structured task plan. The large oracle model module returns this task plan to the agent module, which then sends it to the working platform and displays it visually to the user, awaiting confirmation.

[0056] The user reviews the task plan. If the review fails, or if the user confirms the task plan, the intelligent agent module calls its built-in task decomposition engine. Using the confirmed task plan and platform capability specifications as context, it requests the large language model module to decompose the plan into a sequence of execution commands. If the user does not confirm or suggests modifications, the intelligent agent module will, based on the user's feedback, call the large language model again to integrate and understand the requirements and feedback information, iteratively optimize the structured task plan, and resubmit it for user confirmation until the user's final confirmation is obtained.

[0057] The agent module receives the sequence of execution commands returned by the large language model and distributes the execution commands to the corresponding downstream platforms.

[0058] Commands related to component creation are sent to the extensible low-code platform. The platform's component module, based on the custom code in the commands, searches the component library. If a matching component exists, the component module directly retrieves it as the target component. If no matching component exists, the component module executes its core dynamic generation function. Based on the custom code logic, the agent module calls a large language model to generate high-quality, directly usable visual component code. This code is sent to the low-code working module's code workspace, where the agent module drives the sandbox environment provided by the platform for automated testing. If the test passes, the visual component code is sent back to the component module. If the test fails, the result serves as feedback, triggering the agent module to readjust and generate new component source code, iterating this process until the test passes. The component module then encapsulates the tested visual component code using a meta-template, creating a new, compliant target component. The metaprogramming module standardizes and encapsulates the target component according to predefined meta-template specifications, outputting a complete, structured target meta-template. The target meta-template is then fed into the meta-module engine. The meta template engine parses and renders it into a visual component, and finally the meta module engine renders the meta template and binds the logic to generate a reusable visual component.

[0059] Commands related to external operations or testing are sent to the tool platform. The platform's tool registry parses and routes these commands. Based on the tool name or function description specified in the command, the tool registry searches its tool directory to confirm the tool's details and access endpoints. When the target tool is a local tool, the tool registry routes the request to the local tool container. The local tool container loads and executes the tool in a separate Docker container instance and returns the execution result. When the target tool is a cloud service, the tool registry routes the request to the cloud service adapter. The cloud service adapter converts its internally standardized call format into the specific API request required by the target cloud service provider, processes the response, and directs the execution of the specific tool operation to either the local tool container or the cloud service adapter, returning the result.

[0060] The agent module continuously receives return results from various platforms and integrates all generated visual components with tool execution results in the code workspace of the low-code working module, assembling them into complete target code. After integration, the agent module automatically instructs the code workspace to call the secure sandbox environment provided by the tool platform to perform comprehensive automated testing on the integrated target code, including unit tests and integration tests. The test process and results are logged in real time. If a test fails, the agent module automatically retrieves error information from the logs and initiates a new round of inference, code adjustment, and testing, iterating this process until all tests pass successfully. After all automated tests pass, the final generated target code is displayed to the user again on the working platform for final review and confirmation. After user confirmation, the system application is officially deployed to the runtime environment.

[0061] During this process, all newly created, highly versatile, and reusable visual components are standardized and template-encapsulated by the component encapsulator built into the extensible low-code platform, and are automatically stored in the platform's public component library, enabling the continuous evolution of platform capabilities and the accumulation of knowledge.

[0062] During this process, the log platform continuously monitors and records the runtime events and results of all modules, including but not limited to component generation status, tool call results, and test reports. The agent module, as the system's control core, automatically monitors the log platform's data flow. Without manual intervention, the agent module automatically triggers subsequent operations and records new decision logs, forming an automated closed-loop control flow with logs as its perception and the agent as its brain.

[0063] In summary, the low-code development system of this application's embodiments generates target requirement information based on a large language model and initial user input requirements through an intelligent agent module. It then generates execution commands based on the target requirement information, parses these commands using an extensible low-code platform to obtain custom code, encapsulates the custom code to generate reusable visual components, and uses a tool platform to parse the execution commands to obtain target tool invocation instructions. Based on these instructions, the system invokes the target tool, and then the intelligent agent module generates target code using the reusable visual components, the target tool, and the execution commands. Finally, the target code is displayed through a working platform within the low-code working module. This enables automated generation, testing, and delivery of reliable application code from natural language requirements, significantly improving development efficiency.

[0064] In the description of this specification, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature. In the description of this application, "multiple" means at least two, such as two, three, etc., unless otherwise explicitly specified.

[0065] In the description of this specification, the references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of this application. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of different embodiments or examples.

[0066] Although embodiments of this application have been shown and described above, it is understood that the above embodiments are exemplary and should not be construed as limiting this application. Those skilled in the art can make changes, modifications, substitutions and variations to the above embodiments within the scope of this application.

Claims

1. A low-code development system, characterized in that, include: The intelligent agent module is used to generate target requirement information based on the large language model and the initial requirement information input by the user, and to generate execution commands based on the target requirement information; An extensible low-code platform is connected to the intelligent agent module and is used to parse the execution command to obtain custom code, and encapsulate the custom code to generate reusable visual components. A tool platform, connected to the intelligent agent module, is used to parse the execution command to obtain the target tool invocation instruction, and to invoke the target tool according to the target tool invocation instruction; The intelligent agent module is further configured to generate target code based on the reusable visualization component, the target tool, and the execution command; A low-code working module is connected to the intelligent agent module, wherein the low-code working module includes a working platform for displaying the target code.

2. The low-code development system according to claim 1, characterized in that, The intelligent agent module is specifically used for: Receive the initial requirement information input by the user, and preprocess the initial requirement information to generate requirement description information; The large language model is invoked to process the requirement description information to generate the target requirement information; The task decomposition engine is invoked to break down and analyze the target requirement information in order to generate the execution command.

3. The low-code development system according to claim 1, characterized in that, The extensible low-code platform includes: The component module is used to obtain the target component from the component library according to the custom code, wherein the component library includes basic UI components and business logic components; Metaprogramming module, used to encapsulate the target component to obtain the target meta template; The meta-module engine is used to render and logically bind the target meta-template to generate the reusable visual component.

4. The low-code development system according to claim 3, characterized in that, The component module is also used for: If the target component is not found in the component library, the target component is generated based on the custom code.

5. The low-code development system according to claim 3, characterized in that, The extensible low-code platform also includes: A component wrapper is used to encapsulate the reusable visual component into a template and store it.

6. The low-code development system according to claim 1, characterized in that, The tool platform includes a local tool container, a cloud service adapter, and a tool registry.

7. The low-code development system according to claim 1, characterized in that, The tool platform is also used to test the target tool.

8. The low-code development system according to claim 1, characterized in that, The low-code working module also includes: A log platform is used to collect and store log data generated during the operation of the low-code development system.

9. The low-code development system according to claim 1, characterized in that, Also includes: A large language model module, connected to the intelligent agent module, includes a model repository and a parameter control console. The model repository is used to deploy the large language model, wherein the deployment methods include local deployment and cloud deployment; The parameter control console is used to receive input information from the administrator to adjust the parameters of the large language model.

10. The low-code development system according to claim 3, characterized in that, The scalable low-code platform is also used for: If the reusable visualization component is confirmed to exist in the template component database based on the custom code, then it can be retrieved directly.

Images