Multi-agent power grid project intelligent monitoring, control and evaluation system and method

Abstract

The invention relates to the technical field of project intelligent management and control, and discloses a multi-agent power grid project intelligent monitoring, management and control and evaluation system and method, and the system comprises a mixed data resource library, a multi-agent system, an index calculation module and a process control module. The mixed data resource library stores structured business data and unstructured documents; the multi-agent system comprises an information extraction agent, an index design agent, a code generation and treatment agent and the like, works cooperatively, and converts a high-level natural language management and control rule into an executable code; the index calculation module is responsible for executing codes according to a scheduling strategy and calculating quantitative indexes; and the process control module automatically identifies risks and executes management and control operations such as process locking according to the index result and a preset threshold value. According to the invention, the complex business logic can be automated and coded, the accuracy and timeliness of risk identification are improved, and refined and prospective intelligent management and control of the power grid project are realized.

Description

Technical Field

[0001] This invention relates to the field of intelligent project management and control technology, and in particular to an intelligent monitoring, management and evaluation system and method for multi-agent power grid projects. Background Technology

[0002] Power grid projects are typically characterized by large-scale investment, long construction periods, high technical requirements, and involvement of numerous professional fields, making their full lifecycle management an extremely complex systems engineering project. To improve management efficiency and decision-making capabilities, modern power grid companies have generally deployed multiple information-based business systems, such as project management systems, financial management systems, material procurement systems, and production operation systems, accumulating massive amounts of business data.

[0003] However, in current technological practices, these information systems often exist as independent "data silos," resulting in severe fragmentation of project data across different systems. This data fragmentation makes obtaining a comprehensive, real-time view of a project extremely difficult. Therefore, when risk identification or comprehensive analysis is required, business experts often have to rely on their personal experience to manually query, export, and integrate data from multiple systems. This process is not only inefficient and labor-intensive, but also highly susceptible to misjudgments due to data omissions or misinterpretations.

[0004] Furthermore, existing risk management logic is mostly hard-coded and solidified in business systems. These rules are rigid and difficult to maintain, unable to flexibly adapt to rapidly changing business needs or dynamically adjusted regulatory policies. When new control requirements arise, they often require lengthy software development and deployment cycles, failing to respond nimbly to management intentions. More importantly, for some complex risks requiring cross-system collaborative handling, existing technologies lack effective automation methods. The closed-loop process from risk identification to handling heavily relies on manual communication and offline coordination, leading to response delays, potentially missing the optimal intervention opportunity, and failing to effectively avoid or mitigate the losses caused by risks. Summary of the Invention

[0005] The technical problem that this invention aims to solve is that existing power grid project management methods rely on manual interpretation of rules and manual configuration of the system, resulting in rigid risk monitoring and effectiveness evaluation rules and slow response. At the same time, risk handling is limited to alarms or process blockages within the system, lacking cross-system collaborative handling capabilities, and making it difficult to form an efficient risk management closed loop.

[0006] To address the aforementioned technical problems, this invention provides a multi-agent intelligent monitoring, control, and evaluation system and method for power grid projects.

[0007] The first aspect of the present invention provides a multi-agent intelligent monitoring, control and evaluation system for power grid projects, including a hybrid data resource library, a multi-agent system, an index calculation module and a process control module;

[0008] The hybrid data repository is configured to store structured business data and unstructured documents for power grid projects;

[0009] The multi-agent system is connected to the hybrid data resource library, and the multi-agent system includes:

[0010] An information extraction agent is configured to retrieve and extract relevant contextual information from unstructured documents in the hybrid data resource library according to a preset task.

[0011] An indicator design agent is configured to receive the context information and generate structured indicators containing natural language computation logic using a large language model.

[0012] A code-generating agent is configured to automatically convert the natural language computation logic into executable code.

[0013] The indicator calculation module is configured to execute the executable code generated by the code generation agent to generate indicator calculation results;

[0014] The process control module is configured to perform preset control operations on the power grid project based on the comparison between the calculated results of the indicators and preset thresholds.

[0015] In one specific embodiment, the hybrid data resource library includes:

[0016] A relational database is used to store the structured business data, which includes at least the project's entire lifecycle data, including plans, contracts, execution data, and asset data.

[0017] A vector database is used to store the unstructured documents and the metadata description of the relational database. The unstructured documents include at least management methods, regulations and standards, feasibility study reports, preliminary design reports, and contract documents.

[0018] In one specific embodiment, the information extraction agent is specifically configured to extract relevant contextual information from the unstructured document according to a preset task using at least one of the following methods:

[0019] The vector-based retrieval method uses a pre-trained embedding model to vectorize the text fragments of the pre-set task and the unstructured document, and retrieves and extracts the relevant contextual information by calculating the vector similarity between the task vector and the text fragment vector.

[0020] The method based on large model generation involves providing the text content of the unstructured document and the preset task as input to the first large language model, and instructing the first large language model to directly summarize, extract, or generate the relevant context information.

[0021] In one specific embodiment, the indicator design agent is specifically configured as follows:

[0022] By constructing a composite prompt that includes system instructions, output format specifications, and the aforementioned context information, and providing it to the second language model, the context information is converted into one or more structured indicators. The structured indicators at least include indicator names and computational logic described in natural language entries to facilitate subsequent code generation.

[0023] In one specific embodiment, the code generation agent operates in the following manner:

[0024] First, using retrieval enhancement generation technology, database table structure descriptions related to the natural language computing logic are retrieved from the hybrid data resource library;

[0025] Then, the natural language computing logic and the database table structure description are input into the large language model to generate the executable code;

[0026] Furthermore, the code-generating agent is also configured to:

[0027] The executable code is verified, and when execution fails, the large language model is driven to correct the code based on the returned error information, forming a closed loop of code generation and verification.

[0028] In one specific embodiment, the multi-agent system further includes:

[0029] A governance agent is configured to be activated when the process control module identifies a risk event.

[0030] The governance agent adopts a mode that combines reasoning and action, and performs cross-system collaborative operations by invoking a preset toolset to handle the risk events.

[0031] Furthermore, the governance agent's execution of cross-system collaborative operations specifically includes the following steps:

[0032] The risk events are reasoned out and decomposed into execution plans consisting of sub-tasks;

[0033] For each subtask in the execution plan, the corresponding external system application programming interface is selected and invoked from the toolset;

[0034] Observe the return results of external system application interface calls and deduce the next action until the execution plan is completed.

[0035] Furthermore, the governance agent is also configured to:

[0036] After completing the cross-system collaborative operation, relevant tools are periodically invoked to verify the handling status of risk events;

[0037] Once it is verified that the risk event has been resolved, the process control module is automatically triggered to release the control operation on the power grid project.

[0038] In one specific embodiment, the system further includes:

[0039] The analysis report generation module is configured to automatically generate analysis reports based on the set analysis topic, driving the large language model.

[0040] The specific configuration of the analysis report generation module is as follows:

[0041] Based on the analysis topic, background information is obtained from external data sources through enhanced retrieval methods;

[0042] Based on the analysis topic and the background information, generate and confirm the report outline;

[0043] The required data metrics and contextual information are automatically collected according to the report outline, and all the aforementioned information is combined to compile and integrate into the final analysis report.

[0044] In one specific embodiment, the control operation performed by the process control module is as follows:

[0045] The system locks or unlocks the process for key business nodes of the power grid project within its own system.

[0046] A second aspect of this invention provides a method for intelligent monitoring, control, and evaluation of multi-agent power grid projects, comprising the following steps:

[0047] Construct a hybrid data resource repository to store structured business data and unstructured documents for power grid projects;

[0048] Using a multi-agent system, perform the following operations:

[0049] a) Based on the preset task, retrieve and extract relevant contextual information from the unstructured documents in the hybrid data resource library;

[0050] b) Receive the context information and use the large language model to generate structured metrics containing natural language computing logic;

[0051] c) Automatically convert the natural language computation logic into executable code;

[0052] Execute the executable code to generate the metric calculation results;

[0053] Based on the comparison between the calculated results of the aforementioned indicators and the preset thresholds, preset control operations are performed on the power grid project.

[0054] In summary, the present invention has at least one of the following beneficial technical effects:

[0055] 1. This invention achieves automated conversion from unstructured natural language rules to executable code through the collaboration of multiple intelligent agents, including information extraction, indicator design, and code generation. This mechanism avoids the traditional method of relying on manual interpretation of management documents and manual configuration of system rules, directly transforming upper-level business requirements into lower-level executable logic, thereby improving the response speed and flexibility of risk monitoring and effectiveness evaluation rule system construction and updates.

[0056] 2. This invention addresses the technical problem of potential syntax errors or logical deviations in code directly generated by large language models by configuring a verification and correction mechanism for the code generation agent. This mechanism performs execution verification immediately after code generation and uses the error information returned when verification fails to drive the large language model to perform autonomous correction, ensuring the accuracy and reliability of the final executable code at the execution level.

[0057] 3. This invention, by introducing a governance agent and its cross-system collaborative operation capabilities, extends risk management from passive process blocking within a system to proactive collaborative management across systems. This agent can call external system application programming interfaces to execute specific operations and confirm whether the risk has been resolved through a subsequent closed-loop verification mechanism. This achieves end-to-end management from risk identification to automated collaborative management, improving the efficiency of the risk closure loop. Attached Figure Description

[0058] Figure 1 This is a schematic diagram of the structure of a multi-agent intelligent monitoring, control and evaluation system for power grid projects according to an embodiment of the present invention;

[0059] Figure 2 This is a schematic diagram of the workflow of a governance intelligent agent according to an embodiment of the present invention;

[0060] Figure 3 This is a schematic diagram of the workflow of the analysis report generation module according to an embodiment of the present invention.

[0061] Among them, 10. Hybrid Data Resource Library; 11. Relational Database; 12. Vector Database; 20. Multi-Agent System; 21. Information Extraction Agent; 22. Indicator Design Agent; 23. Code Generation Agent; 24. Governance Agent; 30. Indicator Calculation Module; 40. Process Control Module; 50. Analysis Report Generation Module. Detailed Implementation

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

[0063] See attached document Figure 1 , Figure 1 This is a schematic diagram of the structure of a multi-agent intelligent monitoring, control, and evaluation system for power grid projects according to an embodiment of the present invention. The system provided in this embodiment may include: a hybrid data resource library 10, a multi-agent system 20, an index calculation module 30, and a process control module 40.

[0064] The hybrid data repository 10 is configured to store structured business data and unstructured documents throughout the entire lifecycle of a power grid project. In one embodiment, the hybrid data repository 10 includes a relational database 11 and a vector database 12. The relational database 11 stores structured business data, including basic project information, annual plans, monthly execution information, equipment ledger information, project-equipment association information, and equipment operating status information. The vector database 12 stores unstructured documents, including management regulations, industry regulations, project feasibility study reports, and metadata descriptions from the relational database 11.

[0065] The construction process of the vector database 12 includes segmenting unstructured documents and vectorizing the text fragments using a pre-trained embedding model. After vectorization, the original text, corresponding vector, and source metadata of the text fragments are stored in the database. Subsequent retrieval is achieved by calculating the similarity between the query vector and the text fragment vectors in the database.

[0066] The multi-agent system 20 establishes a data communication connection with the hybrid data resource library 10 to acquire data and knowledge from it. In this embodiment, the multi-agent system 20 includes an information extraction agent 21, an indicator design agent 22, a code generation agent 23, and a governance agent 24. These agents work collaboratively to translate high-level natural language instructions into low-level, executable computer instructions.

[0067] During system operation, the information extraction agent 21 in the multi-agent system 20 first extracts relevant contextual information from the unstructured documents of the hybrid data resource library 10 according to a preset task, through vector retrieval or direct processing by a large model. The extracted contextual information is passed to the indicator design agent 22, which uses a large language model to generate structured indicators containing natural language computation logic. Subsequently, the structured indicators are passed to the code generation agent 23, which is responsible for automatically converting the natural language computation logic into executable code.

[0068] The output of the code generation agent 23, i.e., the executable code, is sent to the indicator calculation module 30. The indicator calculation module 30 executes the code according to a preset scheduling strategy, and the generated indicator calculation results are sent to the process control module 40.

[0069] The process control module 40 compares the received indicator calculation results with preset thresholds. When the comparison result triggers a risk condition, the process control module 40 executes control operations on the power grid project, such as locking key business nodes of the project within the system. Simultaneously, the process control module 40 activates the governance agent 24 in the multi-agent system 20 to initiate further handling procedures.

[0070] In an optional embodiment, the system further includes an analysis report generation module 50. This module is connected to the indicator calculation module 30 and the multi-agent system 20, and is used to acquire data indicators and contextual information to generate a structured analysis report.

[0071] In one embodiment of the present invention, the construction of the relational database 11 in the hybrid data resource library 10 provides a unified and standardized structured data foundation for the quantitative analysis and management of the entire life cycle of power grid projects.

[0072] Specifically, when constructing the relational database 11, the system first extracts raw business data from multiple independent business systems (such as power grid planning systems, infrastructure management systems, financial systems, and material procurement systems) through preset data interfaces. This data comprehensively covers the entire lifecycle of power grid projects, including project planning, preliminary work, reserves, plans, budgets, bidding, contracts, materials, construction, ERP execution, equipment ledgers, and operational information.

[0073] After acquiring the data, the system executes a standardized ETL (Extract, Transform, Load) process. This process includes:

[0074] Data cleaning is used to identify and remove null values, outliers, and duplicate records from raw data.

[0075] Data conversion is used to unify the units of measurement (e.g., unify amounts to ten thousand yuan), data formats (e.g., unify dates to YYYY-MM-DD format), and encoding systems of data from different sources;

[0076] Data loading involves loading the processed, standardized data into a predefined data table model in the relational database 11.

[0077] In this embodiment, the data table model is designed based on the business logic of power grid project management, and the core data table includes, but is not limited to, the following parts:

[0078] The project basic information table (T_proj) stores the static or infrequently updated attributes of the project. This table uses the project's unique code (item_code) as the primary key. Its fields include: project name (item_name), planned total investment (plan_total_investment), feasibility study approval date (feasibility_approval_date), approval date (approval_date), planned start date (plan_start_date), planned commissioning date (plan_commissioning_date), bidding amount (bidding_amount), construction contract signing date (construction_contract_date), and actual start date (actual_start_date).

[0079] The Annual Plan and Budget Information Table (T_annual) stores dynamic business information for projects divided by year. This table is linked to the Project Basic Information Table via a foreign key using the project code (item_code). Its fields include: project code (item_code), year (t_year), annual investment plan (annual_investment_plan), annual financial budget (annual_financial_budget), and cumulative investment allocated (cumulative_investment_allocated).

[0080] The monthly execution information table (T_monthly) stores the monthly execution data for projects. This table is linked to the project basic information table via a foreign key using the project code (item_code). Its fields include: project code (item_code), year (t_year), month (t_month), monthly investment completed (monthly_investment_completed), monthly service booked amount (monthly_service_booked_amount), and monthly material booked amount (monthly_material_booked_amount), etc.

[0081] The Equipment Ledger Table (T_asset) stores static information about equipment related to the project. This table uses the equipment's unique identifier (e_id) as the primary key. Its fields include: equipment name (e_name), equipment type (e_type), and model number (e_model).

[0082] The project-device association table (T_link) is used to establish many-to-many relationships between projects and devices. This table uses the project code (item_code) and device code (e_id) as a composite primary key.

[0083] The Equipment Operation Information Table (T_runtime) records dynamic operating status data of the equipment. This table is linked to the Equipment Ledger Table via a foreign key using the equipment code (e_id). Its fields include: equipment code (e_id), timestamp (t_stamp), active power (pwr_active), etc.

[0084] Furthermore, to enable the multi-agent system 20 to understand and use this data, the system generates standardized metadata descriptions for each data table and its fields in the relational database 11. These metadata descriptions define in detail the business meaning of each table, the relationships between tables (e.g., a one-to-many relationship between the project basic information table and the annual plan information table through project codes), and the name, data type, and business meaning of each field. These metadata descriptions are then stored in the vector database 12 as part of the knowledge base, providing structured knowledge support for the subsequent code generation agent 23 to automatically generate database query code.

[0085] In one embodiment of the present invention, the purpose of constructing the vector database 12 in the hybrid data resource library 10 is to convert unstructured documents, including management methods, industry regulations, project feasibility study reports, preliminary design reports, contract documents, and metadata descriptions of the relational database 11, into formatted knowledge that can be semantically retrieved and understood by the multi-agent system 20.

[0086] Specifically, when constructing this vector database 12, the system first receives the original document (e.g., PDF or DOCX format file) and extracts its plain text content. Then, based on the document's type and structure, the system uses a preset segmentation strategy to divide the long text into a series of semantically coherent text segments, or chunks. The segmentation strategy is configured according to document attributes to preserve the text's inherent logical structure.

[0087] In this embodiment, the system employs multiple sharding strategies:

[0088] One strategy is regular expression-based segmentation. For documents with clear structured features, such as regulations or management measures containing chapter titles like "Chapter X" or "§XX," the system applies predefined regular expression patterns to identify these titles. The document is segmented at the identified titles, ensuring that each text block corresponds to a specific chapter or clause, thus guaranteeing the integrity and independence of the content.

[0089] Another strategy is to segment text based on specific formats, such as question-and-answer (QA) pairs. For documents containing explicit question-and-answer formats (such as business guides or FAQ documents), the system extracts each question and its corresponding complete answer as an independent text block by recognizing specific markers such as "Q:" and "A:". This approach preserves the direct association between questions and answers.

[0090] Another strategy is parent-child document fragmentation. For long reports with complex content hierarchies, the system first defines a complete chapter or section as a parent text block. Then, the system further divides each paragraph or key point within that parent text block into smaller sub-text blocks. During storage, each sub-text block contains an identifier pointing to its parent text block. This strategy supports two-stage retrieval: first, by retrieving finer-grained sub-text blocks, precise location of specific information is achieved; then, the parent text block corresponding to that sub-text block is loaded as needed, providing more complete and richer contextual information for subsequent processing.

[0091] After fragmentation is completed, the system attaches a set of structured metadata to each generated text block. This metadata includes: document source identifier, document type, chapter or page number information of the text block in the original document, and the fragmentation strategy type used to generate the text block.

[0092] Next, the system vectorizes each text block. This embodiment uses a pre-trained word embedding model, denoted as... Receive a text block As input, it outputs a high-dimensional real vector. This process can be represented as:

[0093] ;

[0094] in, , This is the preset vector dimension.

[0095] Finally, the system stores the processed data into the vector database 12. Each storage entry is a composite object containing multiple parts, specifically including: the original text content of the text block, its corresponding vector representation, etc. This storage structure, along with its associated structured metadata, supports not only semantic retrieval based on vector similarity but also precise filtering and selection through metadata.

[0096] In one specific implementation of the present invention, a pre-trained word embedding model A bidirectional encoder model based on the Transformer architecture is employed. This model has been pre-trained on large-scale general text corpora (such as publicly available web pages, books, and encyclopedia texts). Through this pre-training process, the model learns the ability to map text to a high-dimensional vector space, in which text blocks with similar semantic content are geometrically close to each other.

[0097] For example, in this embodiment, a publicly available pre-trained model optimized for the Chinese language, such as M3E-base or BGE-large-zh, can be selected. Such models take a text block as input and output a fixed-dimensional real vector (e.g., 768-dimensional or 1024-dimensional), which is the semantic representation of the text block.

[0098] like Figure 1 As shown, in one embodiment of the present invention, the function of the information extraction agent 21 is to retrieve and extract the context information necessary for constructing the downstream business logic from the vector database 12 according to the upstream instructions.

[0099] The workflow of the information extraction agent 21 is triggered by a preset task. The preset task is a task instruction described in natural language, which clarifies the type of information to be extracted and the intent. For example, the task instruction could be: "Extract information from the project feasibility study report to evaluate the project's investment effectiveness, focusing on the necessity and expected benefits of the project." It could also be: "Extract clauses from various management regulations and documents to determine the project's compliance, focusing on specific prohibitions or constraints in project construction, material procurement, and fund payment."

[0100] Upon receiving the task instruction, the information extraction agent 21 first invokes the same pre-trained word embedding model used when constructing the vector database 12. This converts the natural language task instruction into a query vector. The position of the query vector in the vector space represents the core semantic intent of this information extraction task.

[0101] Subsequently, the information extraction agent 21 will extract the query vector. Submit the query vector to vector database 12 and perform a k-nearest neighbor search. Vector database 12 calculates the query vector. With all text block vectors stored in the library Calculate the cosine similarity between them and return the top [number] with the highest similarity scores. These text blocks form an initial candidate set.

[0102] In this embodiment, vector similarity is calculated using the cosine similarity formula:

[0103] ;

[0104] in, This represents the cosine similarity score.

[0105] Furthermore, to improve the accuracy of the extraction results, the information extraction agent 21 performs a post-filtering and refining step on the initial candidate set. This step utilizes metadata stored in the vector database 12.

[0106] First, the candidate set is filtered based on the document type implied in the task instructions (e.g., "feasibility study report" or "management measures"), retaining only the text blocks that match the document_type field in the metadata.

[0107] Next, a similarity threshold is set. (For example, Then, the filtered candidate set is further refined, retaining only text blocks with a cosine similarity score greater than a certain threshold. After this step, the final relevant context information is obtained.

[0108] Finally, the information extraction agent 21 formats and outputs the final selected set of text blocks. It extracts the original content of each text block and organizes it according to a preset structure.

[0109] In this embodiment, the output format is a JSON object. This object contains key-value pairs, where the key is "text" and the value is an array of strings, where each element is the original text of an extracted text block. This standardized output structure is passed to the metric design agent 22 in the multi-agent system 20.

[0110] In another embodiment, the information extraction agent 21 can directly utilize the understanding and generation capabilities of a large language model to extract contextual information. The workflow of this approach is as follows:

[0111] First, the information extraction agent 21 receives a preset task instruction, such as "extract all prohibitions on high-altitude operations from the latest power grid safety production management regulations".

[0112] Secondly, the agent encapsulates the task instruction along with a specified unstructured document (or a portion of its text content) into a structured prompt. This prompt clearly indicates the role of the large language model (e.g., "You are a power grid security expert") and the specific task to be completed.

[0113] The prompt is then sent to a large language model (e.g., a generative pre-trained model based on the Transformer architecture). The large language model performs deep semantic understanding of the input text and, according to the task instructions, directly summarizes the content, extracts key information, or generates a summary text that meets the requirements. For example, for the aforementioned task, the large language model would directly output a list of all prohibitions related to high-altitude operations.

[0114] Finally, the information extraction agent 21 receives the text returned by the large language model and formats it into a standard JSON object as the final context information output.

[0115] In a preferred embodiment of the present invention, the two methods described above can work together. For example, the information extraction agent 21 first uses method one (vector retrieval) to quickly locate several most relevant text fragments from a massive amount of documents, and then uses these highly relevant text fragments as input to perform more in-depth and accurate information extraction and structured processing using method two (large model generation), thereby balancing processing efficiency and information quality.

[0116] like Figure 1 As shown, in one embodiment of the present invention, the function of the indicator design agent 22 is to receive and process contextual information provided by the information extraction agent 21, and automatically generate a series of structured indicators using a large language model. Each generated indicator contains computational or judgment logic described in natural language.

[0117] The indicator design agent 22 first receives a JSON object output from the information extraction agent 21, which contains an array of text blocks related to a specific task (such as risk warning or effectiveness evaluation).

[0118] Upon receiving the input, the indicator design agent 22 constructs a structured, compound prompt word, which is then sent to a pre-configured large language model.

[0119] In this embodiment, the prompt word consists of three main parts to ensure that the large language model can complete the task accurately and consistently:

[0120] The first part is the system instruction block, which sets clear roles and objectives for the large language model. For example, an instruction could be: "You are an expert in power grid project management. Your task is to extract early warning indicators from the following text to identify project risks." This instruction block also includes specific constraints, such as: "Each indicator should be independent of the others to avoid content overlap," "Indicator names should be concise, with a length not exceeding 8 Chinese characters," and "Indicator logic should be clearly described in an itemized format."

[0121] The second part is the output format specification block, which provides a strict, machine-parseable output format definition for the large language model to ensure the structured nature of the returned results. In this embodiment, the specification requires the output to be a JSON object. This JSON object contains a key named `index_list`, and its values ​​are arrays. Each element in the array is an independent index object, which must contain the following three keys:

[0122] index_name: A string representing a general indicator name.

[0123] index_logic: A string that describes, in natural language, the specific steps and conditions for calculating or judging the index.

[0124] source_text: A string containing the original text excerpt from the input context information on which the metric is based.

[0125] The third part is the context injection block, which merges the array of text blocks received from the information extraction agent 21 into a complete text string and inserts it into the context information area reserved in the prompt template.

[0126] After sending the complete prompt to the large language model and receiving the returned text string, the indicator design agent 22 further performs parsing and validation steps. The returned string is processed by calling a JSON parser. This parser verifies that the syntax of the returned content conforms to the JSON format and checks that its structure exactly matches the pattern defined in the output format specification block. If parsing fails or the structure does not match, the system can be configured with a retry mechanism or log errors.

[0127] After parsing, the indicator design agent 22 obtains a structured data object, which fully contains a list of indicators generated by the large language model and conforming to preset specifications. This structured data object is then passed to the code generation agent 23 in the multi-agent system 20 for subsequent code conversion processing.

[0128] like Figure 1 As shown, in one embodiment of the present invention, the function of the code generation agent 23 is to automatically convert the indicator logic generated by the indicator design agent 22 and described in natural language into deterministic executable code that can be executed in the indicator calculation module 30.

[0129] The code generation agent 23 receives structured indicator objects output from the indicator design agent 22. For each indicator object, the agent executes a complete process including retrieval, generation, verification, and correction.

[0130] First, the agent performs the first stage of Retrieval-Augmented Generation (RAG), namely, relevant data table retrieval. It extracts the content of the `index_logic` field from the metric object as the query and vectorizes it using a pre-trained word embedding model. Subsequently, it uses this vector to perform semantic retrieval in the vector database 12. The retrieval target here is the metadata description of the previously stored relational database 11. The retrieval operation returns a set of data tables and their structural descriptions that are semantically most relevant to the metric logic. The purpose of this step is to limit the range of data sources required for subsequent code generation, avoiding providing all pattern information from the entire database to a large language model, thereby reducing the complexity of subsequent processing.

[0131] Next, the executable code generation phase begins. Code generation agent 23 constructs a composite suggestion, which includes the following parts:

[0132] 1. Role and Task Definition: Define clear identities and tasks for the large language model, for example: "You are a data analysis expert, skilled at writing SQL and Python code based on business logic and database table structure. The database type you use is {database type_version}."

[0133] 2. Data Structure Context: The complete structure description of the relevant data tables retrieved in the previous step (including table name, field name, data type, business meaning, and inter-table relationships) is injected into the prompt.

[0134] 3. Logic to be implemented: Inject the original content of the index_logic field in the indicator object into the prompt.

[0135] 4. Output format instructions: Explicitly require the large language model to output code in a specific format, such as a complete code block containing SQL query statements and Python calculation logic.

[0136] After sending the aforementioned compound prompt to the large language model and receiving the generated code string, agent 23 does not output it directly. Instead, it initiates an automated verification and correction closed-loop process. It submits the generated code to a preset code execution environment for trial execution. This environment is connected to the relational database 11 and can simulate real data query and calculation processes.

[0137] If the code executes successfully without returning any errors, it is considered valid, and the process ends. If the code execution returns an error message (such as an SQL syntax error, a non-existent field, or a data type mismatch), the code generation agent 23 will capture the error message.

[0138] Upon detecting an error, agent 23 enters the correction phase. It constructs a new correction suggestion containing the original logic to be implemented, the previously generated erroneous code, and the complete error message returned by the execution environment. This context-rich correction suggestion is then sent back to the large language model, instructing it to correct the code based on the error message. Upon receiving this information, the large language model generates a new version of the code. This newly generated code then re-enters the verification phase. This correction loop can be configured with a maximum number of attempts, such as three, to prevent infinite loops.

[0139] Once the executable code has been verified and confirmed to be correct, it is finally encapsulated and output to the indicator calculation module 30, awaiting scheduling and execution.

[0140] like Figure 1 As shown, in one embodiment of the present invention, the metric calculation module 30 is connected to the code generation agent 23 in the multi-agent system 20, and is used to receive and execute the executable code generated therein. This module contains a scheduler and an execution engine. The scheduler is responsible for triggering the calculation of metrics according to preset strategies. These strategies are stored in a scheduling configuration table, and each record associates a metric code with a triggering condition.

[0141] In this embodiment, the triggering condition can be a timed trigger, defined using a CRON-like expression (e.g., 0 2*** represents execution at 2 AM daily), suitable for metrics requiring periodic, global scanning. The triggering condition can also be an event trigger, where the scheduler listens for changes to specific fields in specific tables of the relational database 11. For example, when the actual start date field (actual_start_date) of a project is updated from null to non-null, an event is triggered, which in turn schedules the calculation of metrics related to the project's duration.

[0142] When the triggering condition is met, the scheduler dispatches the corresponding executable code to the execution engine. The execution engine runs the code in an isolated environment. The code execution process includes:

[0143] An SQL query is sent to relational database 11 to obtain the basic data required for calculation. Then, the calculation logic defined in the Python code segment is executed to finally produce a quantitative indicator result. For example, for the indicator "Construction effectiveness not achieved", the code will query the commissioning date of the equipment associated with the project and the equipment operation information for subsequent months, and calculate the equipment utilization rate. This calculation result, along with the corresponding project code and indicator code, is stored in a dedicated result table (e.g., T_indicator_results) in relational database 11 and is simultaneously sent to process control module 40.

[0144] like Figure 1 As shown, in one embodiment of the present invention, the process control module 40 is connected to the indicator calculation module 30, and is used to receive the indicator calculation results and execute corresponding control operations. The core of this module is a rule engine, which is configured with a set of control rules. Each rule defines a mapping relationship of "indicator-condition-action". For example, the rule can be defined as: when the result of the "validity period of project approval document" indicator is less than 0 (condition), execute the action of "locking project commencement". The rule can also be defined as: when the result of the "deviation rate between preliminary design and feasibility study investment" indicator is greater than 0.15 (condition), execute the action of "locking investment plan issuance".

[0145] Once the process control module 40 receives the indicator calculation result, the rule engine will traverse the rule set and compare the result with the conditions in the rules. If the conditions of a certain rule are met, the module will execute the action defined by that rule.

[0146] In this embodiment, the "locking" action is technically implemented as follows:

[0147] Modify the status field of the corresponding project in the project basic information table (T_proj) of relational database 11. For example, update the value of the project_status field of a project from "ACTIVE" to "LOCKED_START". This status change will prevent downstream business systems from performing subsequent operations on that project.

[0148] For risk events that meet the preset high severity level conditions, the process control module 40 will perform an additional action while executing the internal locking action:

[0149] The governance agent 24 is activated by sending a structured signal containing details of the risk event to the governance agent 24, thereby initiating a cross-system collaborative response process.

[0150] Once a project's risks are resolved through business personnel management or changes in external conditions, the system supports manual or automatic recalculation of the project's relevant metrics. After the metric calculation module 30 performs the calculation, it sends the new results back to the process control module 40. If the new results no longer meet any locking rules, the process control module 40 performs an unlocking action, restoring the project status field to "ACTIVE," allowing the project process to continue.

[0151] See attached document Figure 2 , Figure 2 This is a schematic diagram of the workflow of a governance agent according to an embodiment of the present invention. The function of the governance agent 24 is to perform cross-system collaborative operations to handle risk events that require proactive intervention when the system identifies them, and to perform closed-loop verification of the handling results.

[0152] The activation of governance agent 24 is triggered by process control module 40. When the calculated results of one or more indicators exceed a preset threshold representing a high-severity risk, process control module 40 sends an activation signal to governance agent 24 while performing its internal control operations (such as process locking). The payload of this signal is a JSON object containing detailed information about the risk event, such as the project code, risk type description, and indicator data that triggered the risk.

[0153] Upon receiving the activation signal, the governance agent 24 employs a reasoning and acting (ReAct) framework to perform its tasks. The core of this framework is breaking down complex disposal tasks into a series of "reasoning-action-observation" loops.

[0154] First, the governance agent 24 enters the "Reasoning" phase. It combines the received risk event information with a pre-defined instruction template and inputs it into the large language model. This instruction template guides the large language model to analyze the risk event and generate a preliminary execution plan consisting of multiple sub-tasks. For example, for a risk event of "suspected severe delay in commencement of work," the generated execution plan might be:

[0155] 1. Find the project manager's contact information;

[0156] 2. Send alert notifications to the project manager via instant messaging system;

[0157] 3. Create a high-priority risk tracking task in the project collaboration management system.

[0158] Next, governance agent 24 enters the "Acting" phase. It processes the subtasks in the execution plan one by one. For this purpose, governance agent 24 is configured with a predefined toolset. This toolset is a series of functions that encapsulate external system application programming interface (API) calls. Each tool corresponds to a specific operation, for example:

[0159] query_hr_system(query_key): Used to call the API of the human resources system to query relevant personnel information based on the project code.

[0160] send_im_message(recipient_id, message_content): This is used to call the API of an enterprise instant messaging system to send a message with specified content.

[0161] create_pm_task(project_id, task_details): This function calls the API of the project collaboration management system to create a new task entry.

[0162] query_database(sql_string): Used to call the internal interface and execute a query on relational database 11.

[0163] For each subtask, the governance agent 24 selects and calls the corresponding tool function from the toolset, and takes the subtask's parameters (such as project code and message content) as the function input.

[0164] After invoking the tool, governance agent 24 enters the "Observation" phase. It receives and parses the return results of external system API calls. These results can be data returned after a successful API execution (such as retrieved personnel information), or error codes and information returned when an API call fails.

[0165] This "reasoning-action-observation" cycle continues. The observation results at each step serve as new context, which is then fed into the next reasoning stage so that the large language model can determine the next action, until all subtasks in the execution plan are completed.

[0166] After the execution plan is completed, governance agent 24 enters a periodic closed-loop verification state. Based on the risk type, it periodically (e.g., every 24 hours) calls a pre-set verification tool (usually the query_database tool) to re-examine the original indicators that triggered the risk. When the verification results show that the risk conditions are no longer met (e.g., the actual_start_date field of the project is found to have a value), governance agent 24 determines that the risk has been resolved.

[0167] Finally, after confirming that the risk has been eliminated, the governance agent 24 sends a signal indicating that the handling is complete to the process control module 40. Upon receiving this signal, the process control module 40 automatically releases the control operations previously applied to the power grid project, thereby completing the entire process of the risk event from identification and collaborative handling to closed-loop verification.

[0168] See attached document Figure 3 , Figure 3 This is a schematic diagram of the workflow of an analysis report generation module according to an embodiment of the present invention. The analysis report generation module 50 establishes a data communication connection with the multi-agent system 20 and the indicator calculation module 30, and its function is to automatically generate a structured analysis report based on a given analysis topic.

[0169] The workflow of the analysis report generation module 50 is triggered by an initial natural language instruction that defines the topic of the report, such as "Analysis Report on the Implementation of Power Grid Infrastructure Investment in the First Half of This Year".

[0170] In one embodiment of the present invention, the generation of the analysis report includes the following steps:

[0171] The first step is to generate and confirm the report outline:

[0172] To ensure higher quality in the generated outline, the module first performs background research in the initial stage of this step. Specifically, the analysis report generation module 50 uses the initial report topic as query keywords and calls external data sources (such as public Internet search engines or designated industry information databases) through the built-in search enhancement module to obtain background information such as the latest news, policy documents, technology trends, or market analysis related to the topic.

[0173] The retrieved background information, along with the original report topic, is then encapsulated in a compound prompt and sent to a large language model, which generates a hierarchical report outline. This outline is returned in a structured data format (e.g., JSON), defining the report's chapters and sub-chapter titles. The module then presents this structured outline to the user for review. The user can modify the outline through an interactive interface, including renaming, reordering, adding, or deleting chapters. The module receives the final outline after user confirmation, serving as structured input for subsequent steps.

[0174] The second step is to identify and acquire data requirements:

[0175] The analysis report generation module iterates through each chapter in the confirmed outline 50 times. For each chapter, it extracts the chapter title as keywords and performs two parallel operations:

[0176] 1. Contextual Information Retrieval: Using the chapter title as the query, semantic retrieval is performed in the vector database 12 to obtain unstructured text fragments such as background materials, legal clauses, or project descriptions related to the chapter topic.

[0177] 2. Quantitative Indicator Identification: Send the chapter title to a large language model, instructing it to generate a list of quantitative indicators necessary for writing the chapter.

[0178] After obtaining the list of required metrics, the module queries an internal metric registry to determine if the executable code needed to calculate these metrics exists. For existing metrics, the module directly calls the metric calculation module 30 to obtain its latest calculation results. For non-existent metrics, the module automatically generates a task description based on the metric name and context information, and assigns the task to the code generation agent 23 in the multi-agent system 20 to create the corresponding executable code. After the code is generated and verified, the module then calls the metric calculation module 30 to obtain the results.

[0179] The third step is to generate chapter-by-chapter content:

[0180] For each chapter in the outline, the analysis report generation module 50 constructs a compound prompt. This prompt consists of three parts: the chapter title, relevant contextual text fragments retrieved in the first step, and all the quantitative indicator data required for that chapter obtained in the second step.

[0181] This module sends this compound prompt to the large language model, instructing it to compose detailed content for the chapter based on the data and context. This step generates a separate text for each chapter in the outline.

[0182] The fourth step is the final integration of the report:

[0183] The analysis report generation module 50 aggregates all independently generated chapter texts and calls the large language model again. The instructions at this point are: based on the existing chapter content, generate the report's summary (introduction) and conclusion, and organize all parts (introduction, chapter content, conclusion) into a logically coherent and formatted analysis report document according to the final outline. The final output document format can be configured as Markdown, PDF, or DOCX, etc.

[0184] To more clearly illustrate the technical solutions of the embodiments of the present invention, specific application scenarios will be described below.

[0185] Example 1:

[0186] This embodiment is set as a management and control scenario, requiring the automatic identification and control of power grid projects whose approval documents are about to expire but have not yet commenced. This management and control requirement stems from the provisions regarding the validity period of project approval documents in the "Administrative Measures for Government-Approved Investment Projects". Business personnel input the rules defined in natural language through a human-computer interaction interface: "Identify all projects whose approval documents have a validity period of less than 30 days and have not yet commenced, mark them as high-risk, and prohibit their commencement."

[0187] After the natural language rule is received by the system, it is directly passed to the indicator design agent 22 in the multi-agent system 20. The indicator design agent 22 calls the large language model to convert the natural language rule into a structured indicator object. This object contains an indicator name, such as "risk of project approval document expiring soon", and the judgment logic described in natural language: "Get the project's approval date and its two-year validity period expiration date, and get the project's current status. If the current date is less than or equal to 30 days away from the expiration date, and the project status is 'not started', then it is judged as a risk."

[0188] Subsequently, the structured indicator object is passed to code generation agent 23. Code generation agent 23 first extracts the keywords "approval date" and "project status" from the indicator's natural language logic, and then uses these to retrieve metadata descriptions from relational database 11 in vector database 12. The search results clearly indicate that these two data items correspond to the `approval_date` and `project_status` fields in the project basic information table (T_proj), respectively.

[0189] After obtaining the exact table and field names, the code generation agent 23 constructs a prompt containing this data structure information and natural language judgment logic, and sends it to the large language model, instructing it to generate an executable data query code. The core logic of this generated and verified code is to perform a filtering operation in the relational database 11: it is designed to query the project basic information table (T_proj), accurately identify all projects with a status of 'not started' and whose approval document validity period (i.e., two years after the approval date) is less than 30 days from the current system date, and return a list of codes for these projects that meet the conditions.

[0190] This executable data query code is sent to the metric calculation module 30. The scheduler of this module configures a daily scheduled execution strategy based on the nature of the metric. In each execution cycle, the execution engine runs this code, queries the relational database 11, and generates a list of project codes that meet the specified conditions.

[0191] Suppose that in a certain execution, the calculation result of project "proj-A-001" meets the conditions, the project code is included in the result list and sent to the process control module 40.

[0192] The process control module 40 receives this result. Its internal rule engine has a pre-set rule: "If a risk signal is received from the 'risk of project approval documents nearing expiration' indicator, then execute the action of 'locking the project commencement process'." Based on this rule, the module performs a locking action on project "proj-A-001". Specifically, this action involves sending an update command to the relational database 11, updating the value of the project_status field in the record with item_code "proj-A-001" in the project basic information table (T_proj) to "LOCKED_APPROVAL_EXPIRY".

[0193] In this state, any downstream business system that needs to read the project status (such as a system used to approve commencement reports) will, upon finding the "LOCKED_APPROVAL_EXPIRY" status, prohibit the submission or approval of commencement reports. This achieves process locking within the system, effectively avoiding the risk of the project commencing work illegally after the approval document expires. This locked state will persist until the project unit applies for and receives an extension according to regulations. After the validity period of the approval document is updated in the system, the project will no longer meet the risk conditions in the next indicator calculation, and the process control module 40 will automatically execute the unlocking operation.

[0194] Example 2:

[0195] Another embodiment of the present invention aims to address complex risks requiring cross-system collaborative handling and to achieve closed-loop verification of the handling process. This scenario uses the complex risk of "failure to achieve project construction goals" as an example for illustration.

[0196] This scenario begins with a routine calculation by the indicator calculation module 30. This module executes indicator code generated by the code generation agent 23. The logic of this code is as follows: for all power grid projects that have been in operation for more than a month, query the operating information of their associated equipment (such as main transformers) over the past month. If it is found that the active power of a certain device is consistently zero throughout the month, it is judged as a risk of "construction results not being achieved".

[0197] In this calculation, the system found that the transformer "E-XYZ-001" associated with project "proj-B-002" meets this risk condition. The indicator calculation module 30 sends structured data containing project code, equipment code, and risk type to the process control module 40.

[0198] Upon receiving the risk signal, the process control module 40 determines that the risk is of high severity based on its internal rule set. The module then executes two parallel actions:

[0199] 1. Internal process lockout: Send a command to relational database 11 to update the status field project_status of project “proj-B-002” to “LOCKED_PAYMENT” to prevent the final settlement payment process of the project.

[0200] 2. Activate the governance agent: Send an activation signal to governance agent 24. The payload of the signal is a JSON object that describes the risk event in detail, for example: {"risk_type": "effectiveness_not_achieved", "item_code": "proj-B-002", "e_id": "E-XYZ-001"}.

[0201] Once activated, the governance agent 24 begins to operate using a "reasoning-action-observation" framework.

[0202] Reasoning Phase One:

[0203] The governance agent 24 inputs risk information into the large language model and asks: "How to handle an event where a newly commissioned transformer operates at zero load for a month?"

[0204] The large language model generates a preliminary execution plan: [1. Query project manager information; 2. Send alarm notification; 3. Create a work order in the operation and maintenance system, requesting on-site verification].

[0205] Phase 1 of Action and Observation:

[0206] When the governance agent 24 executes the plan, it first calls the `query_hr_system` tool in its toolset to query the human resources system using the project code "proj-B-002" as a parameter. The system API returns the employee ID and name of the project manager. This is the first "observation".

[0207] Reasoning Stage Two:

[0208] The governance agent 24 adds the newly observed information (project manager ID) to the context and continues to execute the plan.

[0209] Phase Two: Action and Observation

[0210] Governing agent 24 invokes the `send_im_message` tool to send a pre-defined message to the project manager's instant messaging account: "Warning: Transformer E-XYZ-001 associated with your project proj-B-002 has been in operation for one month, but the load is zero. Please pay attention immediately." The instant messaging system API returned a success message. This is the second "observation."

[0211] Phase 3 of Action and Observation: Governance Agent 24 then calls the create_ops_ticket tool to connect to the external business system responsible for handling maintenance work orders and creates a new work order with the content: "Please send personnel to the site to verify the reason for the zero-load operation of transformer E-XYZ-001." The maintenance system API returns a work order number. This is the third "observation."

[0212] After completing cross-system collaborative notification and task assignment, governance agent 24 enters a closed-loop verification monitoring state. It sets a scheduled task to automatically perform a verification operation every 12 hours. This operation calls the query_database tool to execute an SQL query to obtain the recent active power data of transformer "E-XYZ-001".

[0213] After the operational personnel completed the on-site handling (e.g., connecting the downstream load), the transformer began normal operation. In the next verification query, the governance agent 24 observed that the returned active power value was greater than zero. It determined that the risk condition had been eliminated.

[0214] Finally, the governance agent 24 sends a signal indicating that the process is complete to the process control module 40. Upon receiving this signal, the process control module 40 automatically performs an unlocking operation, restoring the status field "project_status" of project "proj-B-002" to "ACTIVE", thereby allowing the final settlement and payment process to continue, completing the entire process of complex risk from automatic identification and cross-system collaborative handling to final closed-loop verification.

[0215] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A multi-agent intelligent monitoring, control, and evaluation system for power grid projects, characterized in that, It includes a hybrid data resource library, a multi-agent system, an indicator calculation module, and a process control module; The hybrid data repository is configured to store structured business data and unstructured documents for power grid projects; The multi-agent system is connected to the hybrid data resource library, and the multi-agent system includes: An information extraction agent is configured to retrieve and extract relevant contextual information from unstructured documents in the hybrid data resource library according to a preset task. An indicator design agent is configured to receive the context information and generate structured indicators containing natural language computation logic using a large language model. A code-generating agent is configured to automatically convert the natural language computation logic into executable code. The indicator calculation module is configured to execute the executable code generated by the code generation agent to generate indicator calculation results; The process control module is configured to perform preset control operations on the power grid project based on the comparison between the calculated results of the indicators and preset thresholds.

2. The intelligent monitoring, control, and evaluation system for multi-agent power grid projects according to claim 1, characterized in that, The hybrid data resource library includes: A relational database is used to store the structured business data, which includes at least the project's entire lifecycle data, including plans, contracts, execution data, and asset data. A vector database is used to store the unstructured documents and the metadata description of the relational database. The unstructured documents include at least management methods, regulations and standards, feasibility study reports, preliminary design reports, and contract documents.

3. The intelligent monitoring, control, and evaluation system for multi-agent power grid projects according to claim 1, characterized in that, The information extraction agent is specifically configured to extract relevant contextual information from the unstructured document according to a preset task using at least one of the following methods: The vector-based retrieval method uses a pre-trained embedding model to vectorize the text fragments of the pre-set task and the unstructured document, and retrieves and extracts the relevant contextual information by calculating the vector similarity between the task vector and the text fragment vector. The method based on large model generation involves providing the text content of the unstructured document and the preset task as input to the first large language model, and instructing the first large language model to directly summarize, extract, or generate the relevant context information.

4. The intelligent monitoring, control, and evaluation system for multi-agent power grid projects according to claim 1, characterized in that, The specific configuration of the indicator design agent is as follows: By constructing a composite prompt that includes system instructions, output format specifications, and the aforementioned context information, and providing it to the second language model, the context information is converted into one or more structured indicators. The structured indicators at least include indicator names and computational logic described in natural language entries to facilitate subsequent code generation.

5. The intelligent monitoring, control, and evaluation system for multi-agent power grid projects according to claim 1, characterized in that, The specific configuration of the code generation agent is as follows: Using retrieval enhancement generation technology, database table structure descriptions related to the natural language computing logic are retrieved from the hybrid data resource library; The natural language computing logic and the database table structure description are input into the large language model to generate the executable code. Furthermore, the code-generating agent is also configured to: The executable code is verified, and if execution fails, the large language model is driven to correct the code based on the returned error information.

6. The intelligent monitoring, control, and evaluation system for multi-agent power grid projects according to claim 1, characterized in that, The multi-agent system also includes: A governance agent is configured to be activated when the process control module identifies a risk event. The governance agent adopts a mode that combines reasoning and action, and performs cross-system collaborative operations by invoking a preset toolset to handle the risk events; The governance agent performs cross-system collaborative operations, specifically including: The risk events are reasoned out and decomposed into execution plans consisting of sub-tasks; For each subtask in the execution plan, the corresponding external system application programming interface is selected and invoked from the toolset; Observe the return results of external system application interface calls and deduce the next action until the execution plan is completed.

7. The intelligent monitoring, control, and evaluation system for multi-agent power grid projects according to claim 6, characterized in that, The governance agent is also configured to: After completing the cross-system collaborative operation, relevant tools are periodically invoked to verify the handling status of risk events; Once it is verified that the risk event has been resolved, the process control module is automatically triggered to release the control operation on the power grid project.

8. The intelligent monitoring, control, and evaluation system for multi-agent power grid projects according to claim 1, characterized in that, Also includes: The analysis report generation module is configured to automatically generate analysis reports based on the set analysis topic, driving the large language model. The specific configuration of the analysis report generation module is as follows: Based on the analysis topic, background information is obtained from external data sources through enhanced retrieval methods; Based on the analysis topic and the background information, generate and confirm the report outline; The required data metrics and contextual information are automatically collected according to the report outline, and all the aforementioned information is combined to compile and integrate into the final analysis report.

9. The intelligent monitoring, control, and evaluation system for multi-agent power grid projects according to claim 1, characterized in that, The control operations performed by the process control module are as follows: The system locks or unlocks the process for key business nodes of the power grid project within its own system.

10. A method for intelligent monitoring, control, and evaluation of multi-agent power grid projects, implemented by the system described in any one of claims 1-9, characterized in that, Includes the following steps: Construct a hybrid data resource repository to store structured business data and unstructured documents for power grid projects; Using a multi-agent system, perform the following operations: a) Based on the preset task, retrieve and extract relevant contextual information from the unstructured documents in the hybrid data resource library; b) Receive the context information and use the large language model to generate structured metrics containing natural language computing logic; c) Automatically convert the natural language computation logic into executable code; Execute the executable code to generate the metric calculation results; Based on the comparison between the calculated results of the aforementioned indicators and the preset thresholds, preset control operations are performed on the power grid project.

Images