Demand-driven data processing method and device, equipment and medium

Abstract

The invention relates to the technical field of artificial intelligence, can be applied to business scenes such as financial science and technology and medical health, and discloses a demand-driven data processing method, device and equipment and a medium, and the method comprises the steps: obtaining demand information, and generating a structured demand analysis report through a demand analysis agent; generating an executable code by combining a strategy conversion agent with a zero code operation platform; generating a test case through the automatic test agent and executing an automatic test; when the test result is wrong, adjustment is carried out through the result feedback agent; when the test result is passed, executing the executable code to generate a processing result, and verifying the intelligent experience certificate by the accuracy; and storing the verified processing result, and performing multi-level data analysis through the data analysis agent to obtain an analysis result. By establishing a closed loop of demand analysis, rule conversion, test verification and data analysis, rapid conversion and accurate verification from the demand to the result are realized, the processing efficiency is improved, and the error risk is reduced.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, and in particular to a demand-driven data processing method, apparatus, device, and storage medium. Background Technology

[0002] In the process of digitalizing enterprise human resources, the shortcomings of payroll management systems have gradually become a significant factor restricting enterprise operational efficiency and compliance management. Existing systems, when dealing with complex and diverse payroll needs, still rely on traditional payroll calculation logic and single functional modules, resulting in significant bottlenecks in performance, security, rule adaptation, and cross-system integration.

[0003] In the fintech sector, companies face the challenge of handling high-concurrency computations of massive datasets and stringent compliance audit requirements. However, existing payroll management systems often experience lag, delays, or even crashes during peak periods such as monthly payroll calculations or year-end bonus payments due to insufficient architectural support. This not only leads to payroll delays but can also result in data loss, triggering employee trust crises and compliance risks. Furthermore, payroll data contains sensitive personal accounts, salary details, and tax information, but existing systems generally suffer from deficiencies in access control, data transmission, and storage encryption. They often employ outdated encryption algorithms or lack fine-grained access controls, making them vulnerable to serious data breaches from both internal privilege abuse and external attacks. An even more significant issue is the complexity and variability of payroll calculation rules in financial institutions, involving hundreds of bonus distribution models and cross-regional social security and individual income tax policies. Existing systems lack the flexibility to adapt to these rules, making it difficult to respond promptly to regulatory updates or quickly adjust business logic, leading to frequent payroll errors that directly impact compliance and corporate reputation.

[0004] In the healthcare sector, organizations typically face the need for payroll calculation across regions, positions, and personnel types. For example, the pay rules for clinicians, nurses, researchers, and outsourced service personnel vary significantly. Existing payroll management systems often fail to accurately support this multi-dimensional and multi-level payroll calculation, forcing HR departments to perform supplementary calculations manually, increasing workload and increasing the risk of errors. Meanwhile, the healthcare industry has extremely high requirements for data security and privacy protection; however, some systems fail to meet the requirements of minimum access control and strong encryption, creating the risk of excessive internal data access or leakage of sensitive data. Regarding integration with systems for attendance, research funding management, and financial reimbursement, existing systems generally suffer from insufficient compatibility, hindering smooth data flow and often requiring repetitive manual entry, which is not only inefficient but also increases the probability of errors. Summary of the Invention

[0005] The main objective of this invention is to provide a demand-driven data processing method, apparatus, device, and storage medium, aiming to solve the technical problem that the existing technology lacks intelligent connection of the entire process from demand acquisition, rule transformation, automated testing to result verification and data analysis, which leads to the inability to quickly and accurately transform complex business requirements into executable and verifiable processing results.

[0006] To achieve the above objectives, the present invention provides a demand-driven data processing method, comprising: The system obtains input requirement information through a visual interface, parses the requirement information through a requirement analysis intelligent agent, extracts key information, and generates a structured requirement analysis report. The strategy-transformation agent receives the structured requirements analysis report and generates executable code by combining it with the configuration parameters of the zero-code operation platform. The automated testing agent generates test cases based on the executable code, executes automated tests based on the test cases, and records the test results. When the test result indicates an error, the error information is fed back to the requirement analysis agent or the strategy transformation agent through the result feedback agent for adjustment. When the test result indicates that the test is passed, the executable code is executed to generate a processing result, and the processing result is verified by an accuracy verification agent. The processed results after storage verification are then subjected to multi-level data analysis by a data analysis agent to obtain the data analysis results.

[0007] Furthermore, to achieve the above objectives, the present invention provides a demand-driven data processing apparatus, comprising: The requirements analysis module is used to obtain input requirements information through a visual interface, parse the requirements information through a requirements analysis intelligent agent, extract key information, and generate a structured requirements analysis report. The strategy conversion module is used to receive the structured requirements analysis report through the strategy conversion agent and generate executable code by combining the configuration parameters of the zero-code operation platform. The automated testing module is used to generate test cases based on the executable code through an automated testing agent, execute automated tests based on the test cases, and record the test results. The result feedback module is used to feed back the error information to the requirement analysis agent or the strategy transformation agent for adjustment when the test result indicates an error. An accuracy verification module is used to execute the executable code to generate a processing result when the test result indicates that the test is passed, and to verify the processing result through an accuracy verification agent. The data analysis module is used to store the processed results after verification. The data analysis agent performs multi-level data analysis on the stored processed results to obtain the data analysis results.

[0008] Furthermore, to achieve the above objectives, the present invention also provides a computer device, the computer device including a memory, a processor, and a demand-driven data processing program stored in the memory and executable on the processor, wherein when the demand-driven data processing program is executed by the processor, it implements the steps of the demand-driven data processing method as described above.

[0009] Furthermore, to achieve the above objectives, the present invention also provides a computer-readable storage medium storing a demand-driven data processing program, which, when executed by a processor, implements the steps of the demand-driven data processing method described above.

[0010] Beneficial Effects: This invention relates to the field of artificial intelligence technology and can be applied to business scenarios such as fintech and healthcare. It discloses a demand-driven data processing method, apparatus, device, and medium, comprising: acquiring input demand information through a visual interface, and having a demand analysis agent parse the demand information to generate a structured demand analysis report; generating executable code through a strategy transformation agent combined with configuration parameters of a zero-code operation platform; generating test cases based on the executable code and executing automated testing through an automatic testing agent; when the test result indicates an error, feeding back the error information to the demand analysis agent or strategy transformation agent through a result feedback agent for adjustment; when the test result indicates a pass, executing the executable code to generate a processing result, and verifying the processing result through an accuracy verification agent; storing the verified processing result, and performing multi-level data analysis through a data analysis agent to obtain the data analysis result. This invention forms a complete closed loop between demand acquisition, rule transformation, automated testing, error feedback, result verification, and data analysis, enabling complex business requirements to be quickly converted into executable code, and ensuring the accuracy and traceability of processing results in the automated verification and analysis stages, thereby improving business processing efficiency and reducing risk. Attached Figure Description

[0011] The present invention will be further described below with reference to the accompanying drawings and embodiments. In the accompanying drawings: Figure 1 This is a schematic diagram of an application environment for a demand-driven data processing method according to an embodiment of the present invention; Figure 2 This is a flowchart illustrating an embodiment of the demand-driven data processing method of the present invention; Figure 3This is a schematic diagram of the functional modules of a preferred embodiment of the demand-driven data processing device of the present invention; Figure 4 This is a schematic diagram of the structure of a computer device according to an embodiment of the present invention; Figure 5 This is another structural schematic diagram of a computer device according to one embodiment of the present invention. Detailed Implementation

[0012] It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the scope of the invention.

[0013] The demand-driven data processing method provided in this embodiment of the invention can be applied to, for example... Figure 1 In this application environment, the user terminal communicates with the server via a network. The server can obtain input requirement information through the user terminal's visual interface, and the requirement analysis agent parses the requirement information to generate a structured requirement analysis report; the strategy transformation agent generates executable code based on the configuration parameters of the no-code operation platform; the automated testing agent generates test cases based on the executable code and executes automated tests; when the test result indicates an error, the result feedback agent feeds the error information back to the requirement analysis agent or strategy transformation agent for adjustment; when the test result indicates a pass, the executable code is executed to generate the processing result, and the accuracy verification agent verifies the processing result; the verified processing result is stored, and the data analysis agent performs multi-level data analysis to obtain the data analysis result. This invention forms a complete closed loop between requirement acquisition, rule transformation, automated testing, error feedback, result verification, and data analysis, enabling complex business requirements to be quickly converted into executable code, and ensuring the accuracy and traceability of the processing results in the automated verification and analysis stages, thereby improving business processing efficiency and reducing risks. The user terminal can be, but is not limited to, various personal computers, laptops, smartphones, tablets, and portable wearable devices. The server can be implemented using a standalone server or a server cluster consisting of multiple servers. The invention will be described in detail below through specific embodiments.

[0014] Please see Figure 2 , Figure 2 This is a flowchart illustrating an embodiment of the demand-driven data processing method provided by the present invention. It should be noted that although a logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than that shown here.

[0015] like Figure 2 As shown, the demand-driven data processing method proposed in this invention includes the following steps: S10: Obtain the input requirement information through a visual interface, parse the requirement information through a requirement analysis intelligent agent, extract key information, and generate a structured requirement analysis report; In this embodiment, obtaining input requirements through a visual interface refers to the ability of users to directly input business requirements, rule descriptions, or configuration instructions in a graphical operating environment. The visual interface typically includes form controls, graphical components, and interactive input boxes, drawing inspiration from graphical user interface research in the field of human-computer interaction. Users can express their requirements through text box input, drop-down menu selection, or graphical drag-and-drop operations. The actual implementation of this process includes establishing a data acquisition module at the interface layer to structurally save the input content to an intermediate data cache. The interface layer can call a front-end framework (such as a web-based component library) for dynamic rendering, or it can use desktop tools to capture information.

[0016] The requirements analysis agent parses requirements information, which means transforming raw input content obtained from the visual interface into a computable and recognizable semantic representation. The parsing process originates from the fields of natural language processing and knowledge representation, involving operations such as word segmentation, part-of-speech tagging, named entity recognition, and semantic dependency analysis. In actual implementation, the requirements analysis agent invokes a language understanding model to identify key verbs, conditional statements, and entities, thereby constructing the logical framework of the requirements. During parsing, a semantic tree structure is built from the input data, and it is matched against a predefined business dictionary or industry rule base to ensure the accuracy and consistency of the parsing results.

[0017] Extracting key information refers to filtering out elements directly related to the target requirements from the parsing results. Key information includes strategy logic, triggering conditions, scope of application, and entity relationships, which are derived from research findings in rule engines and business modeling. In practice, feature selection algorithms or rule matching models can be used to weight and evaluate the parsing results to determine highly relevant elements. For example, strategy logic is mapped to decision tree nodes, triggering conditions are transformed into Boolean expressions, scope of application is represented as a limited set, and entity relationships are described using nodes and edges in a graph database.

[0018] Generating a structured requirements analysis report refers to storing and outputting extracted key information according to a fixed structure, forming a data representation that can be used for subsequent processing. Structured reports originate from applied research in information extraction and knowledge graph construction, and their formats typically include key-value pairs, tables, or tree structures. Specific implementation methods include using a template rendering engine to populate key information into a predefined data structure, generating a report with hierarchical labels and attribute identifiers. For example, strategy logic and triggering conditions are combined into logic blocks, the scope of application is inserted as contextual limiting information into the report, and entity relationships are stored in the dataset in the form of structured labels, ensuring that the report can be directly called by the strategy transformation module.

[0019] In terms of implementation, the visual interface can be based on web-based components or mobile interactive application development; the combination of interface controls varies depending on the scenario. When parsing requirement information, rule-based parsing models or deep learning semantic analysis models can be used. Rule-based methods are easier to implement when rules are simple and the data volume is small, while semantic analysis models are better at identifying implicit logic in complex cross-domain requirement environments. In the key information extraction stage, keyword weight calculation can be used, or business semantic networks can be leveraged to enhance the accuracy of information filtering. For generating structured reports, tabular storage can be used to adapt to integration with traditional databases, or graph structure storage can be used to support the expansion of cross-entity relationships.

[0020] Example Explanation: In the fintech business sector, enterprise users input a description via a visual interface: "Quarterly performance bonuses are calculated based on the quarterly profit margin. A profit margin above 15% results in 20% of the salary; a profit margin between 10% and 15% results in 10% of the salary; and a profit margin below 10% results in no bonus." The demand analysis agent receives this input and uses a natural language processing model to convert the text into a machine-readable structure. It then breaks down the key information, identifying the conditional indicator as "profit margin," with threshold ranges of ">15%", "10%-15%", and "<10%", corresponding to calculation methods of "salary 20%", "salary 10%", and "0". The parsed results are then structured to form a demand analysis report containing the indicator, thresholds, and corresponding calculation formulas, ensuring that subsequent steps can accurately generate executable rules.

[0021] In the healthcare sector, the regional health management platform allows users to input the following description via a visual interface: "Community health service institutions receive quarterly subsidies based on population coverage rates. For coverage rates above 95%, the subsidy is 12% of operating costs; for coverage rates between 85% and 95%, the subsidy is 6% of operating costs; and for coverage rates below 85%, no subsidy is provided." The demand analysis agent parses this input, identifying the indicator as "population coverage rate" and the threshold ranges as "≥95%", "85%-95%", and "<85%", with corresponding subsidy rules of "12% of operating costs," "6% of operating costs," and "0," respectively. After parsing, the system organizes this information into a structured table, labeling the indicator name, threshold conditions, and corresponding subsidy percentages, generating a demand analysis report. This report can be directly used as input for subsequent rule conversion, avoiding errors caused by manual interpretation.

[0022] This embodiment achieves automated conversion of requirements from natural language to a computable representation by inputting requirement information into a visual interface and having the requirement analysis agent complete the parsing and structured report generation. This avoids the process of manually sorting and coding requirements, and improves the efficiency and accuracy of requirement processing.

[0023] S20, the strategy conversion agent receives the structured requirements analysis report and generates executable code by combining the configuration parameters of the zero-code operation platform; In this embodiment, the strategy transformation agent receives a structured requirements analysis report. This report, derived from the previous requirements analysis process, typically includes strategy logic, triggering conditions, applicable scope, and entity relationships. This content is standardized and can be transformed into a system-recognizable data structure, such as key-value pairs, tabular rules, or annotated semantic trees. The strategy transformation agent first parses the report, establishing a semantic mapping to map natural language logic to rule types, thereby determining whether a particular rule should match fixed salary, performance-based salary, or subsidy rules.

[0024] During the parsing process, the strategy conversion agent needs to interact with the no-code operation platform and call the platform's configuration parameters. These parameters include calculation formula templates, process node settings, approval conditions, and data binding methods set by the user in the visual interface. These parameters are stored in the form of forms, configuration files, or visual configuration items. The strategy conversion agent reads and loads these parameters through an interface, ensuring that the generated code conforms to both business logic and the requirements of the platform's operating environment.

[0025] Subsequently, the policy transformation agent maps the parsed rules to an intermediate representation supported by the no-code operation platform. This intermediate representation is a structured logical expression that facilitates the automatic generation of system code. This logical expression includes conditional statements, loop rules, calculation formulas, and trigger action definitions. For example, a logic regarding performance bonuses can be mapped to a combination of conditional nodes and percentage calculation formulas.

[0026] After generating the intermediate representation, the policy transformation agent calls the code generation engine to integrate the logical expression with the configuration parameters of the no-code operation platform, automatically generating executable code. This process not only covers rule transformation but also parameter injection, data type checking, error protection logic embedding, and runtime environment adaptation, ensuring that the code can run directly in the system.

[0027] In one implementation, the strategy conversion agent performs rule matching through a template library. Each rule type corresponds to a template; for example, fixed salaries use an addition template, performance-based salaries use a percentage multiplication template, and subsidies use a conditional trigger template. Upon receiving a requirements analysis report, the system automatically identifies the rule category and calls the corresponding template, filling the template parameters with key information to obtain intermediate encoding.

[0028] In another implementation, the policy transformation agent uses a rule engine to achieve flexible mapping. The rule engine supports dynamic expansion and can define new rule matching patterns in configuration files. Computational logic added by users on the no-code operation platform, such as regionally differentiated subsidy policies, will be transformed into new mapping rules and stored in the engine, allowing subsequent similar needs to be directly invoked.

[0029] Distributed code generation can also be used in large-scale scenarios. The policy transformation agent breaks down structured requirements into multiple independent sub-rules, distributes them to multiple sub-processes for parallel transformation, and each sub-process is responsible for template matching and code generation for a type of rule. Finally, the merging module integrates the generated results into a complete executable code.

[0030] This embodiment establishes an automatic mapping between requirement information and system code, reducing ambiguity and errors caused by manual intervention. Requirement descriptions can be accurately translated into runnable code logic, and combined with the configuration parameters of the no-code operation platform, rapid integration of business logic with the runtime environment is achieved. This not only improves the efficiency of rule deployment but also reduces computational errors and maintenance costs caused by manual implementation.

[0031] S30, The automatic testing agent generates test cases based on the executable code, performs automated testing based on the test cases, and records the test results; In this embodiment, after receiving the executable code, the automated testing agent first needs to parse the encoded logic. The focus of the parsing is to identify the input parameter range, logical branch conditions, operational relationships, and exception handling mechanisms. After parsing, the system automatically generates different types of test cases. Test cases are divided into three categories: normal input scenarios, boundary input scenarios, and abnormal input scenarios. Normal input scenarios are used to verify the correctness of the output results under normal conditions, boundary input scenarios are used to verify whether the system operates stably under extreme conditions, and abnormal input scenarios are used to verify whether the system can correctly reject or prompt when there is an incorrect input.

[0032] During test case generation, the automated test agent invokes the built-in rule generator, combining the logical model output by the rule transformation agent to construct data pairs containing input parameters and expected output values. For example, if a salary calculation rule involves conditional judgments, the test case generator will automatically construct input data covering all conditional branches to ensure that no logical path is missed.

[0033] After generating test cases, the automated test agent invokes the execution engine, injects the input parameters from the test cases into the executable code, runs it, and collects the actual output values. The actual output values ​​are compared with the expected output values, the differences are calculated, and deviation information is generated. Deviation information includes not only numerical errors but also the execution status of the logical path, execution time, and exception handling behavior.

[0034] Finally, the automated testing agent compiles the execution status, expected results, actual results, and deviation information of each test case into test results, which are stored in a unified data recording module. These test results can serve as input for subsequent feedback agents, providing evidence for requirement adjustments or rule revisions.

[0035] In one implementation, the automated testing agent generates test cases using a pre-defined scenario library. The scenario library covers common combinations of boundary values ​​and abnormal inputs, such as zero, negative values, the largest integer value, or empty inputs, ensuring universal coverage for different coded logic.

[0036] In another implementation, the automated testing agent uses dynamic analysis techniques to generate test cases. The system identifies uncovered logical paths by tracing the runtime of executable code, and then generates supplementary test cases to ensure that the coverage reaches a preset threshold.

[0037] It can also combine machine learning models to automatically recommend high-risk test cases. By learning from historical test data and discovered defect patterns, the model predicts which input combinations are more likely to lead to coding errors, and thus prioritizes generating such test cases to improve the efficiency and effectiveness of testing.

[0038] Example Explanation: In the fintech business, when a company configures employee bonus calculation rules—that a 5% bonus is calculated on sales exceeding 100,000 yuan—the automated test AI will automatically generate test cases based on these rules, including three input types: sales of 99,000 yuan, 100,000 yuan, and 150,000 yuan. After executing these test cases, the system outputs bonuses of 0 yuan, 5,000 yuan, and 7,500 yuan respectively, and compares these results with the expected results. If it is found that the 99,000 yuan input was incorrectly used to calculate the bonus, the test results will record the deviation information to ensure the accuracy of rule execution.

[0039] This embodiment automates the generation and execution of test cases, comprehensively covering different input scenarios without human intervention. Automatic comparison of expected and actual outputs reduces human oversight and subjective judgment, improving the objectivity and consistency of the test. Simultaneously, by recording deviation information, the testing process not only identifies errors but also provides clues for problem localization. This mechanism significantly enhances the reliability and stability of executable code, providing a data foundation for subsequent feedback and correction.

[0040] S40, when the test result indicates an error, the error information is fed back to the requirement analysis agent or the strategy transformation agent through the result feedback agent for adjustment; In this embodiment, during automated testing, if the test results indicate that the executable code fails to meet the expected logic, the result feedback agent receives the test results and extracts the error information. The main content of the error information includes the input parameters that caused the error, the difference between the expected output and the actual output, and the runtime conditions that triggered the exception. The result feedback agent performs structured processing on this error information, generating adjustment data containing the error type, error location, and possible scope of impact. Subsequently, the result feedback agent determines whether the error belongs to the requirements analysis phase or the rule transformation phase based on the adjustment data. If it is determined to be a requirement misunderstanding error, the adjustment data is passed to the requirements analysis agent; if it is determined to be a code transformation error, the adjustment data is passed to the policy transformation agent. This process ensures that error information can flow efficiently between different agents and drives the relevant agents to perform targeted corrective operations.

[0041] In practical implementation, error information can be transmitted using a message queue, pushing adjustment plans containing deviation information and the root cause of the error to the corresponding agent, or by directly calling an API interface. Error type determination can be achieved by comparing the input-output differences in the test results with known error patterns in the historical amendment example library, or by training a classifier using a machine learning model to distinguish between requirement errors and coding errors. To improve feedback efficiency, the result feedback agent can also be configured with a priority mechanism. For example, when an error causes a discrepancy in key salary calculations, the error can be prioritized for the strategy transformation agent; when the error only involves descriptive conditions, it can be prioritized for the requirements analysis agent.

[0042] This embodiment introduces a feedback mechanism between automated testing and the requirements analysis and rule transformation stages. Error information can be captured promptly and directed to the appropriate agent, enabling rapid problem correction. This approach prevents errors from being amplified and accumulated in subsequent processes, improves the system's adaptability to complex payroll calculation rules, and reduces computational risks and manual repair costs caused by error propagation.

[0043] S50, when the test result indicates that the test is passed, the executable code is executed to generate a processing result, and the processing result is verified by an accuracy verification agent; In this embodiment, after the automated testing phase is completed, if the test results show that the generated executable code conforms to the expected logic in the comparison of input and output, the execution phase will begin. First, the system directly runs the executable code to generate actual processing results, which typically contain calculated values ​​or decision information corresponding to business rules. Next, an accuracy verification AI takes over the processing results and verifies their reliability and correctness. The verification process includes multiple dimensions: first, consistency comparison with historical datasets, checking for abnormal fluctuations by comparing processing results under the same conditions with historical results; second, sampling verification, extracting a portion of the generated processing results according to a preset ratio for manual rule verification to ensure that the result logic meets business requirements; and third, using a built-in verification model to perform anomaly analysis on the overall processing results, assessing the risk of deviations from the normal range. These operations ensure that the processing results not only pass the testing phase but also remain stable and accurate in real-world scenarios.

[0044] In practical implementation, the execution of executable code can be completed in a separate computing module, and the generated processing results are automatically written to the data storage module. For consistency comparison, the accuracy verification agent can call historical data interfaces to obtain historical processing records for the corresponding scenario and calculate the deviation using hash verification or numerical differencing methods. If the deviation is within a threshold range, it is considered consistent; otherwise, it is marked as a suspicious result. Different ratio parameters can be configured in the sampling verification stage; for example, the sampling ratio can be increased under high-risk business rules to strengthen the verification. For anomaly analysis, the accuracy verification agent can incorporate statistical or machine learning-based models, such as using cluster analysis to discover abnormal distributions or using supervised models to identify potential error patterns. The parameters of the verification model can also be flexibly adjusted for different business environments to adapt to different data volumes and computing scenarios.

[0045] This embodiment effectively ensures the reliability of processing results in real-world scenarios by adding an accuracy verification step after executing the executable code, avoiding erroneous outputs due to insufficient test coverage or environmental differences. This verification mechanism, through multi-dimensional comparison and anomaly analysis, enables the system to maintain a high level of accuracy when dealing with complex business rules and large-scale data, improving the stability of business operations and user trust in the results.

[0046] S60 stores the processed results after verification. The data analysis agent performs multi-level data analysis on the stored processed results to obtain the data analysis results.

[0047] In this embodiment, after the verification process, all verified results need to be stored for subsequent retrieval and analysis. The data storage module is responsible for persistent storage and efficient retrieval, supporting batch writing and indexing mechanisms to ensure rapid read and write operations even in large-scale data environments. After storage, the data analysis agent loads these processing results and performs multi-level data analysis based on predefined data analysis dimensions. Analysis dimensions typically include organizational, time, and indicator dimensions. Organizational dimensions correspond to departments, positions, or team structures within an enterprise; time dimensions are used to construct hierarchical relationships at the year, quarter, month, or even day level; and indicator dimensions cover calculation objectives such as costs, performance values, and bonus amounts. The data analysis agent receives selection instructions from the user, which include primary and secondary dimensions, guiding the direction of the analysis process. The system extracts the corresponding hierarchical dataset according to the instructions and performs aggregation or drill-down operations within the dataset. Aggregation operations involve merging statistics at a higher level, while drill-down operations refine the data level step by step within the dimension hierarchy until a lower granularity of data is displayed. The final data analysis results will include dimension labels to clarify the correspondence between the results and the primary and secondary dimensions in the selection instructions.

[0048] In implementation, the data storage module can adopt a hybrid database architecture, storing structured processing results in a relational database while storing logs or semi-structured descriptions in a non-relational database to support flexible queries. The data analysis agent can be implemented using multidimensional data modeling techniques, such as OLAP cubes, to accelerate the response speed of multi-level analysis through pre-computation and caching. For parsing user commands, a dimension mapping table can be designed to map natural language descriptions to internal field definitions, ensuring that selection commands directly drive data extraction. Aggregation operations can be implemented using GROUP BY and SUM in SQL, while drill-down operations can be completed through hierarchical path mapping and dynamic queries. In practical applications, a caching mechanism can be set up to store the analysis results of high-frequency dimension combinations to reduce redundant calculations. For large enterprise environments, a distributed computing framework can be deployed to improve the efficiency of multi-level analysis through parallel processing.

[0049] This embodiment introduces a data analysis agent after storing and verifying the processed results to achieve multi-level data analysis. This effectively transforms raw calculation results into structured insights, allowing enterprises to flexibly view data across different dimensions and levels. This design not only improves data utilization but also helps business personnel quickly identify problems and trends, reducing the workload of manual screening and calculation, thereby improving the efficiency and accuracy of decision-making.

[0050] This invention relates to the field of artificial intelligence technology and can be applied to business scenarios such as fintech and healthcare. It discloses a demand-driven data processing method, apparatus, device, and medium, comprising: acquiring input demand information through a visual interface, and having a demand analysis agent parse the demand information to generate a structured demand analysis report; generating executable code through a strategy transformation agent combined with configuration parameters of a zero-code operation platform; generating test cases based on the executable code and executing automated tests through an automated testing agent; when the test result indicates an error, feeding back the error information to the demand analysis agent or strategy transformation agent through a result feedback agent for adjustment; when the test result indicates a pass, executing the executable code to generate a processing result, and verifying the processing result through an accuracy verification agent; storing the verified processing result, and performing multi-level data analysis through a data analysis agent to obtain the data analysis result. This invention forms a complete closed loop between demand acquisition, rule transformation, automated testing, error feedback, result verification, and data analysis, enabling complex business requirements to be quickly converted into executable code, and ensuring the accuracy and traceability of the processing results in the automated verification and analysis stages, thereby improving business processing efficiency and reducing risk.

[0051] In one embodiment, step S10 above includes: S101, Receive requirement information containing a strategy description through the visual interface; S102, the demand analysis agent performs semantic parsing on the demand information to obtain the semantic parsing result; S103, Identify the strategy logic, triggering conditions, applicable scope, and entity relationships as key information from the semantic parsing results; S104, The key information is processed in a structured manner to generate a set of demand elements; S105, construct a structured requirements analysis report based on the set of requirements elements, including strategy relationships and strategy hierarchy markers.

[0052] In this embodiment, the visual interface is used to collect demand information and complete input validation, metadata recording, and format standardization. The interface accepts various input formats, including form fields, free text, file uploads, and parameterized selections. Form fields carry structured fields such as salary item name, calculation expression, threshold, applicable population, applicable region, and start and end period; free text is used to submit long statements describing the strategy; file uploads carry raw text of policy provisions, current regulations, and external constraints. Upon submission, the interface performs standardization processing, including numerical unit conversion, currency precision standardization, date and time standardization, organization name alignment, and personnel tag mapping, and generates input traceability information, recording the submitter, timestamp, version number, and data source tag. To ensure the accuracy of subsequent parsing, the interface implements strong constraint validation on key fields; for example, calculation expressions must pass syntax checks, thresholds must fall within the business-permitted range, and the applicable scope must match the registered list of organizations and positions. For free text, minimum length, sensitive word masking, and character set legality checks are performed.

[0053] The demand analysis agent is responsible for performing semantic parsing on demand information and producing semantic parsing results. The parsing process includes sub-processes such as language recognition, syntactic segmentation, lexical reconstruction, part-of-speech tagging, dependency analysis, named entity recognition, and referential resolution. It also incorporates a salary domain lexicon and a thesaurus to map synonymous expressions to unified terminology; for example, performance coefficients and bonus coefficients are merged into the same concept. The parsing output uses a computable representation, including annotated lexical sequences, entity lists, relation triple sets, logical fragments, and confidence scores. To reduce ambiguity, semantic constraints are established during the parsing phase; for example, monetary entities must be bound to currency, threshold comparisons must have comparison operators and thresholds, and time expressions must include granularity. If the same statement contains mutually exclusive conditions or missing terms, the agent writes conflict and missing term markers into the result and traces the source back to the original text location, facilitating completion or confirmation in subsequent structured processing stages.

[0054] Strategy logic, triggering conditions, scope of application, and entity relationships are extracted from the semantic parsing results using specialized extractors. The strategy logic extractor translates numerical calculations and Boolean judgments into an abstract syntax tree, supporting piecewise functions, tiered tax rates, interval unions, weighted averages, and rounding rules, preserving original operator precedence and generating executable intermediate representations. The triggering condition extractor identifies thresholds, hurdles, preconditions, and mutually exclusive conditions, forming predicate sets and combination methods, supporting short-circuit combinations of AND, OR, and NOT operations with an effective time window. The scope of application extractor parses organizations, positions, contract types, regions, and time intervals, constructing filtering predicates and aligning them with the master data dictionary to ensure that objects referenced within the scope are uniquely solvable. The entity relationship extractor outputs cross-entity dependencies, such as salary projects depending on performance results, bonus calculations depending on attendance summaries, and regional strategies constrained by policy versions, forming relation triples. Relationship types cover dependency, inheritance, overriding, mutual exclusion, and inclusion. Each extraction result includes confidence level, unit normalization information, and a source anchor to ensure traceability and verifiability.

[0055] The requirement element set carries the extracted key information and provides a consistent data contract. The set has a hierarchical structure: the top layer is the element list, the middle layer is the element details, and the bottom layer is the original text anchor mapping. Element details include unique identifiers, category labels, expressions or predicates, scope bindings, unit and precision constraints, value ranges, default values, conflict flags, and confidence levels. Expressions use abstract syntax trees or intermediate representations, supporting computation graph traversal and static checks. During set construction, a series of rules are executed, including unit unification, currency conversion, time granularity alignment, organizational code standardization, synonym merging, and placeholder variable binding. Consistency checks and cross-element conflict detection are also performed; for example, the same salary item cannot have duplicate definitions, and mutually exclusive conditions cannot be true simultaneously. After successful validation, the set and input traceability are stored in the database, and an immutable validation fingerprint is generated for easy comparison with subsequent versions.

[0056] The structured requirements analysis report is generated based on a set of requirements elements, covering a list, element details, strategy relationships, and strategy hierarchy markers. It provides both human-readable and machine-readable artifacts. Strategy relationships are expressed using a directed acyclic graph (DAG), showing dependencies, coverage, and mutual exclusion between strategy logics. Edges include conditional predicates and effective intervals. The generation process first sorts dependencies by topology, then performs cycle detection and minimum cut repair suggestions, providing hints for splitting or rewriting detected potential cycles. Strategy hierarchy markers define the priority and applicable order of strategies; for example, national-level strategies are higher than regional-level strategies, company-level strategies are higher than department-level strategies, and general strategies are lower than specific strategies. Hierarchical inference is calculated based on scope granularity, legal priority, and explicit priority weights, outputting hierarchical paths and conflict resolution explanations. The report provides a difference matrix, showing the differences in calculation expressions, triggering conditions, and applicable scope among different versions of strategies within the same scope, and outputs a consistency score and coverage metric. To support subsequent automatic conversion and testing, the report includes a machine-readable encapsulation containing element tables, relationship tables, hierarchy tables, and source tables, with all identifiers and unit specifications consistent with the sets.

[0057] Security and compliance are implemented throughout the process. Sensitive fields undergo de-identification and replacement before parsing; the parsing and storage processes employ a minimum access set; report outputs are hierarchically de-identified, and visibility is controlled by role. Multilingual and multi-regional scenarios are achieved through localized thesaurus and regulatory mapping; time and currency processing adhere to regional standards; and strategy-level calculations automatically adapt to different administrative levels. Robustness is enhanced through confidence thresholds and multi-strategy fusion. When discrepancies arise between machine learning extraction and rule extraction, a reconciliation strategy is employed, and manually reviewed points are marked to ensure that reports still output usable results even with weak signal input.

[0058] This embodiment transforms strategy descriptions into structured requirements analysis reports containing strategy relationships and strategy hierarchy markers, achieving a stable mapping from natural language to computable rules and reducing subsequent rework caused by semantic ambiguity and inconsistent terminology. Semantic parsing, element extraction, and unit normalization unify rule expression across numerical, temporal, and organizational dimensions, facilitating subsequent coding generation and automated testing by directly consuming the same contract. Strategy relationships and strategy hierarchy markers provide verifiable application order and conflict resolution criteria, reducing execution uncertainty caused by implicit coverage and circular dependencies. Source tracing and confidence mechanisms provide a chain of evidence for version management and quality auditing, maintaining traceable and evolvable engineering characteristics for large-scale payroll rule scenarios, thereby shortening the cycle from requirements to deployment and reducing the probability of computational errors.

[0059] In one embodiment, step S20 above includes: S201, the structured requirements analysis report is received by the policy conversion agent; S202, parse the strategy information in the structured requirements analysis report, including strategy logic, triggering conditions, applicable scope, and entity relationships; S203, call the policy template in the policy template library to match the policy type of the policy information; S204, convert the policy information into intermediate encoding according to the matched policy template; S205, combining the configuration parameters of the zero-code operation platform, optimize the intermediate code through structural adjustments and parameter injection; S206 uses a code generation engine to convert optimized intermediate code into executable code.

[0060] In this embodiment, when the strategy transformation agent receives the structured requirements analysis report, it performs data verification and version freezing through a controlled interface. The verification covers architectural consistency, field completeness, unit and currency consistency, time granularity consistency, and reference solvability. Before being stored in the database, an immutable snapshot and verification fingerprint are generated to ensure that subsequent processing is performed within the same context. The receiving process also records the report source, generation time, semantic parsing confidence distribution, and source tracing anchor point as the basis for subsequent error location and rollback.

[0061] The parsing phase extracts strategy information from a structured requirements analysis report. The strategy logic is translated into a dual representation of an abstract syntax tree and a computation graph, simultaneously preserving computational priorities, interval unions, piecewise functions, tiered tax rates, weighted averages, and rounding rules, forming a statically verifiable set of expressions. Triggering conditions are standardized into predicate sets and combination relationships, including threshold comparisons, preconditions, mutual exclusion conditions, effective time windows, and deactivation time windows, generating standardized predicate signatures for template matching. The scope of application is mapped to filtering predicates based on dimensions such as organization, position, contract type, region, and payment period, all aligned with the master data dictionary to ensure unique and solvable identifiers. Entity relationships are constructed as a dependency graph, with relationship types covering dependency, overriding, mutual exclusion, inheritance, and inclusion. Edges retain conditional constraints and priority weights, providing a basis for priority ordering and conflict resolution. The parsing output is summarized into a strategy information list, carrying confidence levels, unit specification information, and traceability anchors for subsequent optimization and auditing.

[0062] The strategy template library serves as a repository for reusable strategy templates and matching metadata. Each strategy template is bound to a strategy type and defines input slots, required and optional predicates, constraints, default value strategies, injectable variables, boundary behaviors, and exception handling branches. It also includes semantic fingerprints and example snippets to improve matching accuracy. The strategy template library employs domain-based hierarchical management and version control, supporting regional, organizational, and period-specific differences. A compatibility matrix is ​​used to mark cross-version replaceable relationships. Strategy types cover common forms such as fixed salaries, performance-based salaries, commission tiers, allowances and subsidies, overtime pay, tax deductions, social security contributions, and regional difference deductions. An extension type registration entry is also reserved to adapt to new business scenarios. The matching process is based on a comprehensive score of semantic fingerprint similarity, predicate coverage, slot availability, and conflict penalties. Priority rules and whitelists are introduced to ensure that explicit business definitions are prioritized. When there are candidates with the same high score, discriminative rules and static constraints are triggered for review to eliminate ambiguity.

[0063] Intermediate encoding serves as the transition from policy information to executable code. This representation employs a domain-specific intermediate layer, with its core consisting of a rule set, expression tree, control flow graph, and data flow graph. It requires pure functionalization, no side effects, strong typing, and reasoning capability. During construction, topological sorting is first performed based on policy relationships to ensure dependencies are prioritized. Then, policy logic is mapped to expression nodes, triggering conditions to Boolean gating, applicability to filtering and partitioning operators, and entity relationships to cross-rule reference edges. Static checks are performed at the graph level, covering unbound variables, inconsistent units, type mismatches, dead branches, and unreachable paths, and outputting minimum cut suggestions when potential loops are detected. After generation, the intermediate encoding is fingerprinted with content addressing and a structural summary to ensure reproducible construction.

[0064] The configuration parameters of the no-code operation platform are imported through a unified configuration service for structural adjustments and parameter injection. Parameter sources include organizational dimension constants, regional dimension thresholds, period dimension rates, switch identifiers, rounding and precision rules, currencies and exchange rates, holidays and work calendars, and external data connection identifiers, all with effective ranges and priorities. Parameter injection is accomplished through placeholder binding and secure replacement, supporting scalar, list, and mapping injection. Type validation, value range validation, and default substitution strategies are performed before injection to prevent parameterless construction and empty parameter execution. Structural adjustments are implemented in the intermediate coding layer, including condition merging, common factor extraction, common subexpression elimination, interval normalization, branch short-circuiting, interval endpoint unification, and gating shifting, balancing readability and execution efficiency. When configuration parameters trigger regional or organizational differences, a partitioned compilation strategy is used to segment the differing parts, minimizing the incremental changes of multiple variants originating from the same source.

[0065] The code generation engine is responsible for converting optimized intermediate code into executable code. The generation pipeline includes target selection, semantic preservation mapping, optimization, and artifact assembly. Target selection chooses interpreted or compiled backends based on the runtime environment and throughput requirements, supporting various forms such as embedded functions, containerized services, batch jobs, and streaming operators. Semantic preservation mapping ensures a one-to-one correspondence between expressions, triggering conditions, applicable scope, and entity relationships in the target language, using templated emission and symbol table alignment to achieve stable output. The optimization phase performs constant folding, strength reduction, branch prediction hints, vectorized candidate annotations, and short-circuit operation solidification, utilizing platform-native parallel operators and caching when necessary. The artifact assembly phase generates executable code and supporting components, including a metadata manifest, interface description, parameter manifest, monitoring point definitions, and audit log points, and completes signature and integrity verification. To facilitate subsequent automated testing, callable test hooks and simulation entry points are output synchronously during generation, and intermediate code and template fingerprints are retained to ensure that problems are localized, builds are replayable, and rollbacks are accurate.

[0066] Abnormal branching and security compliance are addressed proactively and in a closed loop within the pipeline. Template mismatches, missing policy types, incomplete configuration parameters, and failed static checks directly block the build process and return a list of issues and their origins. Sensitive parameters appear only as reference identifiers during the injection phase, and executable code is never written in plaintext. In multi-tenant environments, configuration read permissions are controlled through namespace isolation, key partitioning, and short-lived access tokens. All critical processes are written into the audit trail and can be reviewed by version, ensuring that a piece of code and a set of configurations can be restored to their original state at any point in time.

[0067] This embodiment constructs a deterministic channel from policy information to executable code through a policy transformation agent, a policy template library, intermediate encoding, configuration parameters of the zero-code operation platform, and a code generation engine. A structured requirements analysis report provides unified semantics and traceability anchors; template matching ensures consistent mapping for similar policies; intermediate encoding provides an inspectable and optimizable transitional representation; configuration parameters achieve differentiation without branching logic through structural adjustments and parameter injection; and the code generation engine maintains semantic parallelism and execution efficiency. This reduces the discrepancies and implementation differences introduced by manual coding, shortens the time from rule changes to deployment, lowers maintenance costs in regionally and organizationally differentiated scenarios, and provides stable interfaces and replayable artifacts for subsequent automated testing and result verification, maintaining consistency and auditability throughout continuous version evolution.

[0068] In one embodiment, step S30 above includes: S301, The execution logic of the executable code is analyzed by an automatic testing agent, the range of input parameters is identified, and normal input scenarios, boundary input scenarios and abnormal input scenarios are identified based on the range of input parameters; S302, generate test cases containing input parameters and expected output values ​​for each identified scenario; S303, Execute the executable code using the input parameters to obtain the actual output value; S304, compare the difference between the actual output value and the expected output value to obtain deviation information; S305, Record the test results containing the deviation information.

[0069] In this embodiment, the automated testing agent acquires executable code and then performs joint static and dynamic analysis to form a testable view. On the static side, a control flow graph and a data flow graph are established, parsing function entry points, exit points, conditional branches, loop boundaries, external dependencies, numerical domains, and unit information, and extracting a list of input variables and type constraints involved in the computation. On the dynamic side, a lightweight interpreter or shadow executor runs through a clean input set, capturing path opening and closing states and runtime assertions to provide a baseline for scene coverage computation. These two types of information are merged into an execution logic summary, including path predicates, a reduced expression tree, dependency order, and parallelizable segment identifiers.

[0070] Input parameter range identification is based on type constraints, configuration thresholds, business dictionaries, and historical value statistics. Numerical parameters are processed through inequality solving, interval union, and boundary refinement to obtain continuous or discrete domains. Currency-related parameters are fitted with additional precision and rounding modes, while date and time parameters are mapped to work calendars and settlement cycles. Enumerated parameters are aligned with the master data dictionary and invalid items are removed. String parameters are given length and character set constraints and regularization constraints are generated. Multi-parameter coupling is addressed by constraint propagation and intersection to obtain the feasible domain. Multi-table join conditions are transformed into existence predicates to avoid generating unexecutable combinations.

[0071] Scene recognition follows a strategy combining equivalence class partitioning and boundary value analysis. For normal input scenarios, representative point sets are selected from the feasible region, covering the main path and the normal threshold range. For boundary input scenarios, adjacent point pairs and cross-edge samples are constructed around thresholds, gear shifts, interval endpoints, rounding thresholds, and time window alternation points to ensure sensitivity testing of segmentation and step-by-step logic. For abnormal input scenarios, out-of-bounds values, illegal formats, missing fields, conflicting combinations, and empty set results are generated based on type and constraints, while also adding security-related variants such as excessively long strings and special character embeddings. Hierarchical sampling and orthogonal arrays are used for the multi-parameter space to reduce combinatorial explosion, retaining the minimum coverage set that can trigger predicates for different paths. Each scenario includes path expectations, constraint sources, and priorities for pruning when resources are limited.

[0072] Test case generation is implemented using a unified test case pattern. Core fields include identifier, scenario type, input parameter mapping, expected output, path expectation, precision rules, preconditions and postconditions, idempotency flag, and dependent data references. Expected output is constructed through three mechanisms. The first uses a shadow executor to run executable code or equivalent intermediate expressions in a constrained environment, avoiding external side effects and solidifying precision and rounding. The second uses a provable algebraic benchmark expression to perform comparative calculations on specific sub-expressions, used for parsed logic such as segmented tax rates, proportions, and upper limit caps. The third applies a transformation relation generator to construct necessary relationships for multiple inputs under the same semantics; for example, proportional scaling results in proportional changes within a proportion range, thereby verifying order relations. Expected output carries a tolerance model along with path and precision rules. For currency scenarios, the minimum currency unit and banker rounding or a rounding model are used; interval comparisons employ a closed-open interval consistency strategy.

[0073] The execution engine runs test cases in a sandbox and captures actual output. The runtime environment uses containers or lightweight virtualization to isolate dependencies, locking versions, time zones, currencies, calendars, and random seeds to ensure reproducibility. Input injection supports three types: scalars, structs, and batch vectors. External services are replaced by stubs or simulated endpoints, and return values ​​are generated according to contracts. During execution, branch coverage, condition coverage, exception stacks, execution time, and resource counts are collected, and parallel path expansion is triggered to improve coverage when thresholds are met. For paths with side effects, snapshots and rollbacks are used to ensure consistency across multiple executions.

[0074] Comparison and deviation calculation are performed in a domain-aware comparator. For scalar values, a mixed tolerance of absolute and relative tolerances is used, prioritizing the smallest unit given by the precision rules before comparison. For segmented results, segmentation is matched first, then compared; when crossing segments, segmentation errors are marked and the nearest threshold difference is appended. Keyed alignment and order-independent comparison are performed on sets or detailed lists; masking or range matching is allowed for some fields. Strings are normalized before comparison, including removing formatting symbols, standardizing case and whitespace. The comparator outputs deviation information, including the deviation value, tolerance, segment or field, trigger predicate, path hash, and location fragment, for direct use in the feedback chain.

[0075] Test results are recorded as structured audit documents. Fields include test case metadata, execution environment summary, coverage metrics, actual output summary, deviation information, judgment conclusions, time consumption and resource usage, relevant snapshot fingerprints, and dependency stub versions. Records are written to two types of storage simultaneously: a transactional library ensures retrieval, and object storage preserves complete artifacts. To support subsequent result feedback and location, the results embed traceability anchors associated with executable code versions, configuration parameter versions, and template matching fingerprints. In concurrent scenarios, a queue order and idempotent key are added to each batch, and duplicate deliveries are automatically merged. Sensitive data undergoes field-level anonymization and minimal retention before being written to disk, and original details are only retained in the traceable area within a controlled sandbox.

[0076] Data quality and stability are ensured throughout the entire process. After generation, the use case pool performs deduplication and dominance relationship pruning, eliminating covered redundant samples. Coverage targets are jointly measured by branch, condition, decision-condition combinations, path sampling, and rule hit rate; boundary samples are continuously added until the target is reached. Stabilization strategies are introduced for volatile expressions, such as changing floating-point operations to fixed-point operations and fixing the time function to the billing cycle benchmark. Abnormal path execution triggers automatic classification, distinguishing between expected and unknown anomalies to avoid false positives. All stages use content addressing for fingerprinting to ensure verifiable and replayable results.

[0077] This embodiment utilizes an automated testing agent to drive scenario construction through execution logic summaries, generates verifiable expectations using controlled shadow execution or algebraic representations, quantifies deviations using a domain-aware comparator, and abstracts the complete process and environment into auditable records. This achieves high-coverage verification and reproducible regression of executable code, significantly reducing the probability of missing boundary conditions and segmented logic, avoiding numerous false positives caused by precision and rounding differences, improving defect localization efficiency, and providing directly usable deviation and path evidence for subsequent feedback and correction. In high-accuracy scenarios such as payroll settlement, it can obtain near-full-path assurance with a small sample size before deployment, while rapidly replaying verification after version and configuration changes, shortening the release cycle and reducing the risk of production defects.

[0078] In one embodiment, step S40 above includes: S401, when the test result indicates an error, the test result containing deviation information is received by the result feedback agent; S402, the test results are analyzed to determine the root cause of the error as either a misunderstanding of requirements or a coding conversion error; S403, Generate a correction suggestion corresponding to the root cause of the error based on the historical amendment example library; S404, Generate an adjustment plan that includes the root cause of the error and the suggested corrections; S405, based on the root cause of the error, the adjustment plan is fed back to the demand analysis agent or the strategy transformation agent, triggering the demand analysis agent or the strategy transformation agent to perform the correction operation.

[0079] In this embodiment, when the result feedback agent receives test results, it first obtains the complete result set output by the automated testing agent through a standardized data interface. The result set includes deviation information, input parameters, expected output, actual output, and path information. The deviation information, serving as the entry point for subsequent analysis, is further extracted and formatted into a structured representation of deviation type, deviation magnitude, triggering conditions, and corresponding paths. To avoid information omissions, the feedback process verifies whether the deviation information covers all failed test cases and associates it with executable code through version identifiers to ensure the completeness of error tracing.

[0080] In the root cause analysis phase, the feedback agent invokes the error classification module to compare the test results with the semantic parsing model and the encoding conversion rule base. If the error manifests as missing rule logic, incorrect trigger condition identification, or inappropriate understanding of the applicable scope, it is classified as a requirement misunderstanding error; if the error manifests as code logic deviation, incorrect threshold judgment, or condition nesting not conforming to the strategy template, it is classified as an encoding conversion error. The analysis process combines path predicates, conditional branch coverage, and input-output comparison results, using decision trees or rule engines to achieve automatic discrimination, while also supporting manual intervention for correction.

[0081] The introduction of a historical amendment case library provides empirical support for bug fixing. The case library is indexed according to bug type, business domain, input characteristics, and solution method. The feedback agent retrieves cases highly relevant to the current bug's root cause using a similarity matching method. When generating correction suggestions, the system extracts correction steps, parameter adjustment schemes, template replacement methods, and verification techniques from historical cases and adapts them to the current context and business logic. For example, when multiple similar cases are matched, the system uses a weighted evaluation mechanism to select the optimal correction path to ensure the feasibility and accuracy of the correction suggestions.

[0082] When generating an adjustment plan, the feedback agent combines the root cause of the error with the suggested corrections to form a structured adjustment document. This document includes error location information, corrective action steps, parameter adjustment suggestions, dependency verification conditions, and expected result verification methods. This document is not only used for feedback but also serves as the basis for subsequent repair execution and retesting. A consistency check is performed during the adjustment plan generation process to ensure that the adjustment plan does not conflict with existing requirement descriptions or rule templates.

[0083] During the feedback execution phase, the feedback agent selects different targets based on the type of error root cause. If the error stems from a misunderstanding of requirements, the feedback path points to the requirements analysis agent; if it's a coding transformation error, the feedback path points to the strategy transformation agent. The feedback process is conducted via a message bus or interface call, carrying adjustment plans and relevant context, triggering the receiver to perform corresponding corrective operations. After receiving feedback, the requirements analysis agent re-parses the user requirements or corrects the structured expression of key information; after receiving feedback, the strategy transformation agent reselects the strategy template or corrects the logical structure of intermediate coding. The entire process ensures that errors are quickly located and closed-loop repaired.

[0084] This embodiment automates the analysis and classification of test results through a result feedback agent, accurately distinguishing between errors in requirement understanding and errors in coding transformation, thus avoiding repeated repairs and iteration delays caused by unclear error attribution. The introduction of a historical amendment example library provides experience-based support for correction suggestions, improving the rationality and execution efficiency of adjustment plans. The structured generation and automatic distribution of adjustment plans ensure that the requirement analysis agent and strategy transformation agent can quickly execute targeted correction operations, forming a closed-loop process of requirement, transformation, testing, and feedback. This achieves automated linkage between error detection and correction, reducing delays and errors caused by manual intervention, and significantly improving the stability and accuracy of the system in handling complex payroll rules.

[0085] In one embodiment, step S50 above includes: S501, when the test result indicates that the test is passed, the executable code is executed to generate the processing result; S502, the intelligent agent receives the processing result after accuracy verification; S503, compare the processing result with the historical dataset to generate a comparison result; S504, extract a portion of the processing result according to a preset sampling ratio for business strategy verification, and generate verification results; S505, Analyze the anomaly level of the processing results through the verification model and generate anomaly analysis values; S506, when the comparison result, verification result and anomaly analysis value all meet the preset verification threshold, the processing result is marked as the final result.

[0086] In this embodiment, when the test result indicates a pass, the executable code is run and the processing result is generated. The execution process starts from a controlled execution environment, loads policy dependencies and configuration parameters consistent with the version number, and ensures that the complete batch of processing results is generated in one go through transaction control. Each record is appended with a generation timestamp, execution version fingerprint, and input digest check value before entering the result set, facilitating traceability and anomaly investigation in the subsequent verification phase. After the batch execution is completed, the output structure adopts a two-level organization method of row-level details and aggregated index. The row-level details are used for record-by-reproducibility verification, while the aggregated index is used for rapid consistency detection and statistical sampling.

[0087] After receiving the processing results, the accuracy verification agent establishes a verification context. First, it parses the batch metadata to confirm that the execution version, parameter set, and input range are consistent with the testing phase. Then, it maps the processing results to the corresponding partitions of the historical dataset using business keys and time keys. The historical dataset is organized by rolling time windows and business dimensions, containing recent benchmark values, approved revision records, and anomaly handling records, supporting cross-period comparisons and year-on-year / month-on-month calculations. To avoid data pollution, the historical partitions in the verification context are mounted in read-only mode, and marking and compensation strategies are provided for missing periods or changes in definitions.

[0088] Consistency comparisons are performed on a batch basis. The verification process first standardizes the definitions of key indicators, using a metric transformation table to convert different periodic or rule-based definitions to the current baseline definition, and then performs alignment. After alignment, multi-granularity difference indicators are calculated, including single-value difference, relative difference, year-on-year / month-on-month difference, and structural difference. For time series indicators, dynamic time warping and offset window smoothing are introduced to mitigate spurious differences caused by seasonal fluctuations; for structural indicators, distribution distance and group proportion differences are calculated to identify structural abrupt changes. The comparison results generate judgment labels and difference summaries according to the indicator, group, and time dimensions, serving as the first input for subsequent judgments.

[0089] Business strategy verification is performed according to a preset sampling ratio. The sampling strategy supports three paths: stratified proportional, anomaly-priority, and adaptive. Stratified proportional ensures coverage of all departments, positions, or regions; anomaly-priority increases the sampling weight of marginal samples identified during the consistency comparison phase; and adaptive increases the sampling intensity of high-risk subsets based on historical error distribution. The extracted samples enter the verification engine, which loads the business strategy library and parameter mappings, re-enacts the calculation chain line by line, and checks whether threshold judgments, conditional branches, and cascading relationships are consistent with the strategy logic. The verification process outputs intermediate variables and breakpoint snapshots for key nodes; in case of ambiguity, the effective definition in the strategy registration ledger prevails. The verification results consist of pass / fail indicators, failure reasons, difference variables, and re-enactment trajectories, forming a structured output.

[0090] The validation model evaluates the anomaly level of the processed results to generate anomaly analysis values. The model set includes three types: statistical, graph, and learned. The statistical model focuses on distribution shift and outlier detection; the graph model utilizes entity relationships and rule dependencies to construct an influence network to identify anomaly propagation paths; and the learned model scores based on historical feature vectors from batches and anomalous batches. To avoid single-model bias, the validation process employs ensemble judgment, weighting and fusing the outputs of multiple models and providing confidence intervals. Anomaly analysis values ​​are represented by both interval scores and level labels. Scores are used for threshold determination, and level labels are used for audit records and visualization. Model input features include macro-distribution, local gradients, rule triggering frequency, and replay consistency. Feature engineering is performed within the validation context to ensure consistency with business requirements.

[0091] The final judgment is based on the intersection of three types of inputs. The comparison results, verification results, and anomaly analysis values ​​jointly drive the judgment state machine. The judgment logic first checks whether all verification results pass, then checks whether consistency differences fall within the threshold range, and finally checks whether the anomaly analysis value does not exceed the allowable level. The threshold system consists of global thresholds and dimensional thresholds. Global thresholds constrain overall risk, while dimensional thresholds set differentiated boundaries for departmental, positional, or regional differences, supporting monthly rolling automatic calibration. When all conditions are met, the processing result is labeled with a final result tag, written to the acceptance batch ledger, and an unalterable hash voucher is generated. If any condition is not met, the final tag is automatically rolled back, a cause classification is output, and the process enters the anomaly handling workflow. The entire process retains a complete audit chain, including configuration version, training snapshot, calculation trajectory, and human intervention traces, facilitating compliance review and scenario replay.

[0092] This embodiment introduces a parallel verification path—consistency comparison, business strategy verification, and anomaly assessment—after batch execution. This allows for simultaneous constraint on result accuracy from three perspectives: data alignment, rule replay, and risk quantification. The comparison stage ensures continuity and stability with historical standards; the verification stage ensures consistency and repeatability with strategy logic; and anomaly assessment ensures sensitivity to hidden deviations and structural mutations. These three types of judgments are jointly decided using a threshold system, reducing misjudgments caused by single criteria, lowering the burden of manual review, and improving traceability and compliance credibility through audit-based output.

[0093] In one embodiment, step S60 above includes: S601 stores the verified processing results through the data storage module; S602 defines data analysis dimensions, including organizational, time, and indicator dimensions, through a data analysis intelligent agent. S603, Receive the selection instruction for the analysis dimension, the selection instruction including the main dimension, the secondary dimension and the analysis index; S604, Based on the defined data analysis dimensions, extract the hierarchical dataset from the stored processing results according to the primary and secondary dimensions of the selection instruction; S605, based on the data analysis dimension, perform data aggregation or drill-down operation along the dimension hierarchy on the hierarchical dataset according to the analysis indicators to generate data analysis results with dimension identifiers.

[0094] In this embodiment, after the processing result is verified, it needs to be persistently saved to support subsequent data analysis. The data storage module receives the processing result and writes it to the data storage system according to a unified storage format. During storage, the module adds metadata information to each record, including generation time, execution version, and data source identifier, thereby ensuring accurate traceability in subsequent analysis. The storage structure adopts a partitioning and indexing mechanism to support fast retrieval based on time and organizational structure, avoiding performance bottlenecks during large-scale data queries.

[0095] After accessing the stored data, the data analysis agent first defines the data analysis dimensions. These dimensions encompass organizational, time, and metric dimensions. The organizational dimension represents the hierarchical relationship of data within an enterprise or organizational structure, such as company, department, or position. The time dimension represents the time attribute of the data, including year, quarter, and month levels. The metric dimension identifies the numerical values ​​that need to be calculated in the analysis, such as salary, bonuses, or attendance hours. Dimension definitions not only clarify the scope of the analysis but also provide hierarchical paths and aggregation criteria for subsequent multi-level analyses.

[0096] Before analysis, the system receives user input indicating the analysis dimension selection. The selection instructions include the primary dimension, secondary dimensions, and analysis metrics. The primary dimension determines the first level of classification for the analysis, such as categorization by department; secondary dimensions are further subdivided under the primary dimension, such as expanding by job position within a department; analysis metrics indicate the numerical values ​​to be calculated for each dimension combination, such as average salary or performance bonus. The selection instructions undergo semantic parsing and validity verification to ensure consistency with the defined analysis dimensions.

[0097] Based on defined data analysis dimensions and user selection instructions, the data analysis agent extracts corresponding hierarchical datasets from the stored processing results. The extraction process filters and groups the data according to the hierarchical path defined by the dimensions. For example, when the primary dimension is "department" and the secondary dimension is "job position," the agent will extract records for each job position under the corresponding department from the stored results, forming a hierarchical dataset that can be further aggregated or drilled down. To ensure processing efficiency, pre-established indexes and caching mechanisms are utilized during the extraction process.

[0098] After obtaining the hierarchical dataset, the system performs aggregation operations based on the selected analytical indicators, or drill-down operations along the dimensional hierarchy. Aggregation operations include summation, averaging, maximum, and minimum values, suitable for summarizing indicator values ​​at a specific level. Drill-down operations, based on the dimensional hierarchy, progressively expand high-level data to lower levels, displaying a more granular data distribution. For example, drilling down from the department level to the job level, and then down to the individual level. Both aggregation and drill-down rely on predefined dimensional relationships and indicator definitions to ensure logical consistency of the results.

[0099] Finally, the data analysis results are output in the form of dimension labels. Dimension labels clearly record the primary and secondary dimensions corresponding to the current analysis result, enabling the results to clearly reflect the data's position within the organizational and temporal structure. Dimension labels are stored and transmitted as part of the results, facilitating user understanding of the analysis results and supporting subsequent traceability and reuse of the results.

[0100] Example Description: In the process of digital transformation in the healthcare sector, a regional public health management center needs to build a salary management and human resource cost analysis system to meet the salary calculation and expense management needs of a large number of health service personnel. The system first receives requirement information from health service management positions through a visual interface, such as "night shift subsidies for community nurses are calculated hourly" and "transportation subsidies for personnel dispatched for public health projects are calculated based on actual reimbursement amounts." The requirement analysis agent semantically parses these inputs, identifies key salary logic, triggering conditions, applicable scope, and entity relationships, and generates a structured requirement analysis report. In this way, the previously scattered rules in the management center, fragmented across documents and manual communication, are transformed into a set of elements that the system can understand.

[0101] The structured requirements analysis report is passed to the strategy transformation agent, which parses the rule logic and parameter constraints within it, and calls the corresponding templates from the rule template library to complete rule matching. For example, it identifies night shift subsidies as a subsidy rule calculated based on working hours, and then, combined with the configuration parameters of the zero-code operation platform, automatically injects the subsidy standard and applicable personnel scope through a visual interface. Subsequently, the code generation engine transforms the optimized intermediate logic into directly executable code, enabling the health management center to quickly obtain runnable payroll calculation logic without manually writing complex code.

[0102] After obtaining executable code, the automated testing agent generates multiple sets of test cases, covering normal, boundary, and abnormal scenarios. For example, scenarios such as night shift hours reaching the subsidy threshold, exceeding the subsidy limit, or missing work hour records will be included in the test cases. The agent executes these test cases, compares the actual calculation results with the expected results, and generates test results containing deviation information. If an error is detected, the result feedback agent will feed back adjustment plans containing the root cause of the error to the requirements analysis agent or strategy transformation agent to reconfirm the requirements logic or repair the rule transformation logic, thereby ensuring that the final rule expression and implementation are consistent.

[0103] Once the test results pass verification, the executable code generates the processing results in the system. The accuracy verification agent performs multiple checks on the results. First, it compares the results with historical datasets to ensure there are no abnormal fluctuations under similar business conditions. Second, it samples the salary results of a portion of personnel according to a preset sampling ratio and compares them with the manual calculation strategy to further confirm the logical rationality. Simultaneously, it uses a verification model to perform anomaly analysis on the overall data to avoid systematic bias. Only when the comparison results, verification results, and anomaly analysis values ​​all meet preset thresholds is the processing result marked as the final result.

[0104] The final results are stored in the data storage module, and the data analysis agent performs multi-level data analysis on these validated results. The management center can define organizational dimensions (such as region, service site, personnel category), time dimensions (such as year, quarter, month), and indicator dimensions (such as total salary, subsidy amount, performance bonus), and execute data extraction and analysis by selecting the analysis dimension. Data analysis can quickly obtain the overall trend of various personnel costs through aggregation, or it can expand layer by layer through drill-down, from region to service site, and then to specific personnel groups, to achieve refined human resource cost analysis and resource optimization. The analysis results are labeled with dimensions, ensuring that subsequent decision-makers can clearly trace the organizational scope and time frame corresponding to each indicator.

[0105] In a fintech application scenario, a large online financial services company needed to build an intelligent payroll management and business incentive settlement system to handle the settlement needs of a large number of employees and partners. The system first receives requirement information input from business departments through a visual interface, such as "financial advisors' commissions are calculated at 2% of the transaction amount, but a single transaction must exceed 50,000 yuan to be counted as a commission" or "call center customer service performance bonuses are only issued if the customer satisfaction score is above 90." The requirement analysis intelligent agent performs semantic parsing on these inputs, automatically identifying strategy logic, triggering conditions, applicable scope, and entity relationships. It extracts scattered rules into a clear set of elements, forming a structured requirement analysis report, avoiding the ambiguities and omissions common in manual interactions.

[0106] The structured requirements analysis report is then passed to the strategy transformation agent, which parses the conditions and logic in the rules, calls the matching rule templates from the strategy template library, and completes the transformation by combining the configuration parameters on the no-code operation platform. For example, the commission rule is matched to the "proportional sharing" template, and then the proportion parameters and applicable conditions are automatically injected. Through the code generation engine, the intermediate code, after structural adjustment and parameter injection, is transformed into executable code, enabling complex settlement rules to run efficiently in the system.

[0107] The automated testing agent generates test cases covering various scenarios based on executable code. These include normal transaction data that conforms to rules, as well as boundary transaction data that triggers critical points and abnormal input data. For example, the test data includes cases where the transaction amount is exactly 50,000 yuan, high-amount transactions exceeding the threshold, and transactions below the threshold, ensuring that the system can accurately output results under various input conditions. The agent executes these test cases and records the results. If discrepancies are found, the result feedback agent feeds back the deviation information to the requirements analysis agent or strategy transformation agent to help recalibrate the rule understanding or code transformation logic.

[0108] Once the test results are passed, the executable code will generate processing results in a real settlement scenario. The accuracy verification AI will perform multi-layered verification on the results. It will compare the results with historical data to confirm that there are no abnormal fluctuations in results under similar business scenarios. At the same time, it will sample and manually compare some settlement documents and use the verification model to perform anomaly detection on the overall data to prevent rule or data deviations from being amplified. Only when the comparison, sampling, and model verification all meet the set thresholds will the processing result be confirmed as the final result.

[0109] The finalized settlement data is stored in the data storage module, and the data analysis agent performs multi-level analysis based on the stored data. Financial enterprises can set organizational dimensions (such as regional branches, business lines), time dimensions (such as quarters, months), and indicator dimensions (such as total commission amount, bonus amount), and flexibly combine analytical perspectives through dimension selection instructions. The system can quickly obtain the overall incentive costs of different business lines through aggregation, and can also refine them layer by layer through drill-down to track the incentive expenditures of specific teams or individuals. The analysis results are labeled with dimensions, ensuring that decision-makers can clearly locate the scope and time window corresponding to each indicator, thereby providing strong support for bonus budgeting, risk control, and performance evaluation.

[0110] This embodiment stores the verified processing results and allows a data analysis agent to perform multi-level analysis within a framework of organizational, time, and indicator dimensions, enabling hierarchical data insights from macro to micro levels. The combination of primary and secondary dimensions supports flexible data segmentation and refinement, drill-down operations enhance the depth of data exploration, and aggregation operations provide a rapid grasp of overall trends. Dimension labeling ensures the interpretability and traceability of the results, avoiding ambiguity caused by inconsistent analytical standards.

[0111] In one embodiment, a demand-driven data processing apparatus is provided, which corresponds one-to-one with the demand-driven data processing method described in the above embodiments. (Refer to...) Figure 3 , Figure 3 This is a schematic diagram of the functional modules of a preferred embodiment of the demand-driven data processing device of the present invention. The modules include a demand analysis module 10, a strategy conversion module 20, an automatic testing module 30, a result feedback module 40, an accuracy verification module 50, and a data analysis module 60. Detailed descriptions of each functional module are as follows: The requirements analysis module 10 is used to obtain input requirements information through a visual interface, parse the requirements information through a requirements analysis intelligent agent, extract key information, and generate a structured requirements analysis report. The strategy conversion module 20 is used to receive the structured requirements analysis report through the strategy conversion agent and generate executable code by combining the configuration parameters of the zero-code operation platform. The automatic testing module 30 is used to generate test cases based on the executable code through an automatic testing agent, perform automated testing based on the test cases, and record the test results. The result feedback module 40 is used to feed back the error information to the requirement analysis agent or the strategy transformation agent for adjustment when the test result indicates an error. The accuracy verification module 50 is used to execute the executable code to generate a processing result when the test result indicates that the test result is passed, and to verify the processing result through the accuracy verification agent. The data analysis module 60 is used to store the processed results after verification. The data analysis agent performs multi-level data analysis on the stored processed results to obtain the data analysis results.

[0112] Specific limitations regarding the demand-driven data processing device can be found in the foregoing limitations of the demand-driven data processing method, and will not be repeated here. Each module in the aforementioned demand-driven data processing device can be implemented entirely or partially through software, hardware, or a combination thereof. These modules can be embedded in or independent of the processor in a computer device, or stored in the memory of a computer device as software, so that the processor can call and execute the operations corresponding to each module.

[0113] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 4 As shown, the computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides determination and control capabilities. The memory includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The network interface is used for communication with external user terminals via a network connection. When the computer program is executed by the processor, it implements a demand-driven data processing method on the server side, fulfilling server-side functions or steps.

[0114] In one embodiment, a computer device is provided, which may be a user terminal, and its internal structure diagram may be as follows: Figure 5 As shown, the computer device includes a processor, memory, network interface, display screen, and input devices connected via a system bus. The processor provides determination and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The network interface is used to communicate with an external server via a network connection. When the computer program is executed by the processor, it implements a demand-driven data processing method's user-side functions or steps.

[0115] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to perform the following steps: The system obtains input requirement information through a visual interface, parses the requirement information through a requirement analysis intelligent agent, extracts key information, and generates a structured requirement analysis report. The strategy-transformation agent receives the structured requirements analysis report and generates executable code by combining it with the configuration parameters of the zero-code operation platform. The automated testing agent generates test cases based on the executable code, executes automated tests based on the test cases, and records the test results. When the test result indicates an error, the error information is fed back to the requirement analysis agent or the strategy transformation agent through the result feedback agent for adjustment. When the test result indicates that the test is passed, the executable code is executed to generate a processing result, and the processing result is verified by an accuracy verification agent. The processed results after storage verification are then subjected to multi-level data analysis by a data analysis agent to obtain the data analysis results.

[0116] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, the computer program performing the following steps when executed by a processor: The system obtains input requirement information through a visual interface, parses the requirement information through a requirement analysis intelligent agent, extracts key information, and generates a structured requirement analysis report. The strategy-transformation agent receives the structured requirements analysis report and generates executable code by combining it with the configuration parameters of the zero-code operation platform. The automated testing agent generates test cases based on the executable code, executes automated tests based on the test cases, and records the test results. When the test result indicates an error, the error information is fed back to the requirement analysis agent or the strategy transformation agent through the result feedback agent for adjustment. When the test result indicates that the test is passed, the executable code is executed to generate a processing result, and the processing result is verified by an accuracy verification agent. The processed results after storage verification are then subjected to multi-level data analysis by a data analysis agent to obtain the data analysis results.

[0117] It should be noted that the functions or steps that can be implemented by the computer-readable storage medium or computer device described above can be referred to the relevant descriptions on the server side and user side in the foregoing method embodiments. To avoid repetition, they will not be described one by one here.

[0118] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0119] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

[0120] It should be noted that if any software tools or components not belonging to this company appear in the embodiments of this application, they are merely illustrative examples and do not represent actual use. The embodiments described above are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included within the protection scope of the present invention.

Claims

1. A demand-driven data processing method, characterized in that, Includes the following steps: The system obtains input requirement information through a visual interface, parses the requirement information through a requirement analysis intelligent agent, extracts key information, and generates a structured requirement analysis report. The strategy-transformation agent receives the structured requirements analysis report and generates executable code by combining it with the configuration parameters of the zero-code operation platform. The automated testing agent generates test cases based on the executable code, executes automated tests based on the test cases, and records the test results. When the test result indicates an error, the error information is fed back to the requirement analysis agent or the strategy transformation agent through the result feedback agent for adjustment. When the test result indicates that the test is passed, the executable code is executed to generate a processing result, and the processing result is verified by an accuracy verification agent. The processed results after storage verification are then subjected to multi-level data analysis by a data analysis agent to obtain the data analysis results.

2. The demand-driven data processing method as described in claim 1, characterized in that, The system obtains input requirement information through a visual interface, parses the requirement information through a requirement analysis agent, extracts key information, and generates a structured requirement analysis report, including: Receive requirement information containing strategy descriptions through the visual interface; The demand analysis agent performs semantic parsing on the demand information to obtain the semantic parsing results; The key information includes the strategy logic, triggering conditions, applicable scope, and entity relationships identified from the semantic parsing results. The key information is structured to generate a set of requirement elements; Based on the set of required elements, construct a structured requirements analysis report that includes strategy relationships and strategy hierarchy markers.

3. The demand-driven data processing method as described in claim 1, characterized in that, The strategy transformation agent receives the structured requirements analysis report and generates executable code by combining it with the configuration parameters of the no-code operation platform, including: The structured requirements analysis report is received by the strategy-transformation intelligent agent; The structured requirements analysis report includes strategy information such as strategy logic, triggering conditions, applicable scope, and entity relationships. Call the policy template in the policy template library to match the policy type of the policy information; The policy information is converted into intermediate encoding based on the matched policy template; By combining the configuration parameters of the no-code operation platform, the intermediate code is optimized through structural adjustments and parameter injection; The optimized intermediate code is converted into executable code using a code generation engine.

4. The demand-driven data processing method as described in claim 1, characterized in that, An automated testing agent generates test cases based on the executable code, executes automated tests based on the test cases, and records the test results, including: The execution logic of the executable code is analyzed by an automated testing agent to identify the range of input parameters, and normal input scenarios, boundary input scenarios and abnormal input scenarios are identified based on the range of input parameters. Generate test cases containing input parameters and expected output values ​​for each identified scenario; The executable code is executed using the input parameters to obtain the actual output value; By comparing the difference between the actual output value and the expected output value, deviation information is obtained; Record the test results containing the aforementioned deviation information.

5. The demand-driven data processing method as described in claim 1, characterized in that, When the test result indicates an error, the error information is fed back to the requirements analysis agent or the strategy transformation agent through the result feedback agent for adjustment, including: When the test result indicates an error, the result feedback agent receives the test result containing the deviation information. Analysis of the test results determined that the root cause of the error was either a misunderstanding of the requirements or a coding conversion error. Based on the historical amendment example library, generate correction suggestions corresponding to the root causes of the errors; Generate an adjustment plan that includes the root cause of the error and suggested fixes; Based on the root cause of the error, the adjustment plan is fed back to the demand analysis agent or the strategy transformation agent, triggering the demand analysis agent or the strategy transformation agent to perform the correction operation.

6. The demand-driven data processing method as described in claim 1, characterized in that, When the test result indicates a pass, the executable code is executed to generate a processing result, and the processing result is verified by an accuracy verification agent, including: When the test result indicates that the test is passed, the executable code is executed to generate the processing result. The accuracy of the intelligent agent's receipt of the processing result is verified. The processing results are compared with the historical dataset to generate comparison results. A portion of the processing results is extracted according to a preset sampling ratio for business strategy verification, and verification results are generated. The abnormality level of the processing results is analyzed by validating the model, and anomaly analysis values ​​are generated. When the comparison result, verification result, and anomaly analysis value all meet the preset verification threshold, the processing result is marked as the final result.

7. The demand-driven data processing method as described in claim 1, characterized in that, The processed results after storage verification are subjected to multi-level data analysis by a data analysis agent to obtain the data analysis results, including: The verified processing results are stored through the data storage module. The data analysis agent defines data analysis dimensions, including organizational, time, and indicator dimensions. Receive an instruction to select an analysis dimension, the instruction including a primary dimension, a secondary dimension, and analysis metrics; Based on the defined data analysis dimensions, hierarchical datasets are extracted from the stored processing results according to the primary and secondary dimensions of the selection instructions. Based on the data analysis dimensions, perform data aggregation or drill-down operations along the dimension hierarchy on the hierarchical dataset according to the analysis indicators to generate data analysis results with dimension labels.

8. A demand-driven data processing device, characterized in that, The demand-driven data processing device includes: The requirements analysis module is used to obtain input requirements information through a visual interface, parse the requirements information through a requirements analysis intelligent agent, extract key information, and generate a structured requirements analysis report. The strategy conversion module is used to receive the structured requirements analysis report through the strategy conversion agent and generate executable code by combining the configuration parameters of the zero-code operation platform. The automated testing module is used to generate test cases based on the executable code through an automated testing agent, execute automated tests based on the test cases, and record the test results. The result feedback module is used to feed back the error information to the requirement analysis agent or the strategy transformation agent for adjustment when the test result indicates an error. An accuracy verification module is used to execute the executable code to generate a processing result when the test result indicates that the test is passed, and to verify the processing result through an accuracy verification agent. The data analysis module is used to store the processed results after verification. The data analysis agent performs multi-level data analysis on the stored processed results to obtain the data analysis results.

9. A computer device, characterized in that, The computer device includes a memory, a processor, and a demand-driven data processing program stored in the memory and executable on the processor, wherein the demand-driven data processing program, when executed by the processor, implements the steps of the demand-driven data processing method as described in any one of claims 1-7.

10. A computer-readable storage medium, characterized in that, The storage medium stores a demand-driven data processing program, which, when executed by a processor, implements the steps of the demand-driven data processing method as described in any one of claims 1-7.

Images