A multi-agent parallel data correction method and system based on a large language model

Abstract

The application discloses a multi-agent parallel data correction method and system based on a large language model, and is applied to a data processing scene. The method respectively traverses a first result set and a second result set in to-be-corrected inspection data, and constructs a read-only unified data view through a source path, a project identifier and an association relationship. According to a correction task category and a data source configuration after hierarchical merging, a plurality of correction agents and a dedicated read-only sub-view are constructed. A directed acyclic workflow is used to execute the plurality of correction agents in parallel, and structured correction results are isolated and written into a shared state. After termination of a parallel node, format verification, state determination and problem item merging are performed, and a data quality audit report and a downstream processing routing identifier are generated. The application takes into account double result set coverage and source tracing, and reduces the risk of serial waiting and single node abnormal diffusion.

Description

Technical Field

[0001] This invention relates to the fields of computer data processing and artificial intelligence technology, and in particular to a multi-agent parallel data error correction method and system based on a large language model. Background Technology

[0002] Inspection data processing systems typically need to receive data from different inspection departments, different equipment interfaces, and different historical versions. Before report generation or data exchange, they must perform quality checks on field completeness, numerical and unit matching, cross-project logical consistency, and textual semantic consistency. Some data sources simultaneously store a filtered result set for quick browsing and a full result set as a complete record; the two result sets have similar hierarchical structures but different record scopes.

[0003] Existing data verification solutions often employ hard-coded rule chains based on data format or serially feed different verification tasks into a single model for processing. The former approach typically requires maintaining separate traversal code for the filtered result set and the full result set, making it difficult to retain the data source while avoiding redundant processing; the latter approach places independent verification tasks in the same execution path, and timeouts or output anomalies in any task may extend the overall processing time.

[0004] In existing technologies, the raw data is first converted into a unified table, then several validation programs or language models are called sequentially, and the output is summarized at the end of the process. Unified table conversion is prone to losing the original hierarchical path and the correlation information between the two result sets; serial calling causes the processing delay to accumulate with the number of tasks, and free text output requires separate parsing logic to be designed for different tasks.

[0005] Therefore, the existing technology has at least two interrelated problems: First, the unified processing mechanism for heterogeneous dual result sets is difficult to simultaneously satisfy full coverage, duplication suppression and source traceability, resulting in missed detections, duplicate alarms or insufficient location information; Second, multiple semantic review tasks lack a parallel orchestration mechanism with result isolation and fault degradation capabilities, causing the overall latency to be affected by the number of tasks, and the output anomaly of a single node is easy to spread to the aggregation process. Summary of the Invention

[0006] The technical problem to be solved by the present invention is to provide a multi-agent parallel data error correction method and system based on a large language model, so as to construct a unified data entry while preserving the source and correlation of heterogeneous result sets, and enable multiple error correction tasks to be executed in parallel, isolated and degraded, thereby generating structured audit results that can be directly processed by downstream systems.

[0007] To solve the above-mentioned technical problems, the present invention adopts the following technical solution:

[0008] A multi-agent parallel data error correction method based on a large language model includes:

[0009] Obtain the error-checking data and data source configuration containing the first result set and the second result set. The first result set records the filtered result items, and the second result set records all result items.

[0010] Traverse the first result set and the second result set, configure the source path and project identifier for the obtained data items, associate the data items of the two result sets according to the project identifier, and normalize them to form a read-only unified data view;

[0011] Multiple error correction agents are constructed based on the error correction task category and the data source configuration. A unique read-only subview is extracted for each error correction agent from the read-only unified data view, and an agent running configuration is generated.

[0012] Construct a directed acyclic workflow that includes parallel nodes and aggregation nodes corresponding to the error correction agent, execute the parallel nodes to call the large language model to process the corresponding dedicated read-only subview, and isolate and write the structured error correction results into the shared state;

[0013] After the parallel node terminates, the structured error correction results are subjected to format verification, status determination, and problem item merging to generate a data quality audit report and downstream processing route identifiers.

[0014] Further, the step of traversing the first result set and the second result set, configuring source paths and project identifiers for the obtained data items, associating data items in the two result sets based on the project identifiers, and normalizing them to form a read-only unified data view includes: recursively traversing the first result set according to department level, subgroup level, and project level; recursively traversing the second result set according to the same hierarchical order as the first result set; adding a full source marker to the source path for data items from the second result set; extracting the department identifier, subgroup identifier, project index, and project content from each data item to form a unified data item quadruple; extracting the project name, project code, and hierarchical path from the project content, and generating the project identifier using at least two of the project name, project code, and hierarchical path; retaining a single data item from the associated data items or simultaneously retaining data items with different source paths according to the deduplication strategy corresponding to the error correction task, to obtain the read-only unified data view.

[0015] Further, generating the project identifier using at least two of the project name, the project code, and the hierarchical path includes: performing character normalization on the project name to obtain a normalized project name; performing null value detection on the project code to obtain a valid project code status; splitting the hierarchical path into departmental path fragments and subgroup path fragments; when the valid project code status indicates that the project code is valid, combining the project code, the normalized project name, and the subgroup path fragments; when the valid project code status indicates that the project code is invalid, combining the normalized project name, the departmental path fragments, the subgroup path fragments, and the project index; performing deterministic encoding on the combination result to obtain the project identifier, and writing the project identifier and the source path together into the corresponding unified data item quadruple.

[0016] Furthermore, the process involves constructing multiple error correction agents based on the error correction task category and the data source configuration, extracting a dedicated read-only subview for each error correction agent from the read-only unified data view, and generating an agent runtime configuration. This includes: reading the code default configuration, external rule configuration, and the data source configuration; performing overwrite merging on the enabled fields and model parameter fields according to the increasing priority of the code default configuration, external rule configuration, and data source configuration, where the enabled fields indicate whether each error correction agent is enabled, and the model parameter fields represent the calling parameters of the large language model; sequentially concatenating the text rule fields in the code default configuration, external rule configuration, and data source configuration; preserving the field associations between triggering conditions, processing actions, processing reasons, and severity levels in the structured rules; generating a degraded runtime configuration carrying a configuration error flag when any configuration parsing fails; and projecting the data fields corresponding to the view type declared by each error correction agent from the read-only unified data view to form the corresponding dedicated read-only subview.

[0017] Furthermore, the construction of a directed acyclic workflow comprising parallel nodes and a summary node corresponding to the error correction agent, executing the parallel nodes to call the large language model to process the corresponding dedicated read-only subview, and isolating and writing the structured error correction result into the shared state, includes: establishing a context extraction node, multiple parallel nodes, and the summary node; connecting the context extraction node to multiple parallel nodes respectively, and connecting the multiple parallel nodes to the summary node respectively; allocating a unique agent namespace and a corresponding dedicated read-only subview to each parallel node; scheduling the parallel nodes that have met the pre-determined dependencies according to the preset maximum concurrency; calling the large language model and parsing the returned content in each parallel node according to the corresponding agent running configuration to obtain the structured error correction result; using the agent's namespace as the key, atomically writing the structured error correction result into the result field of the corresponding agent in the shared state, and releasing the summary node after multiple parallel nodes have reached the termination state, the termination state including completed, skipped, disabled, and failed.

[0018] Further, scheduling the parallel nodes that have met the prerequisite dependency conditions according to the preset maximum concurrency includes: establishing a node state for each parallel node as pending scheduling, running, completed, skipped, disabled, and failed; determining a candidate node set from the pre-generation node set, the post-generation node set, or the union of the pre-generation node set and the post-generation node set according to the stage selection parameters, wherein the pre-generation node set is a set of nodes containing parallel nodes used to process the data to be corrected, and the post-generation node set is a set of nodes containing parallel nodes used to process the generation result of the data to be corrected after upstream processing; filtering out disabled nodes and nodes with incomplete prerequisite dependencies from the candidate node set to form a ready node queue; selecting parallel nodes from the ready node queue that do not exceed the preset maximum concurrency and submitting them for execution; for parallel nodes that time out or fail to call, sequentially performing exponential backoff retry, switching to a backup large language model, and skipping state degradation; writing the node state and error flag of each parallel node into the corresponding agent result field, so that the anomaly of a single parallel node does not change the node state of other parallel nodes.

[0019] Further, after the parallel node terminates, the structured error correction results are subjected to format verification, status determination, and problem item merging to generate a data quality audit report and a downstream processing route identifier. This includes: verifying the pass flag and problem list in each structured error correction result; supplementing each problem item in the problem list with missing fields in problem location, problem description, severity level, evidence content, and processing suggestions; mapping unparseable return content to a skipped state carrying a parsing error flag; deduplicating problem items from different error correction agents according to the problem key formed by the problem location and problem description; counting the number of problems at different severity levels and distinguishing between completed, skipped, disabled, and failed node states; generating the data quality audit report based on the severity level statistics and node states, and outputting one of the downstream processing route identifiers: allow, block, or manually review.

[0020] Furthermore, the method also includes: receiving a custom error correction direction configuration submitted by a domain operator, the custom error correction direction configuration including an agent identifier, a prompt instruction, a view type, an enabled status, and a default severity level; verifying the uniqueness of the agent identifier and the availability of the view type; generating a custom error correction agent and a corresponding custom parallel node based on the custom error correction direction configuration; connecting the custom parallel node between the context extraction node and the aggregation node; persisting the custom error correction direction configuration as an external rule configuration that follows the agent operation configuration merging rule; enabling the custom parallel node in the next workflow version, and incorporating the structured error correction results of the custom error correction agent into the data quality audit report.

[0021] Furthermore, the method further includes: dividing the dedicated read-only subview into multiple data blocks based on the number of data items and the context capacity of the large language model; calling the large language model to process the multiple data blocks respectively, performing logical AND operations on the results of the multiple blocks using flags and merging the problem lists; performing joint encoding on the data item content, the agent's running configuration, and the rule version to generate an audit fingerprint; associating the audit fingerprint with the corresponding structured error correction result and storing it in the result cache; matching the current audit fingerprint with the historical audit fingerprint in the result cache in subsequent calls, reusing the structured error correction result corresponding to the matched data item; forming an incremental read-only subview from the unmatched data items, and performing large language model calls only on the incremental read-only subview.

[0022] A multi-agent parallel data error correction system based on a large language model includes: a data acquisition module for acquiring error-to-be-corrected inspection data and data source configuration, comprising a first result set and a second result set, wherein the first result set records filtered result items and the second result set records all result items; a unified view construction module for traversing the first result set and the second result set, configuring source paths and item identifiers for the obtained data items, associating data items from the two result sets according to the item identifiers, and normalizing them to form a read-only unified data view; and an agent construction module for constructing an agent based on the error correction task category and the data source configuration. Multiple error-correcting agents extract a dedicated read-only subview for each agent from the unified read-only data view and generate the agent's runtime configuration. A parallel error-correcting module is used to construct a directed acyclic workflow containing parallel nodes and summary nodes corresponding to the error-correcting agents, execute the parallel nodes to call the large language model to process the corresponding dedicated read-only subview, and isolate and write the structured error-correcting results into the shared state. A report generation module is used to perform format verification, status determination, and problem item merging on the structured error-correcting results after the parallel nodes terminate, and generate a data quality audit report and downstream processing route identifiers.

[0023] The beneficial effects of this invention are as follows: By constructing a read-only unified data view of the filtered result items and the full result items into a single data view that allows for the selection of deduplication strategies based on tasks, while retaining the source path and project identifier, full coverage, duplication suppression, and problem source location can be achieved in the same data entry point; Because the directed acyclic workflow isolates the write fields of parallel nodes through the agent namespace and controls the aggregation and release with explicit termination status and degradation path control, multiple error correction tasks can be executed in parallel, and the timeout, disabling, or parsing failure of a single node will not change the status of other nodes; The structured error correction results, after unified verification and problem item merging, directly form the downstream processing route identifier, reducing the secondary adaptation of different task outputs. Attached Figure Description

[0024] Figure 1 A flowchart illustrating the multi-agent parallel data error correction method based on a large language model provided in an embodiment of the present invention;

[0025] Figure 2 This is a schematic diagram of the overall execution flow of multi-agent parallel error correction and aggregation provided in an embodiment of the present invention;

[0026] Figure 3 This is a schematic diagram of the process for constructing a unified data view with dual result sets and read-only access, provided in an embodiment of the present invention.

[0027] Figure 4 This is a schematic diagram of the parallel scheduling and result isolation process of a directed acyclic workflow provided in an embodiment of the present invention;

[0028] Figure 5 This is a schematic diagram of the initialization and construction process of a directed acyclic workflow provided in an embodiment of the present invention;

[0029] Figure 6 This is a schematic diagram of the registration and execution return process of a custom error correction agent provided in an embodiment of the present invention;

[0030] Figure 7 This is a schematic diagram of the module structure of a multi-agent parallel data error correction system based on a large language model provided in an embodiment of the present invention.

[0031] Figure 8 This diagram illustrates the mapping relationship between the technical features, code files, and key functions provided in the embodiments of the present invention. Detailed Implementation

[0032] The present invention will be further described below with reference to the accompanying drawings and embodiments. The first result set may be a set of result items filtered from the original inspection data; the second result set may be a set of result items covering all inspection items; "read-only" indicates that the data extraction, view projection, and agent processing do not modify the input data object; "structured error correction result" indicates a result object with preset field constraints that can be parsed by a computer program. The following embodiments are used to illustrate the technical solution and do not constitute a limitation on the scope of protection.

[0033] Example 1

[0034] This embodiment can be applied to scenarios where the quality of raw examination data is reviewed before the generation of a physical examination report. Taking a physical examination institution as an example, it needs to process hundreds of examination data files from multiple sources such as testing equipment, ultrasound equipment, and consultation systems every day. The data generally suffers from quality problems such as missing fields, mismatched units, logical contradictions across items, and inconsistent text semantics. If directly sent to the downstream report generation pipeline, it will lead to item matching failures, data merging errors, and disordered sorting. The method provided in this embodiment connects to the main process of examination data processing through an independent bridging interface. The main process calls this method without modifying its own processing logic, obtains a data quality audit report, and then performs release, interception, or manual review.

[0035] like Figure 1 As shown, this embodiment provides a multi-agent parallel data error correction method based on a large language model, including the following steps:

[0036] S1. Obtain the error-checking data and data source configuration containing the first result set and the second result set. The first result set records the filtered result items, and the second result set records all result items.

[0037] Data acquisition can be accomplished through file interfaces, message interfaces, or application programming interfaces (APIs). The data source configuration must at least carry a data source identifier, field mapping version, and rule version. The acquisition phase can be implemented using conventional format validation and copy reading methods, which are not limited in this invention. In one implementation, the data to be corrected is accessed through a zero-intrusion bridging interface in this embodiment: the bridging interface only takes the data to be corrected as input and returns a data quality audit report, without importing the program module of the main data processing flow or modifying the input data; the data source identifier is stored in the thread-local context to avoid context pollution during multi-threaded concurrent calls; the bridging interface also provides pluggable progress callback parameters, allowing the caller to register a progress callback function to obtain the execution progress of parallel error correction without relying on the main flow's logging mechanism.

[0038] Specifically, the data to be corrected can be encapsulated as a read-only input snapshot of this correction task before proceeding to subsequent steps. This read-only input snapshot records at least the task identifier, reception time, root path of the first result set, root path of the second result set, and input data summary value. Multiple correction agents in the workflow reference the same read-only input snapshot and do not directly hold modifiable original input objects. If any result set is missing from the received data, the missing result set can be initialized as an empty set, and a missing set marker can be written into the input snapshot. If both result sets are empty, a summarizable empty task state is still generated, allowing subsequent summary nodes to distinguish between "empty input" and "workflow not executed."

[0039] Optionally, data source configuration and input snapshots are managed separately: the former describes field mappings, rule versions, and agent activation status, while the latter stores the actual data content read in this call. Therefore, even if the external rule configuration is updated during workflow execution, the current task will still be processed according to the configuration version determined at startup, and the next task will only read the updated configuration, avoiding the use of different versions of rules or field mappings in the same data quality audit report.

[0040] S2. Traverse the first result set and the second result set, configure the source path and project identifier for the obtained data items, associate the data items of the two result sets according to the project identifier, and normalize them to form a read-only unified data view;

[0041] The mechanism of this step includes: identifying the root fields of the two result sets; recursively drilling down in the same hierarchical order; recording path fragments at the departmental and subgroup levels; extracting project names, project codes, project indexes, and project content from leaf nodes; performing character normalization on project names; generating project identifiers based on valid project codes or hierarchical paths; establishing cross-result set associations based on project identifiers; selecting whether to retain a single data item or dual-source data items according to the error correction task; and encapsulating the processing results into immutable sequences or read-only mappings. A full-source marker is added to the second result set so that the two associated data items still retain different source paths, avoiding the loss of location information after deduplication.

[0042] In one implementation, the project identifier is generated according to equation (1):

[0043] Equation (1)

[0044] in, Indicates the data item number; Indicates the first Project identifier for each data item; This represents a deterministic coding function; Indicates the first Each data item has a valid item code; if the item code is invalid, a preset empty flag is used. Indicates the first The normalized item name for each data item; Indicates the first The combination of departmental path segments and subgroup path segments for each data item; Indicates the first The item index of each data item in its respective item list; symbol This indicates a field concatenation operation. If the project code has cross-datasource uniqueness, this should be used preferentially. , and If the project code is missing, add it. To reduce the probability of conflicts with projects with the same name.

[0045] Because the item identifier simultaneously incorporates both the semantic field and the hierarchical location field, a stable association can be established between the same item in both result sets. Furthermore, the source path is not replaced by the item identifier, allowing subsequent question items to still trace back to their original location, thus alleviating the difficulty of simultaneously achieving full coverage, duplication suppression, and source tracing. Character normalization can include whitespace folding, full-width / half-width character unification, and case unification; deterministic encoding functions can employ digest encoding or reversible combinatorial encoding. In one example, the item names of two data items are identical after normalization, both have the item code "ITEM-001," and their subgrouping path segments are the same, thus generating the same item identifier. The deduplication agent retains the data items in the second result set, while the semantic comparison agent retains two data items with different source paths.

[0046] In this embodiment of the invention, the read-only unified data view is not a simple concatenation of two result sets, but rather a task input structure that simultaneously stores data item entities, source descriptions, and association descriptions. The data item entity carries the project content, the source description carries the result set type and hierarchical path, and the association description connects the corresponding data items in the two result sets using project identifiers. With these three types of information separated, the same data item can be referenced by multiple dedicated read-only sub-views without copying the project content, and any question item can return to its original data location along the source description.

[0047] Specifically, when constructing the read-only unified data view, candidate records can be created first for the traversed data items, and then the candidate records can be grouped according to the item identifier. Each group forms an association unit, which stores references to candidate records from the first result set and the second result set, respectively. If a group contains candidate records from only one source, the association state is set to single source; if both sources exist and the item content is consistent, the association state is set to consistent association; if both sources exist but the item content is different, the association state is set to differing association. The association state only describes the data relationship and does not directly replace the processing result of the error correction agent on the item content.

[0048] It's important to note that deduplication doesn't apply the same deletion rule to all tasks during view construction. Instead, it selects the projection method for related units based on the consumption semantics declared by the error correction task. Field integrity tasks typically prioritize the second result set to ensure full item coverage; filtering consistency tasks read from both sources simultaneously to identify content differences between filtered results and the full result set; source tracing tasks retain related units and all source paths. Thus, deduplication transforms from irreversible data deletion into configurable view projection, reducing unnecessary large language model inputs without compromising the dual-source evidence that other tasks might require.

[0049] The mechanism works because: the project identifier answers "Do two records point to the same project?", the source path answers "Where does the record come from?", and the task-oriented projection answers "Which source does the current error-correcting agent need to observe?". These three questions are expressed by different fields, avoiding information loss that can occur when a single deduplication key simultaneously handles identity verification, source location, and retention strategies. For boundary cases such as missing project codes, projects with the same name, or changes in hierarchical position, the project identifier generates branches, conflict numbers, and association states, all preserving uncertainty. Subsequent agents can then treat these uncertain associations as evidence to be verified, rather than silently merging them.

[0050] In an extended example, the first result set records item A under a certain department path, and the second result set records item A, item B, and item C under the corresponding path. A unified traversal generates four source records, where two item A records form the same associated unit, and item B and item C each form a single-source associated unit. The numerical and unit matching agent uses a deduplication-specific read-only subview, receiving only items A, B, and C from the second result set; the consistency filtering agent receives the dual-source pairings of item A and the single-source states of items B and C. In this way, a single low-level traversal can support different error correction directions and avoid repeatedly sending the same item A content to each large language model.

[0051] S3. Construct multiple error correction agents based on the error correction task category and the data source configuration, extract a unique read-only subview for each error correction agent from the read-only unified data view and generate the agent's running configuration;

[0052] Error correction tasks can be categorized into fields of completeness, numerical and unit matching, cross-item consistency, historical change consistency, and text semantic consistency. The specific division of error correction agents is based on the error correction task categories. Taking data error correction as an example, multiple error correction agents can include agents for original data completeness, patient information validity, examination item field completeness, numerical and unit validity, physiological range rationality, gender and age applicability, consistency between examination items, differences from previous data, questionnaire and medical history completeness, and consistency between observations and conclusions. Each error correction agent corresponds to a parallel node in a directed acyclic workflow. Dedicated read-only subviews reduce irrelevant data transmission through field projection and item filtering. Agent runtime configuration can be formed by merging code default configuration, external rule configuration, and data source configuration. In other implementations, the external rule configuration can also be provided through a configuration center or database without changing the hierarchical merging and view projection relationships.

[0053] Specifically, each error-correcting agent can declare its agent identifier, error-correction task category, view type, allowed set of fields to be read, output field constraints, and model parameter names in its registration information. The agent construction module performs field projection from the read-only unified data view based on the registration information, forming a dedicated read-only subview containing only the data required for that error-correction task. For example, the subview for the numerical and unit matching task might include the project identifier, project name, project result, unit, and source path; the subview for the text semantic consistency task might include two related text segments, the project identifier, and the source path. Undeclared fields are not included in the corresponding subview, limiting the interference of irrelevant fields on model inference from the data entry point.

[0054] Furthermore, the agent's runtime configuration can be serialized into a configuration snapshot, which includes system prompts, concatenated text rules, structured rules preserving field associations, model identifiers, temperature parameters, timeout parameters, retry parameters, and configuration error flags. When the large language model is invoked, the configuration snapshot and the dedicated read-only subview together constitute the node input, while the returned content is constrained by a unified structured output. This input-output boundary allows different agents to use different sets of model parameters and rules, while maintaining a consistent field structure for the result objects in the shared state.

[0055] S4. Construct a directed acyclic workflow containing parallel nodes and aggregation nodes corresponding to the error correction agent, execute the parallel nodes to call the large language model to process the corresponding dedicated read-only subview, and isolate and write the structured error correction results into the shared state;

[0056] like Figure 2 As shown, this step represents context extraction, agent execution, and result aggregation as workflow nodes. The implementation includes: establishing a node registry; verifying that dependencies between nodes do not have loops; allocating a unique namespace for each agent node; using a dedicated read-only subview and agent runtime configuration as node inputs; adding nodes to the ready queue according to dependency satisfaction status; submitting nodes under a preset maximum concurrency constraint; calling the large language model; performing structured parsing; atomically writing the results to the corresponding fields in the namespace; and recording the node termination status. Multiple agents only read common inputs, and each agent only writes its own result fields; therefore, parallel execution does not require modification of the states of other agents.

[0057] The main waiting time for parallel execution can be expressed by equation (2):

[0058] Equation (2)

[0059] in, Indicates the completion time of a parallel error correction workflow; This represents the set of error-correcting agents activated this time; Indicates the first The processing time of an error-correcting agent from the start of execution to obtaining parsable return content; Indicates the first The additional time required for an error-correcting agent to retry, switch to a backup large language model, or undergo downgrade processing; This indicates the time required for the aggregation node to perform format validation, status determination, and issue merging. The preset maximum concurrency can be determined based on the number of processor threads, remote call rate limits, and memory usage. A value that is too small will increase queuing time, while a value that is too large may trigger interface rate limiting or resource contention.

[0060] In one application example, the numerical and unit validity agent identified a miswritten unit of measurement for a hematological test item as pressure (mmHg) from a dedicated read-only subview; the physiological range rationality agent identified a hematological indicator value of 45 g / L, which is far below common physiological levels; the consistency between test items agent identified a cross-item logical contradiction where the systolic blood pressure value of 90 is lower than the diastolic blood pressure value of 150 for the same subject; and the observation and conclusion consistency agent identified a semantic contradiction where the observation description of a test item shows no nodular abnormalities, while the conclusion field states no abnormalities were found. These four types of problems exceed the coverage of fixed rule enumeration. The corresponding error-correcting agent calls the large language model to process the dedicated read-only subview and outputs structured error-corrected results.

[0061] Because the directed acyclic workflow only releases nodes whose dependencies have been completed, the execution order is determined by explicit dependencies rather than accidental reads and writes of shared variables. Furthermore, the agent namespace restricts the writable boundaries of each parallel node, preventing result overwriting or abnormal states of a single node from contaminating other nodes. The summary node waits for the termination state, not just the success state, enabling the generation of an interpretable and complete report even when some nodes are skipped or fail. Therefore, this mechanism reduces the cumulative waiting time of independent tasks while decreasing the probability of single-node anomalies propagating to the entire process.

[0062] In this embodiment of the invention, the directed acyclic workflow is an execution structure that explicitly encodes data dependencies, concurrency qualifications, and aggregation conditions as nodes and directed edges. Context extraction nodes generate a read-only unified data view and configuration snapshot; parallel nodes consume their respective dedicated read-only sub-views; and aggregation nodes only consume the result fields of each agent and the node status. When there are no result dependency edges between parallel nodes, they can simultaneously enter the ready node queue; a directional dependency is established between two nodes only when a new error correction direction genuinely requires the structured error correction result of the previous node, thereby avoiding the artificial serialization of logically independent tasks.

[0063] The agent namespace is essentially a write permission boundary within the shared state. Each parallel node obtains a unique namespace key before startup and can only write structured error correction results, node status, error flags, and execution metadata to the agent result field corresponding to that namespace key. Read-only references are used when reading public data, and atomic substitutions or conditional writes with version comparisons are used when writing results. Even if two parallel nodes complete simultaneously, they will not perform competitive writes to the same result field; even if a single node returns an abnormal format, it will only mark the corresponding namespace as skipped or failed.

[0064] Specifically, the workflow orchestrator maintains a node registry, a dependency count table, a ready node queue, a set of running nodes, and a set of terminated nodes. After a node is extracted from the context, the orchestrator decrements the dependency count of each parallel node; nodes with a dependency count of zero are added to the ready node queue; execution is committed when concurrency quotas are available; and after a node completes, a unified callback writes its termination status and releases the quota. The release condition for a summary node is that all candidate parallel nodes have entered the terminated node set, not that all candidate nodes have successfully completed. Therefore, disabled, skipped, or failed nodes will not cause the workflow to wait indefinitely.

[0065] Preferably, each workflow execution is associated with a workflow version and a task identifier, and the agent namespace is formed by combining the workflow version, task identifier, and agent identifier. This combination prevents the results of the same agent from overwriting each other in different tasks or versions and supports backtracking of all state changes in a single execution. The workflow version is only used after topology verification, configuration resolution, and node registration integrity checks have all passed; running tasks continue to reference the version used at startup to maintain topology stability during execution.

[0066] The technical contribution of parallel orchestration compared to serial invocation lies not only in initiating multiple model requests simultaneously, but also in establishing deterministic summary semantics through explicit termination states and namespace isolation. If an agent times out, the orchestrator can perform retry, switch to a backup large language model, or skip degradation within the corresponding namespace, while other agents continue to proceed in their original states. The summary node reads a complete state vector composed of successful results and abnormal states, thus generating an interpretable report containing information such as "run successfully," "problem found," "skipped," "disabled," or "failed," avoiding mistaking a non-running state for a problem-free state.

[0067] In one example, this workflow utilizes six error-correcting agents, with a preset maximum concurrency of three. The first three nodes enter the running state; upon completion of any node, a concurrency quota is released and the next node is submitted from the ready node queue. One node times out on its first call, switches to a backup large language model after exponential backoff, and obtains a parsable result; another node uses a degraded running configuration due to corrupted external rule configuration. The remaining nodes are unaffected by these state changes. After all six nodes enter the terminated state, the aggregation node simultaneously reads five completed results and one result marked with a configuration error, generating the corresponding data quality audit report.

[0068] S5. After the parallel node terminates, perform format verification, status determination and problem item merging on the structured error correction result to generate a data quality audit report and downstream processing route identifier.

[0069] Format validation checks at least the pass / fail flag and the issue list. Status determination distinguishes between completed, skipped, disabled, and failed. Issue merging can be performed based on an issue key formed by the issue location and issue description. The data quality audit report may include the data source identifier, audit timestamp, overall status, category summary, detailed issue list, and severity statistics. Downstream processing routing identifiers can be selected as allow, block, or manual review. In other implementations, the mapping between different severity levels and routing identifiers can be adjusted according to the data source configuration without changing the structured aggregation mechanism.

[0070] Specifically, the structured error correction results can be stored in object form, where a flag indicates whether the corresponding agent has found a valid problem, and a problem list stores zero or more problem items. Each problem item includes at least the problem location, problem description, severity level, and evidence content; processing suggestions are optional fields. Format validation first checks the object type and required fields, then checks the consistency between the pass flag and the problem list; when the problem list is not empty but the pass flag is set to pass, the pass flag can be corrected to fail and a format alarm recorded, thereby ensuring that the summary results have definite semantics.

[0071] It should be noted that the downstream processing route identifier is determined by both structured fields and node status, rather than directly using the free text returned by any large language model. If a problem item with a preset interception level exists, an interception is output; if no interception level problem item exists but there are skipped, failed, misconfigured, or low-confidence results, a manual review is output; otherwise, the route is allowed. The mapping relationship can be adjusted by the data source configuration, but each mapping records the rule version and triggering basis, enabling the downstream system to trace the routing cause.

[0072] In the application example of physical examination data review, the summary node counts the number of problems at each severity level and determines the overall status. When there are error-level problems, the overall status is "fail" and an interception route is output. The downstream pipeline transfers the corresponding inspection data to manual review. With the help of the above routing, the workload of manual review is reduced from manually checking all data items one by one to only processing the problem items marked by the system.

[0073] Example 2

[0074] like Figure 3 As shown, this embodiment further defines the unified traversal of dual result sets and the construction of a read-only unified data view, including:

[0075] The process of traversing the first result set and the second result set, configuring source paths and project identifiers for the obtained data items, associating data items from the two result sets based on the project identifiers, and normalizing them to form a read-only unified data view includes:

[0076] S2.1. Recursively traverse the first result set according to the department level, subgroup level, and project level;

[0077] S2.2. Recursively traverse the second result set in the same hierarchical order as the first result set;

[0078] S2.3. Add a full source marker to the source path for data items from the second result set;

[0079] S2.4. Extract the department identifier, subgroup identifier, item index, and item content from each data item to form a unified data item quadruple;

[0080] S2.5. Extract the project name, project code, and hierarchical path from the project content, and generate the project identifier using at least two of the project name, project code, and hierarchical path;

[0081] S2.6. According to the deduplication strategy corresponding to the error correction task, retain a single data item in the associated data items or retain data items with different source paths at the same time to obtain the read-only unified data view.

[0082] The recursive traverser first performs node type identification on parent nodes, title nodes, and empty placeholder nodes, outputting only leaf nodes containing substantial item fields as unified data item quadruples. For data items with missing hierarchical fields but existing item content, a preset empty path marker is used to replace the missing hierarchy, without interrupting the traversal of other data items. Deduplication strategies are tied to error correction tasks: tasks focusing only on item values ​​can prioritize retaining data items from the second result set; tasks requiring comparison and filtering states retain data items from both sources; tasks requiring source consistency checks pair views with associated data items. This structure allows the agent to read the adapted view through a unified interface without needing to know the original root field name.

[0083] Specifically, node type identification can be based on a combination of fields rather than a single non-empty condition. Nodes with a subgroup list but no project result field are identified as group nodes; nodes with only title text and all project content fields are empty are identified as title nodes; nodes with at least one substantive field among project name, project result, unit, and text content are identified as candidate project nodes. This avoids sending group titles or placeholder lines as missing field data items to the error-correcting agent.

[0084] The two result sets are recursively traversed in the same hierarchical order, ensuring that the meanings of fragments at the same level in the source path remain consistent. When adding a full source marker to the source path for data items from the second result set, a preset marker field can be appended to the end of the source path to distinguish between filtered and full sources. After adding the marker, data items with identical content in both result sets still retain distinguishable source paths, providing a basis for filtering consistency checks and source tracing. Furthermore, the marker does not participate in the generation of item identifiers.

[0085] When constructing a unified data item quadruple, the department identifier and subgroup identifier can maintain standardized text or internal encoding, the item index is used to preserve the original list order, and the item content saves a read-only reference or field copy of the original data item. If multiple items with the same name exist at the same level, the item index and item encoding jointly participate in the generation of the item identifier; if the aliasing of the department level or subgroup level name of the data source changes, it can be converted into a standardized level identifier by the field mapping in the data source configuration before entering the item association process.

[0086] When extracting the project name, project code, and hierarchical path from the project content of the unified data item quadruple, the project name and project code are read from the corresponding field values ​​of the project content, and the hierarchical path is formed by combining the department identifier and the subgroup identifier in traversal order; then, the project identifier is generated using at least two of the project name, the project code, and the hierarchical path, so that the project identifier carries both project semantics and hierarchical position information.

[0087] When associating data items from two result sets based on the project identifier, the candidate records obtained from the traversal can be grouped according to the project identifier. Each group forms an association unit. The association unit stores references to candidate records from the first and second result sets, and sets the association status according to the source composition within the group: it is set to single-source when only a single source exists, set to consistent association when both sources exist and the project content is the same, and set to differential association when both sources exist but the project content is different. The association status describes the data relationship between the data items from the two sources, allowing the subsequent deduplication strategy to select the projection method of the association unit according to the consumption semantics of the error correction task, so that the retention of a single data item or the retention of data items from different source paths are based on the same underlying traversal result.

[0088] Optionally, the traverser exposes three modes to the caller: deduplication mode, dual-source mode, and full mode. Deduplication mode outputs a single candidate record corresponding to each item identifier; dual-source mode outputs associated units with both first and second source records; and full mode outputs all source records without performing associated item suppression. All three modes share the same underlying traversal results and source paths, reducing the overhead of repeatedly parsing tree data for different error correction tasks.

[0089] Example 3

[0090] This embodiment further defines the generation of the project identifier, including:

[0091] The project identifier is generated using at least two of the project name, the project code, and the hierarchical path, including:

[0092] S2.5.1. Perform character normalization processing on the project name to obtain a normalized project name;

[0093] S2.5.2. Perform null value detection on the item code to obtain the valid status of the item code;

[0094] S2.5.3. Divide the hierarchical path into departmental path segments and subgroup path segments;

[0095] S2.5.4. When the project code is valid, the project code, the normalized project name, and the subgroup path segment are combined.

[0096] S2.5.5. When the project code valid state indicates that the project code is invalid, combine the standardized project name, the department path segment, the subgroup path segment, and the project index;

[0097] S2.5.6. Perform deterministic encoding on the combination result to obtain the project identifier, and write the project identifier and the source path together into the corresponding unified data item quadruple.

[0098] Character normalization eliminates differences in character representation without altering the semantics of the item; item code null value detection can simultaneously identify empty strings, preset invalid placeholders, and non-compliant encodings. Deterministic encoding should ensure that the same combination of results yields the same item identifier. To avoid incorrect deduplication due to encoding collisions, a conflict sequence number can be appended when multiple inconsistent item contents corresponding to the same item identifier are detected, and the encoding conflict is recorded as a view construction alarm, without directly overwriting data items.

[0099] In this embodiment of the invention, character normalization processing can sequentially perform character encoding unification, invisible character removal, continuous whitespace folding, full-width / half-width character conversion, and preset delimiter unification. The above processing is only used to form project identifiers and does not modify the original project content stored in the unified data item quadruple, so that the evidence of the problem can still present the original input. In addition to null value detection, the validity status of project codes can also be checked based on the encoding format expression in the data source configuration; project codes that do not meet the format requirements are treated as invalid codes and retained in the original project content.

[0100] When splitting the hierarchical path into departmental path segments and subgroup path segments, the hierarchical path can be segmented according to a preset hierarchical separator. The first segment in the segmentation result is taken as the departmental path segment, and the first segment after it is taken as the subgroup path segment. The remaining segments are retained in the complete hierarchical path. When the departmental level or subgroup level is missing in the original data, the corresponding segment is filled with a preset empty path marker to keep the input structure of the two combined branches consistent.

[0101] The combination operation can perform string concatenation according to a preset field order and insert boundary separators between adjacent fields: when the project code is valid, it combines the project code, normalized project name, and subgroup path fragment in that order; when the project code is invalid, it combines the normalized project name, department path fragment, subgroup path fragment, and project index in that order. Boundary separators are characters that do not appear in the normalized project name and path fragment to avoid concatenating the same combination result from different field values.

[0102] Deterministic encoding can be implemented using hash algorithms: the combined result is serialized into a byte sequence using a unified character encoding, a secure hash digest is calculated, such as SHA-256 (Secure Hash Algorithm-256), and the hexadecimal representation of the digest or a digest truncated to a preset length is used as the item identifier. Hash algorithms always produce the same output for the same input, and the probability of producing the same output for different inputs is negligible, making the item identifier both deterministic and distinguishable.

[0103] Furthermore, the deterministic coding result can be stored together with the normalized field summaries involved in the coding. When two candidate records have the same item identifier but different normalized field summaries, the system does not perform a direct merge. Instead, it sets a coding conflict flag for the corresponding related units and retains the candidate records separately. This conservative approach transforms the risk of erroneous merging into a visible view of the warning, enabling downstream error-correcting agents or manual review processes to observe conflict evidence.

[0104] In one example, the first candidate record has a valid item code "ITEM-002", while the second candidate record lacks an item code but has the same item name and hierarchical path as the first candidate record. Because they generate branches using different item identifiers, they are not directly considered identical; the system can mark them as weakly related candidates in the associated unit. If the data source configuration explicitly specifies that the item name is unique under the corresponding hierarchy, then these weakly related candidates can be output in pairs when constructing the dedicated read-only subview, but different item identifiers and source paths will still be retained.

[0105] Example 4

[0106] This embodiment further defines the formation of the dedicated read-only subview and the agent's runtime configuration, including:

[0107] The process involves constructing multiple error correction agents based on the error correction task category and the data source configuration, extracting a unique read-only sub-view for each error correction agent from the read-only unified data view, and generating the agent's runtime configuration, including:

[0108] S3.1. Read the default code configuration, external rule configuration, and the data source configuration;

[0109] S3.2. Perform an overwrite merge on the enabled field and model parameter field according to the increasing priority of the code default configuration, external rule configuration, and data source configuration. The enabled field indicates whether each error correction agent is enabled, and the model parameter field is used to represent the calling parameters of the large language model.

[0110] S3.3. Perform sequential concatenation of the text rule fields in the default code configuration, the external rule configuration, and the data source configuration;

[0111] S3.4. Preserve the field relationships between triggering conditions, processing actions, processing reasons, and severity levels in structured rules;

[0112] S3.5. Generate a degraded run configuration carrying configuration error flags when any configuration resolution fails;

[0113] S3.6. Based on the view type declared by each error-correcting agent, project the data fields corresponding to the view type from the read-only unified data view to form the corresponding dedicated read-only sub-view.

[0114] The overwrite merging process applies to two types of single-value fields: the enable field and the model parameter field. The enable field determines whether each error-correcting agent enters the candidate node set of the workflow. The model parameter field includes large language model call parameters such as model identifier, temperature parameter, timeout parameter, and maximum number of retries. Higher-priority non-null values ​​override lower-priority values.

[0115] Override merging is suitable for single-value configurations, sequential concatenation is suitable for text rules that need to accumulate effects, and structured rules retain field associations on a complete record basis. External rule configurations can be in JSON, YAML, or configuration center records, and data source configurations can be retrieved through data source identifiers. When configuration parsing fails, degraded execution can disable affected additional rules and retain the default code configuration, while recording a configuration error flag in the agent result field. In other implementations, rule identifiers can be set for structured rules, and override or version selection can be performed according to the rule identifier.

[0116] Specifically, the configuration manager can first parse the three-layer configuration into configuration objects with the same field pattern, and then select the merging operator according to the field category. Enabled fields, model identifiers, temperature parameters, timeout parameters, and maximum retries are single-value fields, with higher-priority non-null values ​​overriding lower-priority values; text rule fields are concatenated in the order of code default configuration, external rule configuration, and data source configuration, with boundary markers added between adjacent text; structured rules store the correspondence between triggering conditions, processing actions, processing reasons, and severity levels in rule records as the smallest unit, avoiding semantic misalignment caused by simply concatenating field values.

[0117] In one application scenario, the external rule configuration records that the DOB (Delta OverBaseline) value of a certain carbon-13 breath test item without a unit of measurement is a normal record. After the data source configuration loads the above rule according to the data source identifier, the corresponding error correction agent will no longer output a unit missing alarm for the DOB value of the item. The external rule configuration changes take effect immediately at the next call boundary without modifying the agent program or restarting the service, thus realizing hot rule updates.

[0118] It's important to note that configuration hot updates employ a call boundary effectiveness mechanism. The configuration manager reads the external rule configuration, calculates the rule version, and saves the merged result as a snapshot of the current task's configuration. Subsequent changes in files or the configuration center do not modify the configuration snapshot of already started tasks. If external rule configuration parsing fails, the configuration error flag records at least the configuration source, error type, and rollback level, but does not carry any specific sensitive data. The corresponding error-correcting agent can continue to execute using the default code configuration, while the aggregation node determines whether to route the result to manual review based on the configuration error flag.

[0119] In a configuration merging example, the code defaults to enabling a certain error-correcting agent and specifying general text rules. The external rule configuration adds two structured rules, and the data source configuration only covers the temperature parameter and adds a local field description. After merging, the enabled state retains the default code configuration, the temperature parameter uses the data source configuration value, the general text rules and local field descriptions are concatenated in order, and the two structured rules maintain their respective field associations. This merging result preserves basic capabilities while allowing for differentiated data source configurations without requiring modifications to the agent program.

[0120] Example 5

[0121] like Figure 4 As shown, this embodiment further defines the parallel execution and result isolation of the directed acyclic workflow, including:

[0122] The construction of the directed acyclic workflow includes parallel nodes and aggregation nodes corresponding to the error correction agent. The parallel nodes call the large language model to process the corresponding dedicated read-only sub-view, and the structured error correction results are isolated and written to the shared state, including:

[0123] S4.1. Establish the context extraction node, multiple parallel nodes, and the aggregation node;

[0124] S4.2. Connect the context extraction node to the plurality of parallel nodes respectively, and connect the plurality of parallel nodes to the aggregation node respectively;

[0125] S4.3. Assign a unique agent namespace and the corresponding dedicated read-only subview to each parallel node;

[0126] S4.4. Schedule the parallel nodes that have met the prerequisite dependency conditions according to the preset maximum concurrency;

[0127] S4.5. In each parallel node, the large language model is invoked according to the corresponding agent's running configuration, and the returned content is parsed to obtain the structured error correction result;

[0128] S4.6. Using the namespace of the agent as the key, write the atoms of the structured error correction result into the result field of the corresponding agent in the shared state, and release the aggregation node after multiple parallel nodes have reached the termination state, wherein the termination state includes completed, skipped, disabled and failed.

[0129] like Figure 5 As shown, the initialization and construction process of the directed acyclic workflow is as follows: After receiving the call, the bridging interface first verifies the validity of the stage selection parameter value. The stage selection parameter can be one of three values: before generation, after generation, or the entire process. If the value is invalid, execution is rejected and a parameter error message is returned. Then, the data source identifier is written into the thread-local context, and the shared state is initialized. The shared state records the data to be corrected, the initial value of the agent result field of each correction agent, and the initial value of the agent result field of the custom correction agent. Then, the directed acyclic workflow is constructed according to the stage selection parameter, and the node registration and directed edge dependency configuration are completed. After the workflow is constructed, parallel execution is started. The context extraction node runs first, and multiple parallel nodes proceed concurrently after the prerequisite dependencies are satisfied.

[0130] In one implementation, the workflow orchestrator first performs topology checks on nodes and edges; if a self-loop or back edge is found, the corresponding workflow version is rejected and the previous valid version is used. After the context extraction of nodes is complete, different projection references of the read-only unified data view are sent to the parallel nodes to avoid copying irrelevant fields. The agent namespace can be a combination of agent identifier and workflow version, and atomic writes can be implemented through thread-safe mapping, transaction records, or key-value writes with version comparison. Termination states include completed, skipped, disabled, and failed, ensuring that the aggregation node is not permanently blocked while waiting for a degraded node.

[0131] Specifically, topology verification can perform in-degree statistics and topology sorting on workflow nodes. If a topology sequence containing all nodes can be output, the workflow satisfies the acyclic condition; if there are still nodes that have not been output, the corresponding version will not enter the enabled state. For the basic structure of this embodiment, the outgoing edges of the context extraction node connect to multiple parallel nodes, and the outgoing edges of each parallel node connect to the aggregation node. A fan-out-convergence topology can be formed without setting edges between parallel nodes. The above verification is also performed when an extension node is added.

[0132] The agent's result field can be an immutable result object with a version number. Parallel nodes read the target field version before writing, and commit the result only if the target field is still the initial version; late results after duplicate callbacks or timeouts are not overwritten due to version mismatches. For implementations using transactional storage, structured error correction results, node states, error flags, and end times can be committed as a single transaction record, thus avoiding the aggregation node reading an intermediate state where the result has been written but the node state has not yet been updated.

[0133] Example 6

[0134] This embodiment further defines the scheduling and fault isolation of parallel nodes, including:

[0135] The method of scheduling parallel nodes that have met the pre-defined dependency conditions according to the preset maximum concurrency includes:

[0136] S4.4.1. Establish node states for each parallel node: pending scheduling, running, completed, skipped, disabled, and failed.

[0137] S4.4.2. Based on the stage selection parameters, determine a candidate node set from the pre-generation node set, the post-generation node set, or the union of the pre-generation node set and the post-generation node set, wherein the pre-generation node set is a node set containing parallel nodes for processing the data to be corrected and checked, and the post-generation node set is a node set containing parallel nodes for processing the generation result of the data to be corrected and checked after upstream processing.

[0138] S4.4.3. Remove disabled nodes and nodes with incomplete prerequisite dependencies from the candidate node set to form a ready node queue;

[0139] S4.4.4. Select parallel nodes from the ready node queue that do not exceed the preset maximum concurrency and submit them for execution;

[0140] S4.4.5. For parallel nodes that time out or fail to execute, perform exponential backoff retry, switch to the backup large language model, and skip state degradation in sequence;

[0141] S4.4.6. Write the node state and error flag of each parallel node into the corresponding agent result field so that the anomaly of a single parallel node does not change the node state of other parallel nodes.

[0142] Node state transitions are unidirectionally controlled by the workflow orchestrator: nodes awaiting scheduling only transition to running when dependencies are satisfied and concurrency quotas are available; running nodes transition to completed, skipped, or failed based on execution results; disabled nodes do not enter the ready node queue.

[0143] The stage selection parameters are fixed when the candidate node set is formed: when taking the pre-generation stage, the candidate node set only includes the pre-generation parallel nodes that process the data to be corrected and checked; when taking the post-generation stage, the candidate node set only includes the post-generation parallel nodes that process the upstream generation results; when taking the entire process, the two types of node sets are combined and scheduled uniformly according to the explicit dependency relationship.

[0144] In this embodiment of the invention, the disabled node directly enters the disabled termination state and writes the reason for disabling and the configuration version to the agent result field, without occupying the concurrency quota.

[0145] Optionally, the ready node queue can be sorted according to the priority of error correction tasks, estimated processing time, or number of data blocks. However, the sorting only changes the order of submission and does not change the node dependencies or result aggregation semantics. When the remote call service returns rate limiting information, the workflow orchestrator can temporarily reduce the available concurrency quota; it will then gradually restore it after a preset number of nodes have completed normally. This implementation still uses the preset maximum concurrency as the upper limit and will not exceed resource constraints due to dynamic recovery.

[0146] The initial wait time for exponential backoff can be set to 0.5 to 2 seconds, and the number of retries can be set to 1 to 4. Too short a wait time may trigger the same service exceptions consecutively, while too long a wait time will amplify the latency of the critical path. The output field constraints of the backup large language model are the same as those of the main large language model, so switching models does not change the aggregation interface. Error flags and structured error correction results are stored in the same domain, enabling the aggregator to distinguish between "no problem found" and "no valid results obtained".

[0147] For delayed returns after execution timeout, the workflow orchestrator identifies the node based on its execution generation. Each retry assigns a new execution generation, and only the currently valid generation can be written to the agent's result field; even if earlier generations return subsequently, they are only recorded as delayed events without altering the already confirmed structured error correction results. This mechanism, combined with namespace isolation, further avoids duplicate writes and state rollbacks during the retry process.

[0148] Error flags and structured error correction results are stored in the same domain, enabling the aggregator to distinguish between "no problem found" and "no valid results obtained".

[0149] Example 7

[0150] This embodiment further defines the format validation, status determination, and problem item merging of the agent's result fields, including:

[0151] After the parallel node terminates, the structured error correction results undergo format verification, status determination, and problem item merging to generate a data quality audit report and downstream processing route identifiers, including:

[0152] S5.1. Verify the pass flag and problem list in each of the structured error correction results;

[0153] S5.2. For each issue item in the issue list, fill in the missing fields in issue location, issue description, severity level, evidence content, and handling recommendations;

[0154] S5.3. Map unparseable returned content to a skipped state carrying a parsing error flag;

[0155] S5.4. Deduplicate problem items from different error-correcting agents based on problem keys formed by problem location and problem description;

[0156] S5.5. Count the number of issues at different severity levels and distinguish the status of nodes that are completed, skipped, disabled, and failed;

[0157] S5.6. Generate the data quality audit report based on the severity level statistics and node status, and output one of the downstream processing route identifiers: allow, block, or manually review.

[0158] The content returned by the large language model can be stripped of its outer formatting tags before being read by the structured parser. If there is a contradiction between the flag and the issue list, the severity level of the valid issue item in the issue list is used as the basis for status correction and a formatting alarm is recorded. If the issue location is missing, the batch identifier of the dedicated read-only subview can be used for rollback positioning. The issue key can perform joint encoding on the normalized issue location and the normalized issue description. The manually reviewed route is used to accept results with low confidence, skipped, or with configuration error flags, without changing the original record of the node status in the data quality audit report.

[0159] In this embodiment of the invention, unified structured output means that all error-correcting agents return results according to the same field pattern, while each agent only expresses task differences in the problem description, evidence content, and processing suggestions. The field pattern is constrained by both the format instructions attached before the large language model is called and the structured parser after the call: the format instructions limit the allowed top-level fields and problem item fields, while the structured parser verifies the field types, enumerated values, and required fields. This dual constraint avoids downstream interface failure due to fluctuations in returned content when relying solely on prompt instructions.

[0160] Specifically, the parser first removes leading and trailing whitespace and surrounding markers from the returned content, then locates the boundary of the first structured object and performs object parsing. The pass flag should be a boolean value, the issue list should be an array, and the severity level should belong to a predefined enumeration set. Results that do not conform to the field type are not directly included in the overall status calculation but are mapped to a skipped state carrying a parsing error flag. For missing non-critical fields in the issue items, they can be filled in according to preset default values; for missing critical fields such as the pass flag or issue list, a downgraded state is used to avoid misjudging incomplete returns as pass.

[0161] Severity levels are divided into three categories: Error, Warning, and Alert. Error levels indicate data defects that could lead to incorrect report conclusions or prevent data from being used in subsequent merging, such as mismatched units of measurement, values ​​exceeding physiological ranges, or logical inconsistencies across projects. Warning levels indicate data discrepancies that do not affect report generation but require manual verification, such as missing fields with reversible related fields or inconsistent text semantics. Alert levels offer suggestions on standardization that do not affect data usage, such as non-standard formatting or redundant wording. The severity level classification criteria are set by the code's default configuration or external rule configuration and can be adjusted according to the data source identifier. The summary node determines the blocking, manual review, or allow route based on the severity level statistics. Error-level issues trigger blocking, Warning-level issues trigger manual review, and output is allowed only when Alert-level issues are present.

[0162] When merging issue items, path normalization is first performed on the issue location, and whitespace folding and pre-defined synonym label normalization are performed on the issue description. These two processes then form the issue key. Issue items with the same issue key are merged into a single summary issue item, retaining the source agent set, all evidence citations, and the highest severity level. If the issue locations are the same but the issue descriptions point to different data quality defects, different issue keys are created and retained separately to prevent excessive deduplication from masking independent issues.

[0163] The technical principle behind the downstream processing of routing identifiers lies in transforming the open semantic judgments of the large language model into deterministic control inputs driven by field validation, severity level, and node state. The large language model is responsible for forming the problem description and evidence from dedicated read-only sub-views, the structured parser is responsible for ensuring the data format, and the aggregator is responsible for executing deterministic routing mappings. With the separation of these three responsibilities, a single agent cannot directly control the entire data processing pipeline, reducing the risk of incorrect routing caused by free text or abnormal returns.

[0164] In one example, the first error-correcting agent returns one error-level issue, the second returns two warning-level issues, one of which is in the same location as the first agent's issue but has a different description, and the third agent is marked as skipped because its returned content lacks an issue list. The aggregator retains three distinct issue keys, counts one error-level issue and two warning-level issues, and records one skipped node. If an error-level issue exists, an intercept route is output; if no error-level issue exists but a skipped node still exists, a manually reviewed route is output. This process does not require parsing any free-text control instructions.

[0165] Through the structured output and aggregation mechanism described above, different error correction agents can share the same report generation interface, and there is no need to modify the basic field reading logic of the aggregator when adding a new error correction direction. Parsing failures are explicitly represented as node states instead of throwing unhandled exceptions. Problem deduplication reduces duplicate alarms generated by multiple agents for the same data location, ultimately forming a traceable, machine-readable data quality audit report with deterministic routing semantics.

[0166] Example 8

[0167] like Figure 6 As shown, this embodiment provides a dynamic registration method for custom error-correcting agents, and the method further includes:

[0168] Step A. Receive a custom error correction direction configuration submitted by the domain operator. The custom error correction direction configuration includes agent identifier, prompt instruction, view type, enabled status, and default severity level.

[0169] Step B. Verify the uniqueness of the agent identifier and the availability of the view type;

[0170] Step C. Generate a custom error correction agent and corresponding custom parallel nodes based on the custom error correction direction configuration;

[0171] Step D. Connect the custom parallel node between the context extraction node and the summary node;

[0172] Step E. Persist the custom error correction direction configuration as an external rule configuration that follows the agent's operation configuration merging rules;

[0173] Step F. Enable the custom parallel node in the next workflow version and incorporate the structured error correction results of the custom error correction agent into the data quality audit report.

[0174] Domain operators can submit custom error correction direction configurations through the user interface or application programming interface. For example, reviewers can submit custom error correction direction configurations for drug interaction review based on their medication safety experience, with prompts describing the content of joint review for multiple medication records that occur simultaneously.

[0175] Specifically, the registration request first enters a pending verification state. The system checks whether the agent identifier is duplicated with a preset agent or other custom error-correcting agents, and checks whether the view type can be mapped to the registered dedicated read-only subview generation function. After successful verification, a custom parallel node definition is generated, but it is not immediately written to the running node registry. The workflow orchestrator copies the topology of the previous valid version, inserts the custom parallel node into the copy, and completes acyclic verification. After successful verification, the next workflow version is released.

[0176] When generating a custom error-correcting agent, prompts are bound to view types, forming the basis for the custom error-correcting agent to read the projection of its own read-only subview. A default severity level is written into the agent's runtime configuration as a fallback level when the severity of an issue is not explicitly specified. After creating a custom parallel node based on the agent's runtime configuration, upstream dependencies and downstream outputs are configured for the custom parallel node. The upstream dependency points to the context extraction node, and the downstream output points to the aggregation node, ensuring that the custom parallel node and the preset parallel nodes are both included in the preset maximum concurrency scheduling and namespace isolation.

[0177] Dynamic registration employs versioned publishing. Running workflows continue to reference the original node registry, while newly received tasks reference the next workflow version that has passed topology verification, thus preventing modifications to the graph structure during runtime. View types must correspond to the field projection functions registered by the data extractor; hints allow for length limits and sensitive content filtering before persistence. Custom parallel nodes use the same namespace isolation, output field constraints, and fault degradation mechanisms as preset parallel nodes.

[0178] When persisting custom error correction direction configurations, the configuration version, creation time, last modification time, and enabled status can be recorded. Configuration updates create new versions instead of overwriting the currently used configuration snapshot, while deactivation operations put the corresponding node in the next workflow version into a disabled state. This versioning method allows custom directions to take effect immediately on subsequent tasks, while retaining the space to roll back to the previous valid configuration.

[0179] The persistent external rule configurations participate in the overriding merging and sequential splicing according to the same configuration merging rules as the preset error correction agent when the configuration is loaded in subsequent tasks. This allows the enabling status of custom directions, prompt instructions, and default severity levels to be overridden or adjusted as needed by higher-priority configurations.

[0180] In the next workflow version, custom parallel nodes and preset parallel nodes are subject to the same directed acyclic workflow orchestration. When a custom agent exists, the context extraction node projects the corresponding subview according to the view type declared by the custom error correction agent. The custom error correction agent calls the large language model according to the agent's runtime configuration, and the structured error correction result is atomically written to the shared state using the custom agent's namespace. When no custom agent exists, the workflow skips the custom branch and directly enters the aggregation stage. Since the custom error correction agent uses the same unified structured output fields as the preset error correction agent, the aggregation stage processes custom-sourced issues according to the aforementioned issue key deduplication, severity level statistics, and routing determination mechanisms. When an issue does not explicitly give a severity level, the default severity level written to the agent's runtime configuration is used for statistics. Therefore, there is no need to set separate aggregation logic, return interface, or report format for the custom error correction direction. When the workflow execution returns, it outputs a data quality audit report consistent with the aforementioned mechanism. Domain operators perform subsequent processing according to the downstream processing route identifier attached to the report. The custom error correction direction remains transparent to the return interface and operation process.

[0181] It should be noted that custom error-correcting agents can only select the view types and unified structured output fields provided by the system. They cannot bypass the read-only unified data view to directly modify the input data, nor can they change the routing rules of the aggregation nodes. Therefore, custom extensions are limited to the error-correction direction, prompt instructions, and rule content, while maintaining the parallel execution, state isolation, and structured aggregation framework unchanged.

[0182] Example 9

[0183] This embodiment provides block processing, audit fingerprint caching, and incremental execution methods. The method also includes:

[0184] Step G. Based on the number of data items and the context capacity of the large language model, divide the dedicated read-only subview into multiple data blocks;

[0185] Step H. Invoke the large language model to process multiple data blocks respectively, perform a logical AND operation on the results of the multiple blocks using flags, and merge the question list;

[0186] Step I. Perform joint encoding on the data item content, the agent's operating configuration, and the rule version to generate an audit fingerprint;

[0187] Step J. Associate the audit fingerprint with the corresponding structured error correction result and store it in the result cache;

[0188] Step K. In subsequent calls, match the current audit fingerprint with the historical audit fingerprints in the result cache, and reuse the structured error correction results corresponding to the matched data items;

[0189] Step L. Create an incremental read-only subview for the unmatched data items, and perform the large language model call only for the incremental read-only subview.

[0190] Data chunking can be performed according to project boundaries or semantic association group boundaries, avoiding splitting data items with cross-project dependencies into different chunks. In addition to the audit fingerprint, the result cache key can also include the agent identifier and the large language model version to prevent erroneous reuse under different operating conditions. Any change in rule version, field mapping version, or project content will alter the audit fingerprint. For cross-chunk issue items, a merge review call containing only candidate related items can be added after chunk processing; in other implementations, a sliding overlapping window can be used to preserve the context between adjacent chunks.

[0191] Specifically, the capacity of a data block can be determined based on the number of characters after serialization of the dedicated read-only subview or the estimated number of tags, and context space should be reserved for system prompts, structured rules, and output. Data items with the same item identifier, the same related unit, or the same semantic related group should be placed in the same block first; if a single related group exceeds the block capacity, a sub-block with overlapping boundaries should be used and the common related group identifier should be recorded so as to identify duplicate items across blocks during aggregation.

[0192] The input to the audit fingerprint should include all stable factors affecting the error correction result, including the normalized data item content, agent runtime configuration, rule version, field mapping version, agent identifier, and large language model version. Instantaneous fields such as execution time and thread number, which do not affect the semantics of the result, are not included in the joint encoding. In addition to the structured error correction result, the result cache also stores the fingerprint composition version and cache generation time; when the fingerprint algorithm version changes, the old cache is not used for matching.

[0193] During incremental execution, the system compares the current audit fingerprint with historical audit fingerprints at the data item level. Matched data items reuse the corresponding structured error correction results, while unmatched data items and data items related to unmatched data items together form an incremental read-only subview. This avoids repeatedly calling the large language model for completely unchanged data, and also avoids missing the associated context required for cross-project consistency tasks by only reviewing a single changed item.

[0194] In one example, a dedicated read-only subview contains eighty data items, with a chunk capacity of twenty data items. Seventy-five of these data items have content, rule versions, and model versions consistent with historical tasks. The system reuses the cached results of these seventy-five matching data items, combining five changed data items and their three associated data items into an incremental read-only subview. The large language model processes only this incremental read-only subview, then merges the new results with the reused results according to the question key, thereby reducing redundant calls while maintaining the integrity of the associated review.

[0195] Example 10

[0196] like Figure 7 As shown, this embodiment provides a multi-agent parallel data error correction system based on a large language model, including:

[0197] The data acquisition module is used to acquire the error-checking data and data source configuration containing the first result set and the second result set. The first result set records the filtered result items, and the second result set records all result items.

[0198] The unified view construction module is used to traverse the first result set and the second result set, configure the source path and project identifier for the obtained data items, associate the data items of the two result sets according to the project identifier, and normalize them to form a read-only unified data view;

[0199] The agent construction module is used to construct multiple error correction agents based on the error correction task category and the data source configuration, extract a unique read-only subview for each error correction agent from the read-only unified data view and generate the agent running configuration.

[0200] The parallel error correction module is used to construct a directed acyclic workflow that includes parallel nodes and summary nodes corresponding to the error correction agent, executes the parallel nodes to call the large language model to process the corresponding dedicated read-only subview, and isolates and writes the structured error correction results into the shared state.

[0201] The report generation module is used to perform format verification, status determination, and problem item merging on the structured error correction results after the parallel node terminates, and generate a data quality audit report and downstream processing route identifier.

[0202] The system can be deployed on a single-machine server, container cluster, or distributed computing environment. Each module can be implemented by a processor executing computer programs in memory, or by a combination of software and dedicated computing components. Data is exchanged between modules through read-only object references, message queues, or remote procedure calls; the specific deployment method is not limited as long as a unified data view, namespace isolation, and termination state aggregation relationship are maintained.

[0203] In this embodiment of the invention, the data acquisition module sends a read-only input snapshot to the unified view construction module; the unified view construction module outputs a read-only unified data view and associated states; the agent construction module reads the read-only unified data view and data source configuration, and outputs the error-correcting agent definition, a dedicated read-only sub-view, and the agent's running configuration; the parallel error correction module establishes a directed acyclic workflow based on this and writes isolated structured error correction results; the report generation module only reads the structured error correction results and node states, and does not modify the outputs of the aforementioned modules in reverse. This unidirectional data flow ensures that each module has clearly defined input, output, and exception boundaries.

[0204] Specifically, in a single-machine deployment, shared state can be implemented using thread-safe memory objects, and atomic writes can be guaranteed by locks or compare-and-swap operations. In a container cluster deployment, shared state can be implemented using a key-value store or transactional database that supports conditional updates, and parallel nodes can be distributed through task queues. In a distributed deployment, workflow version, task identifier, and agent namespace together constitute the result key. Different deployment methods share the same field schema and node state definitions, thus not changing the data dependencies between method steps.

[0205] like Figure 8 As shown, this embodiment further illustrates the mapping relationship between technical features and code files and key functions: the zero-intrusion bridging feature corresponds to the synchronous audit entry function in the bridging file; the dual result set traversal feature corresponds to the original item iteration function in the data extraction file; the three-layer configuration merging feature corresponds to the node configuration read / write function in the configuration file; the external rule hot update feature corresponds to the rule loading and merging function in the rule loading file; the large language model call, fault tolerance, caching, and batching feature corresponds to the structured call and retry function in the inference engine file; the pre-generation parallel error correction agent corresponds to the node processing function in each error correction node file; the directed acyclic workflow parallel orchestration feature corresponds to the workflow construction function in the workflow file; the audit report summary feature corresponds to the report assembly function in the report assembly file; the custom error correction direction feature corresponds to the registration and execution function in the custom agent file; and the shared state definition, progress callback, and network service features correspond to the state class, callback setting function, and service application instance in the state definition file, progress release file, and network service file, respectively. The above mapping is used to illustrate the carrying position of each technical feature in a reference implementation. When those skilled in the art implement the same function using other programming languages ​​or frameworks, file division and function naming are not limited.

[0206] In summary, Examples 1 to 10, using the data quality review scenario as an example, have fully illustrated the technical solution. The technical features of each example can be combined and implemented without conflict. This invention, through the collaboration of a read-only unified data view, parallel orchestration of directed acyclic workflows, and agent namespace isolation and structured aggregation, constitutes a multi-agent parallel data error correction method and system based on a large language model. This achieves parallel acceleration, fault degradation, and downstream machine-readable processing while ensuring full coverage and source tracing. All equivalent substitutions and simple improvements made based on the technical solution described in the claims of this invention fall within the protection scope of this invention.

Claims

1. A multi-agent parallel data error correction method based on a large language model, characterized in that, include: Obtain the error-checking data and data source configuration containing the first result set and the second result set. The first result set records the filtered result items, and the second result set records all result items. Traverse the first result set and the second result set, configure the source path and project identifier for the obtained data items, associate the data items of the two result sets according to the project identifier, and normalize them to form a read-only unified data view; Multiple error correction agents are constructed based on the error correction task category and the data source configuration. A unique read-only subview is extracted for each error correction agent from the read-only unified data view, and an agent running configuration is generated. Construct a directed acyclic workflow that includes parallel nodes and aggregation nodes corresponding to the error correction agent, execute the parallel nodes to call the large language model to process the corresponding dedicated read-only subview, and isolate and write the structured error correction results into the shared state; After the parallel node terminates, the structured error correction results are subjected to format verification, status determination, and problem item merging to generate a data quality audit report and downstream processing route identifiers.

2. The multi-agent parallel data error correction method based on a large language model according to claim 1, characterized in that, The process of traversing the first result set and the second result set, configuring source paths and project identifiers for the obtained data items, associating data items from the two result sets based on the project identifiers, and normalizing them to form a read-only unified data view includes: The first result set is recursively traversed according to the department level, subgroup level, and project level; The second result set is recursively traversed in the same hierarchical order as the first result set; Add a full source tag to the source path for data items from the second result set; Extract the department identifier, subgroup identifier, item index, and item content from each data item to form a unified data item quadruple; Extract the project name, project code, and hierarchical path from the project content, and generate the project identifier using at least two of the project name, project code, and hierarchical path; According to the deduplication strategy corresponding to the error correction task, a single data item in the associated data items is retained, or data items with different source paths are retained at the same time, to obtain the read-only unified data view.

3. The multi-agent parallel data error correction method based on a large language model according to claim 2, characterized in that, Generating the project identifier using at least two of the project name, the project code, and the hierarchical path includes: Perform character normalization processing on the project name to obtain a normalized project name; Perform null value detection on the project code to obtain the project code's valid status; The hierarchical path is divided into departmental path segments and subgroup path segments; When the project code is valid, the project code, the normalized project name, and the subgroup path fragment are combined. When the project code is valid, indicating that the project code is invalid, combine the standardized project name, the department path segment, the subgroup path segment, and the project index. Perform deterministic encoding on the combination result to obtain the project identifier, and write the project identifier and the source path together into the corresponding unified data item quadruple.

4. The multi-agent parallel data error correction method based on a large language model according to claim 1, characterized in that, The process involves constructing multiple error correction agents based on the error correction task category and the data source configuration, extracting a unique read-only sub-view for each error correction agent from the read-only unified data view, and generating the agent's runtime configuration, including: Read the default configuration of the code, the configuration of external rules, and the configuration of the data source; Following the principle of increasing priority from default code configuration, external rule configuration, to data source configuration, the enabled field and model parameter field are overridden and merged. The enabled field indicates whether each error correction agent is enabled, and the model parameter field is used to represent the calling parameters of the large language model. The text rule fields in the default code configuration, the external rule configuration, and the data source configuration are concatenated sequentially. Preserve the field relationships between trigger conditions, processing actions, processing reasons, and severity levels in structured rules; Generate a degraded run configuration carrying configuration error flags when any configuration resolution fails; Based on the view type declared by each error-correcting agent, the data fields corresponding to the view type are projected from the read-only unified data view to form the corresponding dedicated read-only sub-view.

5. The multi-agent parallel data error correction method based on a large language model according to claim 1, characterized in that, The construction of the directed acyclic workflow includes parallel nodes and aggregation nodes corresponding to the error correction agent. The parallel nodes call the large language model to process the corresponding dedicated read-only sub-view, and the structured error correction results are isolated and written to the shared state, including: Establish a context extraction node, multiple parallel nodes, and a summary node; The context extraction node is connected to multiple parallel nodes, and the multiple parallel nodes are connected to the aggregation node. Each parallel node is assigned a unique agent namespace and a corresponding dedicated read-only subview; The parallel nodes that have met the pre-defined dependency conditions are scheduled according to the preset maximum concurrency. In each parallel node, the large language model is invoked according to the corresponding agent's running configuration, and the returned content is parsed to obtain the structured error correction result; Using the namespace of the agent as the key, the atoms of the structured error correction result are written into the result field of the corresponding agent in the shared state, and the aggregation node is released after multiple parallel nodes have reached the termination state, the termination state including completed, skipped, disabled and failed.

6. The multi-agent parallel data error correction method based on a large language model according to claim 5, characterized in that, The method of scheduling parallel nodes that have met the pre-defined dependency conditions according to the preset maximum concurrency includes: Establish node states for each parallel node: pending scheduling, running, completed, skipped, disabled, and failed. Based on the stage selection parameters, a candidate node set is determined from the pre-generation node set, the post-generation node set, or the union of the pre-generation node set and the post-generation node set. The pre-generation node set is a set of nodes containing parallel nodes for processing the data to be corrected and checked, and the post-generation node set is a set of nodes containing parallel nodes for processing the generation result of the data to be corrected and checked after upstream processing. Disabled nodes and nodes with incomplete prerequisite dependencies are filtered out from the candidate node set to form a ready node queue; Select parallel nodes from the ready node queue that do not exceed the preset maximum concurrency and submit them for execution; For parallel nodes that time out or fail to execute, perform exponential backoff retry, switch to the backup large language model, and skip state degradation in sequence. Write the node state and error flag of each parallel node into the corresponding agent result field so that the anomaly of a single parallel node does not change the node state of other parallel nodes.

7. The multi-agent parallel data error correction method based on a large language model according to claim 1, characterized in that, After the parallel node terminates, the structured error correction results undergo format verification, status determination, and problem item merging to generate a data quality audit report and downstream processing route identifiers, including: Verify the pass flag and problem list in each of the structured error correction results; For each issue item in the issue list, fill in the missing fields for issue location, issue description, severity level, evidence content, and handling recommendations; Map unparseable returned content to a skipped state with a parsing error flag; Deduplication of question items from different error-correcting agents is performed based on question keys formed by question location and question description. Count the number of issues at different severity levels and distinguish the status of nodes as completed, skipped, disabled, and failed; The data quality audit report is generated based on the severity level statistics and node status, and one of the downstream processing route identifiers (allow, block, or manually review) is output.

8. The multi-agent parallel data error correction method based on a large language model according to claim 1, characterized in that, The method further includes: The system receives custom error correction direction configurations submitted by domain operators. These configurations include agent identifier, prompt instructions, view type, enable status, and default severity level. Verify the uniqueness of the agent identifier and the availability of the view type; A custom error correction agent and corresponding custom parallel nodes are generated based on the custom error correction direction configuration. Connect the custom parallel node between the context extraction node and the summary node; The custom error correction direction configuration is persisted as an external rule configuration that follows the agent's operation configuration merging rules; Enable the custom parallel node in the next workflow version and incorporate the structured error correction results of the custom error correction agent into the data quality audit report.

9. The multi-agent parallel data error correction method based on a large language model according to claim 1, characterized in that, The method further includes: Based on the number of data items and the context capacity of the large language model, the dedicated read-only subview is divided into multiple data blocks; The large language model is called to process multiple data blocks respectively, and the logical AND operation is performed on the results of the multiple blocks by using the flags and the question list is merged. Perform joint encoding on the data item content, the intelligent agent's operating configuration, and the rule version to generate an audit fingerprint; The audit fingerprint is associated with the corresponding structured error correction result and stored in the result cache; In subsequent calls, the current audit fingerprint is matched with the historical audit fingerprints in the result cache, and the structured error correction results corresponding to the matched data items are reused; Unmatched data items are made into incremental read-only subviews, and large language model calls are performed only on the incremental read-only subviews.

10. A multi-agent parallel data error correction system based on a large language model, characterized in that, include: The data acquisition module is used to acquire the error-checking data and data source configuration containing the first result set and the second result set. The first result set records the filtered result items, and the second result set records all result items. The unified view construction module is used to traverse the first result set and the second result set, configure the source path and project identifier for the obtained data items, associate the data items of the two result sets according to the project identifier, and normalize them to form a read-only unified data view; The agent construction module is used to construct multiple error correction agents based on the error correction task category and the data source configuration, extract a unique read-only subview for each error correction agent from the read-only unified data view and generate the agent running configuration. The parallel error correction module is used to construct a directed acyclic workflow that includes parallel nodes and summary nodes corresponding to the error correction agent, executes the parallel nodes to call the large language model to process the corresponding dedicated read-only subview, and isolates and writes the structured error correction results into the shared state. The report generation module is used to perform format verification, status determination, and problem item merging on the structured error correction results after the parallel node terminates, and generate a data quality audit report and downstream processing route identifier.

Images