Multi-agent-based low-code component development method and system and electronic equipment

Abstract

The invention provides a multi-agent-based low-code component development method and system and electronic equipment, and the method comprises the steps: obtaining a user demand, and converting the user demand into an initial business model through a first agent; obtaining a prefabricated component library of the low-code platform, and automatically generating a demand component by using a second agent according to the initial business model and the prefabricated component library; automatically adapting and integrating a cross-platform data source by using a preset cross-domain data integration mechanism, and performing intelligent scheduling on the automatically generated demand component through a third agent; and establishing an automatic service arrangement mechanism based on the micro-service architecture, automatically identifying each service dependency relationship, and dynamically adjusting the execution sequence and resource allocation of each demand component according to the service dependency relationship. Through modular component design, the low-code platform has high flexibility and expandability, efficient collaboration of the components in the complex industry is guaranteed, and resource allocation and use efficiency is optimized.

Description

Technical Field

[0001] The present invention relates to the field of low-code component development, and specifically to a low-code component development method and system based on multi-agent, and electronic equipment. Background Art

[0002] As enterprises' demand for flexibility and agile development continues to increase, low-code platforms have played a vital role in enabling rapid application development and responding to changing business needs. However, in actual applications, the limitations of low-code platforms are gradually becoming apparent. First, the need for highly customized applications is a major challenge developers face when using low-code platforms. While the platform provides a rich library of prefabricated components, the flexibility and scalability of these components are relatively limited. When developers need to perform complex business logic processing or implement specific functions, they often find that prefabricated components are difficult to meet their needs. Developers often need to use traditional programming languages to expand or modify existing components, which increases development complexity and weakens the advantages of low-code platforms in simplifying processes and lowering technical barriers.

[0003] Secondly, insufficient support for complex business scenarios is another bottleneck for low-code platforms. As enterprises undergo digital transformation, business scenarios are becoming increasingly complex, and the need to integrate multiple systems, processes, and data sources is becoming increasingly urgent. However, existing low-code platforms generally fail to provide sufficient flexibility and deep support for these complex scenarios. Developers often need to rely on external tools or manual programming to implement complex workflows and system interactions, which to some extent limits the breadth of low-code technology's application.

[0004] Therefore, the existing technology needs to be further developed. Summary of the Invention

[0005] The purpose of the present invention is to overcome the above-mentioned technical deficiencies and provide a low-code component development method and system based on multi-agent, as well as an electronic device, to solve the problems existing in the prior art.

[0006] To achieve the above technical objectives, according to a first aspect of the present invention, the present invention provides a multi-agent-based low-code component development method, comprising: S100: Obtain user needs and convert the user needs into an initial business model through a first agent; S200: Obtain a prefabricated component library of a low-code platform, and automatically generate required components using a second agent based on the initial business model and the prefabricated component library; S300: Utilize the preset cross-domain data integration mechanism to automatically adapt and integrate cross-platform data sources, and intelligently schedule the automatically generated demand components through a third agent; S400. Establish a service automation orchestration mechanism based on the microservice architecture, automatically identify the service dependencies, and dynamically adjust the execution order and resource allocation of each required component according to the service dependencies.

[0007] Specifically, the first agent is a user demand analysis agent, and the method of obtaining user demand and converting the user demand into an initial business model through the first agent includes: Receive business requirements input by users through visual interfaces or conversational modules; Natural language processing technology is used to understand the business needs and convert the business needs into an operational initial business model.

[0008] Specifically, the second agent is a component generation agent, and the method of automatically generating required components using the second agent according to the initial business model and the prefabricated component library includes: Leveraging AI-generated content technology and a model-driven approach, we can select and automatically generate required components from a prefabricated component library based on user needs. The required components include basic UI elements and logic modules.

[0009] Specifically, the method of automatically adapting and integrating cross-platform data sources by using a preset cross-domain data integration mechanism includes: Users use visual tools to configure preset cross-domain data integration rules, establish standardized interfaces between multiple heterogeneous systems, make data formats on different platforms compatible, and enable data sharing across platforms.

[0010] Specifically, the third agent is a service optimization agent, and the method of intelligently scheduling automatically generated demand components by the third agent includes: Obtain user-defined task processes, use service optimization agents to manage and schedule automatically generated demand components, automatically identify the dependencies and task priorities between tasks, and dynamically adjust the execution order of tasks, so that each demand component can work together according to the user-defined task process.

[0011] Specifically, the method of establishing a service automation orchestration mechanism based on a microservice architecture, automatically identifying service dependencies, and dynamically adjusting the execution order and resource allocation of each required component according to the service dependencies includes: Through the microservice architecture, data interconnection is established between different platforms, the dependencies between microservices are automatically identified and orchestrated, and the running order and resource allocation of each service are dynamically adjusted according to the priority and resource utilization of each task.

[0012] Specifically, the method further includes: Obtain the business logic and requirement components configured by the user, automatically generate an application based on the business logic and requirement components, optimize the program structure through the service automation orchestration mechanism based on the microservice architecture, and use automation tools to perform automated testing of the application.

[0013] Specifically, the method further includes: Set up the one-click deployment function in the low-code platform to publish the generated application to the production environment.

[0014] According to a second aspect of the present invention, a multi-agent-based low-code component development system is provided, comprising: User interaction module: obtains user needs and converts them into initial business models through the first agent; Component construction module: obtains the prefabricated component library of the low-code platform, and uses the second agent to automatically generate the required components according to the initial business model and the prefabricated component library; Task management module: Utilizes a preset cross-domain data integration mechanism to automatically adapt and integrate cross-platform data sources, and intelligently schedules automatically generated demand components through a third agent; Service Management Module: Establishes a service automation orchestration mechanism based on the microservice architecture, automatically identifies the dependencies between services, and dynamically adjusts the execution order and resource allocation of each required component based on the service dependencies.

[0015] According to a third aspect of the present invention, there is provided an electronic device comprising: a memory; and a processor, wherein the memory stores computer-readable instructions, and when the computer-readable instructions are executed by the processor, the above-mentioned multi-agent-based low-code component development method is implemented.

[0016] Beneficial effects: The present invention converts user needs into an initial business model by using a first agent, and automatically generates demand components based on the initial business model and a prefabricated component library using a second agent; automatically adapts and integrates cross-platform data sources using a preset cross-domain data integration mechanism, and intelligently schedules the automatically generated demand components through a third agent; establishes a service automation orchestration mechanism based on a microservice architecture, automatically identifies the dependencies of each service, and dynamically adjusts the execution order and resource allocation of each demand component based on the service dependencies. This solves the problem that the prefabricated component library of the existing low-code platform is difficult to meet the developer's customized needs for complex business scenarios and the cross-platform component integration involving multiple systems and data sources, and is difficult to effectively adapt to complex business logic and cross-system operations. The present invention uses modular component design to make the platform highly flexible and scalable, and can be quickly adjusted and optimized according to different business needs. In addition, multi-agent collaboration ensures the efficient and collaborative operation of each component in complex industrial applications, optimizes the allocation and utilization efficiency of resources, and greatly improves the overall performance of the system. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] Figure 1 It is a flowchart of a multi-agent-based low-code component development method provided in a specific embodiment of the present invention; Figure 2 This is a schematic diagram of the system composition of low-code component development based on multi-agents provided in a specific embodiment of the present invention; Figure 3 This is a diagram of a low-code component development framework based on multiple agents provided in a specific embodiment of the present invention; Figure 4 It is a flowchart of the steps of developing low-code components based on multi-agents provided in a specific embodiment of the present invention; Figure 5 It is a flowchart of user interaction and component construction provided in a specific embodiment of the present invention; Figure 6 It is a task and process management flowchart provided in a specific embodiment of the present invention; Figure 7 It is a flowchart of the underlying architecture and service management provided in a specific embodiment of the present invention; Figure 8 This is a login page generation interface diagram of a multi-agent-based low-code component development method provided in a specific embodiment of the present invention; Figure 9 This is a beautified interface diagram of the login page of the low-code component development method based on multi-agent provided in the specific implementation of the present invention. DETAILED DESCRIPTION

[0018] In order to enable those skilled in the art to better understand the technical solution of the present invention, the technical solution of the present invention is clearly and completely described below in conjunction with the drawings of the present invention. Based on the embodiments in this application, other similar embodiments obtained by ordinary technicians in this field without making creative work should fall within the scope of protection of this application. In addition, the directional words mentioned in the following embodiments, such as "up", "down", "left", "right", etc., are only reference to the directions of the drawings. Therefore, the directional words used are used to illustrate rather than limit the invention.

[0019] The present invention will be further described below with reference to the accompanying drawings and preferred embodiments.

[0020] See also Figure 1 This embodiment provides a multi-agent-based low-code component development method, including: S100: Obtain user needs and convert the user needs into an initial business model through a first agent; Specifically, the first agent is a user demand analysis agent, and the method of obtaining user demand and converting the user demand into an initial business model through the first agent includes: Receive business requirements input by users through visual interfaces or conversational modules; Natural language processing technology is used to understand the business needs and convert the business needs into an operational initial business model.

[0021] It can be understood that in the low-code component development method of this embodiment, users input business requirements through a visual interface or conversational artificial intelligence (AI), and the low-code platform uses natural language processing (NLP) technology to analyze the user's natural language input and convert it into an operational initial business model, that is, converting the user's natural language into a high-dimensional vector representation that the machine can understand. Users can define the required functional modules, such as forms, buttons, data processing processes, etc., through simple interactive dialogues. This process does not require users to have programming experience, thereby lowering the development threshold.

[0022] Furthermore, when users input business requirements through a visual interface or conversational artificial intelligence (AI), the low-code platform uses natural language processing (NLP) technology to analyze the user's natural language input as follows: First, the platform uses the language model to calculate the probability of the input text. The formula is as follows: ; is the entire word sequence The probability of , represents the probability of occurrence of the entire sentence or text paragraph, Is the multiplication symbol, which means multiplying all conditional probabilities. Indicates the position index of the current word, indicating the first words, n represents the total number of words in the sentence, that is, the length of the entire sentence, Is the current word in front of The probability of each word appearing under the condition that the word is known, this conditional probability can be used to predict the probability of each word in the sentence; Next, the platform uses word embedding technology, such as Word2Vec, to convert the user's natural language into a high-dimensional vector representation that can be understood by the machine. Its training goal is to maximize the conditional probability of adjacent words: ; Is the loss function (Loss Function), which means that by optimizing the parameters To minimize the model error, Is the normalization factor, which represents the average loss of all words in the entire corpus, where is the total number of words in the training data, Represents each word in the entire training corpus The sum of the loss is based on the position of all words Calculated, is the sum of all words in the context window, the size of the context window is , both from the current word Left and right are the most viewed words, but exclude the current word itself (i.e. , Given the current word Then, the context word in the window The probability of occurrence, Taking the logarithm of the conditional probability makes it easier to find the gradient when calculating the loss.

[0023] To extract specific business elements from user needs, such as "form" and "button," the platform uses a sequence labeling model, such as the conditional random field. Its core formula is: ; Is a given input sequence Under the condition of The conditional probability of is a normalization factor that ensures that the total probability of all possible label sequences is 1, It is the core function used to calculate the unnormalized probability in the conditional random field model. For each time step in the entire sequence Perform the summation, Sum all the characteristic functions, is the total number of characteristic functions, This is with the characteristic function The associated weight parameters, It is The characteristic function is Time and input sequence and tag sequence A real-valued feature related to the previous time step Tags , the current time step Tags , input feature sequence , the current time step .

[0024] Finally, when processing input sequences, the low-code platform uses long short-term memory networks to maintain contextual information.

[0025] Through these NLP technologies, low-code platforms can automatically convert users' natural language input into actionable business models. Users can define functional modules through simple interactive conversations without having programming experience, thereby greatly lowering the development threshold.

[0026] S200: Obtain a prefabricated component library of a low-code platform, and automatically generate required components using a second agent based on the initial business model and the prefabricated component library; Specifically, the second agent is a component generation agent, and the method of automatically generating required components using the second agent according to the initial business model and the prefabricated component library includes: Leveraging AI-generated content technology and a model-driven approach, we can select and automatically generate required components from a prefabricated component library based on user needs. The required components include basic UI elements and logic modules.

[0027] It should be further explained that based on the analyzed user business needs, the low-code platform uses artificial intelligence generated content (AIGC) technology to automatically select and generate required components from the existing prefabricated component library in the low-code platform. The low-code platform generates required components through a model-driven method, so that it can directly adapt to the user's business scenario needs. The required components include basic UI components and back-end logic modules. The basic UI components include front-end interactive elements (such as buttons, forms) and back-end logic (such as data processing modules, task scheduling modules), etc.

[0028] In some specific embodiments, the steps of selecting and automatically generating required components from a prefabricated component library based on user needs using artificial intelligence content generation technology and a model-driven approach are as follows: (1) Intelligent component matching After the user demand agent analyzes the user's business needs, it performs component semantic retrieval: Component matching based on knowledge graph, including: a) Build a component knowledge graph, where nodes represent prefabricated components and edges represent functional relationships between components; b) Using graph neural networks to calculate the matching degree between demand vectors and component nodes : ; Among them, σ is the Sigmoid function, W is the trainable weight matrix, Represents the matching score between user needs and the i-th component. The higher the value, the more the component meets the user's needs. Represents the eigenvector of the i-th component.

[0029] Context-aware recommendation: Implement collaborative filtering optimization and dynamically adjust recommendation priorities based on historical usage records.

[0030] (2) Dynamic generation of components, including: UI component generation: a) Front-end code synthesis: Use template engines to generate React / Vue component code; inject responsive data binding logic; b) Style Adaptive Optimization: Automatically matches theme colors based on the design specification library and generates CSS variables: Logic module generation: a) Business logic code generation: Converting business process models into executable code: b) Automated exception handling: Predict potential exception points based on historical error logs and insert Try-Catch blocks.

[0031] (3) Component verification and tuning, including: a) Static code analysis: Deploy the SonarQube rule engine to detect potential defects in generated code: null pointer reference risks, unclosed resource vulnerabilities, and thread safety violations; b) Dynamic behavior verification: Implement model checking: Build a state transition model of component behavior; use the UPPAAL tool to verify the properties of sequential logic: c) Performance Tuning: Genetic algorithms are used to optimize component configuration parameters: pageSize and prefetch parameters are adjusted for data paging components; and the number of retries and timeout thresholds are optimized for application programming interface (API) call components.

[0032] Furthermore, in a visual programming environment, users can drag and drop automatically generated components to appropriate locations to form a preliminary application interface. Then, users can configure dynamic events and behaviors for these components in the graphical interface, such as defining button click events, validation rules for data input, etc. All configuration processes are carried out in a low-code manner.

[0033] Furthermore, by enhancing the configurability and scalability of prefabricated components, developers can customize applications more flexibly. The improvement in technical features means that developers do not need to rely heavily on traditional programming languages and can complete more complex business logic processing through the low-code platform itself.

[0034] S300: Utilize the preset cross-domain data integration mechanism to automatically adapt and integrate cross-platform data sources, and intelligently schedule the automatically generated demand components through a third agent; Specifically, the method of automatically adapting and integrating cross-platform data sources by using a preset cross-domain data integration mechanism includes: Users use visual tools to configure preset cross-domain data integration rules, establish standardized interfaces between multiple heterogeneous systems, make data formats on different platforms compatible, and enable data sharing across platforms.

[0035] In some specific embodiments, based on the microservices architecture, the low-code platform can establish standardized interfaces between multiple heterogeneous systems, automatically adapt to different data formats, and ensure data interoperability. In complex industrial environments, data integration is key to ensuring the smooth operation of business processes. The low-code platform allows users to define and configure data integration rules in a graphical interface to ensure seamless data connection between various systems. The specific implementation steps are as follows: (1) Modeling the connection between heterogeneous data sources The visual interaction module can be used to implement protocol adaptation across system data sources, including: a) Deploy a dynamic protocol recognition engine in a graphical interface to support automatic sniffing of industrial standard protocols and Internet protocols. It uses a protocol fingerprint matching algorithm to calculate the Hamming distance between the signature code of the input data stream and the protocol library. When the matching threshold is greater than 85%, it triggers the loading of the protocol adapter. b) Build a data source connector repository and provide an extensible plug-in connector template, which includes: Authentication configuration module: supports parameterized configuration of OAuth2.0 / SAML multi-mode authentication; Data extraction logic: defines a dual-mode data acquisition strategy of batch pull and event-driven; Heartbeat monitoring mechanism: maintains a long connection state through periodic TCP Keep-Alive messages; (2) Intelligent interface specification generation The dynamic interface construction method based on semantic reasoning has the following specific process: a) Perform interface specification derivation: Parse the Web service description file of the legacy system through the WSDL analyzer to extract the operation endpoints and input and output parameter structures; Use the OpenAPI syntax tree generator to convert the request / response model of the RESTful interface into a unified description model (UDM), which uses the JSON-LD format to define semantic relationships. Construct an interface compatibility matrix and calculate the mapping degree between the old and new interface parameters: ; in, is the semantic similarity weight factor based on domain ontology, For the new interface parameters, For old interface parameters; b) Implement standardized interface deployment: Generate an MQTT bridge service that complies with the ISO / IEC 20922 standard and implements the protocol conversion layer: Implement binary to JSON serialization conversion for Modbus RTU protocol; Add timestamp watermark and CRC32 checksum at the transport layer; Deploy an adaptive load balancer to dynamically adjust the thread pool size based on the frequency of interface calls, and use a PID controller to maintain system throughput within a stable range; (3) Multimodal data format conversion Perform intelligent alignment and transformation of heterogeneous data structures, including: a) Establish field-level semantic mapping: Build a domain knowledge graph and calculate the embedding similarity between the source field s and the target field t through a neural network : ; in , is the vector representation of the field name in the knowledge graph; Implementing a structure completion strategy: Automatically generate default value filling rules for missing nested JSON fields, selecting the mode or mean based on historical data distribution; b) Deploy real-time conversion pipeline: Streaming data processing layer: uses Apache Kafka connector to implement data buffering and sets up a sliding window mechanism to process out-of-order data; Format conversion engine: performs named entity recognition on unstructured text, extracts key data elements and restructures them into a structured format; Quality Verification Module: This module performs data integrity verification using a pre-configured Schematron rule set, routing abnormal data to a dead letter queue (DLQ) for manual repair. This embodiment can achieve data integration across multiple heterogeneous systems through a three-tier architecture of visual rule configuration, intelligent protocol conversion, and online learning. The combination of a preset cross-domain data integration mechanism and a low-code platform is particularly suitable for multi-source data fusion scenarios in the field of intelligent manufacturing, helping users seamlessly integrate data from multiple systems and further realizing the smooth linkage of business processes.

[0036] Specifically, the third agent is a service optimization agent, and the method of intelligently scheduling automatically generated demand components by the third agent includes: Obtain user-defined task processes, use service optimization agents to manage and schedule automatically generated demand components, automatically identify the dependencies and task priorities between tasks, and dynamically adjust the execution order of tasks, so that each demand component can work together according to the user-defined task process.

[0037] It should be noted here that the low-code platform uses multi-agent collaborative technology to schedule tasks and allocate resources for generated components. In complex industrial application scenarios, there may be dependencies between different components. By introducing service optimization agents, the platform can dynamically identify the dependencies of each component and optimize the execution order and resource utilization of each component based on system resources and task priorities, further ensuring that the entire application maintains efficient performance and stability during operation.

[0038] In some specific embodiments, the method for intelligently scheduling automatically generated demand components through a service optimization agent is specifically implemented as follows: (1) Acquisition and parsing of task processes. The user-defined task process definition file is received through the user interaction interface. The task process definition file can use a structured data format to describe the logical topological relationship between each requirement component. The service optimization agent performs semantic parsing on the task process, extracts the task node set V = {v1, v2, ..., vn} and the directed edge set E = {eij | vi → vj} between the nodes, and constructs the task topology graph G (V, E); (2) Dependency and priority modeling. Perform multi-dimensional analysis based on the topology graph G(V,E): a) Use the depth-first search algorithm to identify the critical path and calculate the earliest start time EST(vi) and the latest completion time LFT(vi) of each node; b) Task priority is evaluated using a weighted scoring model. The scoring model integrates the task complexity weight α, the resource requirement weight β, and the user-specified priority γ to generate a priority score P(vi) = α·C(vi) + β·R(vi) + γ·U(vi), where C(vi) is the historical execution time statistics, R(vi) is the memory / CPU requirement coefficient, and U(vᵢ) represents the quantified priority value assigned by the user to the task node vᵢ; c) Establish a dynamic dependency matrix D = [d ij ] n×n , when there is e ij ∈E when d ij =1, otherwise d ij = 0, and calculate the reachability matrix R = D + D² + … + Dⁿ; (3) Resource-aware dynamic scheduling. The service optimization agent monitors the status of system resources in real time, including: a) Use resource probes to collect the available memory Mavail, CPU utilization Ucpu, and network bandwidth Bw of each computing node; b) Construct resource adaptation function: F(vi)=w1·f(Mreq / Mavail)+w2·g(Ucpu)+w3·h(Bw / Breq), Among them, f, g, h are normalization functions, w1+w2+w3=1; c) Generate a comprehensive scheduling weight based on the priority score P(vi) and the fitness F(vi): W(vi)=λP(vi)+(1-λ)F(vi), where λ∈[0,1] is an adjustable parameter; (4) Execution queue optimization. An improved topological sorting algorithm is used to generate the initial execution sequence, which includes: a) Establish a set of strongly connected components based on the reachability matrix R; b) Arrange the internal nodes of each component in descending order according to W(vi); c) Insert a checkpoint into the global execution queue. When it is detected that the resource status change exceeds the threshold Δ, the dynamic reordering mechanism is triggered, and the unexecuted tasks are reordered according to the latest W(vi) through the insertion sort algorithm.

[0039] (5) Fault-tolerant collaborative execution. During task execution: a) Deploy a heartbeat detection module to periodically verify the operating status of each required component; b) When a task timeout or failure occurs, the affected tasks are automatically rolled back according to the dependency matrix D and EST and LFT are recalculated; c) Synchronizing data between components through messaging middleware to ensure consistency of execution context. The messaging middleware adopts a publish-subscribe model and the message queue implements a priority preemption mechanism; Step S350: Performance feedback optimization. Collect historical execution data to build a knowledge base, including: a) Record the deviation ΔT(vi) between the actual execution time Treal(vi) and the estimated time Test(vi); b) Use the gradient descent algorithm to update the complexity weight α = α - η ∂ΔT / ∂α; c) Optimize the scheduling strategy through a reinforcement learning model, and design the reward function as R = Σ[P(vi) exp(-twait(vi))], where twait is the task waiting time; It can be understood that this embodiment effectively solves the integration problem of multiple systems and multiple data sources in enterprise-level applications through standardized data exchange interfaces and cross-domain data interconnection integration mechanisms, and can intelligently manage and optimize task flow and process control, making enterprises more efficient in handling multi-task parallelism and dynamic event management.

[0040] S400. Establish a service automation orchestration mechanism based on the microservice architecture, automatically identify the service dependencies, and dynamically adjust the execution order and resource allocation of each required component according to the service dependencies.

[0041] Specifically, the method of establishing a service automation orchestration mechanism based on a microservice architecture, automatically identifying service dependencies, and dynamically adjusting the execution order and resource allocation of each required component according to the service dependencies includes: Through the microservice architecture, data interconnection is established between different platforms, the dependencies between microservices are automatically identified and orchestrated, and the running order and resource allocation of each service are dynamically adjusted according to the priority and resource utilization of each task.

[0042] It should be noted here that after the demand components and business logic are configured, the low-code platform automatically orchestrates microservices. By analyzing the dependencies between services, the low-code platform dynamically adjusts the running order of each service to optimize system performance. Users do not need to intervene manually. The low-code platform automatically identifies resource bottlenecks and makes adjustments to ensure the efficient operation of the entire application. The service orchestration mechanism can also respond to sudden load changes and dynamically allocate more computing resources to meet peak demand.

[0043] In some specific embodiments, the steps of establishing a service automation orchestration mechanism based on a microservice architecture and dynamically adjusting the execution order and resource allocation of each required component according to the identified service dependencies are as follows: (1) Service dependency graph modeling, building a dependency model between microservices, specifically including: Intelligent metadata extraction: a) Deploy the service probe module and extract the service interface definition by parsing the microservice deployment description file, including the data schema of the input / output parameters and the service call endpoint; b) Use static code analysis technology to identify the explicit call relationship between services and construct the initial dependency edge set E={e ij |Service i →Service j}; Runtime dependency discovery: a) Collect service call chain data through the distributed tracing system to generate a dynamic dependency matrix D = [d ij ]: d {ij} = \begin{cases}1&\text{When Service i Calling Service j The number of times > threshold N}\\0&\text{others}\end{cases}; b) Combine heartbeat detection data from the service registry to identify implicit dependencies (such as database connection pool sharing); Dependency graph construction: a) Generate a weighted directed graph G(V,E,W), where the node V={v i} represents a microservice instance, and the edge weight W(e ij ) = mean call delay + α × call error rate (α is the penalty coefficient); b) Perform strongly connected component decomposition, identify cyclic dependency clusters, and generate a topologically sorted sequence Seq={v1,v2,…,v n}; (2) Dynamic priority scheduling, which optimizes the execution order based on dependencies. The specific method is as follows: Critical path analysis: a) Calculate the earliest start time EST(vi) and the latest finish time LFT(v i ) of each service using the critical path algorithm (CPM): ; ; Among them, when calculating EST , and when calculating LFT ; b) Define the service priority P(v i ) = LFT(v i ) - EST(v i ), where the smaller the value, the higher the priority; Elastic queue management: a) Construct a multi-level ready queue, which is divided by priority into: Real-time queue (P ≤ 100ms): Use preemptive scheduling; High-priority queue (100ms < P ≤ 500ms): Use weighted round-robin scheduling; Normal queue (P > 500ms): Use fair-share-based scheduling; b) Deploy a queue dynamic adjuster. When a service SLA violation is detected, migrate the relevant service to a higher-priority queue; (3) Resource-aware allocation, implement multi-dimensional resource optimization allocation, specifically including: Resource demand modeling: a) Define the service resource demand vector R i = (CPU i , Mem i , IO i ), where: CPU i = reference value × call frequency × historical peak factor; Mem i = estimated value of heap memory × parallelism factor; b) Construct a resource fitness function : ; Among them, is the available resource of node j, is the resource type weight; Dynamic allocation strategy: a) Use an improved genetic algorithm for resource allocation optimization: Chromosome encoding: Each gene bit represents the mapping of a service to a node; Fitness function: comprehensive resource utilization, load balancing, and SLA achievement rate; Crossover and mutation: implement two-point crossover and directed mutation (prioritize adjustment of low fitness genes); b) Output the optimal allocation solution Map={v i →Node j},satisfy: ; in, is a safety threshold (e.g. =0.8); (4) Elastic expansion and contraction control, dynamic resource adjustment method to cope with sudden load changes: Horizontal scaling decisions: a) Define the trigger conditions for scaling: Expansion: When the node CPU utilization is continuously greater than 85% for T seconds or the request queue length is greater than Q max ; Scaling down: When the node CPU utilization is less than 30% for T seconds and the request queue empty rate is greater than 60%; b) Use PID controller to calculate the instance number adjustment ΔN: ; Where, e(t) = current load rate - target load rate; Vertical resource adjustment: a) Dynamically adjust container resource quotas through cgroups: b) Implement lossless changes: Use Linux Checkpoint / Restore technology to achieve memory state snapshot and recovery; (5) Closed-loop self-optimization, building a feedback mechanism for continuous optimization: Runtime monitoring and feedback: a) Collect multi-dimensional operating indicators: Service response time distribution (P50 / P90 / P99); Resource utilization heatmap (aggregated by node / service); Dependency change detection (based on call chain change tracking); b) Build a time series database to store historical data, with a sampling frequency of ≥ 1Hz; Reinforcement Learning Optimization: a) Define a Markov Decision Process (MDP): State space: node load vector + service queue state; Action space: {migrate services, expand nodes, adjust priorities}; Reward function: R = ω1 × throughput + ω2 × (1-delay penalty) - ω3 × resource cost; b) Using Deep Q Network (DQN) training scheduling strategy: ; in, represents the expected long-term reward of performing action a in state s, represents the learning rate, Represents the immediate reward signal from the environment after executing action a. represents the future long-term reward of performing the next action a in the next state s.

[0044] Rule knowledge base update: When it is detected that the scheduling strategy is better than the current rules for N consecutive times, the rule base update is triggered.

[0045] Specifically, the method further includes: Obtain the business logic and requirement components configured by the user, automatically generate an application based on the business logic and requirement components, optimize the program structure through the service automation orchestration mechanism based on the microservice architecture, and use automation tools to perform automated testing of the application.

[0046] In some specific embodiments, the low-code platform packages all user-configured business logic and required components into runnable applications in the background. The system automatically generates, optimizes, and tests the applications. With the help of automated tools, the platform optimizes performance and performs error checks during application generation to ensure that the applications can run smoothly, thereby largely guaranteeing the stability and efficiency of the applications. Furthermore, the program structure is optimized using the automated service orchestration mechanism of the microservice architecture. The specific process can refer to the steps of the method for utilizing the automated service orchestration mechanism of the microservice architecture and dynamically adjusting the execution order and resource allocation of each required component based on the identified service dependencies. Automated testing of the application is performed using automated tools to implement quality assurance throughout the entire process. The specific implementation steps are as follows: (1) Intelligent generation of test cases can adopt model-driven testing (MDT) technology, including: a) Analyze the business process model and generate boundary value test cases: b) Generate abnormal path use cases based on mutation testing (2) Perform layered testing and build a multi-stage testing pipeline, which may include unit testing, integration testing, performance testing, security testing, etc. (3) Automatic defect repair, which can use AI-assisted repair engine: a) For unit test failure cases, the CodeBERT model is used to generate repair suggestions; b) Recommend code refactoring solutions based on historical optimization records for performance bottlenecks; Specifically, the method further includes: Set up the one-click deployment function in the low-code platform to publish the generated application to the production environment.

[0047] It is understandable that users can quickly publish applications to the production environment through the one-click deployment function of the low-code platform without having to manually configure the server or underlying architecture, which greatly improves the efficiency of application launch.

[0048] See also Figure 3-Figure 9 , the working principle of the present invention is explained below through specific examples, Figure 3 The overall framework diagram of the present invention is as follows: Step 1: Users input their business requirements through a visual interface or conversational artificial intelligence (AI). The platform uses natural language processing (NLP) technology to analyze the user's natural language input and convert it into an actionable business model. Users can define the required functional modules, such as forms, buttons, and data processing flows, through simple interactive conversations. This process does not require programming experience, lowering the development threshold. Step 2: Based on the analyzed business needs, the platform uses artificial intelligence generated content (AIGC) technology to automatically select and generate basic UI components and background logic modules from the existing prefabricated component library in the low-code platform. The low-code platform generates demand components through a model-driven approach, so that it can directly adapt to the user's business scenario needs. The generated demand components include front-end interactive UI elements (such as buttons, forms) and background logic (such as data processing, task scheduling modules), etc. Figure 8 and Figure 9 As shown in the figure, the test results based on the business requirements of "creating a login page" and "beautifying this login page" show that the required components can be initially implemented through conversational AI; See also Figure 5 ,Step 1 and Step 2 together constitute the user interaction and component construction module,,specifically including the user interaction module and the component construction module.,In this module, users input business requirements through a visual interface or,conversational artificial intelligence (AI), namely, a conversational module,,so that the intelligent agent understands the user requirements and finally,generates the required components through the component generation,,paving the way for the subsequent complex business processes.

[0049] Step 3: In the visual programming environment, users drag and drop the automatically generated requirement components to the appropriate location to form a preliminary application interface; then, users can configure dynamic events and behaviors for these components in the graphical interface, such as defining button click events, data input validation rules, etc. All configuration processes are carried out in a low-code manner.

[0050] Step 4: The low-code platform is based on multi-agent collaborative technology, including service optimization agents, to perform task scheduling and resource allocation for generated components. In complex industrial application scenarios, there may be dependencies between different components. By introducing intelligent task scheduling technology, the platform can dynamically identify the dependencies of each component and optimize the execution order and resource utilization of each component based on system resources and task priorities. This can ensure that the entire application maintains efficient performance and stability during operation.

[0051] Step 5: The platform automatically adapts and integrates data sources from different systems through the built-in cross-domain data integration mechanism.

[0052] Based on the microservice architecture, the platform can establish standardized interfaces between multiple heterogeneous systems, automatically adapt to different data formats, and ensure data interconnection. In complex industrial environments, data integration is the key to ensuring the smooth operation of business processes. The low-code platform allows users to define and configure data integration rules in a graphical interface to ensure seamless data connection between various systems.

[0053] See also Figure 6 Steps 3-5 constitute the task and process management module (task management module). In this module, users can easily build the interface and functions of the application through an intuitive graphical programming interface and low-code development methods. By dragging and dropping components and configuring event responses, users can quickly define the basic interaction logic of the application, avoiding tedious manual coding. The platform automatically handles the dependencies and resource scheduling between components. Especially in complex industrial scenarios, through intelligent task scheduling technology, it ensures that tasks are executed in the optimal order and resource utilization to maintain the efficient operation of the system. Finally, the platform uses a cross-domain data integration mechanism to help users seamlessly integrate data from multiple systems and achieve smooth linkage of business processes.

[0054] Step 6: After configuring the components and business logic, the platform automatically orchestrates microservices. By analyzing the dependencies between services, the platform dynamically adjusts the order in which they run to optimize system performance. No manual user intervention is required; the platform automatically identifies resource bottlenecks and makes adjustments to ensure efficient operation of the entire application. The service orchestration mechanism can also respond to sudden load fluctuations, dynamically allocating more computing resources to meet peak demand.

[0055] Step 7: Behind the scenes, the low-code platform packages all user-configured business logic and components into a runnable application. The system automatically generates, optimizes, and tests the application. Leveraging automated tools, the low-code platform optimizes performance and performs error checking during the application generation process to ensure smooth operation. Finally, users can deploy the application to production using the platform's one-click deployment feature, eliminating the need to manually configure servers or underlying infrastructure, improving application rollout efficiency.

[0056] See also Figure 7 Steps 6 and 7 demonstrate the capabilities of the underlying architecture and service management module (Service Management Module). In this module, the low-code platform automatically analyzes and optimizes service dependencies through intelligent microservice orchestration technology to ensure efficient system operation. Without manual user intervention, the low-code platform automatically adjusts the execution order of services based on the system's real-time resource availability, responds to load fluctuations, and optimizes performance by dynamically allocating computing resources. The low-code platform then automatically generates, optimizes, and tests applications. Its one-click deployment feature rapidly releases applications to production environments, significantly improving launch speed and efficiency.

[0057] It should be noted here that this embodiment provides a low-code component development method based on multiple agents, which converts user needs into an initial business model by using a first agent, and automatically generates demand components based on the initial business model and a prefabricated component library by using a second agent; automatically adapts and integrates cross-platform data sources using a preset cross-domain data integration mechanism, and intelligently schedules the automatically generated demand components through a third agent; establishes a service automation orchestration mechanism based on a microservice architecture, automatically identifies the dependencies of each service, and dynamically adjusts the execution order and resource allocation of each demand component based on the service dependencies, solving the problem that the prefabricated component library of the existing low-code platform is difficult to meet the developer's customized needs for complex business scenarios and the cross-platform component integration involving multiple systems and data sources, and is difficult to effectively adapt to complex business logic and cross-system operations. The present invention uses modular component design to make the platform highly flexible and scalable, and can be quickly adjusted and optimized according to different business needs. In addition, multi-agent collaboration ensures the efficient and collaborative operation of each component in complex industrial applications, optimizes the allocation and utilization efficiency of resources, and greatly improves the overall performance of the system.

[0058] See also Figure 2 , this embodiment provides a multi-agent-based low-code component development system, the system comprising: User interaction module 100: obtains user needs and converts the user needs into an initial business model through the first agent; Component construction module 200: obtains a prefabricated component library of the low-code platform, and automatically generates required components using a second agent based on the initial business model and the prefabricated component library; Task management module 300: Utilizes a preset cross-domain data integration mechanism to automatically adapt and integrate cross-platform data sources, and intelligently schedules automatically generated demand components through a third agent; Service management module 400: establishes a service automation orchestration mechanism based on the microservice architecture, automatically identifies the dependencies between services, and dynamically adjusts the execution order and resource allocation of each required component according to the service dependencies.

[0059] It should be noted here that this embodiment provides a low-code component development system based on multiple agents, which converts user requirements into an initial business model by using a first agent, and automatically generates demand components based on the initial business model and a prefabricated component library by using a second agent; automatically adapts and integrates cross-platform data sources using a preset cross-domain data integration mechanism, and intelligently schedules the automatically generated demand components through a third agent; establishes a service automation orchestration mechanism based on a microservice architecture, automatically identifies the dependencies of each service, and dynamically adjusts the execution order and resource allocation of each demand component based on the service dependencies, solving the problem that the prefabricated component library of the existing low-code platform is difficult to meet the developer's customized requirements for complex business scenarios and the cross-platform component integration involving multiple systems and data sources, and is difficult to effectively adapt to complex business logic and cross-system operations. The present invention uses modular component design to make the platform highly flexible and scalable, and can be quickly adjusted and optimized according to different business needs. In addition, multi-agent collaboration ensures the efficient and collaborative operation of each component in complex industrial applications, optimizes the allocation and utilization efficiency of resources, and greatly improves the overall performance of the system.

[0060] In a preferred embodiment, the present application further provides an electronic device, comprising: A memory; and a processor, wherein the memory stores computer-readable instructions, and when the computer-readable instructions are executed by the processor, the multi-agent-based low-code component development method is implemented. The computer device can be broadly defined as a server, a terminal, or any other electronic device with necessary computing and / or processing capabilities. In one embodiment, the computer device may include a processor, a memory, a network interface, a communication interface, etc. connected via a system bus. The processor of the computer device can be used to provide the necessary computing, processing and / or control capabilities. The memory of the computer device may include a non-volatile storage medium and an internal memory. An operating system, a computer program, etc. may be stored in or on the non-volatile storage medium. The internal memory can provide an environment for the operation of the operating system and the computer program in the non-volatile storage medium. The network interface and the communication interface of the computer device can be used to connect and communicate with external devices through a network. When the computer program is executed by the processor, the steps of the method of the present invention are performed.

[0061] The present invention can be implemented as a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, causes the steps of the method of an embodiment of the present invention to be performed. In one embodiment, the computer program is distributed on a plurality of computer devices or processors coupled to a network so that the computer program is stored, accessed, and executed in a distributed manner by one or more computer devices or processors. A single method step / operation, or two or more method steps / operations, can be performed by a single computer device or processor or by two or more computer devices or processors. One or more method steps / operations can be performed by one or more computer devices or processors, and one or more other method steps / operations can be performed by one or more other computer devices or processors. One or more computer devices or processors can perform a single method step / operation, or perform two or more method steps / operations.

[0062] It should be noted here that the present invention converts user needs into an initial business model by using a first agent, and automatically generates demand components based on the initial business model and the prefabricated component library using a second agent; automatically adapts and integrates cross-platform data sources using a preset cross-domain data integration mechanism, and intelligently schedules the automatically generated demand components through a third agent; establishes a service automation orchestration mechanism based on a microservice architecture, automatically identifies the dependencies of each service, and dynamically adjusts the execution order and resource allocation of each demand component based on the service dependencies, solving the problem that the prefabricated component library of the existing low-code platform is difficult to meet the developer's customized needs for complex business scenarios and the cross-platform component integration involving multiple systems and data sources, and is difficult to effectively adapt to complex business logic and cross-system operations. The present invention uses modular component design to make the platform highly flexible and scalable, and can be quickly adjusted and optimized according to different business needs. In addition, multi-agent collaboration ensures the efficient and collaborative operation of each component in complex industrial applications, optimizes the allocation and utilization efficiency of resources, and greatly improves the overall performance of the system.

[0063] It should be noted that the terms "first", "second", etc. in the specification and claims of the present application and the above-mentioned drawings are used to distinguish similar objects and are not necessarily used to describe a specific order or sequential order. It should be understood that the data used in this way can be interchangeable where appropriate, so that the embodiments of the present application described herein can be implemented in a sequence other than those illustrated or described herein. In addition, the terms "including" and "having" and any of their variations are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device comprising a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0064] The various technical features described above can be combined arbitrarily. Although not all possible combinations of these technical features are described, any combination of these technical features should be considered to be covered by this specification as long as such combination does not conflict.

[0065] The specific embodiments of the present invention described above do not limit the scope of protection of the present invention. Any other corresponding changes and modifications made based on the technical concept of the present invention should be included in the scope of protection of the claims of the present invention.

Claims

1. A low-code component development method based on multi-agent, characterized in that: include: S100: Obtain user needs and convert the user needs into an initial business model through a first agent; S200: Obtain a prefabricated component library of a low-code platform, and automatically generate required components using a second agent based on the initial business model and the prefabricated component library; S300: Utilize the preset cross-domain data integration mechanism to automatically adapt and integrate cross-platform data sources, and intelligently schedule the automatically generated demand components through a third agent; S400. Establish a service automation orchestration mechanism based on the microservice architecture, automatically identify the service dependencies, and dynamically adjust the execution order and resource allocation of each required component according to the service dependencies.

2. The multi-agent based low-code component development method according to claim 1 is characterized in that: The first agent is a user demand analysis agent, and the method of obtaining user demand and converting the user demand into an initial business model through the first agent includes: Receive business requirements input by users through visual interfaces or conversational modules; Natural language processing technology is used to understand the business needs and convert the business needs into an operational initial business model.

3. The multi-agent based low-code component development method according to claim 1 is characterized in that: The second agent is a component generation agent. The method for automatically generating required components using the second agent according to the initial business model and the prefabricated component library includes: Leveraging AI-generated content technology and a model-driven approach, we can select and automatically generate required components from a prefabricated component library based on user needs. The required components include basic UI elements and logic modules.

4. The multi-agent based low-code component development method according to claim 1 is characterized in that: The method of automatically adapting and integrating cross-platform data sources by utilizing a preset cross-domain data integration mechanism includes: Users use visual tools to configure preset cross-domain data integration rules, establish standardized interfaces between multiple heterogeneous systems, make data formats on different platforms compatible, and enable data sharing across platforms.

5. The multi-agent based low-code component development method according to claim 1 is characterized in that: The third agent is a service optimization agent, and the method for intelligently scheduling automatically generated demand components by the third agent includes: Obtain user-defined task processes, use service optimization agents to manage and schedule automatically generated demand components, automatically identify the dependencies and task priorities between tasks, and dynamically adjust the execution order of tasks, so that each demand component can work together according to the user-defined task process.

6. The multi-agent based low-code component development method according to claim 1 is characterized in that: The method of establishing a service automation orchestration mechanism based on a microservice architecture, automatically identifying service dependencies, and dynamically adjusting the execution order and resource allocation of each required component according to the service dependencies includes: Through the microservice architecture, data interconnection is established between different platforms, the dependencies between microservices are automatically identified and orchestrated, and the running order and resource allocation of each service are dynamically adjusted according to the priority and resource utilization of each task.

7. The multi-agent based low-code component development method according to claim 6 is characterized in that: The method further comprises: Obtain the business logic and requirement components configured by the user, automatically generate an application based on the business logic and requirement components, optimize the program structure through the service automation orchestration mechanism based on the microservice architecture, and use automation tools to perform automated testing of the application.

8. The multi-agent based low-code component development method according to claim 7 is characterized in that: The method further comprises: Set up the one-click deployment function in the low-code platform to publish the generated application to the production environment.

9. A low-code component development system based on multi-agent, characterized by: include: User interaction module (100): obtains user needs and converts the user needs into an initial business model through a first agent; Component construction module (200): obtaining a prefabricated component library of a low-code platform, and automatically generating a required component using a second agent according to the initial business model and the prefabricated component library; Task management module (300): Utilizes a preset cross-domain data integration mechanism to automatically adapt and integrate cross-platform data sources, and intelligently schedules automatically generated demand components through a third agent; Service management module (400): establishes a service automation orchestration mechanism based on the microservice architecture, automatically identifies the dependency relationships of each service, and dynamically adjusts the execution order and resource allocation of each required component according to the service dependency relationships.

10. An electronic device, characterized in that: include: Memory; and a processor, wherein the memory stores computer-readable instructions, and when the computer-readable instructions are executed by the processor, the multi-agent-based low-code component development method according to any one of claims 1 to 8 is implemented.

Images