Intelligent agent management methods and systems for low-code design

Abstract

This invention discloses an agent management method and system for low-code design. The method includes: acquiring multiple historical code build records of a user in a low-code platform; determining programming requirement parameters corresponding to each historical code build record based on a prediction model; creating a corresponding basic agent model based on the programming requirement parameters; training the basic agent model based on the historical code build records and the corresponding programming requirement parameters to obtain a code-enhancing agent; the code-enhancing agent is used to optimize the code generated by the user's operations on the low-code platform. Therefore, this invention can achieve accurate agent training based on historical builds and requirement analysis, improve the automation and accuracy of code optimization on low-code platforms, and reduce the risk of code errors caused by manual optimization.

Description

Technical Field

[0001] This invention relates to the field of data processing technology, and in particular to an agent management method and system for low-code design. Background Technology

[0002] With the rapid adoption of low-code platforms in software development, enterprises and developers are increasingly focusing on improving the automation level of code optimization through intelligent tools. A key technical challenge is how to achieve precise code optimization using algorithmic models. Existing technologies typically generate code enhancement tools to support platform code optimization through simple predictive models and users' historical code records. However, existing solutions lack dynamic prediction of programming requirement parameters and in-depth analysis of historical records, making it difficult to create accurate intelligent agent models tailored to user needs. This results in insufficient automation and accuracy in code optimization, making manual optimization prone to errors and limiting the development efficiency and reliability of low-code platforms. Clearly, existing technologies have shortcomings that urgently need to be addressed. Summary of the Invention

[0003] The technical problem to be solved by the present invention is to provide an agent management method and system for low-code design, which can realize accurate agent training based on historical construction and requirements analysis, improve the automation and accuracy of code optimization in low-code platforms, and reduce the risk of code errors caused by manual optimization.

[0004] To address the aforementioned technical problems, the first aspect of this invention discloses a method for managing intelligent agents in low-code design, the method comprising:

[0005] Retrieve multiple historical code build records of a user on a low-code platform;

[0006] Based on the prediction model, the programming requirement parameters corresponding to each historical code construction record are determined.

[0007] Based on the programming requirements parameters, create the corresponding basic intelligent agent model;

[0008] Based on the historical code construction records and the corresponding programming requirement parameters, the basic agent model is trained to obtain a code-enhanced agent; the code-enhanced agent is used to optimize the code generated by the user's operation on the low-code platform.

[0009] As an optional implementation, in the first aspect of the present invention, the historical code construction record includes code module drag-and-drop operations, code modification operations, code module association operations, text input operations, code module addition and deletion operations, and the final code.

[0010] As an optional implementation, in the first aspect of the invention, determining the programming requirement parameters corresponding to each historical code construction record based on a prediction model includes:

[0011] For each historical code build record, filter out the relevant data content in that historical code build record;

[0012] The data of interest is input into the trained programming requirement prediction model to obtain the programming requirement parameters corresponding to the historical code construction record; the programming requirement prediction model is trained on a training dataset that includes multiple training low-code construction records and corresponding programming requirement parameters.

[0013] As an optional implementation, in the first aspect of the present invention, the step of filtering out the data of interest in the historical code construction record includes:

[0014] Calculate the average data similarity between each data part in the historical code construction record and each data part of each other historical code construction record to obtain the repetition parameter corresponding to each data part in the historical code construction record;

[0015] The data portion in the historical code construction record where the repetition parameter is less than a preset parameter threshold is selected to obtain the data content of interest in the historical code construction record.

[0016] As an optional implementation, in the first aspect of the present invention, the programming requirement parameters include programming scenario, programming target function, programming target environment, programming target application device parameters, and programming preference complexity.

[0017] As an optional implementation, in the first aspect of the present invention, the step of creating a corresponding basic intelligent agent model according to the programming requirement parameters includes:

[0018] For each pre-trained candidate agent model, obtain the training materials corresponding to that candidate agent model; the training materials include training code data and corresponding code optimization annotations and programming requirement annotations.

[0019] Calculate the parameter similarity between the programming requirement annotations of the training materials and the programming requirement parameters;

[0020] Candidate agent models whose parameter similarity is greater than a preset similarity threshold are selected to obtain multiple preferred agent models;

[0021] The joint model of all the preferred agent models is determined as the basic agent model.

[0022] As an optional implementation, in the first aspect of the present invention, the step of training the basic agent model to obtain a code-enhanced agent based on the historical code construction record and the corresponding programming requirement parameters includes:

[0023] All the preferred agent models are shared to the same centralized value network; the centralized value network is used to guide the action network of each preferred agent model.

[0024] Determine the loss function corresponding to the centralized value network; the loss function is the weighted sum of the reinforcement learning loss functions corresponding to each of the preferred agent models; the computational weights of the reinforcement learning loss function are proportional to the parameter similarity of the corresponding preferred agent model.

[0025] Based on the multi-agent reinforcement learning algorithm and the loss function, the joint model of all the preferred agent models is trained according to the historical code construction record and the corresponding programming requirement parameters to obtain the code-enhancing agent.

[0026] As an optional implementation, in the first aspect of the present invention, the method further includes:

[0027] Obtain the automatically generated code corresponding to the user's code build operation on the low-code platform;

[0028] The automatically generated code is input into each of the trained preferred agent models in the code enhancement agent to obtain multiple code optimization operations;

[0029] Calculate the intersection of all the code optimization operations to obtain the intersection optimization operations;

[0030] The intersection optimization operation is performed on the automatically generated code to obtain optimized code.

[0031] A second aspect of this invention discloses an agent management system for low-code design, the system comprising:

[0032] The acquisition module is used to retrieve multiple historical code build records of a user in a low-code platform;

[0033] The prediction module is used to determine the programming requirement parameters corresponding to each historical code construction record based on the prediction model.

[0034] A module is created to generate a corresponding basic intelligent agent model based on the programming requirements parameters.

[0035] The training module is used to train the basic agent model based on the historical code construction record and the corresponding programming requirement parameters to obtain a code-enhanced agent; the code-enhanced agent is used to optimize the code generated by the user's operation on the low-code platform.

[0036] As an optional implementation, in a second aspect of the present invention, the historical code construction record includes code module drag-and-drop operations, code modification operations, code module association operations, text input operations, code module addition and deletion operations, and the final code.

[0037] As an optional implementation, in a second aspect of the invention, the prediction module determines, based on a prediction model, the specific method for determining the programming requirement parameters corresponding to each historical code construction record, including:

[0038] For each historical code build record, filter out the relevant data content in that historical code build record;

[0039] The data of interest is input into the trained programming requirement prediction model to obtain the programming requirement parameters corresponding to the historical code construction record; the programming requirement prediction model is trained on a training dataset that includes multiple training low-code construction records and corresponding programming requirement parameters.

[0040] As an optional implementation, in a second aspect of the invention, the specific method by which the prediction module filters out the data content of interest in the historical code construction record includes:

[0041] Calculate the average data similarity between each data part in the historical code construction record and each data part of each other historical code construction record to obtain the repetition parameter corresponding to each data part in the historical code construction record;

[0042] The data portion in the historical code construction record where the repetition parameter is less than a preset parameter threshold is selected to obtain the data content of interest in the historical code construction record.

[0043] As an optional implementation, in the second aspect of the present invention, the programming requirement parameters include programming scenario, programming target function, programming target environment, programming target application device parameters, and programming preference complexity.

[0044] As an optional implementation, in the second aspect of the present invention, the specific method by which the creation module creates the corresponding basic intelligent agent model according to the programming requirement parameters includes:

[0045] For each pre-trained candidate agent model, obtain the training materials corresponding to that candidate agent model; the training materials include training code data and corresponding code optimization annotations and programming requirement annotations.

[0046] Calculate the parameter similarity between the programming requirement annotations of the training materials and the programming requirement parameters;

[0047] Candidate agent models whose parameter similarity is greater than a preset similarity threshold are selected to obtain multiple preferred agent models;

[0048] The joint model of all the preferred agent models is determined as the basic agent model.

[0049] As an optional implementation, in a second aspect of the invention, the training module trains the basic agent model to obtain a code-enhanced agent based on the historical code construction record and the corresponding programming requirement parameters, including:

[0050] All the preferred agent models are shared to the same centralized value network; the centralized value network is used to guide the action network of each preferred agent model.

[0051] Determine the loss function corresponding to the centralized value network; the loss function is the weighted sum of the reinforcement learning loss functions corresponding to each of the preferred agent models; the computational weights of the reinforcement learning loss function are proportional to the parameter similarity of the corresponding preferred agent model.

[0052] Based on the multi-agent reinforcement learning algorithm and the loss function, the joint model of all the preferred agent models is trained according to the historical code construction record and the corresponding programming requirement parameters to obtain the code-enhancing agent.

[0053] As an optional implementation, in a second aspect of the invention, the system is further configured to perform the following steps:

[0054] Obtain the automatically generated code corresponding to the user's code build operation on the low-code platform;

[0055] The automatically generated code is input into each of the trained preferred agent models in the code enhancement agent to obtain multiple code optimization operations;

[0056] Calculate the intersection of all the code optimization operations to obtain the intersection optimization operations;

[0057] The intersection optimization operation is performed on the automatically generated code to obtain optimized code.

[0058] A third aspect of the present invention discloses another agent management system for low-code design, the system comprising:

[0059] Memory containing executable program code;

[0060] A processor coupled to the memory;

[0061] The processor calls the executable program code stored in the memory to execute some or all of the steps in the agent management method for low-code design disclosed in the first aspect of the present invention.

[0062] The fourth aspect of the present invention discloses a computer storage medium storing computer instructions, which, when invoked, are used to execute some or all of the steps in the agent management method for low-code design disclosed in the first aspect of the present invention.

[0063] Compared with the prior art, the embodiments of the present invention have the following beneficial effects:

[0064] This invention obtains the user's historical code build records in a low-code platform and determines programming requirement parameters based on a predictive model. It then creates a basic agent model and trains it using historical records and parameters to obtain a code-enhanced agent. This enables precise agent training based on historical builds and requirement analysis, improving the automation and accuracy of code optimization on low-code platforms and reducing the risk of code errors caused by manual optimization. Attached Figure Description

[0065] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0066] Figure 1 This is a flowchart illustrating an agent management method for low-code design disclosed in an embodiment of the present invention.

[0067] Figure 2 This is a schematic diagram of the structure of an intelligent agent management system for low-code design disclosed in an embodiment of the present invention.

[0068] Figure 3 This is a schematic diagram of another intelligent agent management system for low-code design disclosed in an embodiment of the present invention. Detailed Implementation

[0069] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0070] The terms "first," "second," etc., used in the specification, claims, and accompanying drawings of this invention are used to distinguish different objects, not to describe a specific order. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, apparatus, product, or device that includes a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units not listed, or may optionally include other steps or units inherent to these processes, methods, products, or devices.

[0071] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of the invention. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment mutually exclusive with other embodiments. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0072] This invention discloses an agent management method and system for low-code design. By acquiring historical code build records of users on a low-code platform and determining programming requirement parameters based on a predictive model, a basic agent model is created. Through training with historical records and parameters, a code-enhanced agent is obtained. This enables precise agent training based on historical builds and requirement analysis, improving the automation and accuracy of code optimization on the low-code platform and reducing the risk of code errors caused by manual optimization. Detailed descriptions follow.

[0073] Example 1

[0074] Please see Figure 1 , Figure 1 This is a flowchart illustrating an agent management method for low-code design disclosed in an embodiment of the present invention. Figure 1 The described agent management method for low-code design can be applied to data processing systems / data processing devices / data processing servers (including local processing servers or cloud processing servers). Figure 1 As shown, the agent management method for low-code design may include the following operations:

[0075] 101. Obtain multiple historical code build records of the user in the low-code platform.

[0076] Optionally, the historical code construction record may include code generation logs, user operation sequences, code version history, or task metadata, which are not limited in this invention.

[0077] Optionally, the low-code platform can be a visual development platform, a drag-and-drop build platform, or an automated code generation platform; this invention does not limit the scope of the platform.

[0078] Optionally, the acquisition process can be implemented based on database queries, log extraction, user history records, or real-time capture, and this invention does not limit it.

[0079] 102. Based on the prediction model, determine the programming requirement parameters corresponding to each historical code build record.

[0080] Optionally, the prediction model can be a neural network model, a regression model, or a classification model; this invention does not impose any limitations.

[0081] Optionally, the programming requirements parameters may include requirement priority, functional module focus, performance requirements, or security constraints, which are not limited in this invention.

[0082] 103. Based on the programming requirements parameters, create the corresponding basic intelligent agent model.

[0083] Optionally, the basic intelligent agent model can be an agent model, a reinforcement learning model, or a multi-agent collaborative model; this invention does not impose any limitations.

[0084] Optionally, the creation process can be implemented based on model initialization, pre-training loading, or parameter configuration, and this invention does not limit it.

[0085] 104. Based on historical code construction records and corresponding programming requirement parameters, train the basic agent model to obtain a code-enhanced agent.

[0086] Optionally, code-enhancing agents are used to optimize the code generated by users operating on low-code platforms.

[0087] Optionally, the training process can be implemented based on reinforcement learning, multi-agent training, or supervised learning, and this invention does not limit it.

[0088] Optionally, the training process can be optimized by combining loss function design, iterative optimization, or data augmentation, and this invention does not limit it.

[0089] As can be seen, the above-described embodiments of the invention obtain the user's historical code building records in the low-code platform and determine the programming requirement parameters based on the prediction model, create a basic intelligent agent model, and obtain a code-enhanced intelligent agent through historical records and parameter training. This enables accurate intelligent agent training based on historical building and requirement analysis, improves the automation and accuracy of code optimization on the low-code platform, and reduces the risk of code errors caused by manual optimization.

[0090] As an optional embodiment, the historical code building record in the above steps includes code module drag-and-drop operations, code modification operations, code module association operations, text input operations, code module addition and deletion operations, and the final code.

[0091] As can be seen, the above optional embodiments limit the content of historical code build records to comprehensively characterize the features of historical code builds, assist in the accurate training of intelligent agents based on historical builds and requirements analysis, improve the automation and accuracy of code optimization on low-code platforms, and reduce the risk of code errors caused by manual optimization.

[0092] As an optional embodiment, the step above, determining the programming requirement parameters corresponding to each historical code build record based on the prediction model, includes:

[0093] For each historical code build record, filter out the data content of interest in that historical code build record;

[0094] The data of interest is input into the trained programming requirement prediction model to obtain the programming requirement parameters corresponding to the historical code build record; the programming requirement prediction model is trained on a training dataset that includes multiple trained low-code build records and corresponding programming requirement parameters.

[0095] Optionally, the data content of interest may include key code segments, user interaction data, or task metadata, and this invention does not impose any limitations.

[0096] Optionally, the screening process can be implemented based on data similarity analysis, repetition calculation, or feature extraction, and this invention does not limit it.

[0097] Optionally, the filtering of the data content to be focused on can be optimized by combining the record length or content complexity, and this invention does not limit it.

[0098] Optionally, the programming requirement prediction model can be a deep learning model, a natural language processing model, or a regression model; this invention does not limit it.

[0099] As can be seen, through the above optional embodiments, by filtering the data content of concern in the historical code construction record and inputting it into the programming requirement prediction model to determine the programming requirement parameters, accurate requirement parameter evaluation based on the extraction of the content of concern and model prediction is achieved, which improves the pertinence and efficiency of the code augmentation agent training and reduces the risk of requirement misjudgment caused by irrelevant data interference.

[0100] As an optional embodiment, the step above, filtering out the data of interest in the historical code build record, includes:

[0101] Calculate the average data similarity between each data part in the historical code construction record and each data part of each other historical code construction record to obtain the repetition parameter corresponding to each data part in the historical code construction record;

[0102] The data portion of the historical code build record with a duplication parameter less than a preset parameter threshold is selected to obtain the data content of interest in the historical code build record.

[0103] Optionally, the data similarity can be cosine similarity, Jaccard coefficient, Euclidean distance, or edit distance; this invention does not impose any limitations.

[0104] Optionally, the threshold parameter can be a fixed threshold, a dynamic threshold, or a threshold adjusted based on the record distribution; this invention does not impose any limitations.

[0105] As can be seen, through the above optional embodiments, by calculating the average similarity between the data part in the historical code construction record and the data part of other records as the repetition parameter and filtering the low repetition part as the data content of interest, the precise selection of the content of interest based on similarity analysis is achieved, which improves the accuracy and purity of the extraction of programming requirement parameters and reduces the risk of processing complexity caused by duplicate data redundancy.

[0106] As an optional embodiment, the programming requirement parameters in the above steps include programming scenario, programming target function, programming target environment, programming target application device parameters, and programming preference complexity.

[0107] As can be seen, the above optional embodiments define the content of programming requirement parameters to accurately characterize the features of user programming, assist in the accurate training of intelligent agents based on historical construction and requirement analysis, improve the automation and accuracy of code optimization on low-code platforms, and reduce the risk of code errors caused by manual optimization.

[0108] As an optional embodiment, the step above, creating the corresponding basic intelligent agent model according to the programming requirement parameters, includes:

[0109] For each pre-trained candidate agent model, obtain the training materials corresponding to that candidate agent model; optionally, the training materials include training code data and corresponding code optimization annotations and programming requirement annotations.

[0110] Calculate the parameter similarity between the programming requirement annotations and programming requirement parameters of the training materials;

[0111] Candidate agent models with parameter similarity greater than a preset similarity threshold are selected to obtain multiple preferred agent models;

[0112] The joint model of all preferred agent models is determined as the basic agent model.

[0113] Optionally, the candidate agent model can be an agent model, a reinforcement learning agent, or a multimodal agent; this invention does not impose any limitations.

[0114] Optionally, the training material can be code samples, optimization results, or requirement descriptions; this invention does not impose any limitations.

[0115] Optionally, the process of obtaining the candidate intelligent agent model can be based on model library query, training log extraction or data warehouse, and the present invention does not limit it.

[0116] Optionally, the similarity parameter can be cosine similarity, Euclidean distance, or Jaccard coefficient; this invention does not impose any limitation on it.

[0117] Optionally, the similarity threshold can be a fixed threshold, a dynamic threshold, or a threshold adjusted based on the complexity of the requirements; this invention does not impose any limitations.

[0118] Optionally, the joint model can be an integration model, a multi-agent collaboration model, or a fusion model; this invention does not impose any limitations.

[0119] Optionally, the determination process of the joint model can be based on model integration, parameter fusion, or architecture optimization, and this invention does not limit it.

[0120] As can be seen, through the above optional embodiments, by calculating the similarity between the programming requirement annotations of the candidate intelligent agent model training materials and the target programming requirement parameters, and selecting high similarity models to jointly form the basic intelligent agent model, accurate intelligent agent model selection based on material similarity can be achieved, improving the adaptability of the basic model and the quality of the training foundation, and reducing the risk of training ineffectiveness due to model mismatch.

[0121] As an optional embodiment, the step described above, training the basic agent model to obtain a code-enhanced agent based on historical code construction records and corresponding programming requirement parameters, includes:

[0122] All preferred agent models are shared to the same centralized value network; optionally, the centralized value network is used to guide the action network of each preferred agent model.

[0123] Determine the loss function corresponding to the centralized value network; optionally, the loss function is the weighted sum of the reinforcement learning loss functions corresponding to each preferred agent model; the computational weights of the reinforcement learning loss function are proportional to the parameter similarity of the corresponding preferred agent model;

[0124] Based on the multi-agent reinforcement learning algorithm and loss function, the joint model of all the preferred agent models is trained according to the historical code construction record and the corresponding programming requirement parameters to obtain the code-enhanced agent.

[0125] Optionally, the centralized value network can be a neural network value function, a state value model, or a Q-value model; this invention does not impose any limitations.

[0126] Optionally, this sharing process can be implemented based on parameter sharing, knowledge transfer, or model synchronization, and this invention does not limit it.

[0127] Optionally, the process by which the centralized value network guides the action network can be based on value assessment, action selection, or reward feedback, and this invention does not limit this.

[0128] Optionally, the reinforcement learning loss function can be either TD loss or policy gradient loss; this invention does not impose any limitations.

[0129] Optionally, the multi-agent reinforcement learning algorithm can be the MADDPG algorithm, the QMIX algorithm, or the VDN algorithm; this invention does not limit the specific algorithm.

[0130] Optionally, the training process can be based on environmental simulation, reward design, or exploration-utilization balance, and this invention does not limit it.

[0131] As can be seen, through the above optional embodiments, by sharing the preferred agent model to the centralized value network and training multiple agents based on the weighted reinforcement learning loss function to obtain the code-enhanced agent, accurate joint training based on shared network and similarity weighting is achieved, which improves the collaborative ability and generalization performance of the code-optimized agent and reduces the risk of incomplete optimization caused by the limitations of a single model.

[0132] As an optional embodiment, the method further includes the following steps:

[0133] Get the automatically generated code corresponding to the user's code build operations on the low-code platform;

[0134] The automatically generated code is input into each of the trained, best-performing agent models in the code-enhancing agent to obtain multiple code optimization operations;

[0135] Calculate the intersection of all code optimization operations to obtain the intersection optimization operations;

[0136] Perform an intersection optimization operation on the automatically generated code to obtain optimized code.

[0137] Optionally, the automatically generated code can be a code snippet, function module, or complete program generated by a low-code platform; this invention does not limit the scope of the code.

[0138] Optionally, this acquisition process can be implemented based on platform APIs, code monitoring, or user operation capture, and this invention does not limit it.

[0139] Optionally, the acquisition of the automatically generated code can be optimized in combination with the real-time nature of the operation or the completeness of the code, and this invention does not limit it.

[0140] Optionally, the code optimization operation may include code refactoring, performance optimization, bug fixing, or security enhancement operations, and this invention does not limit these operations.

[0141] Optionally, the intersection calculation can be implemented based on operation matching, set operations, or rule fusion, and this invention does not limit it.

[0142] Optionally, the execution of this intersection optimization operation can be based on a code editor, an automated script, or dynamic compilation; this invention does not impose any limitations on this.

[0143] As can be seen, through the above optional embodiments, by automatically generating code on the low-code platform, inputting the code into the code-enhancing agent, obtaining optimization operations from each preferred model, and executing the intersection to obtain optimized code, accurate code improvement based on multi-model intersection optimization is achieved, thereby improving the quality and reliability of low-code generated code and reducing the risk of code defects caused by a single optimization path.

[0144] Example 2

[0145] Please see Figure 2 , Figure 2 This is a schematic diagram of the structure of an intelligent agent management system for low-code design disclosed in an embodiment of the present invention. Figure 2 The described agent management system for low-code design can be applied to data processing systems / data processing devices / data processing servers (wherein, the server includes local processing servers or cloud processing servers). For example... Figure 2 As shown, the agent management system for low-code design may include:

[0146] Module 201 is used to retrieve multiple historical code build records of the user in the low-code platform.

[0147] The prediction module 202 is used to determine the programming requirement parameters corresponding to each historical code construction record based on the prediction model.

[0148] Create module 203 to create the corresponding basic intelligent agent model based on the programming requirements parameters.

[0149] Training module 204 is used to train the basic agent model based on historical code construction records and corresponding programming requirement parameters to obtain a code-enhanced agent.

[0150] Optionally, code-enhancing agents are used to optimize the code generated by users operating on low-code platforms.

[0151] As can be seen, the above-described embodiments of the invention obtain the user's historical code building records in the low-code platform and determine the programming requirement parameters based on the prediction model, create a basic intelligent agent model, and obtain a code-enhanced intelligent agent through historical records and parameter training. This enables accurate intelligent agent training based on historical building and requirement analysis, improves the automation and accuracy of code optimization on the low-code platform, and reduces the risk of code errors caused by manual optimization.

[0152] As an optional embodiment, the historical code build record includes code module drag-and-drop operations, code modification operations, code module association operations, text input operations, code module addition and deletion operations, and the final code.

[0153] As can be seen, the above optional embodiments limit the content of historical code build records to comprehensively characterize the features of historical code builds, assist in the accurate training of intelligent agents based on historical builds and requirements analysis, improve the automation and accuracy of code optimization on low-code platforms, and reduce the risk of code errors caused by manual optimization.

[0154] As an optional implementation, the prediction module determines the specific method for the programming requirement parameters corresponding to each historical code construction record based on the prediction model, including:

[0155] For each historical code build record, filter out the data content of interest in that historical code build record;

[0156] The data of interest is input into the trained programming requirement prediction model to obtain the programming requirement parameters corresponding to the historical code build record; the programming requirement prediction model is trained on a training dataset that includes multiple trained low-code build records and corresponding programming requirement parameters.

[0157] As can be seen, through the above optional embodiments, by filtering the data content of concern in the historical code construction record and inputting it into the programming requirement prediction model to determine the programming requirement parameters, accurate requirement parameter evaluation based on the extraction of the content of concern and model prediction is achieved, which improves the pertinence and efficiency of the code augmentation agent training and reduces the risk of requirement misjudgment caused by irrelevant data interference.

[0158] As an optional implementation, the prediction module may filter the relevant data content from the historical code build record in the following specific ways:

[0159] Calculate the average data similarity between each data part in the historical code construction record and each data part of each other historical code construction record to obtain the repetition parameter corresponding to each data part in the historical code construction record;

[0160] The data portion of the historical code build record with a duplication parameter less than a preset parameter threshold is selected to obtain the data content of interest in the historical code build record.

[0161] As can be seen, through the above optional embodiments, by calculating the average similarity between the data part in the historical code construction record and the data part of other records as the repetition parameter and filtering the low repetition part as the data content of interest, the precise selection of the content of interest based on similarity analysis is achieved, which improves the accuracy and purity of the extraction of programming requirement parameters and reduces the risk of processing complexity caused by duplicate data redundancy.

[0162] As an optional embodiment, the programming requirement parameters include the programming scenario, the programming target function, the programming target environment, the programming target application device parameters, and the programming preference complexity.

[0163] As can be seen, the above optional embodiments define the content of programming requirement parameters to accurately characterize the features of user programming, assist in the accurate training of intelligent agents based on historical construction and requirement analysis, improve the automation and accuracy of code optimization on low-code platforms, and reduce the risk of code errors caused by manual optimization.

[0164] As an optional implementation, the creation module creates the corresponding basic intelligent agent model according to the programming requirement parameters in the following ways:

[0165] For each pre-trained candidate agent model, obtain the training materials corresponding to that candidate agent model; optionally, the training materials include training code data and corresponding code optimization annotations and programming requirement annotations.

[0166] Calculate the parameter similarity between the programming requirement annotations and programming requirement parameters of the training materials;

[0167] Candidate agent models with parameter similarity greater than a preset similarity threshold are selected to obtain multiple preferred agent models;

[0168] The joint model of all preferred agent models is determined as the basic agent model.

[0169] As can be seen, through the above optional embodiments, by calculating the similarity between the programming requirement annotations of the candidate intelligent agent model training materials and the target programming requirement parameters, and selecting high similarity models to jointly form the basic intelligent agent model, accurate intelligent agent model selection based on material similarity can be achieved, improving the adaptability of the basic model and the quality of the training foundation, and reducing the risk of training ineffectiveness due to model mismatch.

[0170] As an optional implementation, the training module trains the basic agent model based on historical code construction records and corresponding programming requirement parameters to obtain a specific method for code-enhanced agents, including:

[0171] All preferred agent models are shared to the same centralized value network; optionally, the centralized value network is used to guide the action network of each preferred agent model.

[0172] Determine the loss function corresponding to the centralized value network; optionally, the loss function is the weighted sum of the reinforcement learning loss functions corresponding to each preferred agent model; the computational weights of the reinforcement learning loss function are proportional to the parameter similarity of the corresponding preferred agent model;

[0173] Based on the multi-agent reinforcement learning algorithm and loss function, the joint model of all the preferred agent models is trained according to the historical code construction record and the corresponding programming requirement parameters to obtain the code-enhanced agent.

[0174] As can be seen, through the above optional embodiments, by sharing the preferred agent model to the centralized value network and training multiple agents based on the weighted reinforcement learning loss function to obtain the code-enhanced agent, accurate joint training based on shared network and similarity weighting is achieved, which improves the collaborative ability and generalization performance of the code-optimized agent and reduces the risk of incomplete optimization caused by the limitations of a single model.

[0175] As an optional embodiment, the system is also used to perform the following steps:

[0176] Get the automatically generated code corresponding to the user's code build operations on the low-code platform;

[0177] The automatically generated code is input into each of the trained, best-performing agent models in the code-enhancing agent to obtain multiple code optimization operations;

[0178] Calculate the intersection of all code optimization operations to obtain the intersection optimization operations;

[0179] Perform an intersection optimization operation on the automatically generated code to obtain optimized code.

[0180] As can be seen, through the above optional embodiments, by automatically generating code on the low-code platform, inputting the code into the code-enhancing agent, obtaining optimization operations from each preferred model, and executing the intersection to obtain optimized code, accurate code improvement based on multi-model intersection optimization is achieved, thereby improving the quality and reliability of low-code generated code and reducing the risk of code defects caused by a single optimization path.

[0181] Example 3

[0182] Please see Figure 3 , Figure 3 This is another intelligent agent management system for low-code design disclosed in the embodiments of the present invention. Figure 3 The described agent management system for low-code design is applied in data processing systems / data processing devices / data processing servers (wherein, the server includes local processing servers or cloud processing servers). For example... Figure 3 As shown, the agent management system for low-code design may include:

[0183] Memory 301 storing executable program code;

[0184] Processor 302 coupled to memory 301;

[0185] The processor 302 calls the executable program code stored in the memory 301 to execute the steps of the agent management method for low-code design described in Embodiment 1.

[0186] Example 4

[0187] This invention discloses a computer read storage medium that stores a computer program for electronic data interchange, wherein the computer program causes a computer to execute the steps of the agent management method for low-code design described in Embodiment 1.

[0188] Example 5

[0189] This invention discloses a computer program product, which includes a non-transitory computer-readable storage medium storing a computer program operable to cause a computer to perform the steps of the agent management method for low-code design described in Embodiment 1.

[0190] The foregoing has described specific embodiments of this specification; other embodiments are within the scope of the appended claims. In some cases, the actions or steps described in the claims may be performed in a different order than those shown in the embodiments and may still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily have to follow the specific or sequential order shown to achieve the desired result. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0191] The systems, devices, modules, or units described in the above embodiments can be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, a computer can be, for example, a personal computer, laptop computer, cellular phone, camera phone, smartphone, personal digital assistant, media player, navigation device, email device, game console, tablet computer, wearable device, or any combination of these devices.

[0192] For ease of description, the above devices are described in terms of function, divided into various units. Of course, in implementing this specification, the functions of each unit can be implemented in one or more software and / or hardware components.

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

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

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

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

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

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

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

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

[0201] This specification can be described in the general context of computer-executable instructions that are executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform a specific task or implement a specific abstract data type. This specification can also be practiced in distributed computing environments, where tasks are performed by remote processing devices connected via a communication network. In distributed computing environments, program modules can reside in local and remote computer storage media, including storage devices.

[0202] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to interchangeably. Each embodiment focuses on describing the differences from other embodiments. In particular, the system embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions in the method embodiments.

[0203] Finally, it should be noted that the intelligent agent management method and system for low-code design disclosed in the embodiments of the present invention are merely preferred embodiments of the present invention and are only used to illustrate the technical solutions of the present invention, not to limit it. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

Claims

1. A method for managing intelligent agents in low-code design, characterized in that, The method includes: Retrieve multiple historical code build records of a user on a low-code platform; Based on the prediction model, the programming requirement parameters corresponding to each historical code construction record are determined, including: For each of the historical code construction records, calculate the average data similarity between each data part in the historical code construction record and each data part of each other historical code construction record to obtain the repetition parameter corresponding to each data part in the historical code construction record; The data portion in the historical code construction record where the repetition parameter is less than a preset parameter threshold is selected to obtain the data content of interest in the historical code construction record; The data of interest is input into the trained programming requirement prediction model to obtain the programming requirement parameters corresponding to the historical code build record; the programming requirement prediction model is trained on a training dataset that includes multiple training low-code build records and corresponding programming requirement parameters. Based on the programming requirements parameters, a corresponding basic intelligent agent model is created, including: For each pre-trained candidate agent model, obtain the training materials corresponding to that candidate agent model; the training materials include training code data and corresponding code optimization annotations and programming requirement annotations. Calculate the parameter similarity between the programming requirement annotations of the training materials and the programming requirement parameters; Candidate agent models whose parameter similarity is greater than a preset similarity threshold are selected to obtain multiple preferred agent models; The joint model of all the preferred agent models is determined as the basic agent model; Based on the historical code construction records and the corresponding programming requirement parameters, the basic agent model is trained to obtain a code-enhancing agent; the code-enhancing agent is used to optimize the code generated by the user operating on the low-code platform, and the method further includes: Obtain the automatically generated code generated by the user's code build operation on the low-code platform; The automatically generated code is input into each of the trained preferred agent models in the code enhancement agent to obtain multiple code optimization operations; Calculate the intersection of all the code optimization operations to obtain the intersection optimization operations; The intersection optimization operation is performed on the automatically generated code to obtain optimized code.

2. The agent management method for low-code design according to claim 1, characterized in that, The historical code construction record includes code module drag-and-drop operations, code modification operations, code module association operations, text input operations, code module addition and deletion operations, and the final code.

3. The agent management method for low-code design according to claim 1, characterized in that, The programming requirements parameters include the programming scenario, the target programming function, the target programming environment, the target application device parameters, and the programming preference complexity.

4. The agent management method for low-code design according to claim 1, characterized in that, The step of training the basic agent model to obtain a code-enhanced agent based on the historical code construction record and the corresponding programming requirement parameters includes: All the preferred agent models are shared to the same centralized value network; the centralized value network is used to guide the action network of each preferred agent model. The loss function corresponding to the centralized value network is determined; the loss function is obtained by weighted summation of the reinforcement learning loss functions corresponding to each preferred agent model; the computational weights of the reinforcement learning loss function are proportional to the parameter similarity of the corresponding preferred agent model. Based on the multi-agent reinforcement learning algorithm and the loss function, the joint model of all the preferred agent models is trained according to the historical code construction record and the corresponding programming requirement parameters to obtain the code-enhancing agent.

5. An agent management system for low-code design, characterized in that, The system is used to execute the agent management method for low-code design as described in any one of claims 1-4, the system comprising: The acquisition module is used to retrieve multiple historical code build records of a user in a low-code platform; The prediction module is used to determine the programming requirement parameters corresponding to each historical code construction record based on the prediction model. A module is created to generate a corresponding basic intelligent agent model based on the programming requirements parameters. The training module is used to train the basic agent model based on the historical code construction record and the corresponding programming requirement parameters to obtain a code-enhanced agent; the code-enhanced agent is used to optimize the code generated by the user's operation on the low-code platform.

6. An agent management system for low-code design, characterized in that, The system includes: Memory containing executable program code; A processor coupled to the memory; The processor calls the executable program code stored in the memory to execute the agent management method for low-code design as described in any one of claims 1-4.

Images