Multi-agent operation and maintenance work order generation method and system based on intention disassembly tree evolution

Abstract

The application discloses a kind of multi-agent operation and maintenance work order generation method and system based on intention disassembly tree evolution, belong to IT operation and maintenance technical field.The method includes: operation and maintenance request information is parsed, based on initial intention disassembly tree of operation and maintenance knowledge graph construction;Get historical trajectory and current running state, intention evolution extension is carried out to target node, abstract operation and maintenance target is converted into fault location, disposal operation and state verification node, and evolution intention disassembly tree is generated;Evolution tree is reconstructed to form operation and maintenance task chain, and corresponding agent is called to dispose path analysis;The analysis result is mapped to work order process structure, and the action of integrated multi-agent disposal is generated to generate collaborative operation and maintenance work order.Operation and maintenance target is finely disassembled, combined with multi-agent collaboration and work order process automatic mapping, the problem that fault location is not accurate in traditional operation and maintenance, disposal process is fragmented, the degree of automation of operation and maintenance work order generation and fault disposal efficiency are effectively improved.

Description

Technical Field

[0001] This invention belongs to the field of IT operations and maintenance technology, specifically relating to a multi-agent operations and maintenance work order generation method and system based on intent decomposition tree evolution. Background Technology

[0002] As enterprise IT infrastructure continues to expand and system architectures become increasingly complex, the diversity of operational scenarios and the unpredictability of fault types have significantly increased. In current IT operations practices, the generation of operation and maintenance work orders primarily relies on manual entry, automated triggering based on rule engines, or single-agent-assisted generation. However, these methods have significant shortcomings when facing complex fault scenarios.

[0003] First, the manual work order generation method relies heavily on the experience and judgment of operations and maintenance personnel. When a system malfunctions, operations and maintenance personnel need to manually analyze the fault symptoms, deduce possible causes, and fill in the work order information. This process is not only time-consuming and has a delayed response, but also suffers from inconsistent filling standards among different personnel, resulting in incomplete work order information or location errors, directly affecting the efficiency of subsequent handling.

[0004] Secondly, the automated work order generation method based on rule engines triggers work orders through preset alarm thresholds and matching conditions. However, the coverage of rule engines is limited, making it difficult to exhaustively cover all fault combination scenarios. When anomaly manifestations do not completely match historical rules, the system cannot accurately generate corresponding work order content, often requiring manual intervention to supplement, significantly reducing the degree of automation. In addition, rule engines lack the ability to model the fault evolution process and cannot dynamically adjust the handling steps in the work order according to the real-time operating status of the system.

[0005] Furthermore, while single-agent-based work order generation introduces natural language processing and knowledge reasoning capabilities, the knowledge boundaries and reasoning depth of a single agent are limited. When faced with complex faults involving multiple components and dependencies, a single agent struggles to simultaneously address multiple dimensions such as fault root cause localization, handling operation planning, and verification scheme design. The generated work orders often only cover localized issues and lack systematic handling path planning.

[0006] More critically, existing solutions generally lack the ability to structurally decompose and evolve operational intentions. Abstract intentions in operational requests (such as "system freeze") cannot be directly mapped to specific fault location nodes, handling operation nodes, and status verification nodes, resulting in work order content remaining at the level of symptom description, lacking executable step decomposition. At the same time, the capability differences and collaboration mechanisms between different operational agents are not effectively utilized, and the work order generation process lacks task allocation and context passing among multiple agents, making it easy for execution conflicts or duplicate operations to occur between the handling actions of each agent.

[0007] Furthermore, existing work orders are typically statically generated and cannot be dynamically adjusted based on actual feedback during execution. When the result of a certain handling step deviates from the expected outcome, the system cannot automatically backtrack and reconstruct the handling path, requiring manual re-initiation of the work order or manual modification of the process, which severely impacts fault recovery efficiency.

[0008] Therefore, a technical solution is needed that can automatically decompose abstract operation and maintenance intentions into executable nodes, combine historical experience to evolve and expand the intentions, and generate dynamically adjustable operation and maintenance work orders through multi-agent collaboration. Summary of the Invention

[0009] To address the aforementioned problems in the existing technology, this invention provides a multi-agent operation and maintenance work order generation method based on intent decomposition tree evolution. The objective of this invention can be achieved through the following technical solutions: The operation and maintenance request information input by the user is parsed to determine the operation and maintenance object and the abnormal manifestation, and an initial intent decomposition tree is constructed. Obtain the historical handling trajectory and current operating status of the operation and maintenance object, perform intention evolution expansion on the target nodes in the initial intention decomposition tree, transform the abstract operation and maintenance target into fault location nodes, handling operation nodes and status verification nodes, and generate an evolved intention decomposition tree; The node hierarchy in the evolution intention decomposition tree is reconstructed to form an operation and maintenance task chain. Based on the task node attributes in the operation and maintenance task chain, the corresponding operation and maintenance agent is called to perform path resolution for the task nodes in the operation and maintenance task chain. The results of the disposal path analysis are mapped to the operation and maintenance work order process structure, and the disposal actions corresponding to different operation and maintenance agents are integrated to generate multi-agent collaborative operation and maintenance work orders.

[0010] Specifically, the operation and maintenance intent parsing includes: The operation and maintenance request information is semantically parsed to extract the operation and maintenance objects and anomaly representations. Based on the fault impact propagation topology in the operation and maintenance knowledge graph, the propagation path of the anomaly representations is inverted to generate corresponding fault hypothesis branches. The fault hypothesis branches are associated with the corresponding root cause hypothesis and diagnosis path. Establish hierarchical connections with the operation and maintenance object as the root node and the fault hypothesis branch as the child node to construct the initial intent decomposition tree.

[0011] Specifically, the process of determining the target node includes: Based on the abnormal representation in the initial intent decomposition tree, the corresponding historical fault instances are retrieved in the operation and maintenance knowledge graph, and the fault propagation path in the historical fault instances is extracted. The nodes corresponding to the anomalies are matched with the state transition nodes in the fault propagation path to determine the evolution stages. Nodes in the same fault evolution stage are identified as target nodes, and the historical handling trajectories corresponding to the target nodes are extracted. The historical handling trajectories include the fault location process, handling operation process, and state verification results of multiple historical fault instances.

[0012] Specifically, the intention evolution extension includes: Based on the historical handling trajectory corresponding to the target node, the fault location node, handling operation node, and status verification node are extracted from the historical handling trajectory. The running status, configuration parameters, and inter-node connection relationships of each node at the time of the historical fault occurrence are obtained from the historical handling trajectory as node evolution features and input into the intent evolution model. According to the node evolution results output by the intent evolution model, the target node is split into nodes, and the abstract operation and maintenance target is converted into fault location nodes, handling operation nodes, and status verification nodes. The sub-node structure under the target node is reconstructed according to the node hierarchy relationship to generate an evolution intent decomposition tree.

[0013] Specifically, the intent evolution model includes a historical trajectory encoding layer, a state transition determination layer, and a node evolution evaluation layer; The historical trajectory encoding layer encodes the fault location process, handling operation process, and status verification process in the historical handling trajectory to generate historical handling features; The state transition determination layer performs a transition determination on the historical processing characteristics based on the current operating state to determine the degree of compatibility between the historical processing process and the current operation and maintenance request; The node evolution evaluation layer determines the node evolution direction corresponding to the target node based on the degree of fit and outputs the node evolution evaluation result.

[0014] Specifically, the path reconstruction includes: The node branches in the evolution intention decomposition tree are parsed for execution constraints, and candidate paths formed by sequentially connecting fault location nodes, handling operation nodes and status verification nodes are extracted to construct an operation object-action dependency graph. Identify conflicting operations that act on the same object and have execution order dependencies in different candidate paths. Based on the execution constraints and resource consumption of the conflicting operations, rearrange or merge the conflicting operations in time and eliminate invalid paths that cannot be executed in the current environment to form an operation and maintenance task chain.

[0015] Specifically, the formation of the operation and maintenance task chain also includes: Obtain the historical execution success rate and expected fault recovery time corresponding to the candidate task chain, construct a multi-objective optimization function to calculate the comprehensive score of each candidate task chain, select the candidate task chain with the highest comprehensive score as the final operation and maintenance task chain, and store the other candidate task chains as backup task chains. When the final operation and maintenance task chain fails, automatically switch to the backup task chain.

[0016] Specifically, the processing path parsing includes: A capability description table for the operation and maintenance intelligent agent is constructed. The capability description table includes the types of faults that the agent is good at handling and the historical success rate of handling them. For each task node in the operation and maintenance task chain, the task node is mapped and matched with the capability description table based on the processing object and handling target of the task node. The operation and maintenance intelligent agent with the highest mapping matching degree handles the corresponding task node, and the operation and maintenance intelligent agent generates a sequence of handling actions as the handling path parsing result.

[0017] Specifically, the processing path parsing also includes: The system acquires the sequence of actions generated by multiple operation and maintenance agents, constructs a cross-agent action dependency graph, identifies actions that act on the same processing object and have execution order dependencies, merges parallel, conflict-free actions for execution, schedules actions with resource contention according to execution constraints, performs handling context handover between adjacent agents, uses the execution result of the previous agent as the context input for the next agent to generate handling actions, and generates a collaborative handling action sequence.

[0018] Specifically, the process of generating the multi-agent collaborative operation and maintenance work order includes: Each action in the collaborative action sequence is mapped to a work order process node. The flow rules between work order process nodes are configured based on the state transition conditions between actions. The verification indicators corresponding to the state verification nodes are used as the completion judgment conditions for the work order process nodes. The corresponding operation and maintenance agents are associated with the work order process nodes to generate multi-agent collaborative operation and maintenance work orders.

[0019] Specifically, the method further includes: During the execution of multi-agent collaborative operation and maintenance work orders, the actual execution results of the work order process nodes are collected in real time, and the deviation analysis is performed between the actual execution results and the verification indicators corresponding to the status verification nodes. When the deviation exceeds the preset range, the local reconstruction of the evolution intention decomposition tree is triggered. Based on the deviation information, the corresponding fault location node is traced back, the operation and maintenance agent is called again to generate the handling action sequence, and the subsequent unexecuted work order process nodes are updated based on the new handling action sequence.

[0020] The beneficial effects of this invention are as follows: (1) This invention achieves automatic transformation from abstract operation and maintenance requests to executable nodes through operation and maintenance intent parsing and intent evolution extension. Based on the fault impact propagation topology of the operation and maintenance knowledge graph, the propagation path of anomaly representation is reversed, potential root causes are traced in reverse, and fault hypothesis branches related to root cause hypotheses and diagnostic paths are generated, avoiding the positioning bias caused by traditional keyword matching or manual inference. Through evolution stage matching, the current anomaly is aligned with the state transition nodes in the historical fault propagation path in time sequence, accurately determining the specific evolution stage of the target node, providing accurate context anchors for subsequent evolution. On this basis, an intent evolution model including a historical trajectory encoding layer, a state transition judgment layer, and a node evolution evaluation layer is introduced to encode the historical handling trajectory and determine its adaptability to the current operating state, thereby determining the node evolution direction, automatically splitting the abstract operation and maintenance target into fault location nodes, handling operation nodes, and state verification nodes, and reconstructing the tree structure according to the hierarchical relationship. This process fully integrates historical experience with the current system status, making the evolution results highly adaptable to actual scenarios, improving the pertinence and feasibility of fault handling paths, and fundamentally solving the problems of vague operation and maintenance intentions and lack of systematic planning of handling steps in traditional solutions.

[0021] (2) This invention effectively solves the problems of task conflict and collaborative fragmentation in complex operation and maintenance scenarios through path reconstruction and multi-agent collaboration mechanisms. In the path reconstruction stage, the execution constraints of the node branches in the evolution intention decomposition tree are analyzed to construct an operation object-action dependency graph. Conflicting operations acting on the same operation object in different candidate paths are intuitively identified. Based on execution constraints and resource occupancy, the time sequence is rearranged or merged, and invalid paths that cannot be executed in the current environment are eliminated, forming a conflict-free and highly feasible operation and maintenance task chain. In terms of multi-agent allocation, a capability description table containing the types of faults they are good at and the historical success rate of handling them is constructed. Through mapping matching degree calculation, task nodes are accurately allocated to the most suitable agent, avoiding the blindness of task allocation. In the collaborative execution stage, a cross-agent action dependency graph is constructed. Parallel conflict-free actions are merged for execution, actions with resource competition are time-sequentially scheduled, and the execution result of the previous agent is used as the context input of the next agent through a handling context handover mechanism. This design enables seamless information transfer and efficient action coordination among multiple agents, breaking through the bottleneck of limited knowledge boundaries of single agents and eliminating operational conflicts and repetitive executions when multiple agents are in parallel, thereby improving the efficiency and success rate of collaborative handling of complex faults.

[0022] (3) This invention maps the disposal path parsing results to the work order process structure and introduces a closed-loop correction mechanism driven by execution deviation, thereby realizing the dynamic generation and adaptive optimization of maintenance work orders. In the work order generation stage, each disposal action in the collaborative disposal action sequence is mapped to a work order process node. The node flow rules are configured based on the state transition conditions between actions. The verification indicators corresponding to the state verification nodes are used as the node completion judgment conditions. The corresponding intelligent agents are associated with the nodes to construct a multi-agent collaborative maintenance work order with a complete structure, clear responsibilities, and automatic flow, which solves the problem that the content of traditional work orders is limited to phenomenon description and lacks executable steps. More importantly, this invention introduces a dynamic closed-loop correction mechanism in the work order execution process: the actual execution results of each node are collected in real time and deviation analysis is performed with the verification indicators. When the deviation exceeds the preset range, the local reconstruction of the evolution intention decomposition tree is automatically triggered. Based on the deviation information, the corresponding fault location node is traced back, and the intelligent agent is called again to generate the disposal action sequence and update the subsequent unexecuted work order nodes. This mechanism enables work orders to be adaptively adjusted based on actual execution feedback, without the need for manual re-initiation or modification. It effectively overcomes the shortcomings of traditional static work orders in dealing with execution deviations, shortens fault recovery time, and enhances the autonomous repair capability of the operation and maintenance system. Attached Figure Description

[0023] To facilitate understanding by those skilled in the art, the present invention will be further described below with reference to the accompanying drawings.

[0024] Figure 1 This is a flowchart illustrating the multi-agent operation and maintenance work order generation method based on intent decomposition tree evolution of the present invention. Figure 2 This is a schematic diagram of the operation and maintenance work order details and execution verification interface in the intelligent operation and maintenance platform of this invention. Detailed Implementation

[0025] To further illustrate the technical means and effects of the present invention in achieving its intended purpose, the following detailed description of the specific implementation methods, structures, features, and effects of the present invention, in conjunction with the accompanying drawings and preferred embodiments, is provided.

[0026] Please see Figures 1-2 ,in Figure 1 This is a flowchart illustrating the multi-agent operation and maintenance work order generation method based on intent decomposition tree evolution of the present invention. Figure 2This is a schematic diagram of the operation and maintenance work order details and execution verification interface in the intelligent operation and maintenance platform of this invention. The interface follows the work order process as the main line, sequentially displaying the handling steps such as slow SQL diagnosis, maximum connection number adjustment, composite index creation, and performance verification. The performance verification section further presents the thresholds, actual values, and verification results of indicators such as TPS, average response time, and UserID query time, and displays the changes in indicators during the verification period through trend curves. At the same time, the right side records the work order status, priority, scope of impact, and the operation and maintenance intelligent agents involved in the processing. Finally, the work order loop is completed after all verification indicators are passed.

[0027] A multi-agent operation and maintenance work order generation method based on intent decomposition tree evolution includes: The operation and maintenance request information input by the user is parsed to determine the operation and maintenance object and the abnormal manifestation, and an initial intent decomposition tree is constructed. Obtain the historical handling trajectory and current operating status of the operation and maintenance object, perform intention evolution expansion on the target nodes in the initial intention decomposition tree, transform the abstract operation and maintenance target into fault location nodes, handling operation nodes and status verification nodes, and generate an evolved intention decomposition tree; The node hierarchy in the evolution intention decomposition tree is reconstructed to form an operation and maintenance task chain. Based on the task node attributes in the operation and maintenance task chain, the corresponding operation and maintenance agent is called to perform path resolution for the task nodes in the operation and maintenance task chain. The results of the disposal path analysis are mapped to the operation and maintenance work order process structure, and the disposal actions corresponding to different operation and maintenance agents are integrated to generate multi-agent collaborative operation and maintenance work orders.

[0028] This embodiment takes a performance anomaly in an online transaction system of an e-commerce platform as an example. Using the illustrated multi-agent collaboration framework, the operation and maintenance process is divided into four stages: planning, scheduling, execution, and verification. The planning stage corresponds to the parsing of operation and maintenance intent and the evolution of the intent decomposition tree; the scheduling stage corresponds to the formation of the operation and maintenance task chain and the organization of task nodes; the execution stage corresponds to the invocation of operation and maintenance agents and the parsing of handling paths; and the verification stage corresponds to the execution of operation and maintenance work orders and the feedback of execution results. NetworkAPI, CPU Log API, Recent Change API, ITSM, CMDB, and Monitor serve as data and business interfaces for each stage, providing data sources for operation and maintenance object identification, historical handling trajectory acquisition, running status reading, task execution, and status verification.

[0029] Step 1: Parse the user-inputted maintenance request information to determine the maintenance object and anomaly characteristics, and construct an initial intent decomposition tree. In this embodiment, when the operation and maintenance personnel input an operation and maintenance request such as "The system suddenly became slow, please take a look" into the operation and maintenance system, the system first establishes an initial intent decomposition tree around the operation and maintenance object and abnormal characteristics in the operation and maintenance request, providing a structured entry point for subsequent historical handling trajectory positioning and intent evolution.

[0030] The system performs semantic parsing on the maintenance request information, determines that the maintenance object is the e-commerce platform transaction system, and identifies the anomaly as a slow system response.

[0031] The system calls Monitor to read the operational metrics of the e-commerce platform's transaction system over the past 30 minutes. After verification against historical baselines, the average response time of the interface during the normal baseline is 200 ms, the normal TPS is 5000, and the front-end page load timeout rate is 0.5%. The current interface has an average response time of 5200 ms, a TPS of 800, and a page load timeout rate of 30%, thus converting the "system lag" into an abnormal manifestation supported by operational status.

[0032] The system calls CMDB to read the component topology of the e-commerce platform's transaction system and inputs the anomaly representation into a pre-built operations and maintenance knowledge graph. The operations and maintenance knowledge graph records the propagation topology of fault impacts among application servers, Redis, databases, and Kafka.

[0033] The system takes "slower system response" as the starting point for propagation inversion and performs propagation path inversion upstream along the fault impact propagation topology, forming 3 fault hypothesis branches.

[0034] The first fault hypothesis branch is: Redis cache hit rate decreases → database request volume increases → slow SQL accumulation → interface response slows down. The corresponding root cause hypothesis is Redis cache breakdown, and the diagnostic path is Redis hit rate detection, Redis connection count detection, and database QPS detection.

[0035] The second fault hypothesis branch is: the database connection pool reaches its limit → new connections wait → thread blocking → interface response slows down. The corresponding root cause hypothesis is insufficient connection pool configuration, and the diagnostic path is connection pool utilization detection and waiting queue detection.

[0036] The third fault hypothesis branch is: Kafka consumer group lag continues to increase → consumer thread blocking → application server load increases → interface response slows down. The corresponding root cause hypothesis is message queue consumption lag, and the diagnostic path is consumer group lag detection and consumer thread count detection.

[0037] The system uses the "e-commerce platform transaction system" as the root node and connects three fault hypothesis branches to the root node to construct an initial intent decomposition tree. Each fault hypothesis branch retains the corresponding root cause hypothesis and diagnostic path, forming an initial intent structure that expands from the operation and maintenance object to the fault hypothesis branch.

[0038] Step 2: Obtain the historical handling trajectory and current operating status of the operation and maintenance object. Perform intent evolution expansion on the target nodes in the initial intent decomposition tree, transforming the abstract operation and maintenance goal into fault location nodes, handling operation nodes, and status verification nodes, and generating an evolved intent decomposition tree. In this embodiment, after the initial intent decomposition tree is formed, the system does not directly generate handling steps based on the fixed fault template. Instead, it locates the fault stage of the current request from the historical fault evolution process and drives the target node to undergo structural evolution in combination with the current running status, so that the abstract operation and maintenance target is gradually transformed into executable fault location, handling operations and status verification nodes.

[0039] Based on the anomaly representation in the initial intent decomposition tree, the system retrieves historical fault instances through ITSM and reads the fault propagation path corresponding to the historical fault instances from the operation and maintenance knowledge graph.

[0040] This embodiment retrieved a historical fault instance from three months ago, where the system experienced lag during a major sales event. The historical fault instance recorded a complete state transition process: T0: Average interface response time 200 ms, TPS 5000; T1: Business traffic increases to 3 times the normal level; T2: Redis cache hit rate drops to 20%; T3: Database QPS increased to 50,000; T4: The number of slow SQL queries reaches 200 per minute; T5: Average interface response time exceeds 5000 ms, TPS is less than 1000; T6: The system response has slowed down significantly.

[0041] The system matches the current anomaly characteristics with the state transition nodes in the historical fault propagation path to their evolution stages. The current operating state has an average interface response time of 5200 ms, a TPS of 800, and a timeout rate of 30%, which is closest to the state range of the T5 node. Therefore, the current fault is determined to be in the T5 stage of the historical fault propagation path.

[0042] The system further locates the switching node from the anomaly location stage to the handling execution stage along the historical fault propagation path, identifies the switching node as the target node, and reads the historical handling trajectory corresponding to the target node from the ITSM.

[0043] The historical handling trajectory records the fault location process, the handling operation process, and the status verification process. The fault location process includes performing slow SQL analysis and reading the execution plan; the handling operation process includes creating indexes and adjusting the maximum number of database connections; the status verification process includes the TPS, interface response time, and sustained stability time after handling.

[0044] After identifying the target node, the system analyzes the fault location node, handling operation node, and status verification node from the historical handling trajectory, and reads the corresponding operating status, configuration parameters, and node connection information of the node to form node evolution characteristics.

[0045] The database operating status corresponding to the historical fault location node is as follows: CPU utilization 92%, active connections 950, slow SQL statements 180 / min; the maximum number of database connections corresponding to the historical handling operation node is 1000, and the number of historical application servers is 20; the TPS corresponding to the historical status verification node is 4500, the average response time is 300 ms, and it remains stable for 10 minutes.

[0046] Meanwhile, the system reads the current running status through Monitor, CMDB and Recent Change API. The current database CPU utilization is 96%, the number of active connections is 820, the number of slow SQL queries is 210 per minute, the maximum number of database connections is 1000, and the number of application servers has been expanded from 20 during the historical failure to 30.

[0047] The system inputs the node evolution characteristics and current running status into the intention evolution model.

[0048] The intent evolution model includes a historical trajectory encoding layer, a state transition determination layer, and a node evolution evaluation layer.

[0049] In the historical trajectory coding layer, the historical fault location process, handling operation process and status verification process are encoded, and the fault location operation sequence, handling operation sequence and status verification index sequence are converted into historical handling features.

[0050] In the state transition determination layer, historical handling characteristics are compared with the current operating state to determine the state transition. This embodiment uses the distance between historical handling characteristic H and current operating state characteristic C to determine the degree of fit A. A=exp(-λ×|HC| 2 ), Where A represents the degree of adaptation, H represents historical handling characteristics, C represents current operating status characteristics, and λ represents the attenuation coefficient. The system calibrates λ based on the manually labeled results of 50 historical fault scenarios, determining λ=0.5. In this embodiment, the combined difference between H and C is 0.32, therefore: A = exp(-0.5 × 0.32) = 0.852.

[0051] In the node evolution evaluation layer, the node evolution direction corresponding to the target node is determined based on the degree of adaptation. In this embodiment, the high adaptation threshold is preset to 0.70. When A≥0.70, the core processing actions in the historical processing path are retained, and the execution parameters are adjusted according to the current running status. When 0.50≤A<0.70, the adapted nodes in the historical processing path are retained, and the processing nodes with insufficient adaptation are replaced. When A<0.50, the historical processing path is stopped, and subsequent processing actions are replanned.

[0052] In this embodiment, A=0.852, so the node evolution direction is determined to retain the core processing actions in the historical processing path, and the execution parameters are re-determined based on the current running status.

[0053] The system performs node splitting on the target node based on the node evolution results. First, a fault location node is generated, with the content "Analyze the execution plan of the TOP 10 slow SQL queries and confirm missing indexes"; then, a handling operation node is generated, including "Adjust the maximum number of database connections" and "Create a composite index"; finally, a status verification node is generated to verify TPS, average response time, and stable duration.

[0054] The decision to adjust the maximum number of connections to 1500 was based on the current operating status and resource capacity verification. Monitor data showed approximately 13.2 GB of free database memory. Historical monitoring showed that each additional database connection consumed an average of approximately 8 MB of memory. Adjusting the maximum number of connections from 1000 to 1500 is expected to increase memory usage by approximately 4 GB, which is still within the current resource margin. Adjusting it to 2000 would increase memory usage by approximately 8 GB, and combined with temporary database buffering and operating system reserves, this would significantly compress the safety margin. Therefore, 1500 was chosen as the current parameter.

[0055] Therefore, the original target node evolved from the abstract operation and maintenance target to: Fault location node → Handling operation node → Status verification node.

[0056] Other failure hypothesis branches are retained in the evolution intention decomposition tree as backup evolution branches.

[0057] Step 3: Reconstruct the path of the node relationships in the evolutionary intent decomposition tree to form an operation and maintenance task chain. Based on the attributes of the task nodes in the operation and maintenance task chain, call the corresponding operation and maintenance agent to perform path resolution for the task nodes in the operation and maintenance task chain. In this embodiment, after the evolution intention decomposition tree is formed, the system enters the scheduling and execution phase. Instead of directly generating work orders according to the tree structure order, the different node branches are first reconstructed into executable task paths. Then, based on the processing object and disposal target corresponding to the task node, the professional operation and maintenance intelligent agent is called, and the execution status of the previous intelligent agent is used to drive the next intelligent agent to continue the disposal.

[0058] The system extracts fault location nodes, handling operation nodes, and status verification nodes along each node branch of the evolution intention decomposition tree to form candidate paths.

[0059] This embodiment generates 3 candidate paths.

[0060] The first candidate path is: Slow SQL execution plan analysis → Adjust the maximum number of connections to 1500 → Create a composite index → ​​Performance verification.

[0061] The second candidate path is: Connection pool utilization detection → Adjust maximum number of connections → Performance verification.

[0062] The third candidate path is: Kafka consumer group lag detection → Increase the number of consumer threads → Verify consumption rate.

[0063] The system constructs an operation object-action dependency graph for candidate paths, with databases, database connection pools, and Kafka consumer groups as operation objects, and diagnosis, parameter tuning, index creation, and performance verification as action nodes. Execution constraints are determined based on action execution conditions and shared resources.

[0064] For the first candidate path, slow SQL execution plan analysis is a diagnostic action, adjusting the maximum number of connections is a parameter change action, creating a composite index is an I / O intensive action, and performance verification is a post-verification action. Therefore, the execution order is "diagnosis → parameter change → structural change → verification".

[0065] For the second candidate path, the system reads the current database resource status through CMDB and Monitor to verify the resource consumption after increasing the maximum number of connections. When the maximum number of connections is set to 2000, the estimated memory consumption for the new connections is about 8GB. Considering the current memory usage of the database and the space reserved by the operating system, the resource margin is insufficient, so this candidate path is deleted.

[0066] The system converts candidate paths obtained through constraint resolution into candidate task chains and reads the historical execution success rate and average fault recovery time of the candidate task chains from ITSM.

[0067] The first candidate task chain was executed 100 times in the past 6 months, with 93 successes, a historical success rate of 0.93, and an average recovery time of 12 minutes; the third candidate task chain was executed 50 times in the past 6 months, with 34 successes, a historical success rate of 0.68, and an average recovery time of 25 minutes.

[0068] The system adopts: Score = w1 × S - w2 × T The candidate task chains are evaluated, where S is the historical execution success rate, T is the average recovery time, w1=1, and w2=0.03.

[0069] First candidate task chain: Score1=1×0.93-0.03×12=0.57.

[0070] Third candidate task chain: Score3=1×0.68-0.03×25=-0.07.

[0071] Therefore, the first candidate task chain was determined as the final operation and maintenance task chain, and the third candidate task chain was reserved as a backup task chain.

[0072] The system then invokes the corresponding operations and maintenance agent based on the attributes of the task nodes in the final operations and maintenance task chain.

[0073] This embodiment configures three types of professional operation and maintenance intelligent agents: A database diagnostic agent for slow SQL analysis and execution plan diagnosis; A database operations and maintenance intelligent agent used for database index creation and parameter adjustment; The system verification agent is used to verify TPS, average response time, and system stability.

[0074] The system invokes the corresponding operation and maintenance agent based on the processing object and handling target of the task node. The slow SQL diagnosis task node invokes the database diagnosis agent, the maximum connection number adjustment and index creation task node invokes the database operation and maintenance agent, and the performance verification task node invokes the system verification agent.

[0075] The database diagnostic agent generates slow SQL analysis and execution plan diagnostic actions; the database operation and maintenance agent generates "SET GLOBAL max_connections=1500" and "CREATE INDEX idx_ct_status ON order_table(create_time,status)" handling actions; the system verification agent generates TPS and average response time verification actions.

[0076] The system constructs a cross-agent action dependency graph for the actions generated by multiple operation and maintenance agents and performs action context handover.

[0077] After completing the execution plan analysis, the database diagnostic agent sends the top 5 slow SQL queries, their corresponding execution plans, and suggested index fields as the execution results to the database operation and maintenance agent.

[0078] The database operation and maintenance intelligent agent reads the execution results and confirms that the slow SQL mainly involves the create_time and status fields in the order_table. The execution plan shows that the relevant fields have not formed effective indexes. Therefore, a composite index creation action is generated.

[0079] After the database operation and maintenance agent completes the adjustment of the maximum number of connections, it transmits the database parameter update results and the adjusted connection status as the execution results to the subsequent processing nodes; after the index is created, it transmits the index creation results to the system verification agent, which then initiates performance verification.

[0080] This forms a sequence of coordinated actions: Database diagnostic agent analyzes slow SQL queries → Database operation and maintenance agent adjusts maximum connection count → Database operation and maintenance agent creates composite indexes → System verification agent performs performance verification.

[0081] The execution result of the previous operation and maintenance agent is directly used as the context input for the subsequent operation and maintenance agent to generate the disposal action, thus forming a cross-agent disposal context handover.

[0082] Step 4: Map the resolution path analysis results to the operation and maintenance work order process structure, integrate the resolution actions corresponding to different operation and maintenance agents, and generate a multi-agent collaborative operation and maintenance work order. In this embodiment, after the collaborative action sequence is determined, the system enters the verification phase, converts the actions of each agent into work order execution nodes, and judges whether the current work order is completed by continuously verifying the execution results and status verification conditions; when the verification results do not meet the preset conditions, only the local intent decomposition tree corresponding to the abnormal node and the work order process that has not yet been executed are reconstructed.

[0083] The system maps each action in the collaborative action sequence to a work order process node.

[0084] The first work order process node corresponds to slow SQL diagnosis, which is executed by the database diagnosis agent; the second work order process node corresponds to maximum connection number adjustment, which is executed by the database operation and maintenance agent; the third work order process node corresponds to composite index creation, which is executed by the database operation and maintenance agent; and the fourth work order process node corresponds to performance verification, which is executed by the system verification agent.

[0085] The system configures the flow rules for each work order process node based on the sequence of collaborative processing actions. After the first work order process node is completed, the system proceeds to the second work order process node; after the second work order process node is completed, the system proceeds to the third work order process node; and after the third work order process node is completed, the system proceeds to the fourth work order process node.

[0086] The completion conditions for the status verification node are set as follows: TPS≥4000; Average response time <500 ms; The above indicators were maintained continuously for 5 minutes.

[0087] The system writes the above verification conditions into the completion judgment conditions of the corresponding work order process node, and writes the corresponding operation and maintenance intelligent agent into the corresponding work order process node.

[0088] During the work order execution process, the Monitor continuously collects TPS, average response time, number of slow SQL queries, and related query time. The agent reads real-time verification data through the unified interface adaptation layer and records the work order execution results through ITSM.

[0089] In this embodiment, after the slow SQL diagnosis is completed, it is confirmed that the target query has a missing index; the database operation and maintenance agent adjusts the maximum number of connections to 1500, and the database returns that the parameters have been updated successfully; then the composite index idx_ct_status is created.

[0090] After the index was created, the performance verification phase began. Monitor collected running data over 5 minutes, with an average response time of 350 ms, which met the requirement of an average response time < 500 ms. However, the TPS recovered to 3150, failing to meet the completion condition of TPS ≥ 4000.

[0091] The system calculates the TPS verification deviation: Dev_TPS=(4000-3150) / 4000=21.25%.

[0092] The preset deviation threshold is 20%. This threshold is determined based on 100 historical processing samples from the early stages of the system: when the deviation of key verification indicators exceeds 20%, the probability of subsequent processing failure or fault recurrence increases significantly. Therefore, 20% is used as the local reconstruction trigger threshold.

[0093] Since Dev_TPS=21.25%>20%, the system triggers the evolution intention to disassemble the tree and perform local reconstruction.

[0094] The system traces back to the fault location node in the evolution intent decomposition tree for work order process nodes that have not passed verification, and re-calls the database diagnostic agent to expand the scope of slow SQL analysis.

[0095] After analyzing all SQL queries with execution times exceeding 500 ms, the database diagnostic agent identified the following high-frequency queries: SELECT * FROM order_table WHERE user_id=? AND status=?; The average execution time of the SQL was 1.2 seconds, and its execution plan showed that the already established idx_ct_status index was not being used effectively.

[0096] The database diagnostic agent sends the diagnostic result to the database operations agent. The database operations agent then generates the following based on the new diagnostic result: CREATE INDEX idx_user_id ON order_table(user_id).

[0097] The system only performs reconstruction on the local subtree corresponding to the target node. A slow query location node for user_id is added under the original fault location node, a user_id index handling node is added after the original handling operation node, and a verification condition of user_id query time <100 ms is added to the original status verification node.

[0098] Other fault assumptions remain unchanged.

[0099] The system regenerates the actions that have not yet been executed based on the updated local evolution intention decomposition tree, updates the work order process nodes that have not yet been executed, and adds a user_id index optimization node after the original index optimization node.

[0100] After the user_id index is created, the verification is re-executed, and the final result is: The user_id query took 85 ms. TPS=4300; Average response time = 420 ms.

[0101] Each verification metric satisfies the following: 85 ms < 100 ms; 4300≥4000; 420 ms < 500 ms.

[0102] The system confirms that the status verification node is complete and closes the multi-agent collaborative operation and maintenance work order.

[0103] This embodiment completes the entire process from parsing maintenance requests, constructing an initial intent decomposition tree, determining target nodes, evolving and expanding intents, reconstructing paths, generating maintenance task chains, invoking professional maintenance agents, handing over cross-agent handling contexts, generating collaborative maintenance work orders, to verification feedback-driven local reconstruction.

[0104] In this embodiment, during the planning phase, an initial intent decomposition tree is formed based on the maintenance request and the topology of fault impact propagation, and the target node undergoes structural evolution based on historical handling trajectories and the current operating status. During the scheduling phase, an maintenance task chain is formed based on the evolved node structure, and a backup task chain is determined. During the execution phase, different professional maintenance agents are used to handle task nodes, and the handling result of the previous agent becomes the processing input of the next agent through handling context handover. During the verification phase, the status verification node is verified based on the actual operating results. When the verification conditions are not met, only the local intent decomposition tree corresponding to the abnormal node and the work order process that has not yet been executed are updated, realizing the dynamic generation and closed-loop adjustment of multi-agent maintenance work orders.

[0105] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention in any way. Although the present invention has been disclosed above with reference to preferred embodiments, it is not intended to limit the present invention. Any person skilled in the art can make some modifications or alterations to the above-disclosed technical content to create equivalent embodiments without departing from the scope of the present invention. Any modifications, equivalent changes, and alterations made to the above embodiments based on the technical essence of the present invention without departing from the scope of the present invention shall still fall within the scope of the present invention.

Claims

1. A multi-agent operation and maintenance work order generation method based on intent decomposition tree evolution, characterized in that, Includes the following steps: The operation and maintenance request information input by the user is parsed to determine the operation and maintenance object and the abnormal manifestation, and an initial intent decomposition tree is constructed. Obtain the historical handling trajectory and current operating status of the operation and maintenance object, perform intention evolution expansion on the target nodes in the initial intention decomposition tree, transform the abstract operation and maintenance target into fault location nodes, handling operation nodes and status verification nodes, and generate an evolved intention decomposition tree; The node hierarchy in the evolution intention decomposition tree is reconstructed to form an operation and maintenance task chain. Based on the task node attributes in the operation and maintenance task chain, the corresponding operation and maintenance agent is called to perform path resolution for the task nodes in the operation and maintenance task chain. The results of the disposal path analysis are mapped to the operation and maintenance work order process structure, and the disposal actions corresponding to different operation and maintenance agents are integrated to generate multi-agent collaborative operation and maintenance work orders.

2. The method according to claim 1, characterized in that, The operation and maintenance intent parsing includes: The operation and maintenance request information is semantically parsed to extract the operation and maintenance objects and anomaly representations. Based on the fault impact propagation topology in the operation and maintenance knowledge graph, the propagation path of the anomaly representations is inverted to generate corresponding fault hypothesis branches. The fault hypothesis branches are associated with the corresponding root cause hypothesis and diagnosis path. Establish hierarchical connections with the operation and maintenance object as the root node and the fault hypothesis branch as the child node to construct the initial intent decomposition tree.

3. The method according to claim 1, characterized in that, The process of determining the target node includes: Based on the abnormal representation in the initial intent decomposition tree, the corresponding historical fault instances are retrieved in the operation and maintenance knowledge graph, and the fault propagation path in the historical fault instances is extracted. The nodes corresponding to the anomalies are matched with the state transition nodes in the fault propagation path to determine the evolution stages. Nodes in the same fault evolution stage are identified as target nodes, and the historical handling trajectories corresponding to the target nodes are extracted. The historical handling trajectories include the fault location process, handling operation process, and state verification results of multiple historical fault instances.

4. The method according to claim 1, characterized in that, The intention evolution extension includes: Based on the historical handling trajectory corresponding to the target node, the fault location node, handling operation node, and status verification node are extracted from the historical handling trajectory. The running status, configuration parameters, and inter-node connection relationships of each node at the time of the historical fault occurrence are obtained from the historical handling trajectory as node evolution features and input into the intent evolution model. According to the node evolution results output by the intent evolution model, the target node is split into nodes, and the abstract operation and maintenance target is converted into fault location nodes, handling operation nodes, and status verification nodes. The sub-node structure under the target node is reconstructed according to the node hierarchy relationship to generate an evolution intent decomposition tree.

5. The method according to claim 4, characterized in that, The intent evolution model includes a historical trajectory encoding layer, a state transition determination layer, and a node evolution evaluation layer; The historical trajectory encoding layer encodes the fault location process, handling operation process, and status verification process in the historical handling trajectory to generate historical handling features; The state transition determination layer performs a transition determination on the historical processing characteristics based on the current operating state to determine the degree of compatibility between the historical processing process and the current operation and maintenance request; The node evolution evaluation layer determines the node evolution direction corresponding to the target node based on the degree of fit and outputs the node evolution evaluation result.

6. The method according to claim 1, characterized in that, The path reconstruction includes: The node branches in the evolution intention decomposition tree are parsed for execution constraints, and candidate paths formed by sequentially connecting fault location nodes, handling operation nodes and status verification nodes are extracted to construct an operation object-action dependency graph. Identify conflicting operations that act on the same object and have execution order dependencies in different candidate paths. Based on the execution constraints and resource consumption of the conflicting operations, rearrange or merge the conflicting operations in time and eliminate invalid paths that cannot be executed in the current environment to form an operation and maintenance task chain.

7. The method according to claim 6, characterized in that, The formation of the operation and maintenance task chain also includes: Obtain the historical execution success rate and expected fault recovery time corresponding to the candidate task chain, construct a multi-objective optimization function to calculate the comprehensive score of each candidate task chain, select the candidate task chain with the highest comprehensive score as the final operation and maintenance task chain, and store the other candidate task chains as backup task chains. When the final operation and maintenance task chain fails, automatically switch to the backup task chain.

8. The method according to claim 1, characterized in that, The processing path analysis includes: A capability description table for the operation and maintenance intelligent agent is constructed. The capability description table includes the types of faults that the agent is good at handling and the historical success rate of handling them. For each task node in the operation and maintenance task chain, the task node is mapped and matched with the capability description table based on the processing object and handling target of the task node. The operation and maintenance intelligent agent with the highest mapping matching degree handles the corresponding task node, and the operation and maintenance intelligent agent generates a sequence of handling actions as the handling path parsing result.

9. The method according to claim 8, characterized in that, The disposal path analysis also includes: The system acquires the sequence of actions generated by multiple operation and maintenance agents, constructs a cross-agent action dependency graph, identifies actions that act on the same processing object and have execution order dependencies, merges parallel, conflict-free actions for execution, schedules actions with resource contention according to execution constraints, performs handling context handover between adjacent agents, uses the execution result of the previous agent as the context input for the next agent to generate handling actions, and generates a collaborative handling action sequence.

10. The method according to claim 1, characterized in that, The process of generating the multi-agent collaborative operation and maintenance work order includes: Each action in the collaborative action sequence is mapped to a work order process node. The flow rules between work order process nodes are configured based on the state transition conditions between actions. The verification indicators corresponding to the state verification nodes are used as the completion judgment conditions for the work order process nodes. The corresponding operation and maintenance agents are associated with the work order process nodes to generate multi-agent collaborative operation and maintenance work orders.

11. The method according to claim 10, characterized in that, The method further includes: During the execution of multi-agent collaborative operation and maintenance work orders, the actual execution results of the work order process nodes are collected in real time, and the deviation analysis is performed between the actual execution results and the verification indicators corresponding to the status verification nodes. When the deviation exceeds the preset range, the local reconstruction of the evolution intention decomposition tree is triggered. Based on the deviation information, the corresponding fault location node is traced back, the operation and maintenance agent is called again to generate the handling action sequence, and the subsequent unexecuted work order process nodes are updated based on the new handling action sequence.

12. A multi-agent operation and maintenance work order generation system based on intent decomposition tree evolution, comprising a processor for executing the method as described in any one of claims 1 to 11.

Images