Agent-based methods, systems, devices, and storage media for attributing abnormal events.
By constructing an intelligent agent with a dynamically pre-defined knowledge base and feedback data updates, the problem of insufficient accuracy in the attribution analysis of abnormal events in existing technologies is solved. Automatic iteration and closed-loop optimization are achieved, improving attribution efficiency and accuracy, and reducing reliance on human experience.
Patent Information
- Application Number
- CN202611347553.3
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-09-01
- Publication Date
- 2026-11-17
AI Technical Summary
In existing technologies, attribution analysis of abnormal events based on large language models lacks closed-loop optimization capabilities, resulting in insufficient attribution accuracy, inability to achieve cross-session knowledge reuse, and inadequate accuracy and interpretability of the generated attribution reports.
This paper proposes an agent-based attribution method for abnormal events. By constructing a dynamic, pre-defined knowledge base and an agent that updates with feedback data, it achieves automatic iteration and closed-loop optimization of abnormal events. The method retrieves target cases and rules from the pre-defined knowledge base, generates attribution reports using the agent, and updates the knowledge base with feedback data, thus enabling the attribution model to self-iterate and accumulate knowledge.
It improves attribution efficiency and accuracy, reduces reliance on human experience, enables dynamic accumulation of attribution service knowledge and self-iteration of the model, enhances the ability to identify the causes of abnormal events, and solves the problem of agent rigidity.
Smart Images

Figure CN123114828A_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of artificial intelligence technology, and in particular to an agent-based method, system, device, and storage medium for attributing abnormal events. Background Technology
[0002] As information technology systems grow in scale and complexity, timely attribution analysis is crucial to pinpoint the root cause of any abnormal events that occur during system operation. Current technologies rely on large language models to generate attribution analysis reports based on retrieved historical information. However, the internal processing of these models presents a black-box problem, making it difficult to guarantee the standardization and compliance of execution logic in specific service scenarios. This leads to unstable execution quality in the attribution process and reduces the reliability of the attribution results. Furthermore, general models only maintain short-term memory within a single session, failing to achieve cross-session knowledge reuse and hindering the reuse of existing service knowledge. Consequently, the generated attribution reports suffer from deficiencies in accuracy and interpretability. Summary of the Invention
[0003] This application provides an agent-based method, system, device, and storage medium for attributing abnormal events, in order to alleviate or solve the technical problem of insufficient attribution accuracy caused by the lack of closed-loop optimization capabilities in related technologies.
[0004] In a first aspect, embodiments of this application provide an agent-based attribution method for abnormal events, applied to a first end, including: Receive target attribution requests for anomalous events; Based on the target attribution request, target cases and target rules are retrieved from the predetermined knowledge base configured on the first end; the predetermined knowledge base is used to store historical cases and predetermined rules, and the predetermined knowledge base is updated based on the historical attribution reports corresponding to each historical attribution request. The historical cases include attribution process data and historical attribution reports corresponding to historical anomalies, and the predetermined rules are the execution rules followed by each historical case in the attribution process. Based on the target case, the target rule, and the service data associated with the abnormal event, an attribution report of the abnormal event is generated by a first intelligent agent deployed on the first end. The instruction file of the first intelligent agent is updated based on the feedback data of each historical attribution report, and the feedback data represents the data quality of each historical attribution report.
[0005] Secondly, embodiments of this application provide an agent-based attribution method for abnormal events, applied to a second end, including: Send a target attribution request for the anomalous event; Receive and display the attribution report of the abnormal event; The attribution report is generated by a first agent deployed on the first end, based on target cases, target rules, and service data associated with the anomalous event. The instruction file of the first agent is updated based on feedback data from each historical attribution report, where the feedback data indicates the data quality of each historical attribution report. The target cases and target rules are retrieved from a predetermined knowledge base configured on the first end based on the target attribution request. The predetermined knowledge base stores historical cases and predetermined rules, and is updated based on the historical attribution reports corresponding to each historical attribution request. The historical cases include attribution process data and historical attribution reports for the corresponding historical anomalous events, and the predetermined rules are the execution rules followed by each historical case during the attribution process.
[0006] Thirdly, embodiments of this application provide an agent-based attribution system for abnormal events, characterized in that it includes: a first terminal and a second terminal; The second end is used to send a target attribution request for the abnormal event; The first end is configured to retrieve target cases and target rules from a predetermined knowledge base configured on the first end based on the received target attribution request. The predetermined knowledge base stores historical cases and predetermined rules, and is updated based on historical attribution reports corresponding to each historical attribution request. The historical cases include attribution process data and historical attribution reports for corresponding historical anomalies, and the predetermined rules are the execution rules followed by each historical case during the attribution process. Based on the target cases, the target rules, and service data associated with the anomaly, the first intelligent agent deployed on the first end generates an attribution report for the anomaly. The instruction file of the first intelligent agent is updated based on feedback data from each historical attribution report, and the feedback data indicates the data quality of each historical attribution report. The attribution report is then sent to the second end. The second terminal is used to receive and display the attribution report.
[0007] Fourthly, embodiments of this application provide an electronic device, including a memory, a processor, and a computer program stored in the memory, wherein the processor implements any of the methods of embodiments of this application when executing the computer program.
[0008] Fifthly, embodiments of this application provide a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the method of any one of the embodiments of this application.
[0009] Sixthly, embodiments of this application provide a computer program product, including a computer program that, when executed by a processor, implements any of the methods described in the embodiments of this application.
[0010] Based on the agent-based attribution method for abnormal events described in the first aspect above, this application has at least the following beneficial effects or advantages: The embodiments of this application, by constructing a dynamic predetermined knowledge base and combining it with a first agent updated by feedback data for reasoning, achieve automatic iteration of abnormal event attribution, improving attribution efficiency and accuracy, and solving the problems of response lag and difficulty in improving attribution quality caused by relying on human experience. By retrieving target cases and rules from the predetermined knowledge base and reusing the experience provided by historical attribution reports, the reliance on human expert experience is reduced. Real-time updates to the predetermined knowledge base enable dynamic accumulation of attribution service knowledge. Updates to the agent using feedback data achieve closed-loop optimization and self-iteration of the attribution model, enhancing the ability to identify the causes of abnormal events and solving the problem of agent rigidity caused by manually setting attribution rules.
[0011] The above description is only an overview of the technical solution of this application. In order to better understand the technical means of this application, it can be implemented according to the contents of the specification. In order to make the above and other objects, features and advantages of this application more obvious and understandable, specific embodiments of this application are given below. Attached Figure Description
[0012] In the accompanying drawings, unless otherwise specified, the same reference numerals throughout the various drawings denote the same or similar parts or elements. These drawings are not necessarily drawn to scale. It should be understood that these drawings depict only some embodiments according to this application and should not be construed as limiting the scope of this application.
[0013] Figure 1 The flowchart of an agent-based attribution method for abnormal events provided in an embodiment of this application is shown. Figure 2 A flowchart of another agent-based attribution method for abnormal events provided in an embodiment of this application is shown; Figure 3 This illustration shows a schematic diagram of an agent-based attribution system for abnormal events provided in an embodiment of this application. Figure 4 This illustration shows an architecture diagram of an agent-based attribution method for abnormal events provided in an embodiment of this application; Figure 5 This illustration shows a first flowchart of an agent-based attribution method for abnormal events provided in an embodiment of this application. Figure 6This illustration shows a second flowchart of an agent-based attribution method for abnormal events provided in an embodiment of this application. Figure 7 The diagram illustrates a third process flow of an agent-based attribution method for abnormal events provided in an embodiment of this application. Figure 8 This illustration shows a first interface diagram of an agent-based attribution method for abnormal events provided in an embodiment of this application. Figure 9 This illustration shows a second interface diagram of an agent-based attribution method for abnormal events provided in an embodiment of this application. Figure 10 This illustration shows a third interface diagram of an agent-based attribution method for abnormal events provided in an embodiment of this application. Figure 11 This illustration shows a schematic block diagram of an agent-based attribution device for abnormal events provided in an embodiment of this application. Figure 12 This paper shows a schematic block diagram of another agent-based attribution device for abnormal events provided in an embodiment of this application; Figure 13 A block diagram of an electronic device provided in an embodiment of this application is shown. Detailed Implementation
[0014] In the following description, only certain exemplary embodiments are briefly described. As those skilled in the art will recognize, the described embodiments can be modified in various ways without departing from the concept or scope of this application. Therefore, the drawings and description are considered to be exemplary in nature and not restrictive.
[0015] To facilitate understanding of the technical solutions of the embodiments of this application, the relevant technologies of the embodiments of this application are described below. The following relevant technologies are optional solutions and can be combined with the technical solutions of the embodiments of this application in any way, and all of them fall within the protection scope of the embodiments of this application.
[0016] It should be noted that the application scenarios or examples provided in the embodiments of this application are for ease of understanding, and the embodiments of this application do not specifically limit the application of the technical solutions. In addition, the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use and processing of related data must comply with the relevant laws, regulations and standards of relevant countries and regions, and corresponding operation entry points are provided for users to choose to authorize or refuse.
[0017] Because the service planning algorithm relies on multiple sampling strategies, constraints, and multi-layered combination operations, users cannot reverse-engineer the decision path when anomalies occur. Attribution analysis of these anomalies requires the intervention of dedicated engineers, and everything from data retrieval to explanation is done manually. This subjective human processing capability limits the responsiveness of the attribution analysis. Furthermore, related technologies struggle to handle batch tasks and tasks outside of working hours. All batch attribution requests aggregated by users rely on engineers for manual online processing, and requests submitted during off-peak hours such as nights and weekends cannot receive timely responses.
[0018] The experience accumulated during attribution analysis in related technologies cannot be effectively preserved. Even when the same type of anomaly occurs repeatedly, the judgment experience and analysis paths accumulated manually are difficult to transfer and share within the team. After execution, the analysis process and conclusions are not retained; each time a similar problem is encountered, it is necessary to re-enter and re-query, and the judgment logic and attribution paths accumulated in historical analysis cannot be reused. The intelligent answering methods provided in related technologies only have short-term memory capabilities within the same session; the memory is cleared after the session ends, making it impossible to continuously accumulate and iterate analysis experience across different attribution tasks. Related technologies lack a built-in structured knowledge storage mechanism for attribution analysis scenarios. If experience preservation and feedback are required, the knowledge storage is also a flat structure, making it difficult to distinguish and associate different types of experience data. There is a lack of feedback mechanisms for attribution conclusions. Evaluation opinions from algorithm engineers after reviewing the conclusions given by attribution analysis exist only in the form of instant messaging messages or document comments in related technologies. There is no feedback channel for satisfaction with the query results or corrective opinions; these cannot be read and utilized by the attribution analysis system, nor can they affect the quality of the next query, making it difficult to drive continuous improvement of attribution analysis capabilities.
[0019] Therefore, there are shortcomings in the accumulation of experience, utilization of feedback, and continuous operation of attribution analysis in related technologies. The knowledge of attribution analysis is difficult to be accumulated and reused, and the ability of attribution analysis is difficult to be continuously optimized with the feedback during use.
[0020] The technical solution of this application and how it solves the aforementioned technical problems are described in detail below with specific embodiments. The listed specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments. The embodiments of this application will be described in detail below with reference to the accompanying drawings.
[0021] Figure 1 A flowchart of the agent-based attribution method for abnormal events according to an embodiment of this application is shown, as follows: Figure 1 As shown, when applied to the first end, the method may include steps S101, S102, and S103.
[0022] Step S101: Receive a target attribution request for the abnormal event; Step S102: Based on the target attribution request, retrieve the target case and target rule from the predefined knowledge base configured on the first end; the predefined knowledge base is used to store historical cases and predefined rules, and the predefined knowledge base is updated based on the historical attribution report corresponding to each historical attribution request. The historical cases include attribution process data and historical attribution reports of the corresponding historical anomalies, and the predefined rules are the execution rules followed by each historical case in the attribution process. Step S103: Based on the target case, target rules, and service data associated with the abnormal event, the first intelligent agent deployed on the first end generates an attribution report for the abnormal event. The instruction file of the first intelligent agent is updated based on the feedback data of each historical attribution report, and the feedback data indicates the data quality of each historical attribution report.
[0023] In this embodiment, the first terminal receives a target attribution request for an abnormal event. An abnormal event can refer to an event that deviates from the normal state during service operation. The target attribution request is a request used to trigger causal analysis of the abnormal event and can carry relevant parameters of the abnormal event, such as the time of occurrence and service area identifier. Upon receiving the attribution request, the first terminal retrieves historical cases and predetermined rules matching the attribution request from its configured predetermined knowledge base. The predetermined rules are the execution rules followed by each historical case during the attribution process. The predetermined knowledge base is a pre-built and continuously updated structured knowledge storage system, updated based on historical attribution reports corresponding to each historical attribution request. Historical cases include attribution process data and historical attribution reports for the corresponding historical abnormal events. The historical attribution reports are generated based on historical attribution requests, and the attribution process data refers to data recording the processing trajectory during the attribution analysis execution process. The attribution process data focuses on recording how the system performs attribution analysis, recording each processing step and its input / output information from receiving the attribution request to generating the attribution report.
[0024] After retrieving matching historical cases and predefined rules, the first-end, based on these historical cases, predefined rules, and service data associated with the current anomaly, generates an attribution report for the anomaly through a first-level intelligent agent deployed on the first-end. The instruction file of the first-level intelligent agent is updated based on feedback data from each historical attribution report. This feedback data indicates the data quality of each historical attribution report and may include an evaluation of the accuracy of the attribution conclusions and a self-check record of the attribution process. The first-level intelligent agent is an artificial intelligence model used to perform attribution analysis reasoning. It can generate attribution reports in a specified format based on input context information, such as reports in natural language or graphical formats. Updating the first-level intelligent agent refers to updating its instruction file and predefined knowledge base content; it does not involve retraining the model parameters of the first-level intelligent agent, thus avoiding the high costs, long cycles, and uninterpretable conclusions associated with model fine-tuning.
[0025] Because the predefined knowledge base is continuously updated based on historical attribution reports, before each attribution analysis is executed, the first agent can retrieve historical cases and predefined rules matching the current anomalous event from the knowledge base. This provides the first agent with verified reference data, allowing it to learn from successful attribution experiences and avoid repeating errors from previous attributions, thereby improving the accuracy of attribution conclusions. For multiple attribution requests in similar scenarios, the consistency between attribution conclusions is also improved because the same predefined rules are referenced.
[0026] Through the above processing, the automatic evolution of the predetermined knowledge base is achieved. Unlike traditional manual maintenance of knowledge bases, the predetermined knowledge base in this embodiment is automatically updated as attribution requests are executed. After each attribution analysis is completed, the attribution process data and attribution report are accumulated as new historical cases, and the rules discovered during the execution process are extracted as new rules. As attribution requests are continuously executed, the cases and rules in the predetermined knowledge base continue to accumulate, and the attribution capability of the first end is also enhanced, forming a positive self-evolutionary cycle. Since the deployed predetermined knowledge base can be automatically updated, the workload of manually organizing and entering historical experience is reduced. The first intelligent agent is a model used for attribution processing, which can achieve adaptive adjustment based on feedback data, reducing the frequency and cost of manual adjustments.
[0027] In some alternative embodiments, the first end can be either a server or a client. In one deployment configuration, the first end is a server. For example, the first end can be a server or server cluster deployed in a cloud container environment. The target attribution request can originate from a client connected to the first end via a network connection. The client can be a second end, for example, a user submitting an attribution request through a collaborative form or instant messaging component on the client.
[0028] In another deployment model, the first end is a client, which can be a terminal device operated by the user, such as a personal computer or a mobile terminal in a local development environment. In this client-side deployment, the user sending the target attribution request is the user using the client. The user can directly input or select the abnormal event to be analyzed on the client to trigger the target attribution request. The client has a locally deployed first agent and a predefined knowledge base, enabling it to retrieve historical cases and predefined rules locally and generate attribution reports by calling the first agent deployed in the local development environment, without interacting with the server, thus providing local deployment capabilities for attribution analysis. Those skilled in the art can flexibly choose to deploy the first end as a server or a client based on the requirements for computing resources, response latency, data security, etc., in the actual application scenario.
[0029] In some optional embodiments, the attribution process data may include records of data query operations, knowledge retrieval operations, tool call sequences, and file read / write operations. Data query operations may include system-generated database query statements, the name of the target data table, the data partitioning parameters used in the query, the time consumed in query execution, and the size of the result set returned by the query. Records of knowledge retrieval operations may include scene feature parameters used during retrieval, a list of retrieved historical case numbers, a list of matched predetermined rule numbers, and the matching degree of each retrieval result. Records of tool call sequences may include the names of the tool interfaces called in each step, the order in which each tool was called, the input parameters and return results of each tool, whether each tool call was successful, and error messages when it failed. Records of file read / write operations include which configuration files were read, which intermediate result files were written, the storage path of each file, and verification information. Those skilled in the art can set the specific content and granularity of the attribution process data according to the actual processing steps involved in the attribution analysis process; this embodiment does not limit this.
[0030] In some optional embodiments, new historical cases and new rules are generated after each attribution report is generated and automatically added to the case and rule layers of the predetermined knowledge base. The attribution process data can be automatically checked to generate corresponding self-check records, which are stored in the reflection layer of the predetermined knowledge base. Alternatively, a preset feedback integration process can periodically scan the generated attribution reports, extract feedback evaluation content as feedback data, generate an update plan for the predetermined knowledge base based on the feedback content, and execute the update after user confirmation. The above two methods can also be combined to achieve a knowledge base update mechanism that combines automatic accumulation of attribution analysis knowledge with manual review.
[0031] In the embodiments provided in this application, the first end can receive requests of different task types, including attribution requests belonging to the attribution analysis type, and can also handle requests of data query type, algorithm concept question and answer type, and service knowledge query type. An intent routing layer can be set in the first end to handle the classification and distribution of request entry points. This intent routing layer can distribute requests of different task types to corresponding processing paths based on keyword matching and input patterns in the requests of different task types. Each processing path corresponds to a workflow for executing the corresponding task type.
[0032] The intent routing layer can handle various input request formats, including heterogeneous input formats such as natural language descriptions, structured key-value pair parameter strings, and collaborative table links. Input formats can be natural language descriptions, such as descriptive text like "Why did the capacity scale in a certain service area decrease from a first value to a second value within a specific time period?" Input formats can also be structured key-value pair parameter strings, such as semicolon-separated key-value pairs. Input formats can also be collaborative table links, such as links to online data tables containing batch attribution requests. By supporting different heterogeneous input formats, the intent routing layer can adapt to different request submission methods in different service scenarios, improving the usability of the first-side.
[0033] The intent routing layer can distribute requests of different task types to corresponding processing paths based on a hybrid strategy of keyword matching and input format discrimination. Regarding input format discrimination, the intent routing layer can perform initial screening by judging the input format of the request. For example, if the request contains a link and points to a collaborative table, it can be determined as a batch-based, attribution-type task. If the request contains semicolon-separated key-value pairs, the parameter string can be directly parsed, skipping the natural language understanding stage; otherwise, the keyword matching process can begin.
[0034] In keyword matching processing, the intent routing layer can maintain a mapping table between processing paths for different task types and preset keywords. For ease of understanding, the following examples illustrate this: A request containing keywords such as "why," "abnormality," "attribution," "too low," or "too high" can be dispatched to the attribution analysis path. A request containing keywords such as "query," "table," "data," "single quantity," or "scale" can be dispatched to the data query path. A request containing specific algorithm names such as "first calculation mode," "second calculation mode," or "algorithm" can be dispatched to the algorithm concept question-and-answer path. A request containing keywords such as "service line," "constraint," or "granularity" can be dispatched to the service knowledge query path. Each processing path corresponds to a workflow that executes the corresponding task type. The keyword settings described above are for illustrative purposes only and are not intended to impose specific limitations.
[0035] For batch attribution requests, using collaborative table links as input, the intent routing layer can also perform structure validation and pending row filtering of the collaborative table. This verifies whether the collaborative table format meets preset specifications, such as confirming the existence of required columns. Based on the processing status columns of each record in the collaborative table, it can filter out rows that have not yet been processed or need to be reprocessed. After filtering, the intent routing layer can serialize the filtering results into a task list of a predetermined format. The serialized task list can then be passed to the attribution analysis workflow layer for further processing.
[0036] For attribution requests belonging to the attribution analysis type, the attribution processing of abnormal events can be performed by a pre-defined target workflow. The target workflow includes multiple execution units arranged in a pre-defined order, used to indicate the complete execution process of attribution analysis from receipt to delivery. Each execution unit is used to perform different processing steps in the attribution analysis process. The execution order and calling rules of each execution unit in the workflow can be defined in an instruction file, and the first end drives the execution of the workflow by reading this instruction file. Execution units can be hard-coded code segments or calls to the first agent to execute the current step's processing.
[0037] In one optional embodiment, the target workflow employs a unified code logic, applicable to both single and multiple attribution requests. When the target attribution request is a single request, the target workflow executes with a concurrency of one. When the target attribution request consists of multiple requests, the actual concurrency is determined based on the number of requests and a preset maximum concurrency limit, and the target workflow is executed in parallel at this actual concurrency level. For example, assuming the number of requests is N and the preset maximum concurrency limit is K, the actual concurrency can be the smaller value between N and K. This unified code logic design eliminates the maintenance costs and consistency risks associated with maintaining two separate sets of processing code for single and batch requests.
[0038] In one optional embodiment, the identification information carried in the target attribution request can have different levels and granularities, supporting multiple identification formats. The target attribution request can set a merge identifier, a combination identifier, and a configuration segment. The hierarchical relationship among these three is as follows: a merge identifier can include one or more combination identifiers. A merge identifier is an identifier that has a mapping relationship with a combination identifier, and the same combination identifier can include one or more configuration segments. The target attribution request can choose to carry a merge identifier or directly provide a combination identifier according to actual needs. The first end stores a preset mapping relationship between merge identifiers and combination identifiers. By querying the preset mapping table, the merge identifier can be converted into the corresponding combination identifier, and then the subsequent parameter decomposition and parsing process is performed based on the combination identifier. The merge identifier points to the combination identifier through the mapping relationship, and the configuration segment included in the combination identifier represents specific parameters.
[0039] The composite identifier is the identifier of the corresponding service configuration instance, composed of one or more configuration segments. The service configuration instance can be determined based on the service scenario, providing targeted configuration information for different service scenarios. Each configuration segment corresponds to a configuration period or configuration type, and can include sampling seed parameters, fixed-size flag parameters, recruitment cap coefficients, etc., used to define the attributes and strategies of the service configuration instance. By segmenting the composite identifier, detailed configuration information of the service configuration instance can be obtained.
[0040] After receiving the target attribution request, the first-end can parse and complete the parameters carried in the request, automatically completing missing execution parameters. Execution parameters are query parameters required for attribution analysis, specifying the time range and service region to query service data. For example, if the target attribution request only provides a combined identifier, the configuration information of the service configuration instance can be obtained based on the combined identifier. It can then determine if the configuration information lacks the preset query conditions required for attribution analysis, and the first-end can automatically complete execution parameters such as data partition parameters, time parameters, and service region identifier parameters. If the target attribution request provides a merge identifier, the first-end can query a preset mapping table to convert the merge identifier into the corresponding combined identifier, and then complete the parameters based on the converted combined identifier.
[0041] The first end can also perform validity checks on the parameter source. The numeric fields contained in each configuration segment of the combined identifier may be random seed parameters or configuration parameters. When it is necessary to obtain missing execution parameters, the first end is configured to obtain the execution parameters by querying the database. For example, the first end can send a query command to a preset database, using the combined identifier as the query condition, to query the corresponding execution parameters from the database, avoiding attribution analysis bias caused by incorrect extraction of random seeds or configuration parameters.
[0042] In the embodiments provided in this application, before retrieving the target case and target rule from the predetermined knowledge base configured on the first end based on the target attribution request, the following processing may also be included: Check the read / write status of the predefined knowledge base configured on the first end, and the report template read by the first agent deployed on the first end. The report template is used to write the attribution report of the target attribution request in a predefined format. If the read / write status is abnormal or the report template does not conform to the preset configuration, stop executing the target attribution request; Send a notification message to the second end that sent the target attribution request; the notification message is used to indicate why the target attribution request was not executed.
[0043] In this embodiment, the read / write status of the predetermined knowledge base configured in the first terminal is checked, as well as the report template read by the first intelligent agent deployed in the first terminal. The read / write status refers to whether the predetermined knowledge base can currently be read and written normally. The report template is used to write the attribution report of the target attribution request according to a predetermined format. The report template can specify the chapters that the attribution report should include and the order in which the chapters are arranged.
[0044] If the read / write status is abnormal, or the report template does not conform to the preset configuration, the target attribution request will be stopped. Abnormal read / write status could be due to inaccessible storage paths to the knowledge base, corrupted or unparseable index files in the knowledge base, or lack of write permissions to the case file directory. Inconsistent report template configuration could be due to the following: the chapters included in the report template differ from the preset chapters in the preset configuration, or the order of the chapters in the report template differs from the predetermined order in the preset configuration. A notification message will be sent to the second party that sent the target attribution request. This notification message will indicate the reason why the target attribution request was not executed, and may also include suggested remedial measures.
[0045] In related technologies, if the predetermined knowledge base is inaccessible or the attribution report template does not conform to the preset configuration, subsequent retrieval and inference steps will not be executed correctly. Continuing to perform attribution analysis without meeting these preconditions may lead to interruptions in the attribution analysis process, the generation of incomplete attribution reports, or the inability to correctly store and deliver the attribution analysis results. This embodiment achieves access control for attribution analysis by performing a pre-check before retrieving the knowledge base, verifying the readability and writability of the predetermined knowledge base and the standardization of the report template. If the check fails, execution is terminated and a prompt message is sent, thus implementing access control for attribution analysis. This avoids invalid execution and resource waste caused by unavailable knowledge bases or abnormal report templates. The prompt message promptly notifies the second-party of the reason for non-execution, facilitating troubleshooting by the attribution requester.
[0046] In some alternative embodiments, a predetermined knowledge base is the data source upon which the attribution analysis relies. Such checks are used to verify the availability of the data source upon which subsequent data query operations depend, and whether the input parameters are compatible with the data source format. The first end can verify whether the format of the data partitioning parameters carried in the target attribution request is consistent with the format required by the target data table to be queried. Different data tables may use different data partitioning formats; for example, the first data table may require data partitioning parameters to use a first date format, and the second table may require data partitioning parameters to use a second date format. If the data partitioning parameter format does not match the target data table, the query may return an empty result set; therefore, format validation is necessary before executing the query.
[0047] The first end can determine the version type of the target data table to be queried based on the prefix of the combined identifier carried in the target attribution request. For example, when the prefix of the combined identifier is the first prefix, the query can be routed to the online version of the data table; when the prefix of the combined identifier is the second prefix, the query can be routed to the offline version of the data table. By confirming the correctness of the data source selection in the pre-check stage, incorrect data can be obtained due to the query pointing to the wrong version of the data table.
[0048] The first end can also verify whether the predefined knowledge base involved in the target attribution request is accessible, such as checking whether the connection to the predefined knowledge base is normal, and checking the accessibility and writing conditions of the knowledge base on which the attribution analysis depends. If the index file is corrupted or the retrieval interface is abnormal, subsequent knowledge retrieval steps will not be able to obtain valid historical experience data. Therefore, the first end needs to verify the accessibility of the predefined knowledge base, including confirming that the case index file of the predefined knowledge base exists and can be parsed correctly, confirming that the rule index file exists and can be parsed correctly, and verifying whether the case retrieval interface or rule retrieval interface can return structured results normally.
[0049] The first layer can also verify whether write permissions to the predefined knowledge base are available. The predefined knowledge base can be configured with a case layer, a rule layer, and a reflection layer. The case layer contains a case file directory for storing historical cases, and the rule layer contains a rule file directory for storing predefined rules. It can also read the current maximum sequence number in the case index and rule index files to ensure that the sequence number can be read correctly, thus avoiding numbering conflicts when generating new cases or rules. Furthermore, it can verify whether existing case files can be read normally, ensuring that they can be used as format templates for subsequent case generation.
[0050] The first end can verify whether the report template read by the first intelligent agent conforms to the preset configuration, which is a preset document structure specification. For example, it can include verifying whether the template contains a preset number of specified chapters, verifying whether the names of each chapter are consistent with the preset names, and verifying whether the order of each chapter conforms to the preset chapter order. Taking a report template containing eleven required chapters as an example, it can include a basic information chapter, a basic constraint analysis chapter, an algorithm sampling path chapter, a capacity scale calculation chapter, a historical case comparison chapter, a key rule triggering chapter, an anomaly attribution conclusion chapter, a data summary chapter, a cited data chapter, a reference document chapter, and a feedback evaluation chapter. The order and naming of these chapters must not be missing or out of order; the specific chapter names mentioned above are only examples.
[0051] When a target attribution request originates from a collaborative table, the first end can verify the read / write status of the collaborative table. It can also locate the target columns to be read by reading the header content of the collaborative table, such as locating the first target column used to write the attribution report link and the second target column used to record the processing status, without relying on hard-coded column numbers. It can also check whether preset filtering conditions can correctly identify the data rows to be processed, ensuring that subsequent batch processing can accurately filter out the attribution requests that need to be processed. Those skilled in the art can set the specific execution order, checking criteria, and handling strategies for failed checks according to the actual needs and operating environment of the attribution analysis task. For example, some checks can be executed in parallel to improve efficiency, and some checks can be selectively executed according to the task type; this embodiment does not limit this.
[0052] In the embodiments provided in this application, based on the target attribution request, target cases and target rules are retrieved from a predetermined knowledge base configured on the first end, including: Based on the target attribution request, determine the target scenario field of the abnormal event. The target scenario field is used to describe the scenario to which the abnormal event belongs. Based on the first scenario field representing the service mode in each target scenario field, candidate semantic indexes matching the first scenario field are retrieved from the case layer. The case layer is located in the pre-defined knowledge base configured on the first end. Based on the second scenario field representing the exception type in the target scenario field, the target semantic index and the target case corresponding to the target semantic index are retrieved from each candidate semantic index; Based on the overlap of the target scene field with the preset scene tags, the target scene tag that matches the abnormal event is determined from the rule layer, and the target rule corresponding to the target scene tag is determined; each scene tag corresponds to a predetermined rule stored in the rule layer, which is located in the predetermined knowledge base configured on the first end.
[0053] In this embodiment, to prevent the agent from repeating mistakes without referencing historical knowledge, the first end needs to perform hierarchical retrieval from a predetermined knowledge base. The target scenario field is a structured set of fields extracted from the target attribution request, used to describe the scenario in which the abnormal event occurred. The target scenario field can include fields with multiple dimensions, each describing different attributes of the abnormal event. In the retrieval path at the case layer, candidate semantic indexes are retrieved using the first scenario field. These candidate semantic indexes are obtained after a preliminary retrieval at the case layer based on the first scenario field and may contain index information of one or more historical cases that match the first scenario field's matching conditions. Then, the target semantic index is further retrieved from the candidate semantic index using the second scenario field, achieving cross-retrieval at the case layer. The historical case corresponding to the target semantic index is the final retrieved target case. The aforementioned case layer is a data set in the predetermined knowledge base used to store historical case records, storing different historical cases according to each predetermined semantic index.
[0054] In the retrieval path of the rule layer, the overlap between the target scene field and each scene tag is used as the matching criterion to determine the target rule to be referenced. Each scene tag includes one or more preset scene fields. Field overlap refers to the proportion of field values that are consistent between the target scene field and the scene tag in the same field dimension, used to measure the degree of matching between the target scene field and the scene tag. The aforementioned scene tags are pre-labeled for each predefined rule in the rule layer, used to describe the tag information of the scene to which the corresponding predefined rule applies. One or more predefined rules can be stored for the same service scene. The aforementioned rule layer is a data set in the predefined knowledge base used to store predefined rules. Each predefined rule in the rule layer can contain a corresponding scene tag, triggering condition, and recommended action.
[0055] This embodiment achieves targeted retrieval of historical cases and predetermined rules by breaking down scene features into multiple scene fields and employing a hierarchical retrieval strategy to progressively narrow the candidate range. It utilizes field overlap to match predetermined rules. The number of historical cases and predetermined rules stored in the predetermined knowledge base continuously increases as the attribution task is executed. If a single-dimensional keyword matching method is used, a large number of historical records unrelated to the current anomalous event may be retrieved, affecting the efficiency and accuracy of attribution analysis. For anomalous events where the scene is defined by multiple dimensions, a hierarchical retrieval mechanism at the case and rule levels can reduce the matching range of a single retrieval, improve retrieval efficiency, and contribute to improving retrieval accuracy.
[0056] In some optional embodiments, the overlap of fields can be calculated by dividing the number of times the target scene field and the scene label have the same field value on the same dimension by the total number of dimensions. Alternatively, different weights can be assigned to different field dimensions to calculate a weighted overlap. When the field overlap exceeds a preset overlap threshold, it can be determined that the scene label matches an abnormal event.
[0057] In some optional embodiments, to avoid excessive retrieval of historical cases and overloading the agent's context window, historical cases whose similarity meets a predetermined threshold and whose number does not exceed a predetermined number can be identified as target historical cases based on the target scene field. The similarity between the historical cases corresponding to the target semantic index and the abnormal event can be determined by comparing the field values of each dimension in the target scene field with the field values in each target semantic index.
[0058] In some optional embodiments, each attribution request in the first terminal creates an execution directory, serializes the retrieval results for the target attribution request into a structured data file, and persists it to the execution directory of the target attribution request. The retrieval results may include the retrieved target cases and target rules. The first terminal organizes key information such as the case number, scene field, and attribution conclusion of the target case, as well as key information such as the triggering conditions, recommended actions, and matching degree of the target rule, into a structured file according to a preset data structure. This structured file can be stored in a predetermined format and persisted to the execution directory of the current attribution task. It merges the knowledge retrieval results such as cases and rules with the queried service data into a unified attribution context for the first agent to reference when generating an attribution report.
[0059] In some optional embodiments, the retrieved target rule carries a confidence level, which is determined based on the field overlap of the target scene label corresponding to the target rule. The field overlap is directly proportional to the confidence level; the higher the field overlap, the greater the confidence level. When the confidence level of a target rule is greater than or equal to a preset confidence threshold, the first end can use the target rule as a constraint for the current attribution analysis and automatically apply the recommended action of the rule when generating data query instructions or attribution inference. When the confidence level of a target rule is lower than the preset confidence threshold, the first end does not automatically apply the rule but instead attaches it as reference information to the task context. This avoids attribution direction deviation caused by low-confidence historical experience and avoids discarding potentially valuable low-confidence information.
[0060] In the embodiments provided in this application, the first end can adopt a unified data access and concurrent query mechanism when acquiring service data to improve the efficiency and reliability of data acquisition. A unified query template generator can be configured in the first end. This generator generates query instructions for multiple target data tables based on attribution requests, avoiding inconsistencies in field mapping or parameter injection errors introduced by manually writing query instructions. For example, the query template generator can identify the version type of the target data table to be queried, such as online or offline, based on the combined identifier prefix in the attribution request and through preset command routing rules. The query template generator can automatically adapt to the different requirements of different data tables for data partition parameter formats during the generation process. For example, the query template generator is configured with query statement formats corresponding to different data tables; a first date format is used for the first data table, while the second date format is automatically adjusted to the second date format for the second data table, avoiding empty results due to date format mismatch. The first end can use parallel processes to execute query operations on multiple target data tables simultaneously, executing multiple query instructions in sub-processes to obtain service data. The query results can be stored in a standardized structured file format.
[0061] The first end can perform multiple validation operations on the query results. For example, it can confirm that the result files corresponding to each target data table have been generated and are not empty, verify that the core fields in each result file are not missing, check whether the values of numeric fields are within the preset range, and verify whether the embedded structured fields in the result files can be correctly parsed. If any validation fails, the first end can record the reason for the failure and trigger a retry mechanism to try to retrieve the data again.
[0062] In the embodiments provided in this application, based on target cases, target rules, and service data associated with abnormal events, an attribution report for abnormal events is generated by a first intelligent agent deployed on the first end, including the following processing: Based on the target case, target rules, and service data, a task context corresponding to the target attribution request is generated, and the data source of the service data is marked in the task context; The task context is input into the first agent configured on the first end, and an attribution report is output. The data fields referenced in the attribution report are labeled with their corresponding data sources.
[0063] In this embodiment, the first end generates a task context corresponding to the target attribution request based on the retrieved target cases, target rules, and service data associated with the abnormal event. When assembling the task context, each piece of service data is labeled with its source identifier. The integrated structured input data set provides a basis for the first intelligent agent to perform attribution reasoning. It may include the attribution process and conclusion of historical cases, the triggering conditions and recommended actions of predetermined rules, and the service data associated with the current abnormal event.
[0064] Service data is associated with abnormal events and is dynamic operational data obtained from the service operation system by querying the data warehouse or database. It can include basic constraint data, capacity scale data, service forecast data, and supplementary capacity data. Data source is information used to identify where the data is obtained, in order to reduce the model illusion problem of the first agent. Data source can include data table name, data partition identifier, data field name, case number of retrieved historical cases, rule number of matched predetermined rules, etc.
[0065] The first agent inputs a task context, labeled with the data source, from the first endpoint. The first agent then outputs an attribution report. In this attribution report, the referenced data fields are also labeled with their corresponding data sources, ensuring that the source of each data field, from the original service data to the attribution report, can be traced, achieving end-to-end data traceability. The specific source of any data field in the report can be traced back, for example, to a specific data table, a historical case, or a predetermined rule, thereby verifying the reliability of the attribution conclusions.
[0066] In some optional embodiments, the first end can encapsulate the service data and data source within a preset data structure of the task context. This data structure can include a data content field and a data source field, where the data content field stores the specific numerical value or text of the service data, and the data source field stores the source identifier of the service data. For example, for capacity scale data from a basic constraint table, its data source field can record the corresponding data table name and data partition. For attribution conclusions from target cases, its data source field can record the corresponding case number.
[0067] Another alternative approach is to include annotations during the attribution report generation process. For example, when invoking the first agent, the first end can use prompts in the instruction file to instruct the first agent to include source annotations for each data field referenced in the attribution report. Source annotations can be appended to the text of the attribution report in the form of footnotes, reference marks, or embedded tags. For instance, when a capacity scale data is referenced in the attribution report, an annotation can be added after the data to indicate which data table and data partition the data originates from. Alternatively, a jumpable source address can be set for the data field in the attribution report, allowing direct access to the corresponding data source after clicking the source address. Those skilled in the art can set the specific form, granularity, and location of the data source annotations according to the format requirements of the attribution report and the auditing needs of the user; this embodiment does not limit this.
[0068] In the embodiments provided in this application, inputting the task context into the first agent configured on the first end and outputting an attribution report may include the following processing: If the number of task contexts is less than or equal to a predetermined concurrency threshold, each task context is input as the same batch of inputs to the first agent configured on the first end. Based on the existence of identical data content in the task context within the same input batch, the analysis results of the identical data content are reused during the inference process of the first agent configured on the first end to obtain the attribution report corresponding to each attribution request in the same input batch.
[0069] In this embodiment, when the number of task contexts is less than or equal to a predetermined concurrency threshold, the first end inputs each task context as a batch of inputs to the first agent. Task contexts within the same batch are processed in the same execution pipeline. Through batch merging and context reuse, the inference efficiency of the first agent can be improved in batch attribution scenarios. The predetermined concurrency threshold is the maximum number of task contexts allowed to be processed in the same batch. This threshold can be set based on factors such as the maximum context window length of the first agent and the computing resources of the first end. If multiple task contexts within the same input batch contain identical data, the first agent can identify this identical data during inference and reuse the analysis results for the identical data. For identical data that has already been parsed and analyzed, the parsing and analysis operations are not repeated; instead, the previously obtained analysis results are directly referenced and applied to the attribution report generation process of other attribution requests within the same batch, avoiding resource waste caused by redundant calculations.
[0070] This embodiment reduces the redundant computational overhead of the first agent by reusing the analysis results of the same data content during the inference process. For data content that appears repeatedly in multiple task contexts within the same batch, the first agent reduces the computational consumption caused by data parsing, thereby improving the overall processing efficiency in batch attribution scenarios and shortening the total time of batch attribution tasks.
[0071] In some optional embodiments, the same data content can be one or more identical historical cases. When multiple attribution requests within the same batch retrieve the same historical case, the attribution process data and attribution conclusion of that historical case constitute the same data content. Similarly, the same data content can be one or more identical predefined rules. When multiple attribution requests within the same batch match the same execution rule, the triggering condition and recommended action of that rule constitute the same data content. The same data content can also be service data from the same data partition and the same data table. When multiple attribution requests within the same batch need to query the same type of service data within the same time period and service area, the query results constitute the same data content.
[0072] In some optional embodiments, when assembling each task context, the first end can calculate a corresponding feature summary value for each piece of data, and identify the same data content between different task contexts by comparing the feature summary values. The first end can also mark data from the same source within the task context with a unified data identifier, and the first agent can determine whether there are reusable analysis results based on the data identifier during inference. The first agent can also compare the currently pending task context with the task contexts already processed in the same batch during inference to identify and match the same data content.
[0073] In some optional embodiments, after generating attribution reports for each attribution task, the first end can use a concurrent document creation method to submit multiple reports to the collaboration table in parallel. The first end can call a preset concurrent document creation script to start multiple parallel execution subprocesses. Each subprocess is responsible for submitting one attribution report to the collaboration table. After each report is created, the first end can write back the corresponding link address to the corresponding data row in the collaboration table.
[0074] Collaborative tables are a specific implementation of data sharing areas, used to facilitate data interaction between a first-end and a second-end. They are public data sets that can be collaboratively edited and stored by multiple ends, such as online tables provided by a collaborative table platform, where data is organized in a two-dimensional structure of rows and columns. For example, a second end can write its submitted attribution requests into the collaborative table row by row, with each row corresponding to one attribution request and recording the parameter information of each request. The first end can read the attribution requests to be processed from the collaborative table, mark the processing status of initiated attribution analysis, and write back the link to the attribution report and processing status to the corresponding column in the collaborative table after the attribution analysis is completed. The second end can obtain the processing progress and result link of the attribution report by viewing the collaborative table. As a data interaction medium between the first and second ends, collaborative tables enable the submission of attribution requests, the tracking of processing status, and the delivery of attribution results.
[0075] In a single update operation, the first end simultaneously updates two target columns in the collaboration table. The first target column is used to write the link address of the attribution report, and the second target column is used to record the processing status. The first end updates the value of the second target column to indicate a processed status, such as "Not needed, report generated". By updating both columns simultaneously, completed attribution tasks can be avoided from being repeatedly triggered in the next round of scheduled scans. When locating the target row to be updated, the first end dynamically locates it by matching the row content rather than a fixed row number, and rereads the latest status of the collaboration table before each update operation to cope with data changes that may occur in scenarios with concurrent editing by multiple users.
[0076] In the embodiments provided in this application, after generating an attribution report for an anomaly event through a first intelligent agent configured on the first end based on the target case, target rules, and service data associated with the anomaly event, the following processing is also included: Read the endpoint information of the second endpoint to which the target attribution request belongs, determine the access permissions that match the endpoint information, the access permissions are the permissions used to access the attribution report, and the endpoint information is used to identify the second endpoint; The link address of the attribution report is written into the data sharing area. The link address allows access from a second party with the corresponding access permissions. The data sharing area is used for data sharing between the first party and the second party.
[0077] In this embodiment, the first end can be a server, and the second end can be a client. Different clients have different access permissions in the system. The first end reads the end information of the second end to which the target attribution request belongs and determines the access permissions that match that end information. The end information may include a user identifier to identify the identity of the second end, and may also include the device serial number, network address, etc., of the second end. Access permissions are settings used to control the permissions for viewing, editing, or downloading the attribution report. Since the data sharing area can be shared by different second ends and the first end, attribution reports with configured access permissions are written into the data sharing area to achieve controlled delivery of the attribution report. After the first end completes the generation of the attribution report, to avoid sending the entire attribution report, an address link can be used. Different requesters can only access the attribution reports they are authorized to view, ensuring the security and privacy of the report data.
[0078] This embodiment extracts client information from the attribution request and determines the access permissions that match that information, thereby achieving secure delivery and access control of the attribution report. Different second parties can only access the attribution report link that matches their client information. Even if a second party without the corresponding permissions can access the data sharing area, it cannot view the report content that it does not have permission to access, thus ensuring the data security of the attribution report.
[0079] In some alternative embodiments, access permissions may include different levels. For example, access permissions may include read-only permissions, read-write permissions, and download permissions. Read-only permissions allow the second-party device to view the attribution report content but not to modify it. Read-write permissions allow the corresponding second-party device to view and edit the attribution report. Download permissions allow the corresponding second-party device to download the attribution report to its local device.
[0080] In some optional embodiments, the first endpoint sends its endpoint information as a query parameter to an online permission retrieval service, which then returns matching access permissions. The permission retrieval service can maintain the relationship between the endpoint information of each second endpoint and its corresponding access permissions in real time. An empty search result indicates that the second endpoint that submitted the attribution request does not have the permission to submit an attribution report.
[0081] To improve the reliability of access permission queries, this embodiment implements a fallback query scheme. When the online access permission retrieval service is inaccessible, such as due to network failure or service downtime, or when the returned search results do not match any access permissions, the first end can perform an offline query by reading a locally maintained access permission mapping table. This table stores the correspondence between information from different ends and access permissions, and is periodically updated from the online access permission retrieval service. Offline queries allow permission granting to be completed even when the online service is unavailable. If the offline query also fails to find the access permission for the second end, the first end can record the access permission granting status of the attribution report as pending, waiting for external granting. The first end can generate a corresponding prompt message indicating that there is a pending access permission granting task. Through this process, the success rate and robustness of automatically granting access permissions can be increased.
[0082] In the embodiments provided in this application, the feedback data includes self-inspection records and evaluation data corresponding to the attribution report. After generating the attribution report of the abnormal event through the first intelligent agent deployed on the first end based on the target case, target rules, and service data associated with the abnormal event, the following processing is also included: According to multiple predefined checkpoints, the attribution process data included in the attribution report is checked, and self-check records for the attribution report are generated and stored in the reflection layer of the predefined knowledge base. Each checkpoint checks the predefined processing steps in the attribution process data. Based on the self-check record indicating that there are operations in the attribution process data that do not conform to the preset attribution process, a target instruction is generated. The target instruction is used to make the first intelligent agent configured on the first end execute the attribution process of the next attribution request in accordance with the preset attribution process. Based on the evaluation data of each attribution report, the second agent configured on the first end generates adjustment plan information for the first agent configured on the first end. The second agent is used to analyze the attribution conclusions of each attribution report, and the adjustment plan information is used to indicate the fields that need to be modified in the instruction file of the first agent. In response to receiving a confirmation instruction for the adjustment plan information, the instruction file of the first intelligent agent is adjusted by the second intelligent agent belonging to the first end based on the adjustment plan information.
[0083] In this embodiment, the first end checks the attribution process data included in the attribution report according to a number of predefined checkpoints, generates and stores a self-check record for the attribution report, and stores the self-check record as the self-check result of the execution process in the reflection layer of a predetermined knowledge base. Attribution process data refers to data that records the processing trajectory of each step in the attribution analysis execution process, recording the execution order of each processing step, such as whether the knowledge retrieval step is executed before the data query step. The self-check record is a structured record generated after checking each checkpoint item by item based on the attribution process data. The self-check record may include information such as the checkpoint name, check result, description of the problems found, and their severity.
[0084] If the self-check log indicates that there are operations in the attribution process data that do not conform to the preset attribution process, the first end generates a target instruction. This target instruction is used to ensure that the first agent's attribution process conforms to the preset attribution process when executing the next attribution request. The target instruction refers to the instruction generated based on the violation found in the self-check log, used to correct the subsequent attribution analysis execution process. The preset attribution process refers to the processing specifications that each execution step of the attribution analysis should follow, and the preset attribution process can be defined in the first agent's instruction file.
[0085] The first end, based on evaluation data from each attribution report, generates adjustment plan information for the first agent through a second agent. Evaluation data refers to data generated after the user evaluates the data quality of each attribution report. The second agent operates independently of the first agent's attribution analysis process; the two are decoupled in time and resources, and do not block each other. The second agent analyzes the evaluation data from the attribution reports and generates adjustment plan information. The second agent can periodically scan the generated attribution reports according to a preset time window, extracting the evaluation data contained therein for analysis. The adjustment plan information, generated by the second agent based on the evaluation data analysis, is a plan used to modify the first agent's instruction file. The adjustment plan information can list the fields in the instruction file to be modified and their suggested modifications. After receiving a confirmation instruction for the adjustment plan information, the first end, based on the adjustment plan information, adjusts the first agent's instruction file through the second agent. The confirmation instruction must meet preset confirmation conditions, such as containing confirmation words from a preset set of confirmation words.
[0086] Through the above processing, this embodiment addresses both the compliance of the execution process and the rationality of the attribution conclusions. It utilizes a self-inspection channel to generate self-inspection records, performs standardized checks on the attribution process data according to predefined checkpoints, and automatically generates target instructions to correct subsequent execution flows upon detecting violations. This effectively prevents error accumulation and ensures the interpretability of the attribution process. An external audit channel is used to analyze the evaluation data of the attribution report through a second agent, generating adjustment plan information. After manual confirmation, the instruction file of the first agent is corrected. This collaborative approach of introspection and external auditing achieves a closed-loop feedback mechanism for attribution processing, improving the agent's self-correction capabilities.
[0087] In some optional embodiments, self-check records can be written to a reflection layer in a predetermined knowledge base. Self-check records in the reflection layer, historical cases in the case layer, and predetermined rules in the rule layer can be mutually indexed through association identifiers. For example, a self-check record can be queried to find the corresponding historical case using the aforementioned association number, and the relevant predetermined rule can be queried using the association identifier.
[0088] The first aspect involves a multi-dimensional compliance self-check of the execution process of this attribution analysis. This self-reflection can cover multiple dimensions. For example, the first dimension is the process sequence dimension, which can check whether the knowledge retrieval step is executed before the data acquisition step, whether the quality pre-check is confirmed item by item, and whether the execution order of each step conforms to the preset order. The second dimension is the file and data consistency dimension, which can check whether the directory naming conforms to the preset specifications, whether the data field structure of the case records is consistent with the template, whether there are any conflicts in the case numbers, and whether the values of the predetermined fields are consistent across different files. The third dimension is the tool call standardization dimension, which can check whether concurrent queries use the preset parallel processing method, whether data query results are persistently stored, and whether the updates to collaborative tables use dynamic positioning through content matching rather than fixed positioning. The fourth dimension is the report quality dimension, which can check whether the attribution report contains all required sections, whether the attribution conclusions are located in the preset positions in the report, and whether the description of the sampling interval is consistent with the data partitions used in the query. The fifth dimension is the permission granting dimension, which can check whether all submitters have obtained the preset access permissions to the attribution report.
[0089] The first end generates self-check records from the checkpoints according to a preset data structure and persistently stores them in the reflection layer of a predetermined knowledge base. Self-check records can be identified using a preset naming format. When a preset type of problem exists in a self-check record, the first end can mark the field to be updated in the self-check record to trigger the editing process of the instruction file for the first agent.
[0090] In some alternative embodiments, evaluation data can take various forms. For example, evaluation data can be textual evaluations entered by the user in the feedback evaluation section of the attribution report, such as indicating whether the root cause judgment of the attribution conclusion is correct, or suggesting which analytical dimensions to supplement. Alternatively, evaluation data can be quantitative scores given by the user to the attribution report, such as scores for dimensions like attribution accuracy, completeness, and readability. Evaluation data can also be annotations or comments made by the user on specific data fields in the attribution report.
[0091] In the embodiments provided in this application, after generating an attribution report for an anomaly event through a first intelligent agent deployed on the first end based on the target case, target rules, and service data associated with the anomaly event, the method further includes: Based on the attribution process data and attribution reports of anomalous events, generate target historical cases corresponding to the attribution reports; The target historical cases and the semantic index used to identify the target historical cases are stored in the case layer, which is located in the predefined knowledge base at the first end; Based on the attribution process data of anomalous events, candidate rules corresponding to the attribution report are generated. If no candidate rule exists in the predefined rules already stored in the predefined knowledge base, the candidate rule and the corresponding scene label are stored in the rule layer, which is located in the predefined knowledge base at the first end.
[0092] In this embodiment, the first end generates a target historical case corresponding to the attribution report based on the attribution process data and attribution report of the abnormal event. The target historical case is a new historical case generated based on this attribution analysis and is stored in the case layer of the knowledge base. Semantic index refers to index information used to identify and retrieve historical cases. The semantic index can be generated based on scenario fields extracted from the attribution request, such as a combination of service mode fields, capacity line type fields, and abnormality type fields. The semantic index enables subsequent attribution tasks to quickly retrieve matching historical cases based on scenario fields. The case layer is a data set in the predetermined knowledge base used to store historical case records. Each historical case in the case layer can correspond to the complete process and conclusion of the historical attribution analysis. The case layer is stored and managed independently of the reflection layer and rule layer in the predetermined knowledge base.
[0093] The first end also generates candidate rules corresponding to the attribution report based on the attribution process data of the abnormal event. Candidate rules are extracted from the attribution process data of this attribution analysis. Candidate rules need to be verified before being formally stored in the rule layer. To avoid duplicate storage of predefined rules, candidate rules are searched for in the existing rules for deduplication. If a candidate rule does not exist in the predefined rules already stored in the predefined knowledge base, the first end stores the candidate rule and its corresponding scenario tag in the rule layer. Through hierarchical storage and automatic deduplication of cases and rules, the uniqueness and structure of historical cases and predefined rules recorded in the predefined knowledge base are ensured.
[0094] Through the above processing, after the attribution report is generated, attribution process data and attribution conclusions are automatically extracted to generate new historical cases. New predetermined rules are also automatically extracted from the attribution process data and stored in a predetermined knowledge base, achieving automated accumulation and expansion of the knowledge base. The case layer and rule layer store historical cases and predetermined rules respectively. As attribution requests are continuously received and processed, the cases and rules stored in the predetermined knowledge base continuously accumulate. The first agent can retrieve richer historical experience in subsequent attribution analyses, forming a positive cycle of knowledge self-evolution.
[0095] When deploying or updating an intelligent agent attribution system for the first time, it is necessary to reliably deploy validated instruction files, execution scripts, and data from a predefined knowledge base in the development environment to the first-end application. If instruction files and predefined knowledge base data are deployed together, frequent changes to the knowledge base data during operation may affect the stability of the instruction files and execution scripts. Furthermore, if there is a lack of distinction between static configuration data and dynamic runtime data during deployment, it may lead to difficulties in version rollback or data loss.
[0096] To address the aforementioned issues, in the embodiments provided in this application, before receiving the target attribution request for the anomalous event, the following steps are further included: The system receives a pre-set instruction file and execution script, and stores them in the configuration information of the first agent. The instruction file includes behavioral instructions that instruct the first agent to execute attribution requests, and the execution script is a script used to process attribution types. It receives reference cases and reference rules, and stores them as historical cases and predefined rules in the predefined knowledge base configured on the first end.
[0097] In this embodiment, the first terminal receives a pre-defined instruction file and execution script, and stores the instruction file and execution script in the configuration information of the first agent. The instruction file is a configuration file that defines the behavioral instructions that the first agent follows when executing attribution requests. The first agent determines the specific behavior for performing attribution analysis by reading the instruction file. The instruction file can be written using a preset markup language format. The execution script is executable program code used to process attribution types. Multiple execution scripts can be included, each corresponding to a different processing step in the attribution analysis workflow. For example, execution scripts can include data query scripts, data validation scripts, file format conversion scripts, etc.
[0098] The first end also receives reference cases and reference rules, and stores them as historical cases and predefined rules in a predefined knowledge base configured on the first end. Reference cases are the initial historical case records imported into the predefined knowledge base, and can be derived from validated attribution analysis instances in the development environment. After importation, reference cases serve as the initial data for the case layer of the predefined knowledge base, and reference rules are the initial rule records imported into the predefined knowledge base, and can be derived from execution rules extracted from multiple cases in the development environment.
[0099] In this embodiment, the first end can be a client or a server. If the first end is a client, it configures the client's local development environment. The instruction files, execution scripts, reference cases, and reference rules can be obtained by the client from the server. For example, the server can maintain the latest versions of the instruction files and execution scripts, as well as verified reference cases and reference rules. Upon initial deployment or version update, the client can send a configuration retrieval request to the server. In response, the server sends the instruction files, execution scripts, reference cases, and reference rules to the client. After receiving these, the client stores the instruction files and execution scripts in the configuration information of the first agent and stores the reference cases and reference rules in a pre-defined knowledge base configured locally, thereby completing the initialization of the local development environment.
[0100] During the process of the client retrieving configuration data from the server, a batch retrieval approach can be adopted. For example, the client can first retrieve and load the instruction file and execution script as static configuration data from the server, and then retrieve the reference cases and reference rules as initial knowledge data from the server and import them into a predetermined knowledge base. This process is executed separately in time and is independent of each other in storage areas, thereby avoiding the impact of frequent changes in knowledge data on the stability of the static configuration.
[0101] When the first end is the server, the initialization process can involve configuring the cloud container environment where the server resides. The server can be deployed in a cloud container environment, and the loading of instruction files, execution scripts, reference cases, and reference rules can be completed through container images or configuration management tools. For example, during the container image building phase, instruction files and execution scripts can be packaged into the container image and distributed along with the image as static configuration data. When the container starts, the instruction files and execution scripts are automatically loaded into the configuration information of the first agent. Reference cases and reference rules can serve as initial service knowledge data, loaded into a predefined knowledge base by mounting external storage volumes or pulling them from a configuration center. When instruction files or execution scripts need to be updated, this is done by rebuilding the container image and continuously updating the container instance. Newly added historical cases and predefined rules on the server can be persisted to the predefined knowledge base to ensure that knowledge base data is not lost after container restarts or rescheduling. Since static configuration data and dynamic knowledge data are stored and managed independently, frequent changes to knowledge such as cases, rules, and feedback data can avoid triggering frequent rebuilds of the container image, thereby improving the operational stability of the server.
[0102] In some optional embodiments, the instruction file may also include information such as the calling order of each execution unit in the attribution analysis workflow, the processing rules of each execution unit, and the format requirements of the report template. The execution units can schedule the first intelligent agent according to the settings of the instruction file.
[0103] When the system has a first end and a second end deploying a first intelligent agent and a predetermined knowledge base respectively, each end runs the attribution analysis task independently locally, generating its own historical cases, predetermined rules, and self-check records. If the knowledge base data between the ends cannot be shared, the data accumulation of the knowledge bases of each end will be isolated, making it impossible to share the experience accumulated in attribution analysis, thus reducing the richness of the overall system's knowledge base and the consistency and quality of attribution analysis. The embodiments provided in this application also include: In response to receiving a synchronization request from the second end, at least one of the following data from the first end’s predetermined knowledge base: historical cases, predetermined rules, and self-check records, is sent to the second end. The feedback data includes self-check records, which are generated based on the attribution process data included in the corresponding historical attribution report. In response to receiving synchronization data sent by the second end, the synchronization data is stored in a predetermined knowledge base configured by the first end; the synchronization data is generated by the first intelligent agent deployed on the second end, and the synchronization data includes at least one of the following data generated locally by the second end: historical cases, predetermined rules, and self-check records.
[0104] In this embodiment, a bidirectional knowledge base synchronization mechanism is constructed between the endpoints. For the first endpoint, in the data sending direction, in response to a synchronization request, it sends at least one of its local historical cases, predefined rules, and self-check records to the requester. The synchronization request is sent from the second endpoint to the first endpoint to request knowledge base data. The synchronization request can carry parameters such as the requested data type, the time range of the requested data, and the upper limit of the requested data volume. The first endpoint can filter and return data that meets the conditions based on the parameters carried in the synchronization request. Data types can include case types, rule types, and feedback data types. In the data receiving direction, the synchronized data is received and stored in the local predefined knowledge base. Through bidirectional synchronization, data sharing and collaborative evolution of the knowledge bases of each endpoint are achieved.
[0105] In the above embodiments, the first end can be a server, and the second end can be a client. In this deployment configuration, the first end is deployed as a server in a cloud container environment, and the second end is deployed as a client on the user's local device. Both the server and the client are configured with a first intelligent agent and a predetermined knowledge base, and can independently execute attribution analysis tasks.
[0106] In terms of data transmission, when a client needs to retrieve the latest knowledge base data from the server, it can send a synchronization request to the server. In response to this request, the server sends at least one of the following data from its pre-defined knowledge base to the client: historical cases, pre-defined rules, and self-check records. For example, when a client first deploys or comes back online after a long period of offline activity, it can request a full synchronization to retrieve all historical cases and pre-defined rules accumulated by the server. Alternatively, the client can request incremental synchronization to retrieve data added by the server since the last synchronization.
[0107] On the data receiving side, when a client runs an attribution analysis task locally, it also generates new historical cases, predefined rules, and self-check records. The client can send this locally generated data to the server as synchronization data. After receiving this synchronization data, the server stores it in its predefined knowledge base. In this way, the server can aggregate knowledge base data from multiple clients to form a richer knowledge base, while each client can also acquire the experience accumulated by other clients from the server through synchronization.
[0108] In the above embodiments, the first end can be deployed as a client on the user's local device, and the second end can be deployed as a server in a cloud container environment. Each client and server is configured with a first intelligent agent and a predetermined knowledge base, and both can independently execute attribution analysis tasks.
[0109] In terms of data transmission, when the server needs to retrieve locally generated knowledge base data from the client, it can proactively send a synchronization request to the client. In response to this synchronization request, the client sends at least one type of data from its local predefined knowledge base: historical cases, predefined rules, and self-check records. For example, if the client completes a batch of attribution analysis tasks offline, generating new historical cases and predefined rules, the server can request synchronization from the client to sync the data generated during the client's offline period to the server.
[0110] In terms of data reception, as the server continuously processes online attribution requests, its predefined knowledge base constantly accumulates new historical cases, predefined rules, and self-check records. The server can respond to data acquisition requests sent by clients, or, according to a preset period, send the newly generated data as synchronization data to the client. This synchronization data includes at least one of the following: historical cases, predefined rules, and self-check records generated locally on the server. After receiving this synchronization data, the client stores it in its locally configured predefined knowledge base. Through this method, the client can obtain global attribution experience from the server, including attribution knowledge accumulated by other clients and aggregated by the server, thereby improving the quality of local offline attribution analysis.
[0111] In some optional embodiments, for data consistency verification after synchronization, for example, after receiving the synchronized data and storing it in a local predetermined knowledge base, the first end can compare the data states before and after synchronization to confirm whether the synchronization operation was completed correctly. The first end and the second end can respectively calculate the feature digest values of the data in their respective predetermined knowledge bases, and verify the consistency of the data at both ends by comparing the feature digest values.
[0112] Figure 2 A flowchart of another agent-based attribution method for abnormal events provided in an embodiment of this application is shown, such as... Figure 2 As shown, when applied to the second end, the method may include steps S201 and S202.
[0113] Step S201: Send a target attribution request for the abnormal event to the first end; Step S202: Receive and display the attribution report of the abnormal event; The attribution report is generated by the first agent deployed on the first end based on the target case, target rule, and service data associated with the anomalous event. The instruction file of the first agent is updated based on the feedback data of each historical attribution report, and the feedback data indicates the data quality of each historical attribution report. The target case and target rule are retrieved from the predetermined knowledge base configured on the first end based on the target attribution request. The predetermined knowledge base is used to store historical cases and predetermined rules, and it is updated based on the historical attribution reports corresponding to each historical attribution request. Historical cases include attribution process data and historical attribution reports of the corresponding historical anomalous events, and predetermined rules are the execution rules followed by each historical case in the attribution process.
[0114] In this embodiment, the method is applied to a second end, which acts as both the request initiator and the report receiver, and can be a client. The second end sends a target attribution request for the anomalous event to the first end. After sending the request, the second end receives and displays an attribution report for the anomalous event. The generation process of the attribution report involves the first end retrieving historical experience from an evolving, predetermined knowledge base and invoking a first intelligent agent that is continuously updated based on feedback data to perform inference. The first end is a server that deploys a first intelligent agent and a predetermined knowledge base to perform attribution analysis.
[0115] In some optional embodiments, the second end provides a human-computer interaction interface. After the user inputs relevant parameters of the abnormal event in the human-computer interaction interface, the second end assembles the parameters into a target attribution request and sends it to the first end. The second end submits the attribution request through a collaborative table on a collaborative table platform. The collaborative table serves as a data sharing area between the first and second ends. The user fills in the attribution request parameters row by row in the collaborative table. The data rows to be processed in the collaborative table are serialized into the target attribution request and sent to the first end for attribution analysis.
[0116] In some optional embodiments, the second end can receive a link to the attribution report returned by the first end, allowing the user to view the full content of the attribution report in a browser or document application by clicking the link. The second end can also receive the full text or summary information of the attribution report and render it in a local interactive interface. The summary information allows the user to quickly understand the attribution conclusions and view the full report as needed.
[0117] The embodiments provided in this application also include: According to the first predetermined period, a synchronization request is sent to the first end, and at least one type of data is received from the historical cases, predetermined rules and self-inspection records stored in the predetermined knowledge base configured on the first end. Update the pre-deployed knowledge base on the second end based on at least one type of data received; Synchronization data is sent to the first end according to the second predetermined cycle. The synchronization data is generated by the first intelligent agent deployed on the second end and includes at least one of the following data: historical cases, predetermined rules, and self-check records generated locally on the second end.
[0118] In this embodiment, the second end can be a client, and the first end can be a server. The second end sends a synchronization request to the first end according to a first predetermined period and receives at least one type of data from the first end, including historical cases, predetermined rules, and self-check records. The first predetermined period is the time period during which the second end sends a synchronization request to the first end to retrieve knowledge base data. The first predetermined period can be a fixed time interval, such as once every thirty minutes or hour. The first predetermined period can also be a variable period that is dynamically adjusted according to the operating load or network status of the second end.
[0119] In terms of data push, the second scheduled period sends locally generated synchronous data from the second end to the first end. The first end, acting as a server, can interact with multiple clients. Through bidirectional synchronization, the second end can independently run attribution analysis and maintain data exchange with the first end's knowledge base. The second scheduled period is the time interval during which the second end sends locally generated synchronous data to the first end. The second scheduled period can be the same as or different from the first scheduled period. For example, the second scheduled period can be set to a longer time interval than the first scheduled period to reduce push frequency and network overhead. Alternatively, the second scheduled period can be set to trigger a push after a certain amount of new data is generated locally.
[0120] This embodiment establishes a bidirectional, periodic knowledge base data synchronization mechanism between the second end and the first end. The second end can obtain cases, rules, and feedback data gathered by the first end, and can also contribute locally generated knowledge to the first end, so that the knowledge bases of each end can maintain data interoperability and collaborative growth.
[0121] Figure 3 A schematic diagram of an agent-based attribution system for abnormal events according to an embodiment of this application is shown, such as... Figure 3 As shown, it includes a first end 301 and a second end 302.
[0122] The second end is used to send target attribution requests for abnormal events; The first end retrieves target cases and target rules from a predefined knowledge base configured on the first end based on the received target attribution request. The predefined knowledge base stores historical cases and predefined rules, and is updated based on historical attribution reports corresponding to each historical attribution request. Historical cases include attribution process data and historical attribution reports for corresponding historical anomalies, and predefined rules are the execution rules followed by each historical case during the attribution process. Based on the target cases, target rules, and service data associated with the anomaly, the first agent deployed on the first end generates an attribution report for the anomaly. The instruction file of the first agent is updated based on feedback data from each historical attribution report, and the feedback data indicates the data quality of each historical attribution report. The attribution report is then sent to the second end. The second end is used to receive and display attribution reports.
[0123] In this embodiment, the system includes a first end and a second end. The first end acts as a server, and the second end acts as a client. The two ends interact with each other via a network. The first end can be deployed in a cloud container environment or a physical server. The first end is configured with a predetermined knowledge base and a first intelligent agent. The predetermined knowledge base is used to store historical cases, predetermined rules, and self-check records. It can perform knowledge retrieval during attribution analysis and be updated after the attribution analysis is completed. The first intelligent agent is a large language model used to perform attribution analysis reasoning. It determines behavioral rules based on instruction files and continuously optimizes its reasoning capabilities based on feedback data from various historical attribution reports. Updating the first intelligent agent refers to updating its instruction files and the content of the predetermined knowledge base, without involving retraining the underlying model parameters. The second end is deployed on a client operated by the user and can be configured on a personal computer, mobile terminal, etc. The second end can also be configured with a local predetermined knowledge base and a local first intelligent agent, supporting independent execution of attribution analysis tasks locally when the network is offline or has high latency.
[0124] Based on the above optional embodiments, this application also provides an optional implementation method, in which the server is the first end and the client is the second end. The server is equipped with a first intelligent agent and a predetermined knowledge base, used to execute attribution analysis calculation logic and knowledge base data management. The server can be deployed in a cloud container environment. The client is a terminal device operated by the user, used to submit attribution requests to the server and receive attribution reports. The server and the client interact with each other via a network.
[0125] Figure 4The overall server architecture is shown, including an intent routing layer, a unified attribution workflow layer, a data access layer, a three-layer knowledge base layer, a dual-loop feedback layer, a collaborative table layer, and a cloud-based continuous operation layer. These layers communicate via predefined interface protocols, and inter-layer dependencies follow a unidirectional dependency principle: upper layers depend on lower layers, and lower layers are unaware of the existence of upper layers. There is bidirectional data flow between the three-layer knowledge base layer and the unified attribution workflow layer. Before execution, the unified attribution workflow layer reads historical cases and predefined rules from the three-layer knowledge base layer; after execution, it writes newly generated cases and rules from the current attribution analysis back to the three-layer knowledge base layer, thus forming a positive feedback loop of knowledge self-evolution.
[0126] The intent routing layer is responsible for classifying and distributing request entry points. It supports receiving three heterogeneous input formats: natural language descriptions, structured key-value pair parameter strings, and collaborative table links. It adopts a hybrid strategy that combines keyword matching and input format discrimination to distribute requests to four types of processing paths: attribution analysis, data query, algorithm concept question and answer, or service knowledge query.
[0127] The unified attribution workflow layer is the execution engine for attribution analysis. Single attribution requests and batch attribution requests share the same execution pipeline. A single attribution request is a special case with a concurrency of 1. The concurrency of batch attribution requests is adaptively adjusted based on the number of tasks to the smaller of the number of tasks and the preset concurrency limit.
[0128] The data access layer encapsulates the logic for retrieving service data from the data warehouse and generates query statements for multiple core data tables using parameterized templates, thereby ensuring consistency in field mapping. Query execution employs a concurrent mode, and query results are stored in a standardized structured file format.
[0129] The three-layer knowledge base is used to store attribution experience and consists of three sets of structured files: a case layer, a rule layer, and a reflection layer. The case layer records the complete context and attribution conclusions of each attribution analysis; the rule layer stores quantifiable rules extracted from multiple historical cases; and the reflection layer records the self-check records of the workflow execution process.
[0130] The dual-loop feedback layer provides two parallel knowledge feedback channels. The self-inspection channel generates self-inspection records after each attribution analysis execution, including process sequence, document consistency, tool call specifications, report quality, and permission granting, and persists these records to the reflection layer. The external audit channel obtains evaluation sections from each attribution report, extracts evaluation data for the attribution reports, and iterates the workflow based on improvement points after obtaining explicit confirmation from the user.
[0131] The collaborative table layer is used for the standardized delivery and structured collection of attribution reports. The collaborative table includes links to various attribution reports. Each attribution report contains multiple required sections according to a predetermined format, with evaluation sections following each section for providing feedback. The collaborative table layer is also used in batch attribution scenarios to simultaneously write back multiple target columns in the collaborative table, and to grant permissions to attribution report submitters.
[0132] The cloud-based continuous execution layer is used to support the continuous operation of intelligent agents in a containerized execution environment. It has a built-in timed scanning daemon that scans the pending tasks in the collaboration table at preset intervals and automatically triggers the attribution workflow upon detecting a pending task. The cloud-based continuous execution layer resides on the server side of the cloud container environment and maintains data consistency with the client side located in the local development environment through bidirectional synchronization.
[0133] The server needs to perform system initialization, receive pre-defined instruction files and execution scripts, and store them in the configuration information of the first agent. The instruction files and execution scripts can be packaged into a container image and distributed as static configuration data along with the image. The instruction files include behavioral instructions that direct the first agent to execute attribution requests, defining the calling order and processing rules of each execution unit in the attribution analysis workflow. The execution scripts are executable program code used to process attribution types, such as data query scripts and data validation scripts.
[0134] The server can receive reference cases and reference rules, and store them as initial historical cases and predefined rules in a predefined knowledge base. The predefined knowledge base adopts a three-layer structure: a case layer, a rule layer, and a reflection layer. The case layer stores attribution process data and attribution reports for each historical attribution; the rule layer stores execution rules extracted from multiple historical cases; and the reflection layer stores self-check records of each historical attribution execution process. The three layers of records are mutually indexed through association identifiers, and cross-referencing can be achieved through scene tag fields and association number fields.
[0135] After server initialization, it can receive requests from clients of different task types and process them using the intent routing layer. Attribution requests belong to the attribution analysis type; in addition, the server can also handle data query requests, algorithm concept question-and-answer requests, and service knowledge query requests. The server includes an intent routing layer to handle request classification and distribution. The intent routing layer can use a hybrid strategy of keyword matching and input form discrimination to distribute requests of different task types to corresponding processing paths, with each path executing the workflow for its respective task type.
[0136] The server-side intent routing layer can handle various input request formats, such as natural language descriptions, structured key-value pair parameter strings, and collaborative table links. In the natural language description format, users input descriptive text in natural language through the client's interactive interface, such as "Why did the capacity scale in a certain service area decrease from the first value to the second value within a specific time period?" In the structured key-value pair parameter string format, users input parameter strings in semicolon-separated key-value pairs, such as "Data partition=xxxx; Time=yyy; Capacity pool identifier=zzzz". In the collaborative table link format, the address link of an online data table containing batch attribution requests is submitted as the request. By supporting different heterogeneous input formats, the intent routing layer can adapt to different request submission methods in different service scenarios, improving the usability of the server.
[0137] The intent routing layer can perform initial screening by judging the input format of the request. If the request received by the server contains a link and points to a collaborative table service, it can be determined as a batch attribution task. If the request received by the server contains semicolon-separated key-value pairs, the parameter string can be directly parsed, skipping the natural language understanding stage. In other cases, the keyword matching process can be initiated.
[0138] The intent routing layer can maintain a mapping table between processing paths for different task types and preset keywords. After the processing path is determined, each processing path corresponds to a corresponding workflow. The processing in the corresponding workflow is executed according to different task types. In this embodiment, the attribution request is processed using the attribution analysis workflow.
[0139] Batch attribution requests can be submitted to the server via a collaborative table. The collaborative table is a specific implementation of a data sharing area used for data interaction between the client and server. The client writes attribution requests row by row into the collaborative table, with each row corresponding to one attribution request. Each row records the parameter information of the attribution request. The parameter information describes the abnormal event and may include one or more of the following: merge identifier, combination identifier, data partition, time of occurrence of the abnormal event, and service area identifier. Attribution requests in the collaborative table must have at least an attribution report link column and a processing status column. The attribution report link column is used to write the link address of the attribution report. After the attribution report is generated, the server fills in the access link in this column for the client to view. The processing status column records the processing status of the attribution request in that row, indicating to the server whether attribution processing needs to be initiated for that request. The initial processing status can be marked as requiring attribution. After the server starts attribution analysis for the attribution request, it updates the processing status of the column marked as requiring attribution to a status value indicating that attribution analysis is in progress, so as to prevent the repeated triggering of completed or in-process attribution tasks during the next round of timed scanning.
[0140] Based on the processing status column of each row in the collaborative table, rows that have not yet been processed or need to be reprocessed are filtered out. The intent routing layer can serialize the filtering results into a standardized task list, which contains the attribution request parameters corresponding to each row to be processed. The serialized task list can be passed to the attribution analysis type workflow layer for further processing. For attribution requests of the attribution analysis type, the parameters carried in the attribution request are parsed and completed before executing the attribution analysis workflow. When only some necessary parameters are provided in the attribution request, the server can automatically complete the missing execution parameters and also perform validity checks on the source of the parameters.
[0141] After an attribution request enters the unified attribution workflow layer, pre-inspection operations are performed by multiple pre-inspection units set up within the unified attribution workflow layer, such as... Figure 5 As shown, each pre-detection unit performs pre-detection operations on attribution analysis to verify whether the various preconditions on which attribution analysis depends are met. The first pre-detection unit is a knowledge retrieval pre-detection. The server verifies the accessibility of the predetermined knowledge base, confirming that the case index file and rule index file of the predetermined knowledge base exist and can be correctly parsed. The server can call the knowledge base's retrieval interface to perform test searches to ensure that the retrieval interface can return structured results normally.
[0142] The second pre-inspection unit is the document structure pre-inspection. The server verifies whether the report template read by the first agent conforms to the preset document structure specifications. The server checks whether the naming of each chapter is consistent with the preset name, and whether the arrangement order of each chapter conforms to the preset order. Chapters must not be missing or out of order.
[0143] The third pre-inspection unit is the table update pre-inspection, which is performed in batch attribution scenarios. When the target attribution request originates from a collaborative table, the server verifies the read and write permissions of the collaborative table to ensure that the server can read the rows to be processed and write back the processing results. The server dynamically locates the positions of the attribution report link column and processing status column by reading the header content of the collaborative table, and checks whether the preset filtering conditions can correctly identify the data rows to be processed.
[0144] The fourth pre-check unit is the knowledge accumulation pre-check. The server verifies the write permissions of the directory containing the case files in the predetermined knowledge base to ensure that new historical cases can be persisted to the predetermined knowledge base after the attribution analysis is completed. The server reads the current maximum sequence number in the case index to confirm that the sequence number can be read correctly and that newly generated sequence numbers will not conflict with existing sequence numbers. The server can also read existing case files to verify that they can be parsed normally, ensuring that existing cases can be used as format templates for reference when generating new cases.
[0145] The fifth pre-inspection unit is the data consistency pre-inspection. Different data tables can use different data partitioning formats. The server verifies whether the format of the data partitioning parameters carried in the target attribution request is consistent with the format required by each target data table, so as to avoid empty result sets caused by format mismatch.
[0146] The sixth pre-screening unit is for data source selection pre-screening. The server determines the version type of the target data table to be queried based on the prefix of the combined identifier carried in the target attribution request. The version type can include online and offline versions. When the prefix is the first prefix, the query is routed to the online version of the data table; when the prefix is the second prefix, the query is routed to the offline version of the data table.
[0147] If any of the above preflight checks fails, the server will stop executing the target attribution request and may send a notification to the client explaining the specific reason why the target attribution request was not executed. For example, the notification may include the name of the failed preflight check and a description of the abnormal status, allowing the user to troubleshoot and correct the problem before resubmitting the attribution request.
[0148] After the pre-screening is passed, the server performs knowledge retrieval, accessing the three-layer knowledge base to obtain attribution knowledge. Knowledge retrieval is configured to execute before data query operations and is a non-skippable procedure step on the server side. This ensures that subsequent data query and analysis steps can refer to historical experience, avoiding the recurrence of known analytical biases or data query errors. The server maintains case index files and rule index files corresponding to historical cases and predefined rules, respectively. The case index file records the index information of each historical case in the case layer, and the rule index file records the index information of each predefined rule in the rule layer. Each time a new case or rule is added to the knowledge base, the corresponding index file is updated synchronously. By maintaining the index files, retrieval does not require traversing the entire data file in the knowledge base; candidate records can be quickly located through the index, improving retrieval efficiency.
[0149] Based on the received target attribution request, the server determines the target scenario field of the abnormal event. Taking the scenario to which the abnormal event belongs as the capacity scenario as an example, it can include multiple fields such as operating mode, capacity line identifier, and abnormality type. The abnormality type can include sudden changes in capacity scale, abnormal bottom-line capacity, etc. The values of each scenario field can be extracted from the parameters parsed in the target attribution request.
[0150] The server calls the case retrieval interface to access the case layer of the predefined knowledge base. It performs multi-dimensional cross-search using extracted multi-dimensional search conditions, performs coarse screening using the operation mode field, and selects a set of candidate cases that match the operation mode from the case index. In the candidate case set, it performs fine screening using scenario fields such as capacity line type and exception type. Based on the semantic index of each dimensional search condition and the candidate case, it calculates the similarity of each candidate case, sorts the candidate cases from high to low according to the similarity score, and returns a specified number of historical cases with the highest similarity as the target cases.
[0151] The server calls the rule matching interface to access the rule layer of the predefined knowledge base. It matches the scenario tags of the abnormal event with the scenario tags of each predefined rule in the rule layer, calculates the field overlap between the current scenario tag and the scenario tags of each predefined rule, and returns predefined rules that meet preset conditions as target rules. The field overlap is proportional to the confidence level. The returned information for each target rule may include the rule's triggering conditions, recommended actions, and historical success rate. For the retrieved target rules, the server determines the application method based on their confidence level. When the confidence level of a target rule is greater than or equal to a preset confidence threshold (preferably 0.7), for example, when the confidence level is greater than or equal to 0.7, the server uses this target rule as a constraint for the current attribution analysis, and applies the recommended actions of this target rule during attribution inference. When the confidence level of a target rule is lower than the preset matching threshold, it is added to the task context as reference information for the first agent to refer to when generating the attribution report. The first agent can be configured to pay attention to different rules by configuring the confidence level, so as to avoid the attribution direction deviation caused by the intervention of historical experience with low confidence, while retaining low confidence information that may be of reference value.
[0152] After knowledge retrieval is completed, the server organizes the retrieval results according to a preset data structure and serializes them into a structured data file. This data file can be stored in a predetermined format and persistently stored in the execution directory of the current attribution request. The attribution data preparation stage in the attribution process can read this file and merge the knowledge retrieval results with the queried service data into a unified task context.
[0153] The server accesses the data warehouse through a data access layer to query service data associated with the anomaly event. This service data is determined based on the specific service and, for capacity scenarios, can include various types of data such as basic constraint data, capacity scale data, service prediction data, and supplementary capacity data, stored in different target data tables. To generate query commands, the server is configured with a query template generator. This generator automatically generates query commands targeting multiple target data tables based on the parsed input parameters in the attribution request. All query commands are generated from this unified entry point, avoiding inconsistencies in field mapping or parameter injection errors introduced by manually writing query commands, thus ensuring the standardization of query commands.
[0154] During the query command generation process, the query template generator automatically identifies the version type of each target data table according to preset command routing rules. The query template generator can check the prefix of the combined identifier carried in the attribution request; when the prefix is the first prefix, the query is routed to the online version of the data table; when the prefix is the second prefix, the query is routed to the offline version of the data table. The query template generator also automatically adapts to different data table requirements regarding data partition parameter formats. For example, it uses the first date format for the first data table and automatically adjusts it to the second date format for the second data table.
[0155] The server can employ a process-level parallel mechanism to concurrently execute query operations on multiple target data tables, reducing the overall time spent acquiring service data. Query results are persistently stored on the server's local disk in a standardized structured file format. For example, query results for four target data tables can be stored as four independent files, each named according to a preset naming convention, facilitating subsequent attribution analysis and auditing. The server performs multiple validation operations on the query results. These validation operations may include: confirming that the result files corresponding to each target data table have been generated and are not empty; verifying that no core fields are missing from each result file; checking that the values of numeric fields are within a reasonable range; and verifying that embedded structured fields in the result files can be correctly parsed. If any validation fails, the server records the reason for the failure and triggers a retry mechanism to attempt to reacquire data.
[0156] In batch attribution scenarios, when the server executes query operations on service data, if it encounters query rate limiting in the data warehouse, it can employ an adaptive degradation strategy. The current number of concurrent queries is reduced to a preset degradation concurrency level. The server waits for a preset interval before retrying the query; a maximum number of retries can be set. If the retry still fails, the server records the reason for the failure, marks the corresponding attribution task as failed, and skips the task to continue processing other attribution tasks in the batch, preventing the failure of a single attribution task from blocking the execution of the entire batch attribution task.
[0157] After the data query is completed, the unified attribution workflow layer generates a task context corresponding to the target attribution request based on the retrieved target cases, target rules, and the queried service data. During the assembly of the task context, the server labels each piece of service data with its data source information. The data source may include the data table name, data partition identifier, case number of the retrieved historical cases, and rule number of the matched predefined rules, etc.
[0158] In batch attribution scenarios, when the number of task contexts is less than or equal to a predetermined concurrency threshold, the server inputs each task context as a batch of inputs to the first agent. Since multiple task contexts within the same input batch contain identical data, the first agent can identify this identical data during inference and reuse the analysis results for this identical data, thereby obtaining attribution reports corresponding to each attribution request within the same input batch in the same inference process. This identical data can be, for example, the same historical case record, the same predetermined rule record, or service data from the same data partition and the same data table.
[0159] The first intelligent agent generates an attribution report for the anomaly based on the pre-configured report template in the instruction file. The attribution report contains several pre-defined sections, such as basic information, basic constraint analysis, algorithm sampling path, capacity calculation, historical case comparison, key rule triggering, anomaly attribution conclusion, data summary, cited data, reference documents, and feedback evaluation. All data fields referenced in the attribution report are labeled with their corresponding data sources, allowing for tracing the specific origin of any data field in the report.
[0160] The first agent generates an attribution report based on the pre-configured report template requirements in the instruction file. This attribution report is delivered by the collaborative table layer. After the attribution report is generated, the server updates two target columns in the collaborative table simultaneously in a single update operation. The first target column is used to write the link address of the attribution report, and the second target column is used to record the processing status. The server updates the value of the second target column to indicate a processed status value to avoid repeatedly triggering completed attribution tasks during the next round of scheduled scans. When locating the target row to be updated, the server dynamically locates it by matching the row content rather than a fixed row number, and rereads the latest status of the collaborative table before each update operation to handle potential data changes in multi-user concurrent editing scenarios.
[0161] The unified attribution workflow layer also performs permission granting operations in the collaboration table layer. The server extracts the client's endpoint information from the collaboration table and calls the permission management interface to grant preset access permissions to the attribution report. To avoid the problem of not being able to match access permissions, the server first calls the personnel to retrieve the online service query endpoint information. If the service is unavailable or returns an empty value, the server reads the permission mapping table maintained locally for offline query. If it still does not match, it records the pending status and waits for external supplementary granting.
[0162] After the attribution report is delivered, the unified attribution workflow layer performs a knowledge deposition operation, persisting the experience generated by this attribution analysis to the three-layer knowledge base layer. Based on the attribution process data and attribution report of this attribution analysis, the server generates new historical cases, which are recorded as target historical cases.
[0163] For case data storage, target historical cases are stored according to a pre-defined data structure at the case layer. This data structure includes identity and time fields, scenario classification fields, attribution conclusion fields, analysis process fields, and quality and feedback fields. The identity and time field includes a unique case number and timestamp, used to identify the case and record its generation time. The scenario classification field includes an array of scenario tags and scenario fields such as operating mode, capacity line type, and anomaly type, used to describe the service scenario to which the case belongs. The attribution conclusion field includes a root cause description and conclusion confidence level, used to record the attribution conclusion of this attribution analysis. The analysis process field includes input parameters, a key discovery array, a tool call chain, total time consumption, and number of retries, used to record the processing trajectory from input to output. Each element in the tool call chain records information such as tool name, call purpose, call time consumption, query instruction summary value, and target data table. The quality and feedback field includes execution status identifiers, concurrent feedback records, parameter mode characteristics, and user feedback bits, used to record the data quality assessment information for this attribution. The case files use a nested data structure, with hierarchical relationships between fields to ensure consistency in subsequent retrieval and template reuse.
[0164] The server generates corresponding semantic indexes for the target historical cases. These semantic indexes can be generated based on the values of various scenario fields extracted from the attribution request, such as combinations of values from service mode, capacity type, and exception type fields. The server stores the target historical cases in the case layer of a predefined knowledge base and updates the case index file synchronously. Each time a new case is added to the case layer, the server appends the semantic index of the new case to the case index file, keeping the case index file synchronized with the case data in the case layer.
[0165] For rule accumulation, the server generates candidate rules based on the attribution process data from this attribution analysis. The candidate rules are organized according to the preset data structure of the rule layer, which contains multiple preset fields, such as: trigger condition field, action template field, statistical field, lifecycle field, and association field.
[0166] The trigger condition field describes the scenarios and trigger conditions for which the rule applies. It can be a nested object, containing the running mode, exception type, and an array of trigger conditions. Each element in the trigger condition array can describe the trigger condition of the rule in the form of a quantitative indicator threshold, such as the rate of change of a certain indicator being lower or higher than a preset percentage threshold.
[0167] The Action Template field describes the recommended action to be taken after the rule is triggered. It can contain recommended actions, tool invocation templates, and an array of checks. The tool invocation template guides the attribution analysis to follow a pre-defined toolchain after the rule is matched. The checks list the checkpoints that need to be monitored and verified during the attribution analysis process.
[0168] The statistics field is used to record the usage and effect of the rule in historical attribution tasks. The statistics field can include the hit count, success count, and the success rate calculated based on the above two. Each time the attribution task matches the rule and applies it successfully, the hit count and success count are updated accordingly.
[0169] The lifecycle field records the rule's time information and current status. It can include creation time, update time, hit time, and status identifier. The status identifier can be active, pending review, or obsolete. The rule's lifecycle status can be automatically managed based on preset conditions. For example, if a rule fails to hit multiple times consecutively or its success rate falls below a preset threshold, it can transition from an active state to a pending review state.
[0170] The association field is used to establish the index relationship between the rule and historical cases in the case layer. The association field can be an array of association case numbers, which records the case numbers of each historical case on which the rule was extracted, making it easy to trace the rule back to its source case.
[0171] After generating candidate rules, the server compares them with existing predefined rules in the rule layer. If a predefined rule with the same name already exists in the predefined knowledge base, the server does not store the candidate rule again. Instead, it updates the hit count and success count of the existing rule and updates the success rate of this predefined rule. If the candidate rule does not exist in the predefined knowledge base, the server stores it in the rule layer of the predefined knowledge base. Upon confirming the addition of a candidate rule, the rule index file is updated synchronously. The rule index file records the mapping relationship between the scene tags of each predefined rule and the rule file. When adding a rule to the rule layer, the scene tags of the new rule are appended to the rule index file to ensure that the rule index file and the rule data in the rule layer remain synchronized.
[0172] like Figure 6 As shown, the self-reflection step is executed through the self-inspection channel in the double closed-loop feedback layer to perform a compliance self-inspection on the execution process of this attribution analysis. According to multiple predefined checkpoints, the attribution process data generated during the execution of this attribution analysis is checked, and a self-inspection record for this attribution analysis is generated.
[0173] Checkpoints are used to check whether the execution order of each step in the attribution analysis conforms to the preset process. Checkpoints may include checking whether the knowledge retrieval step is executed before the service data acquisition step, checking whether the quality pre-inspection operation confirms each pre-inspection item one by one without skipping any pre-inspection items, and checking whether the order of each execution step is consistent with the preset execution order.
[0174] Checkpoints are used to check whether the intermediate and final result files generated during the attribution analysis process conform to the preset specifications. Checkpoints may include checking whether the naming of the file storage directory for this attribution task conforms to the preset naming specifications, checking whether the data field structure of the newly generated case file is consistent with the preset field structure template of the case layer, checking whether the newly generated case number conflicts with the existing case number, and checking whether the values referenced in the attribution report are consistent between the report text, task context, and original data file.
[0175] Checkpoints are used to check whether the calling methods of various tools and interfaces during the attribution analysis process conform to the preset specifications. Checkpoints may include checking whether the data query operation is executed in a preset process-level parallel mode, checking whether the results of the data query have been persistently stored in the specified storage space, and checking whether the update operation of the collaborative table adopts the method of dynamically locating the target row based on content matching.
[0176] Checkpoints are used to check whether the generated attribution report meets the preset data quality standards. Checkpoints may include checking whether the attribution report contains a preset number of chapters, whether each chapter is complete, whether the attribution conclusion is located in the preset location area of the attribution report, and whether the sampling interval described in the attribution report is consistent with the data partitioning parameters actually used during data query.
[0177] The checkpoint is also used to check whether the permissions granted for the attribution report are complete, and whether all submitters of the target attribution request have obtained the preset access permissions to the attribution report generated this time.
[0178] The server generates self-inspection records based on the inspection results of each checkpoint according to a preset data structure. These records may include a self-inspection record number, a generation timestamp, the case number associated with this attribution analysis, the inspection results of each checkpoint under each inspection dimension, a list of identified issues, and improvement points to be updated in the instruction file. Each issue in the issue list can record its risk level (indicating severity), its category, and a detailed description. When an issue with a preset risk level exists in the self-inspection record, the server can mark the corresponding improvement point in the "to be updated" field, triggering the editing process of the first agent's instruction file. The modified instruction file takes effect during the next attribution analysis task, ensuring that subsequent attribution analysis execution conforms to the preset process.
[0179] After the self-inspection record is generated, the server persistently stores it in the reflection layer of the predefined knowledge base. The reflection layer is independent of the case layer and rule layer, and the reflection record can be indexed and associated with the corresponding case in the case layer by associating the case number. Through the above self-reflection mechanism, the server can automatically check the compliance of the execution process after each attribution analysis, and automatically trigger the correction of the instruction file when process deviations are found, realizing the self-evolution of the attribution workflow.
[0180] The external review channel in the dual-loop feedback layer is configured with a second agent that operates independently of the attribution workflow to process external review feedback. The second agent periodically scans the generated attribution reports according to a preset time window, extracts evaluation data from the feedback evaluation sections of the reports, performs topic clustering on the extracted evaluation data, and synthesizes structured adjustment plan information. This adjustment plan information is used to indicate which fields need to be modified in the instruction file of the first agent. The evaluation data can be integrated and stored in the case layer and rule layer.
[0181] After generating the adjustment plan information, the second agent submits it to the client for confirmation. When it receives a confirmation command from the client, and the confirmation command contains a confirmation word from the preset confirmation word set, the second agent adjusts the instruction file of the first agent based on the adjustment plan information. When the confirmation command does not contain a confirmation word from the preset confirmation word set, the adjustment plan is not executed, and the agent remains in a waiting state.
[0182] In multi-terminal deployment scenarios, a two-way synchronization mechanism for knowledge base data can be established between the server and the client. Multi-terminal deployment refers to deploying a first agent for online attribution on the server and a first agent for offline attribution on the client. Each end is configured with an independent pre-defined knowledge base and can independently execute attribution analysis tasks. In the online attribution scenario, the client sends the target attribution request to the server, and the first agent configured on the server performs the attribution analysis, which can fully utilize the server's computing power and the experience of the global knowledge base.
[0183] In offline attribution scenarios, the client can directly invoke the locally deployed first agent to independently execute attribution analysis tasks based on a pre-configured local knowledge base. Attribution analysis results, historical cases, and pre-defined rules generated by the client in the offline environment are temporarily stored in the local pre-configured knowledge base. Offline attribution is suitable for scenarios with limited network conditions or high data security requirements, avoiding attribution analysis blockage caused by network latency or interruptions.
[0184] Because the server and client run attribution analysis tasks independently, the data in their respective knowledge bases may gradually diverge. As the server continuously processes online attribution requests from multiple clients, it accumulates a large number of historical cases and predefined rules from other clients, while clients also generate local attribution cases and rules during offline attribution. To enable the two knowledge bases to share their accumulated attribution experience, a two-way synchronization mechanism is established between the server and clients. Through this two-way synchronization, the server aggregates local knowledge base data from multiple clients, while each client can obtain attribution experience from the server, improving the quality of its local offline attribution analysis.
[0185] The aforementioned two-way synchronization mechanism includes the client pulling data from the server and the server pulling data from the client. The client can send a synchronization request to the server according to a first predetermined period. In response to this request, the server sends at least one type of data from its configured predetermined knowledge base: historical cases, predetermined rules, and self-check records. Upon receiving this data, the client stores it in its locally deployed predetermined knowledge base, thus updating its local knowledge base. Through this one-way data synchronization, the client can acquire the global attribution experience accumulated by the server during online attribution, as well as attribution knowledge gathered by the server from other clients, thereby improving the quality of the client's local offline attribution analysis.
[0186] The client can send synchronized data generated by the first agent deployed locally during offline attribution to the server according to a second predetermined period. The synchronized data includes at least one of the following: historical cases generated locally by the client, predetermined rules, and self-check records. Upon receiving the synchronized data, the server stores it in a predetermined knowledge base configured on the server. Through this synchronization process, the server can aggregate local attribution experiences from multiple clients, which helps enrich the attribution experiences in the predetermined knowledge base.
[0187] The aforementioned bidirectional synchronization process can employ either a full synchronization or incremental synchronization strategy. In the event of an initial synchronization or a prolonged period of inactivity, a full synchronization can be performed between the client and server, sending all data from one end's knowledge base to the other. During a regular synchronization cycle, only incremental data added or updated since the last synchronization can be synchronized to reduce data transfer volume and synchronization time. After synchronization is complete, both ends can calculate the feature summary values of the data in their respective predefined knowledge bases. Comparing these feature summary values verifies successful synchronization and data consistency between the two ends. If inconsistencies are found, resynchronization can be triggered.
[0188] like Figure 7 As shown, in a scenario where the server is deployed to a cloud container environment, the cloud continuous operation layer adopts a two-stage synchronization strategy that physically separates static structure and runtime data. The files required for attribution analysis are synchronized to the cloud container in two stages. The server categorizes the files required for attribution analysis into two types: static structure data and runtime data. Static structure data refers to instruction files and execution scripts that have a low change frequency and require version management. Runtime data refers to the data stored in a predetermined knowledge base that continuously grows and changes as the attribution task is executed, such as case files, rule files, reflection files, and various index files.
[0189] In the first synchronization phase, the server synchronizes static structured data to the cloud container environment. During the container image building phase, instruction files and execution scripts are packaged into the container image and distributed and deployed along with it. This phase does not include runtime data to ensure the stability and version consistency of the static structured data.
[0190] In the second synchronization phase, the server synchronizes runtime data to the cloud container environment, while runtime data from the local development environment is injected into the cloud container environment. The second synchronization phase is executed separately from the first synchronization phase. After the container starts, the case data, rule data, reflection data, and index data of the knowledge base are loaded into the predetermined knowledge base storage path within the container. Because runtime data is continuously updated during container operation, storing and synchronizing it separately from static structured data avoids frequent changes to runtime data that trigger frequent rebuilds of the container image, and also prevents the loss of runtime data due to container restarts or rescheduling.
[0191] The cloud container environment has a built-in timed scanning daemon that scans the collaborative spreadsheet for pending requests at preset intervals, such as every 30 minutes, and triggers the execution of the attribution workflow upon detecting a pending request. During the continuous operation of the cloud container, runtime data such as new cases and rules generated by the attribution analysis task can be sent back to the local development environment via a reverse synchronization channel. Upon receiving the synchronized data, the local development environment performs file-level difference verification to ensure that the knowledge base data in the local development environment is consistent with that in the cloud container environment. This two-stage separation synchronization strategy achieves stable deployment of the static structure and management of runtime data, balancing system stability and continuous knowledge evolution.
[0192] For attribution services deployed in the cloud, a container management interface is designed in the designated client for operations and maintenance. This interface facilitates viewing the task execution status within containers, as well as quickly viewing trigger logs and attribution logs, supporting rapid container location of issues. Figure 8 As shown, the container management interface displays the container status distribution information in the current cloud container environment. This information includes the number of containers in a running state, the number of containers in a stopped state, and the number of containers in an expired state. It also displays the metadata information of each container in a table format, which includes the container's identifier, status tag, compute resource quota, creation time and expiration time, and the image version identifier that the container depends on.
[0193] The container management interface also includes an operation bar, which contains controls for performing lifecycle management operations on the corresponding containers. These controls can include restart and destroy controls. Through this container list management interface, users can view the container status distribution and detailed configuration information used for attribution analysis, and perform management operations such as restarting or destroying specified containers using the operation controls.
[0194] like Figure 9 As shown, the client for operations and maintenance includes a scheduled task configuration interface, which features a countdown display area and an active period configuration area. The countdown display area shows the remaining time until the next scheduled scan task starts. This area can also be associated with control components, including stop, restart, interval modification, and immediate scan controls. The stop control pauses the scheduled scan task of the scheduled scan daemon. The restart control restarts the scheduled scan daemon. The interval modification control updates the scan interval of the scheduled scan daemon according to the input of a new preset period parameter. The immediate scan control triggers a scan task immediately without waiting for the current countdown to reach zero.
[0195] The active time period configuration area is used to receive configuration operations for the active time window, such as setting the active time window to 06:00 to 01:00 the next day. Outside of this active time window, the scheduled scan daemon will pause its scanning operations. This interface also integrates a task statistics panel, which displays the real-time count of pending tasks, running tasks, completed tasks, and failed tasks. At the bottom of the interface, a recent activity log area can be set, which displays the automatically triggered behavior records of the scheduled scan daemon in chronological order, such as "Scan round x begins" and "No pending tasks."
[0196] like Figure 10 As shown, the client for operations and maintenance includes a container resource monitoring interface, which displays the total number of currently running tasks, the total computing resource utilization of containers, the total storage resource utilization of containers, and the number of alarms for currently high-load tasks. The container resource monitoring interface also includes a task list area, which displays the process-level information for each currently executing attribution task in a table format. This process-level information can include the process identifier, execution status, execution duration, and start time. Each task entry in the task list area is also associated with a termination control, which is used to send a termination signal to the corresponding attribution task process in response to a triggered operation.
[0197] It can also include a log viewing interface and a log statistics bar to display the number of logs in different states, including normal recording status and alarm status.
[0198] Corresponding to the application scenarios and methods provided in the embodiments of this application, such as Figure 11 As shown, this application embodiment also provides an agent-based abnormal event attribution device, applied to a first end, including: The first receiving module 1101 is used to receive a target attribution request for an abnormal event; The retrieval module 1102 is used to retrieve target cases and target rules from the predefined knowledge base configured on the first end based on the target attribution request. The predefined knowledge base is used to store historical cases and predefined rules, and the predefined knowledge base is updated based on the historical attribution reports corresponding to each historical attribution request. Historical cases include attribution process data and historical attribution reports of corresponding historical abnormal events, and predefined rules are the execution rules followed by each historical case in the attribution process. The attribution analysis module 1103 is used to generate an attribution report of anomalies based on target cases, target rules and service data associated with the anomalies, through a first intelligent agent deployed on the first end. The instruction file of the first intelligent agent is updated based on the feedback data of each historical attribution report, and the feedback data represents the data quality of each historical attribution report.
[0199] In the embodiments provided in this application, the retrieval module includes: The Scene Field Determination Submodule is used to determine the target scene field of an abnormal event based on the target attribution request. The target scene field is used to describe the scene to which the abnormal event belongs. The first retrieval submodule is used to retrieve candidate semantic indexes that match the first scenario field from the case layer based on the first scenario field that represents the service mode in each target scenario field. The case layer is located in the predetermined knowledge base configured on the first end. The second retrieval submodule is used to retrieve the target semantic index and the target case corresponding to the target semantic index from each candidate semantic index based on the second scenario field that represents the exception type in the target scenario field. The third retrieval submodule is used to determine the target scene tag that matches the abnormal event from the rule layer based on the field overlap of the target scene field with each preset scene tag, and the target rule corresponding to the target scene tag; each scene tag corresponds to each predetermined rule stored in the rule layer, which is located in the predetermined knowledge base configured on the first end.
[0200] In the embodiments provided in this application, the attribution analysis module includes: The context generation submodule is used to generate a task context corresponding to the target attribution request based on the target case, target rules and service data. The data source of the service data is marked in the task context. The report output submodule is used to input the task context into the first agent configured on the first end and output an attribution report. The data fields referenced in the attribution report are labeled with their corresponding data sources.
[0201] In the embodiments provided in this application, the report output submodule includes: The batch input submodule is used to input each task context as the same input batch to the first agent configured on the first end, based on the fact that the number of task contexts is less than or equal to a predetermined concurrency threshold. The reuse reasoning submodule is used to reuse the analysis results of the same data content in the reasoning process of the first agent configured on the first end, based on the existence of the same data content in the task context within the same input batch, to obtain the attribution report corresponding to each attribution request in the same input batch.
[0202] In the embodiments provided in this application, the device further includes: The permission determination module is used to read the end information of the second end to which the target attribution request belongs, and determine the access permissions that match the end information. The access permissions are the permissions used to access the attribution report, and the end information is used to identify the second end. The link writing module is used to write the link address of the attribution report into the data sharing area. The link address allows access from a second end with corresponding access permissions. The data sharing area is used for data sharing between the first end and the second end.
[0203] In the embodiments provided in this application, the feedback data includes self-inspection records and evaluation data corresponding to the attribution report, and the device further includes: The self-checking module is used to check the attribution process data included in the attribution report according to multiple predefined checkpoints, generate and store self-checking records for the attribution report in the reflection layer of the predefined knowledge base, and each checkpoint checks the predefined processing steps in the attribution process data. The instruction generation module is used to generate a target instruction based on the self-test record indicating that there are operations in the attribution process data that do not conform to the preset attribution process. The target instruction is used to make the first intelligent agent configured on the first end execute the attribution process of the next attribution request in accordance with the preset attribution process. The adjustment plan generation module is used to generate adjustment plan information for the first intelligent agent configured on the first end based on the evaluation data of each attribution report. The second intelligent agent is used to analyze the attribution conclusions of each attribution report, and the adjustment plan information is used to indicate the fields that need to be modified in the instruction file of the first intelligent agent. The instruction adjustment module is used to respond to the received confirmation instruction for adjustment plan information, and adjust the instruction file of the first intelligent agent through the second intelligent agent belonging to the first end based on the adjustment plan information.
[0204] In the embodiments provided in this application, the device further includes: The case generation module is used to generate target historical cases corresponding to the attribution report based on the attribution process data and attribution report of abnormal events; The case storage module is used to store target historical cases and semantic indexes used to identify target historical cases in the case layer, which is located in the predefined knowledge base at the first end. The rule generation module is used to generate candidate rules corresponding to the attribution report based on the attribution process data of abnormal events. The rule storage module is used to store candidate rules and their corresponding scene tags in the rule layer when there are no candidate rules in the predefined rules stored in the predefined knowledge base. The rule layer is located in the predefined knowledge base at the first end.
[0205] In the embodiments provided in this application, the device further includes: The first initialization module is used to receive a pre-set instruction file and an execution script, and store them in the configuration information of the first intelligent agent. The instruction file includes behavioral instructions that instruct the first intelligent agent to execute attribution requests, and the execution script is a script used to process attribution types. The second initialization module is used to receive reference cases and reference rules, and store them as historical cases and predefined rules in the predefined knowledge base configured on the first end.
[0206] In the embodiments provided in this application, the device further includes: The first synchronization module is used to respond to receiving a synchronization request sent by the second end by sending at least one of the following data from the first end's predetermined knowledge base: historical cases, predetermined rules, and self-check records. The feedback data includes self-check records, which are generated based on the attribution process data included in the corresponding historical attribution report. The second synchronization module is used to store the synchronization data in a predetermined knowledge base configured on the first end in response to receiving synchronization data sent by the second end. The synchronization data is generated by the first intelligent agent deployed on the second end and includes at least one of the following data: historical cases, predetermined rules, and self-check records generated locally by the second end.
[0207] In the embodiments provided in this application, the device further includes: The pre-inspection module is used to check the read / write status of the predefined knowledge base configured on the first end, as well as the report template read by the first agent deployed on the first end. The report template is used to write the attribution report of the target attribution request in a predefined format. The termination module is used to stop executing the target attribution request based on the read / write status being in an abnormal state or the report template not conforming to the preset configuration. The prompt module is used to send prompt messages to the second end that sent the target attribution request; the prompt messages are used to indicate the reason why the target attribution request was not executed.
[0208] Corresponding to the application scenarios and methods provided in the embodiments of this application, such as Figure 12 As shown, this application embodiment also provides an agent-based abnormal event attribution device, applied to a second end, including: Sending module 1201 is used to send a target attribution request for an abnormal event to the first end; The second receiving module 1202 is used to receive and display the attribution report of the abnormal event; The attribution report is generated by the first agent deployed on the first end based on the target case, target rule, and service data associated with the anomalous event. The instruction file of the first agent is updated based on the feedback data of each historical attribution report, and the feedback data indicates the data quality of each historical attribution report. The target case and target rule are retrieved from the predetermined knowledge base configured on the first end based on the target attribution request. The predetermined knowledge base is used to store historical cases and predetermined rules, and it is updated based on the historical attribution reports corresponding to each historical attribution request. Historical cases include attribution process data and historical attribution reports of the corresponding historical anomalous events, and predetermined rules are the execution rules followed by each historical case in the attribution process.
[0209] In the embodiments provided in this application, the device further includes: The third receiving module is used to send a synchronization request to the first end according to a first predetermined period, and to receive at least one type of data from historical cases, predetermined rules and self-inspection records stored in the predetermined knowledge base configured on the first end. The local update module is used to update the pre-defined knowledge base deployed on the second end based on at least one type of data received. The data push module is used to send synchronization data to the first end according to the second predetermined period. The synchronization data is generated by the first intelligent agent deployed on the second end and includes at least one of the following data generated locally on the second end: historical cases, predetermined rules, and self-check records.
[0210] The functions of each module in each device in the embodiments of this application can be found in the corresponding description in the above method, and they have corresponding beneficial effects, which will not be repeated here.
[0211] Figure 13 This is a block diagram of an electronic device used to implement embodiments of this application. Figure 13 As shown, the electronic device includes a memory 1301 and a processor 1302. The memory 1301 stores a computer program that can run on the processor 1302. When the processor 1302 executes the computer program, it implements the method described in the above embodiments. The number of memories 1301 and processors 1302 can be one or more. In a specific implementation, the electronic device may also include a communication interface 1303 for communicating with external devices and performing data exchange and transmission.
[0212] In practical implementation, if the memory 1301, processor 1302, and communication interface 1303 are implemented independently, they can be interconnected via a bus to communicate with each other. This bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. This bus can be divided into an address bus, a data bus, a control bus, etc. For ease of representation, Figure 13 The bus is represented by a single thick line, but this does not mean that there is only one bus or one type of bus.
[0213] Optionally, in a specific implementation, if the memory 1301, processor 1302, and communication interface 1303 are integrated on a single chip, then the memory 1301, processor 1302, and communication interface 1303 can communicate with each other through an internal interface.
[0214] This application provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the method provided in this application.
[0215] This application provides a computer program product, including a computer program that, when executed by a processor, implements the method provided in this application.
[0216] This application also provides a chip including a processor for calling and executing instructions stored in a memory, causing a communication device with the chip installed to perform the method provided in this application.
[0217] This application also provides a chip, including: an input interface, an output interface, a processor, and a memory. The input interface, output interface, processor, and memory are connected through an internal connection path. The processor is used to execute code in the memory. When the code is executed, the processor is used to execute the method provided in the application embodiment.
[0218] It should be understood that the aforementioned processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. General-purpose processors can be microprocessors or any conventional processor. It is worth noting that the processor can be a processor supporting Advanced Reduced Instruction Set Machines (ARM) architecture.
[0219] Further, optionally, the aforementioned memory may include read-only memory and random access memory. The memory may be volatile memory or non-volatile memory, or may include both. Non-volatile memory may include read-only memory (ROM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), or flash memory. Volatile memory may include random access memory (RAM), which serves as an external cache. By way of example, but not limitation, many forms of RAM are available. Examples include Static Random Access Memory (SRAM), Dynamic Random Access Memory (DRAM), Synchronous DRAM (SDRAM), Double Data Rate SDRAM (DDR SDRAM), Enhanced Synchronous DRAM (ESDRAM), Sync Link DRAM (SLDRAM), and Direct Rambus RAM (DR RAM).
[0220] In the above embodiments, implementation can be achieved, in whole or in part, through software, hardware, firmware, or any combination thereof. When implemented in software, it can be implemented, in whole or in part, as a computer program product. A computer program product includes one or more computer instructions. When the computer program instructions are loaded and executed on a computer, all or part of the processes or functions according to this application are generated. The computer can be a general-purpose computer, a special-purpose computer, a computer network, or other programmable device. The computer instructions can be stored in a computer-readable storage medium or transferred from one computer-readable storage medium to another.
[0221] In the description of this specification, the references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of this application. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification, as well as the features of those different embodiments or examples.
[0222] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one of that feature. In the description of this application, "a plurality of" means two or more, unless otherwise explicitly specified.
[0223] Any process or method described in the flowchart or otherwise herein can be understood as representing a module, segment, or portion of code comprising one or more executable instructions for implementing a particular logical function or process. Furthermore, the scope of the preferred embodiments of this application includes additional implementations in which functions may be performed not in the order shown or discussed, including substantially simultaneously or in reverse order depending on the functionality involved.
[0224] The logic and / or steps described in the flowchart or otherwise herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus or device (such as a computer-based system, a processor-included system or other system that can fetch and execute instructions from, an instruction execution system, apparatus or device).
[0225] It should be understood that various parts of this application can be implemented using hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented using software or firmware stored in memory and executed by a suitable instruction execution system. All or part of the steps of the methods in the above embodiments can be implemented by a program instructing related hardware, the program being stored in a computer-readable storage medium, which, when executed, includes one or a combination of the steps of the method embodiments.
[0226] Furthermore, the functional units in the various embodiments of this application can be integrated into a processing module, or each unit can exist physically separately, or two or more units can be integrated into a module. The integrated module can be implemented in hardware or as a software functional module. If the integrated module is implemented as a software functional module and sold or used as an independent product, it can also be stored in a computer-readable storage medium. This storage medium can be a read-only memory, a disk, or an optical disk, etc.
[0227] The above are merely exemplary embodiments of this application, but the scope of protection of this application is not limited thereto. Any person skilled in the art can easily conceive of various variations or substitutions within the technical scope described in this application, and these should all be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.
Claims
1. An agent-based attribution method for abnormal events, characterized in that, Applied to the first end, including: Receive target attribution requests for anomalous events; Based on the target attribution request, target cases and target rules are retrieved from the predetermined knowledge base configured on the first end; the predetermined knowledge base is used to store historical cases and predetermined rules, and the predetermined knowledge base is updated based on the historical attribution reports corresponding to each historical attribution request. The historical cases include attribution process data and historical attribution reports corresponding to historical anomalies, and the predetermined rules are the execution rules followed by each historical case in the attribution process. Based on the target case, the target rule, and the service data associated with the abnormal event, an attribution report of the abnormal event is generated by a first intelligent agent deployed on the first end. The instruction file of the first intelligent agent is updated based on the feedback data of each historical attribution report, and the feedback data represents the data quality of each historical attribution report.
2. The method according to claim 1, characterized in that, The step of retrieving target cases and target rules from a predetermined knowledge base configured on the first end based on the target attribution request includes: Based on the target attribution request, the target scenario field of the abnormal event is determined, and the target scenario field is used to describe the scenario to which the abnormal event belongs; Based on the first scenario field representing the service mode in each of the target scenario fields, candidate semantic indexes matching the first scenario field are retrieved from the case layer, wherein the case layer is located in the predetermined knowledge base configured on the first end; Based on the second scenario field representing the exception type in the target scenario field, the target semantic index and the target case corresponding to the target semantic index are retrieved from each of the candidate semantic indexes; Based on the overlap of the target scene field with the preset scene tags, the target scene tag matching the abnormal event and the target rule corresponding to the target scene tag are determined from the rule layer; each scene tag corresponds to each of the predetermined rules stored in the rule layer, and the rule layer is located in the predetermined knowledge base configured on the first end.
3. The method according to claim 1, characterized in that, The process of generating an attribution report for the abnormal event based on the target case, the target rule, and service data associated with the abnormal event, through a first intelligent agent deployed on the first end, includes: Based on the target case, the target rule, and the service data, a task context corresponding to the target attribution request is generated, wherein the data source of the service data is marked in the task context; The task context is input into the first agent configured on the first end, and the attribution report is output. The data fields referenced in the attribution report are marked with their corresponding data sources.
4. The method according to claim 3, characterized in that, The step of inputting the task context into the first agent configured on the first end and outputting the attribution report includes: If the number of task contexts is less than or equal to a predetermined concurrency threshold, each task context is input as the same input batch to the first agent configured on the first end. Based on the existence of identical data content in the task context within the same input batch, the analysis results of the identical data content are reused during the inference process of the first agent configured on the first end to obtain the attribution report corresponding to each attribution request in the same input batch.
5. The method according to claim 1, characterized in that, After generating an attribution report for the abnormal event through a first agent configured on the first end based on the target case, the target rule, and service data associated with the abnormal event, the method further includes: Read the endpoint information of the second endpoint to which the target attribution request belongs, determine the access permission that matches the endpoint information, the access permission being the permission to access the attribution report, and the endpoint information being used to identify the second endpoint; The link address of the attribution report is written into the data sharing area, which allows a second end with corresponding access permissions to access it. The data sharing area is used for the first end and the second end to share data.
6. The method according to claim 1, characterized in that, The feedback data includes self-check records and evaluation data corresponding to the attribution report. After the attribution report of the abnormal event is generated by the first agent deployed on the first end based on the target case, the target rule, and service data associated with the abnormal event, the method further includes: According to a number of predefined checkpoints, the attribution process data included in the attribution report is checked, and a self-check record for the attribution report is generated and stored in the reflection layer of the predetermined knowledge base. Each checkpoint is a check of a predetermined processing step in the attribution process data. Based on the self-check record indicating that there are operations in the attribution process data that do not conform to the preset attribution process, a target instruction is generated. The target instruction is used to make the first intelligent agent configured on the first end execute the attribution process of the next attribution request in accordance with the preset attribution process. Based on the evaluation data of each of the attribution reports, an adjustment plan information for the first agent configured on the first end is generated by the second agent configured on the first end. The second agent is used to analyze the attribution conclusions of each of the attribution reports. The adjustment plan information is used to indicate the fields that need to be modified in the instruction file of the first agent. In response to receiving a confirmation instruction for the adjustment plan information, the instruction file of the first intelligent agent is adjusted by the second intelligent agent belonging to the same first end based on the adjustment plan information.
7. An agent-based attribution system for abnormal events, characterized in that, include: First end and second end; The second end is used to send a target attribution request for the abnormal event; The first end is configured to retrieve target cases and target rules from a predetermined knowledge base configured on the first end based on the received target attribution request; the predetermined knowledge base is used to store historical cases and predetermined rules, and the predetermined knowledge base is updated based on the historical attribution reports corresponding to each historical attribution request; the historical cases include attribution process data and historical attribution reports corresponding to historical anomalies; the predetermined rules are the execution rules followed by each historical case in the attribution process. Based on the target case, the target rule, and the service data associated with the abnormal event, an attribution report of the abnormal event is generated by a first intelligent agent deployed on the first end. The instruction file of the first intelligent agent is updated based on the feedback data of each historical attribution report, and the feedback data represents the data quality of each historical attribution report. The attribution report is then sent to the second end. The second terminal is used to receive and display the attribution report.
8. An electronic device, characterized in that, It includes a memory, a processor, and a computer program stored in the memory, wherein the processor, when executing the computer program, implements the method of any one of claims 1 to 6.
9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the method of any one of claims 1 to 6.
10. A computer program product, characterized in that, It includes a computer program that, when executed by a processor, implements the method according to any one of claims 1 to 6.
