Multi-agent system construction method and equipment based on servitization agent architecture

Abstract

The invention relates to the technical field of computers, in particular to a multi-agent system construction method and device based on a servitization agent architecture, and the method comprises the steps: compiling a configuration file of a servitization agent based on the servitization agent architecture; integrating a plurality of servitization agents into a server according to the configuration file; starting the micro-services of the plurality of service agents, and performing service configuration on the plurality of service agents according to the registration center of the micro-services and the meta-information of the plurality of service agents; service discovery is carried out after service configuration is started, multiple pieces of service intelligent meta-information on the registration center are pulled, multiple service intelligent nodes are generated according to the multiple pieces of service intelligent meta-information, and a multi-agent system is constructed according to the multiple service intelligent nodes to cooperatively execute tasks. Therefore, the problems of relatively poor flexibility, adaptability and execution efficiency, resource waste and the like caused by the fact that a multi-agent system organizes multi-agent cooperation by an agent with a single function in a related technology are solved.

Description

Technical Field

[0001] The present application relates to the field of computer technology, and in particular to a method and device for constructing a multi-agent system based on a service-oriented intelligent agent architecture. Background Art

[0002] With the development of large-scale models and distributed computing, multi-agent systems are able to autonomously perform analysis and reasoning, planning and decision-making, and task execution, particularly helping to solve complex multi-step tasks. Multi-agent systems enable agents with different functions to collaborate to complete complex tasks, overcoming the limitations of large language models, which often have "brains but no hands." At the same time, the rapid evolution of new computing models and environments, such as cloud computing, edge computing, and service computing, is driving the evolution of software systems towards networking, service-oriented, and intelligent development. In related technologies, multi-agent systems are mainly organized by several single-function agents and fixed agent workflows to organize multi-agent collaboration. There is a lack of full-process automation methods from agent construction, agent deployment, and multi-agent collaboration. Service-oriented agents can automate the above processes through service-oriented modeling, construction, deployment, and scheduling methods. The main difficulties of current multi-agent systems are: (1) It is difficult to continuously integrate large-scale agents and tools with different functions; (2) There is a lack of integration and deployment methods for multi-agent systems; (3) There is a lack of multi-agent scheduling and collaboration methods with high availability, high throughput, and maximum resource utilization; thus, it leads to poor flexibility, adaptability, and execution efficiency, as well as resource waste. Summary of the Invention

[0003] The present application provides a method, device and medium for constructing a multi-agent system based on a service-oriented intelligent agent architecture to solve the problems in related technologies where the multi-agent system is organized by a single-function intelligent agent to collaborate with multiple agents, resulting in poor flexibility, adaptability and execution efficiency, as well as waste of resources.

[0004] The first aspect of the present application provides a method for constructing a multi-agent system based on a service-oriented intelligent agent architecture, comprising the following steps: writing a configuration file of a service-oriented intelligent agent based on the service-oriented intelligent agent architecture; integrating multiple service-oriented intelligent agents into a server according to the configuration file; starting the microservices of the multiple service-oriented intelligent agents, and performing service configuration for the multiple service-oriented intelligent agents according to the registration center of the microservices and the metadata of the multiple service-oriented intelligent agents; starting service discovery after the service configuration is completed, pulling the metadata of the multiple service-oriented intelligent agents on the registration center, generating multiple service-oriented intelligent nodes according to the metadata of the multiple service-oriented intelligent agents, building a multi-agent system according to the multiple service-oriented intelligent nodes, and using the multi-agent system to collaboratively perform tasks.

[0005] Optionally, the service-oriented intelligent agent architecture includes: an infrastructure module, a service-oriented task execution module, an intelligent agent service network module and an intelligent agent scheduling module, wherein the infrastructure module is used to integrate the basic conditions of large language models, knowledge graphs, vector databases and cloud service resources; the service-oriented task execution module is used to encapsulate intelligent agent capabilities in the form of target services to achieve parallel execution and context isolation; the intelligent agent service network module is used to dynamically manage the metadata of intelligent agent services through a service registration center to call multiple agents to collaboratively process tasks across services; the intelligent agent scheduling module is used to generate an initial execution graph according to task requirements, and optimize resource allocation through dynamic task planning.

[0006] Optionally, the configuration file includes an agent service group, a service name, a registration center address, a service address, and a device type.

[0007] Optionally, configuring services for the multiple service-oriented intelligent entities based on the registration center of the microservice and the metadata of the multiple service-oriented intelligent entities includes: obtaining a registration request sent by the registration center of the microservice; determining the metadata of the multiple service-oriented intelligent entities and a list of available services based on the registration request; and configuring services for the multiple service-oriented intelligent entities based on the metadata of the multiple service-oriented intelligent entities and the list of available services.

[0008] Optionally, the multi-agent system is used to collaboratively execute tasks, including: obtaining a task list and a list of available services; generating a task plan based on the task list; filtering the agents in the available service list to execute tasks according to the task plan, and filling the records of the executed tasks into the execution graph until all tasks in the task list are completed, and feeding the execution graph back to the scheduler.

[0009] Optionally, generating a task plan based on the task list includes: obtaining task requirements for each task in the task list; matching a corresponding backbone task list and an initial execution node according to the task requirements; generating a task plan based on the backbone task list and the initial execution node Optionally, the agent execution task in the available service list is filtered according to the task plan, including filtering the execution agent that meets the preset conditions according to the task plan, and scheduling the corresponding execution agent and the corresponding execution graph according to the available service list; replaying the execution graph content of the execution agent according to the task requirements, and filling the execution status in the execution graph until all subtasks of the current task are completed, and generating a new execution graph and returning it to the scheduler.

[0010] Optionally, after returning the execution graph to the scheduler, it also includes: determining whether the routing list information in the execution graph is empty; if the routing list information is not empty, scheduling the intelligent agent service pointed to by the route; if the routing list information is empty, executing the next execution intelligent agent service in the backbone task list.

[0011] The second aspect of the present application provides an electronic device, comprising: a memory, a processor, and a computer program stored on the memory and executable on the processor, wherein the processor executes the program to execute the multi-agent system construction method based on the service-oriented intelligent agent architecture as described in the above embodiment.

[0012] The third aspect of the present application provides a computer-readable storage medium having a computer program stored thereon, which is executed by a processor to perform the multi-agent system construction method based on the service-oriented intelligent agent architecture as described in the above embodiment.

[0013] Therefore, this application has at least the following beneficial effects: (1) The embodiment of the present application can compile a configuration file of a service-oriented intelligent agent based on the service-oriented intelligent agent architecture; integrate multiple service-oriented intelligent agents into the server according to the configuration file; start the microservices of multiple service-oriented intelligent agents, and configure the services of multiple service-oriented intelligent agents according to the registration center of the microservices and the metadata of multiple service-oriented intelligent agents; start service discovery after the service configuration is completed, pull the metadata of multiple service-oriented intelligent agents on the registration center, generate multiple service-oriented intelligent nodes according to the metadata of multiple service-oriented intelligent agents, build a multi-agent system according to the nodes of multiple service-oriented intelligent agents, and use the multi-agent system to collaboratively execute tasks. When a new intelligent agent is added, it only needs to update the configuration file and register, and adapt to the node changes in real time. The load-based scheduling strategy reduces resource contention and improves throughput. The execution graph records the entire process, supports task backtracking and performance analysis, and is suitable for scenarios that require high concurrency, high reliability and complex task collaboration.

[0014] (2) Model and construct intelligent agent systems using services as basic units; realize service-oriented integration and deployment of multi-agent systems to improve development efficiency; use services as the basic units for scheduling and collaboration, realize multi-agent asynchronous scheduling methods with execution graphs as context transmission media, and improve task execution throughput and efficiency.

[0015] Additional aspects and advantages of the present application will be given in part in the description below, and in part will become apparent from the description below, or will be learned through practice of the present application. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] The above and / or additional aspects and advantages of the present application will become apparent and easily understood from the following description of the embodiments in conjunction with the accompanying drawings, in which: Figure 1 A flowchart of a method for constructing a multi-agent system based on a service-oriented agent architecture according to an embodiment of the present application; Figure 2 A schematic diagram of the overall process of a multi-agent system construction method based on a service-oriented agent architecture according to one embodiment of the present application; Figure 3 A schematic diagram of a service-oriented intelligent agent architecture provided according to an embodiment of the present application; Figure 4 A schematic diagram of the agent service registration and discovery process provided according to an embodiment of the present application; Figure 5 A schematic diagram of scheduling of a service-oriented intelligent agent according to an embodiment of the present application; Figure 6 A schematic diagram of the structure of an electronic device provided according to an embodiment of the present application. DETAILED DESCRIPTION

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

[0018] The following describes the multi-agent system construction method, equipment and medium based on the service-oriented intelligent agent architecture according to the embodiment of the present application with reference to the accompanying drawings.

[0019] Specifically, Figure 1 A flowchart of a method for constructing a multi-agent system based on a service-oriented intelligent agent architecture provided in an embodiment of the present application.

[0020] like Figure 1 As shown, the method for constructing a multi-agent system based on a service-oriented agent architecture includes the following steps: In step S101, a configuration file of a service-oriented agent is written based on the service-oriented agent architecture.

[0021] Among them, the service-oriented intelligent agent architecture includes: infrastructure module, service-oriented task execution module, intelligent agent service network module and intelligent agent scheduling module. Among them, the infrastructure module is used to integrate the basic conditions of large language models, knowledge graphs, vector databases and cloud service resources; the service-oriented task execution module is used to encapsulate the intelligent agent capabilities in the form of target services to achieve parallel execution and context isolation; the intelligent agent service network module is used to dynamically manage the metadata of intelligent agent services through the service registration center to call multiple agents across services to collaboratively process tasks; the intelligent agent scheduling module is used to generate the initial execution graph according to task requirements and optimize resource allocation through dynamic planning tasks.

[0022] It can be understood that the embodiments of the present application can write configuration files of service-oriented intelligent bodies based on the service-oriented intelligent body architecture, support hybrid deployment mode, improve resource utilization, parallel and isolation mechanisms, improve throughput, the registration center dynamically manages service metadata, and new nodes take effect immediately, greatly improving execution efficiency.

[0023] Specifically, if Figure 2 and Figure 3 As shown, the service-oriented intelligent agent architecture is initialized: Among them, the service-oriented intelligent agent architecture includes four parts: infrastructure module, service-oriented task execution module, intelligent agent service network module and intelligent agent scheduling module. Specifically: (1) Infrastructure module: It mainly provides a stable operating environment and resource support for the intelligent agent, including large language models, knowledge graphs, recommendation systems, vector databases, tool chains, APIs (Application Programming Interfaces), and cloud services, providing the basic conditions for the operation of the intelligent agent. Among them, the large language model supports closed-source large language models such as those called in the form of APIs, such as those from OpenAI (Open Artificial Intelligence), and also supports open-source large language models that can be deployed locally. The large language model can be flexibly configured for each intelligent agent through the configuration file, and the framework can also identify and call the appropriate model according to the task. For example, multimodal large language models are used in image recognition tasks. The knowledge graph can automatically store or extract triple structured information for the intelligent agent during operation, which is used to provide more accurate domain knowledge in a specific field to help reduce hallucinations. The recommendation system is used to solve the specialized recommendation needs in a specific field, such as product recommendation. The vector database is used for retrieval enhancement generation and caching and reasoning acceleration of trajectory graphs during the active reasoning process of the intelligent agent. The tool chain, API, and cloud services are all used as existing tools for the intelligent agent to use. The infrastructure module is called by the service-oriented task execution module in a configuration or adaptive selection manner, providing underlying tools and resource support for the entire RGPS (Requirements, Goals, Processes, and Systems) knowledge-driven service-oriented intelligent agent architecture.

[0024] (2) Service-oriented task execution module: Supported by agent services, each agent provides capabilities to the outside world in the form of Web services. Task execution can achieve parallel execution and context isolation with the help of services, ensuring that the agent system can achieve high throughput while improving resource utilization.

[0025] (3) Agent service network module: Multiple agent services form an agent service network through service registration and discovery. The agent services in the network can achieve collaboration among multiple agents through cross-service calls between microservices according to collaboration needs.

[0026] (4) Agent Scheduling Module: Agent scheduling will plan the initial task steps in advance according to user needs, forming the backbone of the task execution graph. Each step will be handed over to an agent service as the initial node to start execution. During the execution process, subtasks will be further dynamically planned, and dynamic planning and execution will be achieved through the agent scheduler service. The context synchronization of the entire execution process will be carried out in the execution graph.

[0027] In an embodiment of the present application, the configuration file includes an intelligent agent service group, a service name, a registration center address, a service address, and a device type.

[0028] Specifically, if Figure 2 As shown, the construction and modeling of the service-oriented intelligent agent is carried out through the service-oriented intelligent agent configuration file, which includes: intelligent agent service group ( ), Agent Service Name( )、Registration Center Address( )、Service Address( ) and device type ( )Five parts.

[0029] The agent service group divides the visible domain of the agent group when it runs as a service. Agent group services in the same visible domain can discover each other and call them according to tasks through the scheduling service; the agent service name is the identifier of the agent after service, which is used to distinguish the agent service and serves as the unique identifier for service registration and discovery, service deployment and calling; the registration center address is the address information of the registration center to which the agent service is to be connected, including the address link URL, access key and secret key, to ensure that the agent service can safely register and discover services through the registration center; the service address includes the service IP address and service port number, which is used to register the access method of its own service as metadata to the registration center for service callers to perform service discovery; the device type is used to identify the device on which its own service runs. Different device types will affect the calling method of the service-based agent, such as the network communication protocol selected for non-IoT devices is HTTP (HyperText Transfer Protocol) protocol, and for IoT devices is MQTT (Message Queuing Telemetry Transport) protocol.

[0030] In step S102, multiple service-oriented agents are integrated into the server according to the configuration file.

[0031] It can be understood that the embodiment of the present application can integrate multiple service-oriented intelligent agents into the server according to the configuration file, which can not only significantly improve the development and operation efficiency of the system, but also enhance the flexibility, scalability and reliability of the system.

[0032] It should be noted that if Figure 2 As shown in the figure, the integration and deployment of service-oriented intelligent agents include automated integration of service-oriented intelligent agents based on pipeline tools, and registration and discovery of intelligent agent services based on a microservices architecture. The automated integration of service-oriented intelligent agents based on pipeline tools is used to continuously integrate the intelligent agent code written by intelligent agent developers onto the server through automated scripts using git repositories as the basic unit, thereby improving development efficiency. Intelligent agent service registration and discovery based on a microservices architecture organizes each intelligent agent as a microservice, registers its own service metadata with the registration center based on the intelligent agent service configuration file, and simultaneously pulls metadata of other microservices registered with the registration center from the registration center. The metadata of other microservices will be dynamically updated as services are registered and deregistered.

[0033] In step S103, the microservices of the plurality of service-oriented intelligent bodies are started, and service configuration is performed on the plurality of service-oriented intelligent bodies according to the registration center of the microservices and the meta-information of the plurality of service-oriented intelligent bodies.

[0034] It can be understood that the embodiment of the present application starts the microservices of multiple service-oriented intelligent entities and configures services based on the registration center and intelligent entity metadata, which can significantly improve the system's integration speed, flexibility, resource utilization efficiency and collaboration capabilities between intelligent entities, while simplifying the system's maintenance work, and ultimately providing users with a more efficient and reliable service experience.

[0035] In an embodiment of the present application, service configuration is performed on multiple service-oriented intelligent entities based on the registration center of the microservice and the metadata of multiple service-oriented intelligent entities, including: obtaining a registration request sent by the registration center of the microservice; determining the metadata of multiple service-oriented intelligent entities and a list of available services based on the registration request; and performing service configuration on multiple service-oriented intelligent entities based on the metadata of multiple service-oriented intelligent entities and the list of available services.

[0036] It can be understood that the embodiments of the present application can configure services for the microservice registration center and intelligent body information, which not only realizes automated service discovery and registration, but also greatly improves the flexibility, scalability and resource utilization of the system.

[0037] Specifically, if Figure 2 and Figure 4As shown in the figure, (1) Automated integration of service-oriented intelligent agents based on pipeline tools: This step is used to automatically verify, unit test and upload the intelligent agent code written in the code repository written by developers to the server through pipeline tools such as gitlab and jenkins. It supports source code upload and container packaging methods such as docker.

[0038] (2) Agent service registration and discovery based on microservice architecture: Each agent service will run in the form of a microservice and register the service metadata to the registration center at the beginning of the operation. The service metadata includes two parts: the service network communication address and the agent node information. The network communication address is similar to that of traditional microservices, allowing other services to access its own service through the network communication protocol; the agent node information contains the information of multiple agent nodes in the agent group within its own agent service. This information will serve as an important reference information for other agent services when selecting multi-agent collaboration. In addition to service registration, each agent service will pull the metadata registered by other agent services from the registration center at startup to perform service discovery. This process will be dynamically updated during the subsequent service operation to ensure that each agent service can maintain information consistency with the registration center. For example, when a new agent service is registered or an existing agent service is deregistered, it can be dynamically updated.

[0039] In step S104, after the service configuration is completed, service discovery is started, multiple service-oriented intelligent metadata on the registration center is pulled, multiple service-oriented intelligent nodes are generated based on the multiple service-oriented intelligent metadata, a multi-agent system is constructed based on the multiple service-oriented intelligent nodes, and the multi-agent system is used to collaboratively execute tasks.

[0040] It can be understood that the embodiment of the present application can significantly improve the system's integration speed, resource management efficiency, task execution quality and collaboration capabilities by starting the service discovery process after service configuration, using the intelligent agent metadata on the registration center to generate intelligent agent nodes and build a multi-agent system, while also enhancing the system's flexibility and maintainability.

[0041] In an embodiment of the present application, a multi-agent system is used to collaboratively execute tasks, including: obtaining a task list and a list of available services; generating a task plan based on the task list; filtering the agents in the available service list to execute tasks according to the task plan, and filling the records of the executed tasks into the execution graph until all tasks in the task list are completed, and feeding the execution graph back to the scheduler.

[0042] It can be understood that the embodiment of the present application utilizes a method of collaboratively executing tasks by a multi-agent system, which not only improves the efficiency and accuracy of task execution, but also enhances the flexibility and adaptability of the system; through dynamic management of task lists, precise screening of agent services, and real-time updating of execution graphs, this solution can ensure that even in the face of complex and changing task requirements, it can provide stable and reliable service output.

[0043] It should be noted that if Figure 2 As shown in the figure, the execution graph structure and construction principle, where the execution graph is triggered by a task and records the entire process of the multi-agent system being executed collaboratively by multiple agent services after receiving the task. The details are as follows: (1) The structure of the execution graph consists of two parts: the basic information of the execution graph and the detailed information of the execution graph. The basic information of the execution graph is used to record the initial information and summary information of the task, including the execution graph task ID (Identification), the total number of levels, the total task goal, the total token consumption, the total amount consumption, the total time consumption, the task plan list, and the total list of participating agents. The detailed information of the execution graph contains the context information of all agent services executed in the agent service network according to the level. Each level contains multiple agent services executed in parallel, which complete the subtasks split from the previous level. These context information include the name of each executed agent service, the name of the subtask, the interaction information with the large model, the input parameter list, the output parameter list, the task status, the execution node token consumption, the execution node amount consumption, the execution node execution time, and the task type (including agent and agent group). In addition, each level also contains a list of routes of the next level. Each route represents the list of downstream nodes of the current execution node. Each downstream node contains the execution task name, the task type (including agent and agent group), and the input parameter list. The agent dispatching service will dispatch to all agent services at the next level according to the routing list.

[0044] (2) Execution graph construction: The construction of the execution graph is completed by the execution nodes at each level. The overall presentation is that each agent microservice generates an execution graph subgraph in a distributed manner, and then synchronizes the execution graph subgraphs through the scheduling service and merges them into a complete execution graph. As the task is executed, the execution graph will dynamically expand according to the level. Finally, the entire execution graph will correspond to the complete solution of the task originally proposed by the user.

[0045] In an embodiment of the present application, a task plan is generated based on a task list, including: obtaining the task requirements of each task in the task list; matching the corresponding trunk task list and initial execution node according to the task requirements; and generating a task plan based on the trunk task list and the initial execution node.

[0046] It can be understood that the embodiment of the present application can generate a task plan based on the task list, and through accurate task requirement analysis, efficient backbone task matching and scientific task plan generation, it significantly improves the intelligence level and execution efficiency of task planning. It can not only ensure the efficient decomposition and execution of complex tasks, but also flexibly adjust task arrangements in a dynamic environment, providing users with a stable and reliable service experience.

[0047] In an embodiment of the present application, an agent execution task is screened according to a task plan to select an available service list, including: screening an execution agent that meets preset conditions according to the task plan, and scheduling the corresponding execution agent and the corresponding execution graph according to the available service list; replaying the execution graph content of the execution agent according to the task requirements, and filling the execution status in the execution graph until all subtasks of the current task are completed, and generating a new execution graph and returning it to the scheduler.

[0048] Among them, the preset conditions can be set according to actual needs without specific limitations.

[0049] It can be understood that the embodiments of the present application can significantly improve the efficiency, flexibility and reliability of task execution by screening intelligent agents according to task plans and dynamically scheduling execution tasks, combined with the playback and expansion mechanism of the execution graph; it can not only ensure the efficient decomposition and execution of complex tasks, but also flexibly adjust task arrangements in a dynamic environment, providing users with a stable and reliable service experience.

[0050] In an embodiment of the present application, after returning the execution graph to the scheduler, it also includes: determining whether the routing list information in the execution graph is empty; if the routing list information is not empty, then scheduling the intelligent agent service pointed to by the route; if the routing list information is empty, then executing the next execution intelligent agent service in the trunk task list.

[0051] It can be understood that the embodiment of the present application significantly improves the flexibility, efficiency and reliability of task execution by determining whether the routing list information in the execution graph is empty and dynamically adjusting the task scheduling strategy according to its status.

[0052] It should be noted that after receiving the reporting request of the subtask, the scheduling service updates the subtask status. If the subtask has been completed, it will continue to schedule to the start node of the next subtask along the main plan of the execution graph; if it is not completed, it will be scheduled to the next intelligent agent service that needs to participate in the collaboration to complete the current subtask according to the routing information in the execution graph.

[0053] Repeat each subtask until all subtasks are completed to form a complete execution graph. The entire execution graph is sent by the scheduling service to the summary agent service for summary output, and the final result is returned to the user, and the complete execution graph is visualized. The interaction process between the scheduling service and each agent service is as follows Figure 5 shown.

[0054] Specifically, if Figure 5 As shown in the figure, a service-oriented multi-agent system scheduling method based on execution graph is proposed; (1) at the beginning of a task, the task first enters the scheduling service for task recording and resource verification, enters the planning agent service for backbone task planning, generates basic information of the execution graph, and passes the execution graph to the planning agent service.

[0055] (2) The planning agent service then finds all online agent services through service discovery, matches the task to the backbone task list and the corresponding initial execution node, adds the backbone task list to the execution graph, and returns it to the scheduling service.

[0056] (3) The scheduling service finds the first execution agent service in the main task list, records the execution subtask at the scheduler level, and schedules it to the execution agent service based on the resource availability, carrying the execution graph at the same time.

[0057] (4) When the execution agent service receives the scheduling request, it first replays the execution graph context and fills the content in the execution graph back into the memory of the current agent service. Then, the agent group and multiple agents in the current agent service execute the current subtask, expand the execution context into the execution graph, and determine whether the subtask is completed. If not, it automatically discovers and plans the downstream execution node list, fills it into the routing list, and returns the execution graph to the scheduler.

[0058] (5) The scheduling service determines whether the routing list is empty. If it is, it schedules the agent service pointed to by the route. If it is empty, it repeats step (3) to execute the next agent service in the main task list. In other words, it ensures that each subtask in the main task list is completed before scheduling the next subtask. Whether each subtask is completed is dynamically determined by the agent service network module.

[0059] (6) When all subtasks are completed, the scheduling service will schedule the summary agent service to summarize the entire execution graph context and return the final execution result to the user. At the same time, the entire execution graph will be presented to the user as the entire task reasoning process.

[0060] According to the multi-agent system construction method based on the service-oriented intelligent agent architecture proposed in the embodiment of the present application, a configuration file of the service-oriented intelligent agent is written based on the service-oriented intelligent agent architecture; multiple service-oriented intelligent agents are integrated into the server according to the configuration file; the microservices of multiple service-oriented intelligent agents are started, and the service configuration of multiple service-oriented intelligent agents is performed according to the registration center of the microservices and the metadata of multiple service-oriented intelligent agents; after the service configuration is completed, service discovery is started, the metadata of multiple service-oriented intelligent agents on the registration center is pulled, and multiple service-oriented intelligent nodes are generated according to the metadata of multiple service-oriented intelligent agents, and a multi-agent system is constructed according to the nodes of multiple service-oriented intelligent agents. The multi-agent system is used to collaboratively execute tasks. When a new agent is added, it only needs to update the configuration file and register, and adapt to the node changes in real time. The load-based scheduling strategy reduces resource contention and improves throughput. The execution graph records the entire process, supports task backtracking and performance analysis, and is suitable for scenarios that require high concurrency, high reliability and complex task collaboration.

[0061] The following is a detailed description of the multi-agent system construction method based on the service-oriented intelligent agent architecture of the present application in conjunction with specific embodiments, as follows: For the task of "help me generate a PDF report on the development trend of large models in 2025", a multi-agent system consisting of agent services including search agent service, reasoning agent service, image generation agent service, and PDF file generation agent service is implemented as follows: In step 1, the user proposes a requirement, such as "generate a PDF report on the development trend of large AI models in 2025." The system first receives the user input and passes it to the task planning module. Step 2: The task planning module decomposes the task requirements into multiple subtasks based on the available service list capabilities and generates an execution plan.

[0062] Step 3: Subtask execution Each subtask is executed by a corresponding group of agents. The following are the specific implementations of each agent: (1) Search for relevant information: Search for information related to the task from the Internet or other data sources.

[0063] (2) Generate report content: Generate structured report content based on search results.

[0064] (3) Generate charts: Generate required charts based on the report content, such as trend charts or data visualization.

[0065] (4) Generate PDF file: Integrate the report content and charts into one PDF file.

[0066] Step 4: Dynamic task scheduling The system dynamically determines the next task based on the routing list. If the routing list is not empty, it will continue to schedule the next agent; if it is empty, it will execute the next task in the main task list.

[0067] Therefore, the system can automatically generate task plans based on user needs and assign subtasks to the most suitable intelligent agents; each intelligent agent focuses on a specific task to ensure the professionalism and efficiency of the task; the system dynamically adjusts task scheduling based on the routing list and can quickly switch to alternative paths when branch tasks or task failures occur; and finally generates a complete PDF report containing structured content and charts to meet user needs.

[0068] Figure 6 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present application. The electronic device may include: A memory 601 , a processor 602 , and a computer program stored in the memory 601 and executable on the processor 602 .

[0069] When the processor 602 executes the program, the multi-agent system construction method based on the service-oriented agent architecture provided in the above embodiment is implemented.

[0070] Furthermore, the electronic device further includes: The communication interface 603 is used for communication between the memory 601 and the processor 602 .

[0071] The memory 601 is used to store computer programs that can be run on the processor 602 .

[0072] The memory 601 may include a high-speed RAM memory, and may also include a non-volatile memory (non-volatile memory), such as at least one disk memory.

[0073] If the memory 601, processor 602, and communication interface 603 are implemented independently, the communication interface 603, memory 601, and processor 602 can be interconnected via a bus and communicate with each other. The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus. Buses can be divided into address buses, data buses, control buses, etc. For ease of representation, Figure 6 Only one thick line is used in the diagram, but this does not mean that there is only one bus or one type of bus.

[0074] Optionally, in a specific implementation, if the memory 601, the processor 602 and the communication interface 603 are integrated on a chip, the memory 601, the processor 602 and the communication interface 603 can communicate with each other through an internal interface.

[0075] The processor 602 may be a central processing unit (CPU), an application specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of the present application.

[0076] An embodiment of the present application also provides a computer-readable storage medium on which a computer program or instruction is stored. When the computer program or instruction is executed by a processor, it implements the above-mentioned method for constructing a multi-agent system based on a service-oriented intelligent agent architecture.

[0077] In the description of this specification, the description with reference to the terms "one embodiment", "some embodiments", "example", "specific example", or "some examples" means that the specific features, structures, materials or characteristics described in conjunction with the embodiment or example are included in at least one embodiment or example of the present application. In this specification, the schematic representations of the above terms do not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials or characteristics described can be combined in any one or N embodiments or examples in a suitable manner. In addition, those skilled in the art can combine and combine different embodiments or examples described in this specification and features of different embodiments or examples without contradiction.

[0078] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be understood to indicate or imply relative importance or implicitly specify the number of technical features indicated. Thus, a feature specified as "first" or "second" may explicitly or implicitly include at least one such feature. In the description of this application, "N" means at least two, for example, two, three, etc., unless otherwise specifically defined.

[0079] Any process or method description in a flowchart or otherwise described herein may be understood to represent a module, fragment or portion of code comprising one or N executable instructions for implementing a custom logical function or process step, and the scope of the preferred embodiments of the present application includes alternative implementations in which functions may be performed in a different order than shown or discussed, including performing functions in a substantially simultaneous manner or in a reverse order depending on the functions involved, which should be understood by those skilled in the art to which the embodiments of the present application pertain.

[0080] It should be understood that various parts of this application can be implemented using hardware, software, firmware, or a combination thereof. In the above embodiment, the N steps or methods can be implemented using software or firmware stored in a memory and executed by a suitable instruction execution system. For example, if implemented using hardware, as in another embodiment, it can be implemented using any one or a combination of the following technologies known in the art: discrete logic circuits having logic gate circuits for implementing logical functions on data signals, application-specific integrated circuits having suitable combinational logic gate circuits, programmable gate arrays (PGAs), field-programmable gate arrays (FPGAs), etc.

[0081] Those skilled in the art will understand that all or part of the steps in the method of the above embodiment can be completed by instructing related hardware through a program, and the program can be stored in a computer-readable storage medium. When the program is executed, it includes one or a combination of the steps of the method embodiment.

Claims

1. A method for constructing a multi-agent system based on a service-oriented agent architecture, characterized in that: The following steps are involved: Write the configuration file of the service-oriented agent based on the service-oriented agent architecture; Integrate multiple service-oriented agents into the server according to the configuration file; Starting the microservices of the plurality of service-oriented intelligent bodies, and performing service configuration on the plurality of service-oriented intelligent bodies according to the registration center of the microservices and the meta-information of the plurality of service-oriented intelligent bodies; After the service configuration is completed, service discovery is started, and metadata of multiple service-oriented intelligences on the registration center is pulled. Multiple service-oriented intelligence nodes are generated based on the metadata of the multiple service-oriented intelligences. A multi-agent system is constructed based on the multiple service-oriented intelligence nodes, and the multi-agent system is used to collaboratively execute tasks.

2. The method for constructing a multi-agent system based on a service-oriented agent architecture according to claim 1, characterized in that: The service-oriented intelligent agent architecture includes: an infrastructure module, a service-oriented task execution module, an intelligent agent service network module and an intelligent agent scheduling module, wherein: The infrastructure module is used to integrate the basic conditions of large language models, knowledge graphs, vector databases and cloud service resources; The service-oriented task execution module is used to encapsulate the agent capabilities in the form of target services to achieve parallel execution and context isolation; The agent service network module is used to dynamically manage the meta-information of agent services through the service registration center to call multiple agents to collaboratively process tasks across services; The agent scheduling module is used to generate an initial execution graph according to task requirements and optimize resource allocation through dynamic task planning.

3. The method for constructing a multi-agent system based on a service-oriented agent architecture according to claim 1, characterized in that: The configuration file includes the agent service group, service name, registration center address, service address and device type.

4. The method for constructing a multi-agent system based on a service-oriented agent architecture according to claim 1, characterized in that: The performing service configuration on the plurality of service-oriented intelligent agents according to the registration center of the microservice and the meta-information of the plurality of service-oriented intelligent agents includes: Obtain a registration request sent by the registration center of the microservice; Determining, based on the registration request, metadata of a plurality of service-oriented intelligences and a list of available services; Perform service configuration on the plurality of service-oriented agents according to the meta-information of the plurality of service-oriented agents and the available service list.

5. The method for constructing a multi-agent system based on a service-oriented agent architecture according to claim 1, characterized in that: Utilizing the multi-agent system to collaboratively perform tasks, including: Get a list of tasks and a list of available services; generating a task plan according to the task list; The agents in the available service list are screened according to the task plan to perform tasks, and the records of the executed tasks are filled into the execution graph until all tasks in the task list are completed, and the execution graph is fed back to the scheduler.

6. The method for constructing a multi-agent system based on a service-oriented agent architecture according to claim 5, characterized in that: Generating a task plan according to the task list includes: Get the task requirements of each task in the task list; Match the corresponding backbone task list and initial execution node according to the task requirements; A task plan is generated according to the main task list and the initial execution node.

7. The method for constructing a multi-agent system based on a service-oriented agent architecture according to claim 6, characterized in that: The agent performs a task by screening the available service list according to the task plan, including: Screening execution agents that meet preset conditions according to the task plan, and scheduling corresponding execution agents and corresponding execution graphs according to the available service list; Replay the execution graph content of the execution agent according to the task requirements, and fill the execution status in the execution graph until all subtasks of the current task are completed, and generate a new execution graph and return it to the scheduler.

8. The method for constructing a multi-agent system based on a service-oriented agent architecture according to claim 7, characterized in that: After returning the execution graph to the scheduler, the method further includes: Determine whether the routing list information in the execution graph is empty; If the routing list information is not empty, the agent service pointed to by the routing is dispatched; If the routing list information is empty, the next execution agent service in the backbone task list is executed.

9. An electronic device, characterized in that: include: A memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement a method for constructing a multi-agent system based on a service-oriented agent architecture as described in any one of claims 1 to 8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: The program is executed by a processor to implement a multi-agent system construction method based on a service-oriented agent architecture as described in any one of claims 1-8.

Images