Automatic component arrangement and intelligent generation method based on multi-agent cooperation

Abstract

The invention belongs to the technical field of artificial intelligence, and discloses an automatic component arrangement and intelligent generation method based on multi-agent collaboration, which comprises the following steps of: finishing an automatic development task of a software system through interaction and collaboration among agents by adopting a multi-agent collaboration framework. According to the method, the pre-training model and the multi-agent system are utilized to automatically complete component selection, arrangement and intelligent generation in a complex application scene, and the method is suitable for multiple fields of industrial control, production scheduling, intelligent monitoring, medical informatization and the like.

Description

Technical Field

[0001] The present invention belongs to the technical field of artificial intelligence, and particularly relates to an automated component orchestration and intelligent generation method based on multi-agent collaboration. Background Art

[0002] With the rapid development of artificial intelligence technology, software automatic generation has gradually become an important research direction for improving development efficiency and reducing development costs. The traditional software development process usually relies on developers to manually write code, design system architectures, and implement business logics. Although this method can provide high flexibility, in the face of complex requirements, there are often problems such as low efficiency and long development cycles. Especially in an environment where requirements change frequently, the workload of developers increases significantly, resulting in an extended development cycle.

[0003] Automated software generation technology can, to a certain extent, automate code generation, function implementation, and page design by leveraging technologies such as artificial intelligence, big data, and machine learning, greatly reducing the workload of developers. The goal of this automated technology is to help developers complete system design, function implementation, and integration through intelligent methods, and even automatically generate development-related content such as interface documents and test cases, thereby shortening the development cycle and improving development efficiency. However, the existing automatic generation technologies still have the following problems in practical applications:

[0004] 1. Heavy burden of manual implementation for complex requirements

[0005] In the face of complex business requirements, existing automated tools are still difficult to fully replace the manual configuration and development of developers. In many cases, developers need to manually select components, configure attributes, write functions, and perform system integration, which places high demands on the workload of developers. Especially in projects that require rapid delivery, the development process is often not efficient enough.

[0006] 2. Lack of intelligent recommendation and optimization capabilities

[0007] Although automated tools can reduce some manual work, existing technologies often have difficulty in intelligently recommending suitable components or automatically generating functional logics that meet requirements. Especially in complex application scenarios, developers still need to manually complete most of the configuration and integration work.

[0008] 3. Challenges in function integration

[0009] In complex systems, the selection of data sources and the integration of functions often require a large amount of manual coding, and the existing technologies still lack sufficient support in aspects such as intelligent data binding and logic integration. In many cases, developers must manually write the interaction logic with data sources, which is not only time-consuming but also prone to errors.

[0010] 4. Limited capabilities in document and test automation

[0011] Most existing automation technologies are limited to code generation and lack support for automatic generation of documents and test cases. Developers still need to manually write interface documents, functional documents, and test cases, which increases the burden of development and maintenance.

[0012] 5. Flexibility and scalability issues in specific domains

[0013] Existing automatic generation tools usually cannot well adapt to the customized requirements of specific industries. Especially in projects that require frequent adjustment and expansion, developers still need to perform a large amount of manual intervention to meet specific functional requirements and business logics.

[0014] However, with the development of artificial intelligence technologies, especially large language models (LLMs) in recent years, new possibilities have been brought to software automatic construction. LLMs can achieve natural language understanding and semantic generation, providing the following core capabilities in this field:

[0015] 1. Semantic analysis and component recommendation

[0016] LLMs can extract key information from user requirements and automatically recommend suitable component combinations by combining component library and template information. For example, the research by Gillioz et al. shows that the excellent performance of the Transformer model in natural language processing can support semantic matching and classification of components.

[0017] 2. Document generation and knowledge extraction

[0018] Through the context awareness ability of large models, interface documents, test cases, etc. can be automatically generated, significantly reducing the workload of manual participation.

[0019] 3. Potential of multi-agent systems

[0020] Multi-agent systems (MAS) show great potential in development due to their task decomposition and collaboration capabilities. MAS can effectively handle complex tasks through the division of labor and cooperation of multiple autonomous agents.

[0021] 4. Automatic component selection and orchestration

[0022] Agents can decompose tasks based on requirements and complete tasks such as component selection and layout optimization through collaboration to ensure that the generated pages meet business requirements.

[0023] 5. Coverage of the entire development process

[0024] Through the task coordination agent, agents in each development stage work together to complete the full - process automation from requirements analysis to the generation of delivery documents.

[0025] To solve these problems, the present invention proposes an automated component orchestration and intelligent generation method and system based on multi - agent collaboration. Summary of the Invention

[0026] To solve the problems existing in the prior art, the present invention provides an automated component orchestration and intelligent generation method based on multi - agent collaboration. By using a pre - trained model and a multi - agent system, it automatically completes component selection, orchestration, and intelligent generation in complex application scenarios, and is applicable to multiple fields such as industrial control, production scheduling, intelligent monitoring, and medical informatization.

[0027] To achieve the above object, the present invention provides the following solutions:

[0028] An automated component orchestration and intelligent generation method based on multi - agent collaboration, the method comprising:

[0029] Adopt a multi - agent collaboration framework, and through the interaction and collaboration between agents, complete the automated development tasks of the software system.

[0030] Preferably, the concepts related to task modeling include: project, document model, component library, page model, node model, setter, attribute, style, event, data source, function;

[0031] Among them, the project is a Project instance created for each development task;

[0032] The document model is used to describe the description information, usage instructions, and configuration documents of each page under the project, and at the same time describe the relationships between each page;

[0033] The component library is a list of components that can be automatically generated, composed of components produced in a visual way;

[0034] The page model contains a tree composed of a group of components. Each document model corresponds to a root node and multiple component nodes, and is used to describe the page structure of the selected components in the page;

[0035] The node model is used to describe the relevant attributes of the selected components;

[0036] The setter is used for the system to set optional setter attributes for components before each component definition, and can provide large - model automatic configuration and user editing, including attributes, styles, and events;

[0037] The attribute is used to display the general attributes of the component;

[0038] The said style is used to display the attributes of the component style;

[0039] The said event is used to display an event panel for binding events if the component has declared events;

[0040] The said data source is used for the backend data source bound by the component;

[0041] The said function is used for the code to be written to complete the component events.

[0042] Preferably, the intelligent agents include: product manager intelligent agent, project supervisor intelligent agent, front-end design intelligent agent, interface design intelligent agent, function implementation intelligent agent, page generation intelligent agent, task coordination intelligent agent, quality inspection intelligent agent, delivery intelligent agent;

[0043] Among them, the product manager intelligent agent is used to be responsible for interacting with users, collecting requirements, and formulating a preliminary task list according to user requirements;

[0044] The project supervisor intelligent agent is used to extract specific development tasks from the requirements collected by the product manager intelligent agent, and coordinate with other intelligent agents to assign the priorities and sequences of development tasks;

[0045] The front-end design intelligent agent is used to select components that meet preset requirements according to the task list, design the page layout, and define the page style and structure;

[0046] The interface design intelligent agent is used to be responsible for designing the data binding interface with the page components to ensure the functional consistency between the interface and the page components;

[0047] The function implementation intelligent agent is used to automatically generate function implementation code according to the interface document and implement the page functions;

[0048] The page generation intelligent agent is used to automatically generate page-related files and component registration codes after the functions are implemented, ensure that the development results meet the technical requirements, and can be integrated with other system modules;

[0049] The task coordination intelligent agent is used to be responsible for coordinating the results of different development stages to ensure the consistency and integrity of the outputs of various tasks;

[0050] The quality inspection intelligent agent is used to inspect the generated pages, codes, interfaces, and documents to ensure that they meet the quality standards and platform requirements;

[0051] The delivery intelligent agent is used to be responsible for organizing the final development results into deliverable documents and codes and preparing for online delivery.

[0052] Preferably, the construction method of the multi-intelligent agent collaboration framework includes:

[0053] In the system startup phase, demand-related multi-agent collaboration collects user requirements and converts them into a series of executable development tasks. Among them, the development tasks include page design, function implementation, and data interface design. Among them, the core of the task management module is to generate a clear task list and adjust it according to the project progress and development priorities;

[0054] In the task decomposition phase, the agent further decomposes the user requirements into specific development tasks, arranges the development cycle and priorities to ensure that the development tasks are completed on time and with high quality. Among them, the task list is managed in an agile development manner, and the tasks are developed in batches in an iterative manner. Task evaluation, development implementation, and acceptance are carried out in each iteration cycle.

[0055] Preferably, the interaction and collaboration between agents include: user requirement collection and task planning phase, development execution and agent collaboration phase, task coordination and quality inspection phase, and delivery online and feedback optimization phase.

[0056] Preferably, the user requirement collection and task planning phase includes: the product manager agent and the project supervisor agent jointly complete requirement collection and analysis;

[0057] Among them, the product manager agent collects requirements from users and extracts the core functions, and after ensuring accurate understanding, hands them over to the project supervisor agent;

[0058] The project supervisor agent converts the requirements into specific development tasks according to the collected requirements, at the same time refines the requirements into specific subtasks, and sorts the tasks according to the development priorities and urgency.

[0059] Preferably, the development execution and agent collaboration phase includes: after completing the task decomposition, each page will automatically complete page development. The specific development stages are divided into front-end design, back-end design, and system implementation stages according to the implemented functions;

[0060] Among them, in the front-end design stage, the front-end design agent automatically selects platform components according to the task list, conducts page layout design and style definition, and all designs are optimized and adjusted according to the requirement document and user feedback to ensure compliance with the user's usage scenario. After the design is completed, the function implementation agent automatically generates function code according to the interface design and front-end layout to implement the page function;

[0061] In the back-end design stage, the interface design agent generates data interfaces according to the page design requirements of the front-end design agent, and ensures that the data transmission format matches the back-end structure. The agent can connect the front-end page with the back-end interface, generate complete function code, and automatically process the interaction logic of page components to ensure that the function implementation meets the design requirements;

[0062] In the system implementation phase, the application generation agent automatically generates page-related Schema files and component registration codes based on the development results to ensure that the development results are compatible with the platform's template files. The documentation and testing agents are responsible for generating the documents and test cases required during the development process, including interface documents and functional test cases, and automatically testing the page functions to ensure the quality of the development results.

[0063] Preferably, the task coordination and quality inspection phase includes:

[0064] Throughout the entire process of system development, the task coordination agent continuously tracks the progress of each development task, coordinates the work of each module to ensure that there are no missing or conflicting parts, and this agent is also responsible for resolving task conflicts and inconsistencies that occur during the development process;

[0065] The quality inspection agent checks the code, functions, and interfaces of the system modules at the end of each phase or when each agent has a clear output to ensure that they meet the platform's quality standards. After passing the inspection, the relevant modules are handed over to the delivery agent for integration and final delivery.

[0066] Preferably, the delivery, online deployment, and feedback optimization phase includes:

[0067] After all modules are completed, the delivery agent is responsible for integrating the final development results and preparing for online delivery. During the delivery process, the agent aggregates all development documents, test reports, and functional codes, and makes final adjustments based on feedback. The system supports continuous delivery to ensure that the development results can be delivered to users in a timely manner.

[0068] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0069] By constructing a software automatic orchestration system based on multi-agents, the present invention realizes the efficient transformation of user requirements into product prototype development, and takes the generation of a multi-page industrial software system that can run, be re-developed, and be customized as the core driving force. The present invention achieves the following technical effects:

[0070] 1. Significantly improve development efficiency: Through the collaboration of multi-agents, the development process of complex pages and functions is automatically completed.

[0071] 2. Automatically generate high-quality documents: Output complete interface documents and page files.

[0072] 3. Generalizability and modularity: Meet the application requirements of different industries and provide intelligent support for low-code development.

[0073] The present invention effectively improves the intelligence and automation levels in the field of software automatic generation, and provides an efficient and accurate solution for the digital management of complex business requirements. Brief Description of the Drawings

[0074] To more clearly illustrate the technical solutions of the present invention, the drawings required for use in the embodiments will be briefly introduced below. Obviously, the drawings in the following description are only some embodiments of the present invention. For those of ordinary skill in the art, without creative efforts, other drawings can be obtained based on these drawings.

[0075] Figure 1 It is a schematic flowchart of a method for automatic component orchestration and intelligent generation based on multi-agent collaboration according to an embodiment of the present invention. Detailed Embodiments

[0076] Next, the technical solutions in the embodiments of the present invention will be clearly and completely described in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are only some embodiments of the present invention, rather than all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts belong to the scope of protection of the present invention.

[0077] To make the above objects, features, and advantages of the present invention more obvious and understandable, the present invention will be further described in detail below in conjunction with the drawings and specific embodiments.

[0078] Embodiment 1

[0079] The present invention designs an automatic orchestration and application intelligent generation method based on multi-agent collaboration, aiming to combine the advantages of large models, and complete the selection, orchestration, and optimization of automated processing components based on multi-agents to achieve the following goals:

[0080] Intelligent automatic orchestration: Through a multi-agent system, combined with the reasoning ability of large models, automatically complete the selection and orchestration of components in complex task scenarios to adapt to diverse business needs.

[0081] Improve development efficiency and accuracy: Reduce manual intervention, automatically generate application configurations that meet requirements, improve development efficiency, and ensure the accuracy and consistency of the system at the same time.

[0082] Intelligent generation of application functions: Through intelligent generation technology, achieve rapid construction and optimization of complex application functions to adapt to the special needs of different industries.

[0083] Cross-domain adaptability: The tool is applicable to applications in various industries, provides customized intelligent support, and meets the specific needs of different industries.

[0084] An embodiment of the present invention discloses an automated component orchestration and intelligent generation method based on multi-agent collaboration. Using a multi-agent collaboration framework, through the interaction and collaboration between agents, the automated development tasks of software systems are completed. The system design scheme mainly revolves around the following core concepts: overall framework design, system process description, and system detailed design.

[0085] In this embodiment, the overall framework design includes: concepts related to development task modeling, agent roles and collaboration, and agent collaboration framework.

[0086] Specifically, concepts related to development task modeling:

[0087] To better assist the large model in understanding the relevant processes of software development and reduce development contradictions caused by unclear definitions, the system redefines traditional web page development as follows, and its related concepts are as follows:

[0088] Project: A Project instance created for each development task.

[0089] DocumentModel: Describes the description information, usage instructions, configuration documents, etc. of each page under the project, and at the same time describes the relationships between pages.

[0090] Component library: A list of components that can be automatically generated, composed of components produced in a visual manner.

[0091] PageModel: The page model contains a tree composed of a group of components, similar to the DOM. Each document model corresponds to a root node and multiple component nodes, and is used to describe the page structure of the selected components on the page.

[0092] Node: Describes the relevant attributes of the selected component.

[0093] Setter: The system sets optional setter attributes for each component definition before it, which can provide automatic configuration by the large model and user editing, including attributes, styles, and events.

[0094] Attribute: Displays the general attributes of this component.

[0095] Style: Displays the style attributes of this component.

[0096] Event: If this component has declared events, an event panel will appear for binding events.

[0097] Data source: The backend data source bound by the component.

[0098] Function: The code to be written to complete the component event.

[0099] These concepts are closely related in the software development process. A project is the carrier of the entire development task. The document model provides descriptions and relationship explanations for each page of the project, assisting developers in understanding the project structure. The component library provides building components for the page model. The page model defines component-related attributes through the node model, and the setter configures the component attributes. Attributes, styles, and events determine the display and interaction characteristics of the component. The data source provides data support for the component, and the function implements the specific event logic of the component, jointly constituting a complete system of basic elements for software development.

[0100] Specifically, the roles and collaboration of agents:

[0101] To simulate real business scenarios, the system designs the following AI Agents based on the actual process requirements of software development. Each agent collaborates through interaction to jointly complete the software development task to support the automatic construction of industrial software for complex application scenarios. For this purpose, we have set the following agents:

[0102] Product Manager Agent: Responsible for interacting with users, collecting requirements, and formulating a preliminary task list according to user requirements. This agent provides the ability for user requirement analysis and function planning and is the starting point for system collaboration.

[0103] Project Supervisor Agent: Extracts specific development tasks from the requirements collected by the product manager and coordinates with other agents to assign the priorities and sequences of development tasks. The project supervisor agent is also a key role in coordinating the entire development process.

[0104] Front-end Design Agent: According to the task list, selects suitable components, designs the page layout, and defines the page style and structure. Through collaboration with the project supervisor and product manager, this agent ensures that the page design meets user requirements and enables rapid implementation by providing a component library.

[0105] Interface Design Agent: Responsible for designing the data binding interfaces for page components to ensure the functional consistency between the interfaces and page components. This agent automatically generates API interface documents to ensure the accuracy and efficiency of data transmission and processing.

[0106] Function Implementation Agent: Automatically generates function implementation code according to the interface document and implements the page functions. These codes will seamlessly connect with the results generated by the front-end design and interface design agents.

[0107] Page Generation Agent: After the function is implemented, it automatically generates page-related files and component registration codes to ensure that the development results meet the technical requirements and can be integrated with other system modules.

[0108] Task Coordination Agent: Responsible for coordinating the results of different development stages to ensure the consistency and integrity of the outputs of various tasks. This agent can detect conflicts in the development process and provide solutions to avoid inconsistencies during development.

[0109] Quality Inspection Agent: Inspects the generated pages, code, interfaces, documents, etc. to ensure they meet quality standards and platform requirements. The Quality Inspection Agent is also responsible for generating test cases and verifying code functionality.

[0110] Delivery Agent: Responsible for organizing the final development results into deliverable documents and code and preparing for online delivery. The Delivery Agent integrates the outputs of all modules and performs a final check before delivery.

[0111] Specifically, the Agent Collaboration Framework:

[0112] The agent collaboration framework of the present invention takes task-driven and modular collaboration as the core design concept. Each agent is responsible for a specific task, and agents promote the development process of the system through "task collaboration" and "information sharing".

[0113] In the system startup phase, multiple agents related to requirements collaborate to collect user requirements and transform them into a series of executable development tasks. The tasks include page design, function implementation, data interface design, etc. The core of the task management module is to generate a clear task list and adjust it according to the project progress and development priorities.

[0114] In the task decomposition phase, the agents further decompose the user requirements into specific development tasks, arrange the development cycle and priorities to ensure that the development tasks can be completed on time and with quality. The task list is managed in an agile development manner, and tasks are developed in batches in an iterative manner. Task evaluation, development implementation, and acceptance are carried out in each iteration cycle.

[0115] During the operation of the entire system, agents collaborate through message passing and data sharing.

[0116] Specifically:

[0117] 1. Each agent can feedback the progress status of the current task through the task management module in the system. For example, after the front-end design agent completes the page layout, it will notify the task coordination agent and the project supervisor agent in order to adjust subsequent tasks in a timely manner.

[0118] 2. The information sharing between agents is two-way. For example, the interface design agent can modify the return structure of the API interface according to the page design of the front-end design agent, and the front-end agent will feedback on how to adjust the data binding structure of the components. Each agent has the ability to feedback updated task information according to requirements, ensuring the close cooperation of all modules within the system.

[0119] 3. If any conflicts or inconsistencies occur during the development process (such as interface mismatches, component conflicts, etc.), the task coordination agent will automatically detect them and propose solutions. Through continuous collaboration and feedback between agents, seamless docking and continuous optimization of system tasks are achieved.

[0120] In this embodiment, the system process is described as follows:

[0121] The system ensures that development tasks can be efficiently and accurately achieved through the collaborative work of multiple agents. The complete system process is as Figure 1 shown.

[0122] As Figure 1 shown, the system includes 4 stages during operation: the user requirement collection and task planning stage, the development execution and agent collaboration stage, the task coordination and quality inspection stage, and the delivery and online feedback optimization stage.

[0123] 1. User Requirement Collection and Task Planning

[0124] The product manager agent and the project supervisor agent jointly complete requirement collection and analysis. The product manager agent collects requirements from users and extracts the core functions, and after ensuring accurate understanding, hands them over to the project supervisor agent.

[0125] The project supervisor agent transforms the collected requirements into specific development tasks according to the requirements. These tasks include page design, function implementation, interface definition, etc. At the same time, the requirements are refined into specific subtasks, and the tasks are sorted according to the development priority and urgency.

[0126] 2. Development Execution and Agent Collaboration

[0127] After the task decomposition is completed, each page will automatically complete page development according to the following process. The specific development stages can be divided into front-end design, back-end design, system implementation, etc. according to the functions they implement.

[0128] In the front-end design phase, the front-end design agent automatically selects platform components according to the task list, conducts page layout design and style definition, and optimizes all designs based on the requirements document and user feedback to ensure compliance with the user's usage scenario. Here, a component selection algorithm is introduced to assist the large model in making selections. Let the function matching degree of the component be M, the usage frequency be F, and the development difficulty be D. The component applicability S is calculated through the formula S = δM + ∈F + ζD1, where δ, ∈, and ζ are weight coefficients set according to project requirements, so as to more reasonably select components that meet the requirements. After the design is completed, the function implementation agent automatically generates function code according to the interface design and front-end layout to implement the page function;

[0129] In the back-end design phase, the interface design agent generates data interfaces according to the page design requirements of the front-end design agent and ensures that the data transmission format matches the back-end structure. The function implementation agent docks the front-end page with the back-end interface, generates complete function code, and automatically processes the interaction logic of page components to ensure that the implementation of the function meets the design requirements.

[0130] In the system implementation phase, the application generation agent automatically generates Schema files, component registration codes, etc. related to the page according to the development results to ensure that the development results are compatible with the template files of the platform. The documentation and testing agent is responsible for generating the documentation and test cases required during the development process, including interface documentation, function test cases, etc., and automatically tests the page function to ensure the quality of the development results.

[0131] 3. Task Coordination and Quality Inspection Phase

[0132] Throughout the entire process of system development, the task coordination agent continuously tracks the progress of each development task, coordinates the work of each module to ensure that there are no omitted or conflicting parts. This agent is also responsible for resolving task conflicts and inconsistencies that occur during the development process. The quality inspection agent checks the code, functions, interfaces, etc. of the system modules at the end of each stage or when each agent has a clear output to ensure that they meet the quality standards of the platform. After passing the inspection, the relevant modules are handed over to the delivery agent for integration and final delivery.

[0133] 4. Delivery, Go-live, and Feedback Optimization Phase

[0134] After all modules are completed, the delivery agent is responsible for integrating the final development results and preparing for go-live delivery. During the delivery process, the agent aggregates all development documents, test reports, function codes, etc. and makes final adjustments based on the feedback. The system supports continuous delivery to ensure that the development results can be delivered to users in a timely manner.

[0135] In this embodiment, the intelligent agent collaboration method includes:

[0136] Let the set of agents be \(A = \{a_1, a_2, \ldots, a n \}\), and the state \(s i (t)\) of each agent \(a i \) at time \(t\) is a tuple, which can be expressed as \(s i (t)=(c i (t), k i (t), r i (t), p i (t))\), where:

[0137] c i (t)\) represents the current task context of agent \(a i \) at time \(t\), which is a vector containing information such as task descriptions and related constraints. For example, for a front - end design agent, it may include page layout requirements, style preferences, etc.

[0138] k i (t)\) is the knowledge reserve of agent \(a i \) at time \(t\), stored in the form of documents, including relevant information during the current task process and, in some cases, the external knowledge bases of certain agents.

[0139] r i (t)\) represents the resources available to agent \(a i \) at time \(t\), such as computing resources, memory, time, etc., and is a resource vector.

[0140] p i (t)\) is the task progress of agent \(a i \) at time \(t\), which is a real number in the range \([0, 1]\), representing the proportion of the task completed.

[0141] Each agent \(a i \) also has an ability vector \(C i =(c i1 , c i2 , \ldots, c im )\), where \(c ij \) represents the score of agent \(a i \) in the \(j\) - th ability. For example, for a front - end design agent, it may include component design ability, layout design ability, etc.

[0142] Let the set of tasks be \(T=\{t_1, t_2, \ldots, t l \}\), and each task \(t j \) can be represented by a triple \(t j =(d j , r j , g j )\), where:

[0143] dj is the requirement description of task t j , represented in natural language or structured form. For example, a page design task may be described as "Design a login page with a responsive layout".

[0144] r j is the resource required to complete task t j , which is a resource vector and consistent with the resource representation form of the agent.

[0145] g j is the goal of task t j , such as completion time requirements, quality standards, etc.

[0146] The task decomposition process can be represented by a directed acyclic graph G T =(V T , E T ), where V T is the set of task nodes, and E T is the set of edges, representing the dependency relationships between tasks. For example, the front-end page design task may depend on the completion of the requirements analysis task.

[0147] The collaboration between agents is achieved through message passing. Let the message sent by agent a i to agent a k at time t be m ik (t). The message can be a task request, result feedback, knowledge sharing, etc., and is represented by a five-tuple m ik (t)=(s m , r m , c m , t m , p m ), where:

[0148] s m is the sender of the message, i.e., a i .

[0149] r m is the receiver of the message, i.e., a k .

[0150] c m is the content of the message, such as task description, result report, etc.

[0151] t m is the sending time of the message, i.e., t.

[0152] p m is the priority of the message.

[0153] When agent a i receives the message m ikAfter (t), its state update rule is:

[0154] s i (t + 1) = Update(s i (t), m ik (t))

[0155] Among them, the Update function updates the agent's state according to the message content and the agent's rules. For example, if a task request message is received, the agent may update its current task context and resource status.

[0156] In the agent dialogue design, let the instructor be I, the assistant be A, and the message flow S t = ((i1, a1), (i2, a2), …, (i t , a t )) represents all the exchanged messages up to time step t. At time step t + 1, the instructor evaluates the consistency of a t with the instruction and then sends i t . After the assistant receives i t+1 , it generates a t+1 . The processes of the instructor and the assistant generating messages can be represented by functions f and g: t+1 .

[0157] i t+1 = f(S t )

[0158] a t+1 = g(i t+1 , S t )

[0159] When a t+1 meets the termination condition or the interaction reaches the predefined exchange limit, the dialogue ends and the current task is completed.

[0160] In this embodiment, the system detailed design:

[0161] Specifically, the preparatory stage: task decomposition and goal clarification

[0162] Goal: Through the dialogue interaction between the "Product Manager" agent and the "Project Supervisor" agent, clarify the system requirements and generate a complete development task list.

[0163] Specific steps:

[0164] 1. The Product Manager agent interacts with the user to collect requirement information, including page planning, data binding requirements, interaction functions, etc.

[0165] 2. The project supervisor agent decomposes the system functions into specific tasks (such as page design, function development, data docking, etc.) according to the requirements, and generates a detailed task list (Task Backlog).

[0166] Key conversation content and examples:

[0167] "Product Manager: It is necessary to build an industrial equipment monitoring page, including equipment status and fault alarm functions.

[0168] Project Supervisor: We can split the requirements into two page tasks: status monitoring and alarm display. At the same time, define the data source and interface requirements."

[0169] Output example:

[0170]

[0171]

[0172] Overall process:

[0173] 1. The user enters the requirements.

[0174] 2. The product manager agent interacts with the user to clarify the requirements.

[0175] 3. The project supervisor agent decomposes the requirements into a task list.

[0176] 4. Output a complete task list and prepare to enter the iterative development stage.

[0177] 2.3.2. Iterative development stage: Implement the pages one by one according to the task list

[0178] The development process of each page is completed by different agents working together, and the agents continuously promote the development process through conversations.

[0179] (1) Conversation between the product manager and the front-end design agent

[0180] Goal: Clarify the page layout structure, component usage, and style design, and select the optimal solution from the fixed component library and layout templates at the same time.

[0181] Conversation example:

[0182] "Product Manager: The page needs to display a line chart of the equipment operation status, as well as display modules for machine tool and order alarm information. At the same time, combined with the function requirements in the list of characters, add button components at the appropriate position in the module to support related functions

[0183] Front-end Design Agent: According to the component library of the platform, it is recommended to use a line chart component and an alarm light component, adopt a three-column layout template, and the color style is mainly blue. The buttons are styled according to Template 1.

[0184] Output example: Page Component List

[0185]

[0186]

[0187] Next, complete the templated schema code for the attributes of each selected component based on the page component list.

[0188] (2) Conversation between Front-end Design Agent and Task Coordination Agent

[0189] Goal: Through the conversation between the front-end design agent and the task coordination agent, ensure that the page layout, style, and component selection meet the requirements, and obtain the review and confirmation of the task coordination agent.

[0190] Conversation example:

[0191] "Front-end Design Agent: Selected a line chart component and a status indicator component for the device monitoring page, and adopted a three-column layout template."

[0192] Task Coordination Agent: "Please confirm whether the layout and components meet the platform's standard template. It is recommended to modify the size of the components to meet the device display requirements."

[0193] Front-end Design Agent: "Okay, the component sizes have been adjusted and the layout has been optimized."

[0194] (3) Conversation between Product Manager and Interface Design Agent

[0195] Goal: Complete the function definition and data binding of the page.

[0196] Conversation example:

[0197] "Product Manager: An API is needed to return the historical data of the device status for display in the line chart.

[0198] Interface Design Agent: Define the interface / api / data, support filtering by time range, and return the temperature and pressure of the device."

[0199] Output: Interface Documentation

[0200] (3) Conversation between Interface and Function Implementation Agent and Task Coordination Agent

[0201] Objective: According to the page design, the interface and function implementation agent is responsible for generating the backend interface code and communicating with the task coordination agent to ensure that the code complies with the platform rules.

[0202] Dialogue example:

[0203] "Interface and function implementation agent: According to the page requirements, an / api / data interface needs to be implemented to obtain device status data and return it in JSON format.

[0204] Task coordination agent: Please ensure that the response format of the interface complies with the platform's data specifications, and the interface should have pagination and filtering functions to support subsequent expansion requirements.

[0205] Interface and function implementation agent: The interface code has been modified to add pagination and filtering parameters."

[0206] (4) Application generation agent and task coordination agent

[0207] Objective: Generate page files that comply with the rules based on the generated page components and interfaces.

[0208] Dialogue example:

[0209] "Schema generation agent: "The page components have been selected, and now a Schema file needs to be generated to describe the attributes and data sources of each component."

[0210] Quality inspection agent: "Please ensure that the generated page complies with the component registration rules, and the props of the components should strictly match the data sources called by the interfaces."

[0211] Page generation agent: "Okay, I will generate the page files that meet the requirements according to the rules."

[0212] Quality inspection agent: "Please confirm that the attributes of the components in the page are consistent with the interface data sources, and check whether the parameters of the layout template meet the standards."

[0213] Page generation agent: "It has been checked and adjusted to ensure compliance."”

[0214] Specifically, in the summary stage: Document and deliverable generation

[0215] After all page tasks are completed, the system will automatically summarize the results, generate documents and code, and prepare to deliver them to users or teams.

[0216] Objective: Integrate the results of each agent to generate the final page code, interface documents, test cases, etc., and ensure that the delivery is complete and meets the requirements.

[0217] Dialogue example:

[0218] "Task Coordination Agent: "All tasks are completed. Please confirm whether the pages, interfaces, page files, and documents meet the requirements."

[0219] Product Manager: "Confirmed. Generate the final delivery document."

[0220] Task Coordination Agent: "The delivery document has been generated, including the interface document, page file, test cases, and code."

[0221] Through the collaboration and task decomposition among agents, the tool of the present invention can automatically complete multiple tasks such as function generation, data source integration, logical reasoning, and document output according to user requirements, significantly improving the automation level and efficiency of software development. This method can provide more intelligent support in complex scenarios, help developers quickly adapt to requirement changes, improve development efficiency, reduce the burden of manual coding, and promote the development of software towards a more efficient and intelligent direction.

[0222] The embodiments described above are only descriptions of the preferred embodiments of the present invention, and do not limit the scope of the present invention. Without departing from the design spirit of the present invention, various deformations and improvements made by those of ordinary skill in the art to the technical solutions of the present invention shall fall within the protection scope determined by the claims of the present invention.

Claims

1. An automated component orchestration and intelligent generation method based on multi-agent collaboration, characterized in that, The method includes: Adopting a multi-agent collaboration framework to complete the automated development tasks of software systems through the interaction and collaboration among agents.

2. The method according to claim 1, characterized in that, Obtaining task modeling related concepts includes: project, document model, component library, page model, node model, setter, attribute, style, event, data source, function; Among them, the project is a Project instance created for each development task; The document model is used to describe the description information, usage instructions, and configuration documents of each page under the project, and at the same time describe the relationships among the pages; The component library is a list of components that can be automatically generated, composed of components produced in a visual way; The page model contains a tree composed of a group of components. Each document model corresponds to a root node and multiple component nodes, and is used to describe the page structure of the selected components in the page; The node model is used to describe the relevant attributes of the selected component; The setter is used for the system to set optional setter attributes for components before each component definition, and can provide large model automatic configuration and user editing, including attributes, styles, and events; The attribute is used to display the general attributes of the component; The style is used to display the style attributes of the component; The event is used to display an event panel for binding events if the component has declared events; The data source is the backend data source bound by the component; The function is the code that needs to be written to complete the component event; 3. The method according to claim 2, wherein The agents include: Product manager agent, project supervisor agent, front-end design agent, interface design agent, function implementation agent, page generation agent, task coordination agent, quality inspection agent, delivery agent; Among them, the product manager agent is responsible for interacting with users, collecting requirements, and formulating a preliminary task list according to user requirements; The project supervisor agent extracts specific development tasks from the requirements collected by the product manager agent, and coordinates with other agents to assign the priorities and sequences of development tasks; The front-end design agent selects components that meet the preset requirements according to the task list, designs the page layout, and defines the page style and structure; The interface design agent is responsible for designing the data binding interface with the page components to ensure the functional consistency between the interface and the page components; The function implementation agent automatically generates function implementation code according to the interface document and implements the page functions; The page generation agent automatically generates page-related files and component registration code after the function is implemented, ensuring that the development results meet the technical requirements and can be integrated with other system modules; The task coordination agent is responsible for coordinating the results of different development stages to ensure the consistency and integrity of the output of each task; The quality inspection agent checks the generated pages, code, interfaces, and documents to ensure that they meet the quality standards and platform requirements; The delivery agent is responsible for organizing the final development results into deliverable documents and code and preparing for online delivery.

4. The method according to claim 3, wherein The construction method of the multi-agent collaboration framework includes: In the system startup phase, demand-related multi-agent collaboration collects user requirements and transforms them into a series of executable development tasks. Among them, the development tasks include page design, function implementation, and data interface design. Among them, the core of the task management module is to generate a clear task list and adjust it according to the project progress and development priorities. In the task decomposition phase, the agents further decompose the user requirements into specific development tasks, arrange the development cycle and priorities to ensure that the development tasks are completed on time and with quality. Among them, the task list is managed in an agile development manner, and the tasks are developed in batches in an iterative manner. Task evaluation, development implementation, and acceptance are carried out in each iteration cycle.

5. The method according to claim 4, characterized in that, The interaction and collaboration among agents include: user requirement collection and task planning phase, development execution and agent collaboration phase, task coordination and quality inspection phase, and delivery online and feedback optimization phase.

6. The method according to claim 5, characterized in that, The user requirement collection and task planning phase includes: the product manager agent and the project supervisor agent jointly complete requirement collection and analysis. Among them, the product manager agent collects requirements from users and extracts the core functions, and after ensuring accurate understanding, hands them over to the project supervisor agent. The project supervisor agent transforms the requirements into specific development tasks according to the collected requirements, simultaneously refines the requirements into specific subtasks, and sorts the tasks according to the development priorities and urgency.

7. The method according to claim 6, wherein The development execution and agent collaboration phase includes: after the task decomposition is completed, each page will automatically complete page development. The specific development stages are divided into front-end design, back-end design, and system implementation phases according to the implemented functions. Among them, in the front-end design phase, the front-end design agent automatically selects platform components according to the task list, conducts page layout design and style definition, and all designs are optimized and adjusted according to the requirement document and user feedback to ensure compliance with the user's usage scenario. After the design is completed, the function implementation agent automatically generates function codes according to the interface design and front-end layout to implement the page functions. In the back-end design phase, the interface design agent generates data interfaces according to the page design requirements of the front-end design agent, and ensures that the data transmission format matches the back-end structure. The agent can dock the front-end page with the back-end interface, generate complete function codes, and automatically process the interaction logic of page components to ensure that the function implementation meets the design requirements. In the system implementation phase, the application generation agent automatically generates Schema files and component registration codes related to the page according to the development results to ensure that the development results are compatible with the template files of the platform. The documentation and testing agent is responsible for generating the documents and test cases required during the development process, including interface documents and function test cases, and automatically tests the page functions to ensure the quality of the development results.

8. The method according to claim 7, characterized in that The task coordination and quality inspection phase includes: Throughout the system development, the task coordination agent continuously tracks the progress of each development task, coordinates the work of each module to ensure that there are no omitted or conflicting parts, and this agent is also responsible for resolving task conflicts and inconsistencies that occur during the development process. At the end of each stage or when each agent has a clear output, the quality inspection agent checks the code, functions, and interfaces of the system modules to ensure that they meet the quality standards of the platform. After passing the inspection, the relevant modules are handed over to the delivery agent for integration and final delivery.

9. The method according to claim 8, wherein The delivery, online deployment, and feedback optimization stage includes: After all modules are completed, the delivery agent is responsible for integrating the final development results and preparing for online delivery. During the delivery process, the agent summarizes all development documents, test reports, and functional codes and makes final adjustments based on the feedback. The system supports continuous delivery to ensure that the development results can be delivered to users in a timely manner.

Images