Intelligent form processing method based on multi-modal verification and large model feedback

Abstract

The invention provides an intelligent form processing method based on multi-modal verification and large model feedback, and relates to the technical field of artificial intelligence and data processing, and the method comprises the steps: obtaining a corresponding business rule from a relational database through a rule extraction and matching request based on user input data; error verification, service logic verification and cross-field and cross-method verification are carried out on the user input data and the corresponding service rules, and verification results are obtained; based on the verification result, natural language feedback is generated through the large model to provide error prompts and improvement suggestions.

Description

Technical Field

[0001] The present application belongs to the field of artificial intelligence and data processing technology, and specifically relates to an intelligent form processing method based on multimodal verification and large model feedback. Background Art

[0002] As enterprises continue to improve their informatization, business processes like financial reporting and electronic form completion are increasingly reliant on automated systems. Traditionally, after a user submits a form, the system typically validates the input data using hard-coded rules or simple regular expression validation, returning structured error codes. However, with the increasing complexity of business operations, relying solely on single-dimensional validation mechanisms is no longer sufficient to meet the needs of modern enterprise management.

[0003] In recent years, artificial intelligence technologies such as natural language processing (NLP), knowledge graph reasoning, vector database retrieval, and large-scale model-generated feedback have been gradually applied to intelligent auditing and user interaction optimization in business systems. For example, some systems have begun to use semantic models such as BERT to identify user input intent, use graph databases to analyze cross-field logical relationships, and attempt to provide more personalized feedback and suggestions through AI assistants.

[0004] Despite this, the existing technology still has the following significant defects:

[0005] Most systems still use static rule matching for verification, which makes it difficult to deal with complex business logic conflicts, such as cross-field dependencies, multi-document consistency, and other issues. Traditional systems usually report problems in the form of code-level error codes or short prompts, which makes it difficult for users to understand the business logic behind them, and there is a lack of specific modification suggestions. Existing systems generally do not introduce semantic retrieval, historical case matching, and large-model generative feedback mechanisms, resulting in the error correction process still requiring a lot of manual intervention. Front-end verification and back-end business logic are often implemented by different modules, lacking a unified data flow control and rule synchronization mechanism, which makes it easy for "front-end passes and back-end errors" to occur, affecting user experience. Summary of the Invention

[0006] This application provides an intelligent form processing method based on multimodal verification and large model feedback to solve one of the above technical problems.

[0007] The technical solutions adopted in this application are:

[0008] The present application provides an intelligent form processing method based on multimodal verification and large model feedback, including:

[0009] Based on user input data, the corresponding business rules are obtained from the relational database through rule extraction and matching requests;

[0010] Perform error checking, business logic checking, and cross-field and cross-method checking on user input data and corresponding business rules to obtain verification results;

[0011] Based on the verification results, natural language feedback is generated through the large model to provide error prompts and improvement suggestions.

[0012] According to one embodiment of the present application, the corresponding structured rules obtained from the relational database through rule extraction and matching requests based on user input data are specifically:

[0013] The user enters the relevant information of the bill on the front-end interface, and the relevant information includes text, numbers and options;

[0014] Call the built-in rules for preliminary verification and initiate a query request to the relational database to obtain business rules.

[0015] According to one embodiment of the present application, the user input data and the corresponding business rules are subjected to error checking, business logic checking, and cross-field and cross-method checking to obtain a verification result, which is specifically:

[0016] Use regular expressions and SQL constraints to perform real-time verification of user input data and corresponding business rules to generate error prompts;

[0017] The semantic retrieval module is called to vectorize the user input using the BERT or bge-m3 model. The vector database is searched for similar historical tickets and solutions to generate modification suggestions.

[0018] Use knowledge graph reasoning to analyze data matching issues across fields and methods, detect potential conflicts, and provide optimization suggestions;

[0019] The verification results are based on error prompt information, modification suggestions and optimization suggestions.

[0020] According to one embodiment of the present application, the user input data and the corresponding business rules are verified in real time using regular expressions and SQL constraints to generate error prompt information, specifically:

[0021] Call the regular expression verification module to perform real-time verification on the format of each field of user input data, including date fields, amount fields, and required fields;

[0022] If the field format does not conform to the format rules, a format error prompt is generated;

[0023] If the field format complies with the format rules, the verified data is obtained;

[0024] Based on the verified data and the corresponding business rules, SQL constraints are used to compare them. The comparison includes amount range verification, field association verification, and approval process verification.

[0025] If the verified data violates the corresponding business rules, a logical error prompt will be generated;

[0026] Merge format error prompts and logic error prompts to generate error prompt information;

[0027] Error messages are categorized by field, sorted by error type, and prioritized for displaying critical errors.

[0028] According to one embodiment of the present application, the semantic retrieval module is called to vectorize the user input using the BERT or bge-m3 model, and to search the vector database for similar historical work orders and solutions to form modification suggestions, specifically:

[0029] Clean the user input data to generate input text, and encode the input text using the pre-trained BERT model or bge-m3 model;

[0030] After the input text is processed by word segmentation and embedding layers, a vector of fixed dimension is generated;

[0031] Perform L2 normalization on the generated fixed-dimensional vector to generate the semantic vector of the user input;

[0032] Use the cosine similarity or Euclidean distance algorithm to match the semantic vector entered by the user with the historical case vectors in the preset vector database;

[0033] Returns the top-K most similar historical cases, including case descriptions, solutions, and association rules;

[0034] The matching results are sorted according to the similarity score, the cases with the highest similarity are prioritized, and irrelevant or outdated cases are filtered out to generate modification suggestions.

[0035] According to one embodiment of the present application, the use of knowledge graph reasoning to analyze cross-field and cross-method data matching issues, detect potential conflicts, and provide optimization suggestions is specifically as follows:

[0036] Standardize user input data, use a graph database to store entities and relationships, convert business rules into logical constraints in the graph, store common conflicts in historical cases as abnormal patterns in the graph, regularly synchronize the latest business rules and historical cases from the relational database and vector database, and update the knowledge graph to obtain a structured knowledge graph;

[0037] Match the fields in the standardized user-entered data with the entities in the knowledge graph, use the query language of the graph database to analyze the associations between entities, and check whether the user-entered data violates the business rules in the knowledge graph to obtain the matched entity relationships and potential conflict points;

[0038] Use the path search function of the graph database to analyze the propagation path of the conflict, compare the user-entered data with the business rules in the knowledge graph, determine whether there is a violation of business logic, and check whether the user-entered data matches the abnormal patterns pre-stored in the knowledge graph;

[0039] According to the conflict type, the corresponding solution is extracted from the knowledge graph and combined with historical cases in the vector database to generate optimization suggestions.

[0040] According to one embodiment of the present application, based on the verification results, natural language feedback is generated through a large model to provide error prompts and improvement suggestions, specifically:

[0041] Map error messages, modification suggestions, and optimization suggestions into verification results described in natural language to supplement the contextual information of the user-entered data;

[0042] Combine user input data, verification results, and business rules into structured context data;

[0043] Feed structured contextual data into pre-trained large models to generate error warnings and improvement suggestions.

[0044] According to one embodiment of the present application, it further includes:

[0045] Embed static code analysis tools in the front-end to extract verification rules and error code logic in real time and generate structured logs;

[0046] On the back end, the business logic code is parsed through decompilation tools, the function call chain and parameter passing process corresponding to the error prompt are automatically located, and a code logic report is generated.

[0047] A second aspect of the present application provides a computer-readable storage medium having a program stored thereon, which, when executed by a processor, implements the method described in any one of the embodiments of the first aspect.

[0048] An embodiment of the third aspect of the present application provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the method described in any one of the embodiments of the first aspect when executing the program.

[0049] Due to the adoption of the above technical solution, the beneficial effects achieved by this application are as follows:

[0050] This application implements a dynamic rule loading mechanism to ensure that each verification is based on the latest business rules; it improves the system's ability to understand complex business logic and avoids misjudgments due to missing or delayed rules; and provides a standardized, structured, and real-time updated data foundation for subsequent multi-dimensional verification. Format verification ensures the basic legality of input data and prevents invalid data from entering the core process; business logic verification combined with the semantic retrieval module improves the system's understanding and judgment of complex business rules; cross-field and cross-method verification uses the knowledge graph reasoning module to detect logical conflicts in multi-entity associations, effectively preventing common problems such as duplicate reimbursements and inconsistent amounts; multi-level verification mechanisms work together to improve the comprehensiveness and accuracy of error recognition and reduce the missed detection rate.

[0051] This application uses the powerful semantic understanding and generation capabilities of large models to convert technical error messages into natural language descriptions that users can understand; combines historical case libraries with solutions in knowledge graphs to provide users with specific and actionable modification suggestions, improving users' self-correction capabilities; significantly improves the human-computer interaction experience, reduces repeated submissions and manual consultation costs caused by vague prompts; supports personalized feedback generation, adjusts the prompt tone and content depth according to factors such as user roles and historical behaviors, and enhances the humanization of the system. BRIEF DESCRIPTION OF THE DRAWINGS

[0052] The drawings described herein are used to provide a further understanding of the present application and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application and do not constitute an improper limitation on the present application. In the drawings:

[0053] Figure 1 A flowchart of an intelligent form processing method based on multimodal verification and large model feedback provided in an embodiment of the present application;

[0054] Figure 2 A schematic diagram of the structure of an electronic device provided in an embodiment of the present application.

[0055] Reference numerals:

[0056] 810 , processor; 820 , communication interface; 830 , memory; 840 , communication bus. DETAILED DESCRIPTION

[0057] In order to more clearly illustrate the overall concept of the present application, a detailed description is given below in an illustrative manner in conjunction with the accompanying drawings.

[0058] The following description sets forth many specific details to facilitate a thorough understanding of the present application. However, the present application may also be implemented in other ways than those described herein, and therefore, the scope of protection of the present application is not limited by the specific embodiments disclosed below. It should be noted that the embodiments of the present application and the features of each embodiment may be combined with each other unless there is a conflict.

[0059] In this application, unless otherwise expressly specified and limited, a first feature "above" or "below" a second feature may be that the first and second features are in direct contact, or the first and second features are in indirect contact through an intermediate medium. In the description of this specification, the description with reference to the terms "one embodiment", "some embodiments", "example", "specific example", or "some examples" means that the specific features, structures, materials or characteristics described in conjunction with the embodiment or example are included in at least one embodiment or example of the present application. In this specification, the schematic representation of the above terms does not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials or characteristics described may be combined in an appropriate manner in any one or more embodiments or examples.

[0060] Example 1

[0061] like Figure 1 As shown, an intelligent form processing method based on multimodal verification and large model feedback includes:

[0062] S100 , based on user input data, corresponding business rules are obtained from a relational database through rule extraction and matching requests.

[0063] As mentioned above, when users fill out an invoice on the front-end interface, they enter various information, such as date, amount, and expense items. This information forms the basis of the invoice. The system collects this input data and prepares it for subsequent processing and verification.

[0064] Next, the system needs to determine which business rules apply to the current invoice based on the data entered by the user. This step mainly includes the following aspects:

[0065] The system first identifies the key fields involved in the user input, such as the reimbursement amount, expense category, and approver. Based on the identified fields and their values, the system will construct corresponding query conditions. For example, if the user enters a specific expense category (such as travel expenses), the system will construct a query condition to find all business rules related to this expense category. The system sends a query request to the relational database to retrieve all business rules that may apply to the current expense report. These rules typically include but are not limited to:

[0066] Minimum and maximum limits on reimbursement amounts. Permissible ranges or special requirements for specific expense categories. Specific steps and responsible individuals in the approval process. Regulations regarding budget control.

[0067] A relational database stores all business rules within an enterprise. These rules are organized into tables, with each table representing a set of rules (such as reimbursement rules, budgeting rules, etc.). When the system issues a query, the database returns all rules that match the user's input data.

[0068] For example, if the user enters a reimbursement amount of 5,000 yuan and the expense category is travel expenses, the system may obtain the following rules from the database:

[0069] The maximum reimbursement amount for travel expenses is 8,000 yuan. All reimbursements exceeding 3,000 yuan must be approved by the department manager. The total monthly travel expenses for each employee must not exceed 10,000 yuan.

[0070] Once the relevant business rules are captured, the system can apply them to validate the data entered by the user. This process helps ensure that the invoices submitted by users comply with the company's financial policies and operational specifications, thereby reducing errors and improving efficiency.

[0071] In this way, the system not only checks for basic formatting issues (such as whether the date is correct), but also deeply analyzes more complex business logic (such as whether the budget limit has been exceeded), providing more precise feedback to users and helping them quickly correct any potential problems. This approach greatly improves the intelligence of the expense reporting process and reduces the need for manual intervention.

[0072] For example, let's say a company is using an intelligent expense reporting system to process employee travel expense claims. Here are the specific steps and details of the process:

[0073] An employee fills out a new expense report on the front-end interface. The details are as follows:

[0074] Date: May 15, 2025, Amount: RMB 6,500, Expense Item: Travel Expenses, Business Trip Location: Beijing, Approver: Department Manager Wang.

[0075] This information constitutes the basic content of this reimbursement application and is captured by the system for subsequent verification and processing.

[0076] The system needs to determine the business rules applicable to the current expense report based on the information provided by the user. The specific steps are as follows:

[0077] The system first identifies key fields, including the amount (6,500 yuan), expense item (travel expenses), trip location (Beijing), and approver (department manager Wang).

[0078] Based on the identified key fields, the system constructs query conditions to find relevant business rules. For example, for the expense item "travel expenses," the system constructs query conditions to retrieve all business rules related to travel expenses.

[0079] For the Amount field, the system also constructs query conditions to check whether there are rules related to a specific amount range.

[0080] The system sends a query to the relational database to find all possible business rules that may apply to the current expense report. For example, the system might query the following types of rules:

[0081] What is the upper limit for travel expense reimbursement? Are there special reimbursement regulations for specific locations (such as Beijing)? What amount of money requires additional approval?

[0082] A relational database stores all of a company's business rules, organized into tables. When a query is issued, the database returns all the rules that match the user's input. Suppose the database returns the following rules:

[0083] Travel expense reimbursement limit: The reimbursement limit for travel expenses is RMB 8,000.

[0084] Location-Specific Reimbursement Rules:

[0085] If the business trip destination is Beijing and the amount exceeds RMB 5,000, you must provide detailed itinerary and invoice.

[0086] Approval Process:

[0087] All reimbursements exceeding RMB 5,000 must be approved by the department manager.

[0088] The total monthly travel expenses for each employee shall not exceed RMB 15,000.

[0089] Budget Control:

[0090] There is still 7,000 yuan left in the travel expenses budget for the current month.

[0091] The system can now apply these rules to validate user input data:

[0092] Amount check: The system found that the reimbursement amount was 6,500 yuan, which is lower than the upper limit of 8,000 yuan, so there is no problem with the amount.

[0093] Location check: Since the business trip destination is Beijing and the amount exceeds 5,000 yuan, the system prompts the user to provide detailed itinerary and invoice.

[0094] Approval process check: The system confirms that the amount exceeds 5,000 yuan, so it needs to be approved by the department manager Wang.

[0095] Budget control check: The system checks that there is still 7,000 yuan left in the travel expense budget for the current month, and the reimbursement amount is 6,500 yuan, so the budget also meets the requirements.

[0096] Feedback to users

[0097] The system will feed back the above verification results to the user, prompting the user:

[0098] A detailed itinerary and invoice are required (because the business trip is to Beijing and the amount exceeds 5,000 yuan).

[0099] The reimbursement form has been automatically submitted to the department manager Wang for approval (because the amount exceeds 5,000 yuan).

[0100] With sufficient budget, you don't need to worry about exceeding your travel budget for this month.

[0101] In this way, the system not only ensures that user-submitted expense reports comply with the company's financial policies and operational specifications, but also provides clear operational guidance, helping users quickly correct any potential issues. This approach significantly improves the intelligence of the expense reporting process and reduces the need for manual intervention.

[0102] S200: Perform error checking, business logic checking, and cross-field and cross-method checking on the user input data and the corresponding business rules to obtain a verification result.

[0103] As mentioned above, error checking primarily involves validating the basic format of user input, ensuring that all required fields are filled in and that the entered data conforms to predefined formatting requirements. For example, dates must be in the "YYYY-MM-DD" format, amounts must be positive and within a specific range, and certain fields cannot be left blank.

[0104] Business logic validation goes a step further, checking not only the data format but also its rationality according to the company's internal business rules. For example, it checks whether the reimbursement amount exceeds the budget limit, whether the expense item falls within the permitted category, and whether the approval process complies with regulations. This type of validation often involves complex conditional judgments and database queries.

[0105] Cross-field and cross-method validation checks data consistency across multiple related fields or different business modules. For example, it checks whether the total amount of a loan document is consistent with that of multiple reimbursement documents, or whether there are duplicate reimbursements for the same expense in different time periods. This type of validation requires comprehensive consideration of multiple aspects of information and uses methods such as knowledge graph reasoning to identify potential conflicts or inconsistencies.

[0106] Finally, the system will summarize the results of the above three verifications to form a complete verification report, pointing out where the problems exist and giving corresponding modification suggestions.

[0107] For example, suppose an employee submits a travel expense claim with the following information:

[0108] Date: June 1, 2025, Amount: RMB 8,500, Expense Item: Travel Expenses, Travel Location: Shanghai, Approver: Department Manager Li

[0109] The system first checks the basic format:

[0110] The date is in the correct format ("2025-06-01"). The amount is positive and in the correct format ("8500"). All required fields are filled in.

[0111] After this step, the system confirms that the basic format is correct.

[0112] Next, the system performs a logical check based on the company's internal business rules:

[0113] The upper limit for reimbursement of travel expenses is 10,000 yuan, and the current application for 8,500 yuan does not exceed the upper limit.

[0114] The business trip destination is Shanghai. There are no special restrictions, but itinerary and invoices are required.

[0115] The reimbursement amount exceeds 5,000 yuan, so it requires approval from department manager Li.

[0116] There is still 9,000 yuan left in the travel expenses budget for the current month, and the reimbursement amount this time is 8,500 yuan, so the budget is sufficient.

[0117] After business logic verification, the system confirmed that except for the need to provide itinerary and invoice, all other aspects meet the requirements.

[0118] Finally, the system performs cross-field and cross-method validation to ensure data consistency and accuracy:

[0119] The system checked and found that the employee had submitted a travel expense reimbursement claim of 3,000 yuan this month. Together with the 8,500 yuan this time, the total amount was 11,500 yuan, which exceeded the monthly travel expense limit of 15,000 yuan.

[0120] The system also discovered that during the same time period, the employee had a loan order for 4,000 yuan that had not yet been reimbursed. The system prompted the employee to verify the relationship between the loan order and the reimbursement order.

[0121] The system generated the following verification results:

[0122] A detailed itinerary and invoice are required (because the business trip is to Shanghai and the amount exceeds 5,000 yuan).

[0123] Employees are reminded that the cumulative travel expenses this month have reached 11,500 yuan, which is close to the monthly upper limit of 15,000 yuan. Please plan subsequent expenses reasonably.

[0124] It is recommended to check and link the relevant loan documents to ensure the consistency of loans and reimbursements.

[0125] Through this series of verifications, the system not only helps users identify potential problems, but also provides specific improvement suggestions, making the entire reimbursement process more efficient and accurate.

[0126] S300. Based on the verification results, natural language feedback is generated through the large model to provide error prompts and improvement suggestions.

[0127] As mentioned above, after completing error checking, business logic verification, and cross-field and cross-method verification of user input data, the system will generate detailed feedback based on these verification results. This process mainly relies on large models (such as DeepSeek, GPT-4, etc.) to generate easy-to-understand natural language feedback. The specific steps are as follows:

[0128] First, the system organizes and categorizes all verification results. This includes format errors (such as incorrect date format), logical errors (such as reimbursement amounts exceeding the budget limit), and cross-field conflicts (such as duplicate reimbursements within the same time period).

[0129] To make feedback more accurate and relevant, the system builds a complete contextual understanding by combining the user's specific input, verification results, and relevant business rules. For example, the user enters "reimbursement amount is 8,500 yuan," and the verification result shows that this amount exceeds the travel expense budget for this month.

[0130] Next, the system uses a pre-trained large model to process this contextual information and generate natural language error messages and improvement suggestions. The large model can understand complex semantics and generate context-sensitive feedback tailored to human reading habits. For example, if an amount exceeds the budget, the model might generate a suggestion like, "Your reimbursement amount exceeds this month's travel expense budget. Please adjust the amount or submit an additional request."

[0131] The generated feedback may need further optimization to ensure its accuracy and actionability. For example, ensure that all suggestions comply with the company's business rules and provide clear action instructions (such as "click here to modify the amount" or "submit an additional request").

[0132] Finally, the system displays the optimized feedback information to users through the front-end interface to help them quickly understand and correct the problems.

[0133] For example, suppose an employee submits a travel expense claim with the following information:

[0134] Date: June 1, 2025, Amount: RMB 8,500, Expense Item: Travel Expenses, Business Trip Location: Shanghai, Approver: Department Manager Li.

[0135] After a comprehensive system check, the following problems were found:

[0136] The reimbursement amount exceeds the remaining travel expense budget for the current month (7,000 yuan remaining).

[0137] During the same time period, there was another unreimbursed loan order for RMB 4,000, and the relationship needed to be verified.

[0138] A detailed itinerary and invoice are required (because the business trip is to Shanghai and the amount exceeds 5,000 yuan).

[0139] The system uses the large model to generate the following natural language feedback for user reference:

[0140] Error message:

[0141] Your reimbursement amount (8,500 yuan) exceeds the remaining travel budget for the current month (7,000 yuan). Please adjust the reimbursement amount or submit an additional budget request.

[0142] During the same time period, you have an unreimbursed loan order (amount is 4,000 yuan). Please confirm and associate the relationship between this loan order and this reimbursement.

[0143] If the business trip destination is Shanghai and the reimbursement amount exceeds RMB 5,000, please provide detailed itinerary and invoices.

[0144] Improvement suggestions:

[0145] If your actual expenditure is indeed RMB 8,500, please contact the Finance Department to submit an additional budget application and attach the necessary supporting documents.

[0146] Check and ensure that the link between loan documents and reimbursement documents is correct to avoid duplicate reimbursements or omissions.

[0147] Submit detailed travel itinerary and invoices to smooth the reimbursement process.

[0148] In this way, the system not only clearly points out the existing problems, but also provides specific solutions and operation guides, allowing users to easily understand and take quick action, thereby improving the efficiency and accuracy of the entire reimbursement process.

[0149] In some embodiments of the present application, the corresponding structured rules obtained from the relational database through rule extraction and matching requests based on user input data are specifically:

[0150] The user enters the relevant information of the bill on the front-end interface, and the relevant information includes text, numbers and options;

[0151] Call the built-in rules for preliminary verification and initiate a query request to the relational database to obtain business rules.

[0152] In some embodiments of the present application, the error check, business logic check, and cross-field and cross-method check are performed on the user input data and the corresponding business rules to obtain the check results, which are specifically:

[0153] Use regular expressions and SQL constraints to perform real-time verification of user input data and corresponding business rules to generate error prompts;

[0154] The semantic retrieval module is called to vectorize the user input using the BERT or bge-m3 model. The vector database is searched for similar historical tickets and solutions to generate modification suggestions.

[0155] Use knowledge graph reasoning to analyze data matching issues across fields and methods, detect potential conflicts, and provide optimization suggestions;

[0156] The verification results are based on error prompt information, modification suggestions and optimization suggestions.

[0157] As described above, in the technical solution described, the process of validating user input data against corresponding business rules is divided into three main steps: error verification, business logic verification, and cross-field and cross-method verification. Each step has its own specific goals and technical implementation methods, ultimately forming a comprehensive verification result, including error prompts, modification suggestions, and optimization recommendations. The following is a detailed explanation:

[0158] Ensures basic formatting of user input and provides preliminary validation that data conforms to simple predefined rules.

[0159] Regular expressions: Used to check whether the data format of user input is correct. For example, the date must be in the "YYYY-MM-DD" format, the amount must be positive and within a specific range, etc.

[0160] SQL Constraints: Use predefined rules in the relational database (such as amount ranges, required fields, etc.) to perform real-time validation on user input. If any violation of these rules is found, an appropriate error message will be generated.

[0161] Suppose the user enters an invalid date format (e.g., "2025 / 06 / 01" instead of "2025-06-01"). The system will use regular expressions to identify this error and generate an error message: "The date format is invalid. Please enter the format of YYYY-MM-DD."

[0162] In-depth analysis of whether user input data complies with complex business rules and provides specific modification suggestions.

[0163] Suppose a user submits a reimbursement claim for 8,500 yuan, but the current month's travel budget still has 7,000 yuan remaining. The system invokes the semantic search module to search the vector database for similar historical cases. Based on these cases, the system generates a suggestion: "Your reimbursement claim exceeds the remaining travel budget for this month. Please adjust the amount to within 7,000 yuan or submit an additional budget request."

[0164] Check data consistency between multiple related fields or different business modules to ensure there are no potential conflicts or logical errors.

[0165] Knowledge graph reasoning: Utilize graph databases (such as Neo4j) to store the relationships between approval processes, expense items, and business rules. By analyzing the paths of entities and relationships within the graph, potential conflicts can be automatically detected and optimization suggestions can be provided. For example, this can be used to determine whether the total amounts of multiple loan and reimbursement documents are consistent, or whether the same expense has been reimbursed repeatedly over different time periods.

[0166] Generate Optimization Suggestions: Based on detected conflicts, the system generates detailed optimization suggestions to help users correct them. For example, if an employee's loan amount doesn't match their reimbursement amount, the system will recommend reviewing the loan and making adjustments accordingly.

[0167] Suppose a user has an unreimbursed loan order for 4,000 yuan during the same time period, and this time they're reimbursing 8,500 yuan. The system uses knowledge graph reasoning to analyze the relationship between these two amounts, identifying a potential risk of duplicate reimbursement and generating an optimization suggestion: "Please confirm and associate this loan order with this reimbursement to avoid duplicate reimbursement."

[0168] Finally, the system will integrate the results of the above three types of verification to form a complete verification report, which includes the following contents:

[0169] Error messages: Point out any formatting errors and simple rule violations.

[0170] Modification suggestions: Specific improvement suggestions for complex business logic issues.

[0171] Optimization suggestions: Optimization measures proposed for cross-field and cross-method data matching issues.

[0172] Semantic Retrieval Module: This module vectorizes user input using the BERT or bge-m3 model and searches the vector database for similar historical tickets and solutions. This step helps identify complex issues in user input and find similar cases and their solutions.

[0173] Generate modification suggestions: Based on solutions from similar historical cases and the specific circumstances of the current user input, generate targeted modification suggestions. For example, if a user's reimbursement amount exceeds the budget limit, the system can recommend adjusting the amount or submitting an additional application.

[0174] In some embodiments of the present application, the regular expressions and SQL constraints are used to perform real-time verification of user input data and corresponding business rules to generate error prompt information, specifically:

[0175] Call the regular expression verification module to perform real-time verification on the format of each field of user input data, including date fields, amount fields, and required fields;

[0176] If the field format does not conform to the format rules, a format error prompt is generated;

[0177] If the field format complies with the format rules, the verified data is obtained;

[0178] Based on the verified data and the corresponding business rules, SQL constraints are used to compare them. The comparison includes amount range verification, field association verification, and approval process verification.

[0179] If the verified data violates the corresponding business rules, a logical error prompt will be generated;

[0180] Merge format error prompts and logic error prompts to generate error prompt information;

[0181] Error messages are categorized by field, sorted by error type, and prioritized for displaying critical errors.

[0182] As mentioned above, the regular expression validation module is called to ensure that each field entered by the user complies with the predefined format requirements.

[0183] The system first identifies key fields in the user input, including but not limited to date fields, amount fields, and required fields. It then calls the regular expression validation module to perform real-time validation on the formats of these fields. For example:

[0184] Date field: Check whether it conforms to the "YYYY-MM-DD" format.

[0185] Amount field: Check whether it is a legal number and is within a reasonable range (for example, it does not contain negative numbers or excessively large values).

[0186] Required fields: Check for empty or missing values.

[0187] If the field format does not comply with the rules, a corresponding format error prompt will be generated.

[0188] For each field, if its format is found not to conform to the predefined rules, the corresponding error information is recorded.

[0189] Generate specific format error prompts based on detected errors, for example, "Date format is incorrect, please enter in YYYY-MM-DD format" or "Amount must be a positive number."

[0190] Confirm that the data is in the correct format and prepare for further business logic verification.

[0191] Data screening: All fields that pass format validation are marked as validated data.

[0192] Data preparation: Organize and prepare this data for subsequent business logic verification.

[0193] Based on the verified data and the corresponding business rules, SQL constraints are used to compare them to ensure that the verified data is not only formatted correctly but also complies with the company's business rules.

[0194] Based on the validated data, the system extracts the corresponding business rules from the relational database. These rules may include:

[0195] Amount range check: Check whether the amount is within the allowed range (such as not exceeding the budget limit).

[0196] Field association verification: Verify the logical relationship between related fields (such as the consistency of the amount on the loan form and the reimbursement form).

[0197] Approval process verification: Confirm whether the current operation complies with the preset approval process (for example, if the amount exceeds a certain limit, it must be approved by the department manager).

[0198] If the verified data violates the business rules, a corresponding logical error prompt will be generated.

[0199] For each business rule, if it is found that the verified data violates the rule, the corresponding error information will be recorded.

[0200] Generate specific logical error prompts based on detected errors, such as "The reimbursement amount exceeds the budget limit, please adjust the amount" or "This expense item requires approval from a higher level."

[0201] Integrate all generated error prompt information into a complete error report.

[0202] Merge prompts: Merge format error prompts and logic error prompts into a comprehensive error prompt information list.

[0203] Classification and organization: Classify error prompts according to fields to ensure that errors related to each field are displayed together.

[0204] Sorting priority: Sort prompts according to the importance of error types, and display critical errors first (such as amount exceeding budget, etc.) so that users can quickly focus on the most important issues.

[0205] Error prompt information is classified by field, and critical errors are sorted and displayed first according to the error type, ensuring that the error prompt information is presented to users clearly and orderly, making it easy to understand and correct.

[0206] Error messages are displayed by field category, allowing users to see at a glance which fields have problems.

[0207] Sort alerts by severity and impact of errors, ensuring the most critical issues are displayed first. For example, errors indicating budget exceeded will be displayed before formatting errors.

[0208] Highlights the most critical errors that require immediate attention, helping users quickly locate and correct problems.

[0209] Through these steps, the system not only ensures that user-entered data is formatted correctly, but also conducts in-depth analysis to determine if the data complies with complex business rules and provides detailed error messages. This approach significantly improves the intelligence of the reimbursement process, reduces the need for manual intervention, and enhances the user experience.

[0210] In some embodiments of the present application, the semantic retrieval module is called to vectorize the user input using the BERT or bge-m3 model, and to search the vector database for similar historical work orders and solutions to form modification suggestions, specifically:

[0211] Clean the user input data to generate input text, and encode the input text using the pre-trained BERT model or bge-m3 model;

[0212] After the input text is processed by word segmentation and embedding layers, a vector of fixed dimension is generated;

[0213] Perform L2 normalization on the generated fixed-dimensional vector to generate the semantic vector of the user input;

[0214] Use the cosine similarity or Euclidean distance algorithm to match the semantic vector entered by the user with the historical case vectors in the preset vector database;

[0215] Returns the top-K most similar historical cases, including case descriptions, solutions, and association rules;

[0216] The matching results are sorted according to the similarity score, the cases with the highest similarity are prioritized, and irrelevant or outdated cases are filtered out to generate modification suggestions.

[0217] As described above, the data input by the user is cleaned to generate input text, ensuring that the data input by the user is clean and standardized for subsequent processing.

[0218] Preprocess the user-entered data, including removing unnecessary punctuation, unifying capitalization, and handling spaces. The cleaned data is converted into a standard text format suitable for model processing. For example, information such as date fields and amount fields can be consolidated into a descriptive text to facilitate subsequent semantic analysis.

[0219] Use the pre-trained BERT model or bge-m3 model to encode the input text and convert the user input text into a high-dimensional vector representation to facilitate similarity calculation in the vector space.

[0220] Use a pre-trained model (such as BERT or bge-m3) to tokenize the input text, breaking it down into a series of meaningful vocabulary units. Each vocabulary unit is mapped into a fixed-dimensional vector space through the model's embedding layer. This process leverages the vocabulary representation capabilities learned during the model's pre-training phase. The result is a fixed-dimensional vector representing the entire input text, which captures the semantic information of the input text.

[0221] After the input text is processed by the word segmentation and embedding layers, a fixed-dimensional vector is generated to ensure that the generated vector has a fixed dimension, which is convenient for comparison and matching in subsequent steps.

[0222] The model's word segmentation and embedding layers generate a fixed-length vector, typically 768 dimensions or higher, depending on the model architecture used. This vector not only contains the vocabulary information in the input text, but also implies the semantic relationship between them, allowing different texts to measure similarity through vector distance.

[0223] Perform L2 normalization on the generated fixed-dimensional vector to generate the semantic vector of the user input, ensuring that the length of the vector is consistent, which is convenient for comparison using cosine similarity or other distance measurement methods.

[0224] The generated vector is L2 normalized, adjusting its modulus to 1. This helps eliminate differences in vector scales and makes similarity calculations more accurate. The normalized vector becomes the semantic vector of the user input, which can be effectively compared with other vectors in the vector space.

[0225] Using cosine similarity or Euclidean distance algorithm, the semantic vector input by the user is matched with the historical case vector in the preset vector database, and the historical case most similar to the user input is found in the vector database to provide relevant solutions and suggestions.

[0226] Using algorithms such as cosine similarity or Euclidean distance, the system calculates the similarity score between the semantic vector entered by the user and the historical case vectors stored in the vector database. Based on the calculated similarity score, the system searches the vector database for historical cases most similar to the user input and returns the top-K most similar results.

[0227] Returns the top-K most similar historical cases, including case descriptions, solutions, and association rules, to provide users with specific reference cases and their solutions, helping them understand and correct current problems.

[0228] Based on the similarity score, the top-K most relevant historical cases are selected. These cases typically include detailed descriptions, solutions, and related business rules. Key information is extracted from these selected historical cases, including the case description, recommended solutions, and possible related rules.

[0229] Matching results are sorted according to similarity scores, with the cases with the highest similarity being prioritized. Irrelevant or outdated cases are filtered out to generate modification suggestions, ensuring that the provided modification suggestions are the most relevant and up-to-date, thereby improving the user's modification efficiency.

[0230] The matching results are sorted according to the similarity score, and the cases with the highest similarity are displayed first.

[0231] Remove irrelevant or outdated cases to ensure that the modification suggestions presented to users are accurate and practical.

[0232] Based on the best matching cases screened out, specific modification suggestions are generated to guide users on how to correct the current problems.

[0233] Through the above steps, the system can effectively use semantic retrieval technology to compare the data entered by users with historical cases and generate highly relevant modification suggestions, thereby significantly improving the user experience and reducing the need for manual intervention.

[0234] In some embodiments of the present application, the use of knowledge graph reasoning to analyze cross-field and cross-method data matching problems, detect potential conflicts, and provide optimization suggestions is specifically as follows:

[0235] Standardize user input data, use a graph database to store entities and relationships, convert business rules into logical constraints in the graph, store common conflicts in historical cases as abnormal patterns in the graph, regularly synchronize the latest business rules and historical cases from the relational database and vector database, and update the knowledge graph to obtain a structured knowledge graph;

[0236] Match the fields in the standardized user-entered data with the entities in the knowledge graph, use the query language of the graph database to analyze the associations between entities, and check whether the user-entered data violates the business rules in the knowledge graph to obtain the matched entity relationships and potential conflict points;

[0237] Use the path search function of the graph database to analyze the propagation path of the conflict, compare the user-entered data with the business rules in the knowledge graph, determine whether there is a violation of business logic, and check whether the user-entered data matches the abnormal patterns pre-stored in the knowledge graph;

[0238] According to the conflict type, the corresponding solution is extracted from the knowledge graph and combined with historical cases in the vector database to generate optimization suggestions.

[0239] As mentioned above, when the user fills out the invoice on the front end, the system will collect the original data entered by the user (such as date, amount, expense items, loan order number, etc.).

[0240] The system cleans and formats this data to ensure consistency with the entity names, attributes, and relationships in the knowledge graph.

[0241] Graph databases (such as Neo4j or JanusGraph) are used to build knowledge graphs, where:

[0242] Node (Entity): represents an object in the real world, such as "reimbursement form", "loan form", "budget", "approver", etc.

[0243] Edge (Relationship): Represents the association between entities, such as "Reimbursement Form → Association → Loan Form", "Budget → Limit → Reimbursement Amount", etc.

[0244] All business rules, process logic, permission settings, etc. are modeled as part of the graph structure.

[0245] Convert business rules into logical constraints in the diagram

[0246] For example, "the reimbursement amount must not exceed the budget limit" will be expressed as a constraint path or query rule in a graph;

[0247] For example, "reimbursement forms must be associated with loan forms" enforces the existence of a certain type of edge connecting two nodes through the graph structure.

[0248] Typical errors that occurred in the past (such as "the total amount of multiple loan orders exceeds the budget") are abstracted into "abnormal subgraph patterns" in the graph as templates for future conflict identification.

[0249] The system synchronizes the latest business rules (such as new budget configurations and approval level adjustments) from the relational database;

[0250] At the same time, newly generated historical work orders and solutions are also obtained from the vector database;

[0251] This information will be converted into a graph structure and injected into the knowledge graph to maintain the real-time and integrity of the graph model.

[0252] The system maps the standardized user input fields to the corresponding entities in the knowledge graph. For example:

[0253] Reimbursement form number → "Reimbursement Form" node in the diagram

[0254] Loan order number → "Loan order" node in the diagram

[0255] Expense Category → "Budget Category" node in the diagram

[0256] Using a graph query language such as Cypher, the system can perform complex path finding, such as:

[0257] MATCH (r: Reimbursement Form)-[: Association]->(b: Loan Form)

[0258] WHERE.amount>b.amount

[0259] RETURN r,b

[0260] The above statement can detect the situation where "the reimbursement amount is greater than the loan amount", which is a potential conflict.

[0261] The system will traverse the graph path involved in the user input and compare it with the business rules preset in the graph.

[0262] If any situation is found in the path that does not comply with the rules (such as missing necessary approval nodes, amount exceeds the limit, loan order is not associated, etc.), it will be marked as a conflict point.

[0263] The system will also compare the graph structure currently input by the user with the “abnormal subgraph pattern” stored in the knowledge graph.

[0264] If similar structures are found, it is judged as a known type of conflict and the corresponding repair mechanism is triggered.

[0265] Each conflict type may be associated with one or more resolution nodes in the knowledge graph.

[0266] For example, if it is detected that the "reimbursement amount exceeds the budget", the knowledge graph may link solution paths such as "adjust the amount" and "submit a budget increase application".

[0267] The system also calls historical work orders in the vector database to find past cases and their solutions that are highly similar to the current conflict.

[0268] These cases may contain more specific operational instructions or manual processing experience.

[0269] The system integrates the solutions extracted from the graph with historical cases in the vector database to form specific and actionable natural language feedback.

[0270] For example:

[0271] "Your reimbursement amount exceeds the budget limit. Please adjust it to within the budget."

[0272] "You have not yet linked the loan order. Please add relevant information before submitting."

[0273] This technical solution builds and maintains a structured knowledge graph, enabling deep understanding and logical reasoning of user input data. It not only identifies simple field errors but also analyzes complex logical conflicts across fields and business modules, automatically matching solutions from historical cases to generate clear and precise optimization recommendations.

[0274] This graph-based intelligent verification method significantly improves the system's understanding and decision-making capabilities, and is suitable for scenarios that require strong logical verification and complex rule management (such as financial reporting, contract review, risk control, etc.).

[0275] In some embodiments of the present application, based on the verification results, natural language feedback is generated by a large model to provide error prompts and improvement suggestions, specifically:

[0276] Map error messages, modification suggestions, and optimization suggestions into verification results described in natural language to supplement the contextual information of the user-entered data;

[0277] Combine user input data, verification results, and business rules into structured context data;

[0278] Feed structured contextual data into pre-trained large models to generate error warnings and improvement suggestions.

[0279] As mentioned above, the system will obtain three types of key information after completing the following three types of verification:

[0280] Format error prompt: such as incorrect date format, non-numeric amount, etc.

[0281] Business logic modification suggestions: such as reimbursement amounts exceeding the budget limit, expense item mismatch, etc.

[0282] Cross-field / method optimization suggestions: such as the amount on the loan form and the reimbursement form not matching, missing approval process, etc.

[0283] This information originally existed in the form of structured data (such as JSON) or code-level status codes and could not be directly understood by users.

[0284] To facilitate user understanding and operation, the system converts the above three types of information into readable natural language expressions. For example:

[0285] Convert "Amount field violates SQL constraint" to: "The reimbursement amount exceeds the budget limit. Please adjust the amount."

[0286] Convert "Path analysis found conflict mode" to: "The current reimbursement form is not associated with the loan form. Please provide relevant information."

[0287] This process typically involves:

[0288] Field name escape: Translate the field name in the database (such as amount) into Chinese expressions familiar to users (such as "reimbursement amount").

[0289] Semanticization of rules: Convert abstract business rules (such as "the amount must be less than or equal to the budget balance") into specific statements (such as "Your reimbursement amount exceeds the current budget balance, please adjust it to the available amount").

[0290] In order for the large model to generate accurate and contextually appropriate feedback, the system must also expand the original data entered by the user and add relevant contextual information. This includes:

[0291] Specific values ​​filled in by the user (such as amount, date, expense category, etc.);

[0292] The business stage of the reimbursement (e.g., initial submission, modification after approval rejection, etc.);

[0293] The current user's permission role (such as ordinary employee, department manager, etc.);

[0294] Time dimension information such as current time, month, budget cycle, etc.

[0295] This contextual information helps the model understand the context in which the problem occurred, thereby generating more targeted feedback. For example, when generating recommendations, it can consider:

[0296] Is the budget deadline approaching?

[0297] Are there any similar historical cases for reference?

[0298] Is it necessary to remind users to perform additional operations (such as uploading attachments or contacting approvers)?

[0299] The system combines the following types of information into a unified structured data object (such as JSON format) as input for subsequent large model processing:

[0300] User input data: field values ​​of the original invoice;

[0301] Verification results: including format errors, logical errors, graph conflicts, etc.

[0302] Related business rules: budget constraints, approval processes, field dependencies, etc.

[0303] Contextual information: time, role, historical behavior, etc. as mentioned above.

[0304] This structured data usually has clear hierarchies and labels, making it easier for large models to identify and extract key information.

[0305] To ensure that the large model can stably process various requests, the system will standardize the input data, such as:

[0306] Unified field naming conventions;

[0307] Canonical error type identifier;

[0308] Unified encoding processing for multi-language support.

[0309] The system inputs the above structured context data into a pre-trained large model with strong language understanding and generation capabilities (such as the GPT series, DeepSeek, Tongyi Qianwen, etc.). This model has the following capabilities:

[0310] Understand complex business semantics;

[0311] Automatically generate grammatically and logically natural language text based on input content;

[0312] Maintaining contextual coherence across multiple conversations;

[0313] Supports multi-language output (if necessary).

[0314] The large model automatically performs the following tasks based on the input contextual data:

[0315] Summarize error messages: summarize and organize all error prompts to avoid duplication or redundancy;

[0316] Explain the reason: Explain the reason behind each error to help users understand why the error needs to be corrected.

[0317] Provide operational guidance: Give clear modification steps or operational suggestions, such as: "Please adjust the amount to within 6,000 yuan", "Click here to upload your itinerary";

[0318] Recommended best practices: Combine historical cases and solutions in the knowledge graph to recommend better reporting methods.

[0319] The generated content is also processed as follows to improve usability:

[0320] Style control: Choose a formal or friendly tone depending on the context;

[0321] Unified terminology: ensure the use of a common terminology system within the enterprise;

[0322] Sensitive word filtering: prevents the generation of inappropriate or misleading content;

[0323] Format beautification: Display feedback content in a structured manner, such as point-by-point prompts, highlighting key fields, etc.

[0324] This technical solution combines structured validation results with rich contextual information and leverages the language generation capabilities of large models to transform technical error prompts into user-friendly feedback. This mechanism not only improves the intelligence of the system but also significantly enhances the user experience, allowing users to more quickly and accurately understand the problem and make effective corrections.

[0325] The entire process reflects the advantages of the deep integration of artificial intelligence and business rules, and is applicable to multiple complex business scenarios such as financial auditing, contract review, and data entry.

[0326] In some embodiments of the present application, further comprising:

[0327] Embed static code analysis tools in the front-end to extract verification rules and error code logic in real time and generate structured logs;

[0328] On the back end, the business logic code is parsed through decompilation tools, the function call chain and parameter passing process corresponding to the error prompt are automatically located, and a code logic report is generated.

[0329] As mentioned above, when the user operates the front-end interface (such as filling out a bill), the system will embed a static code analysis module in the front-end.

[0330] This module does not rely on the behavior of the program at runtime, but instead scans and analyzes the front-end logic before the code is loaded or executed.

[0331] The system will identify and extract the code logic used to validate user input in the front-end, for example:

[0332] Regular expression verification (such as date format, amount format, etc.);

[0333] Conditional judgment statements (such as whether a field is empty, whether the value range is legal);

[0334] The triggering mechanism of error prompts (such as pop-up windows, highlighted fields, and binding logic of prompt text).

[0335] These logics will be recorded in a structured manner as the basis for subsequent debugging and problem tracking.

[0336] All extracted validation rules and error prompt logic will be recorded as logs in a structured JSON format.

[0337] These logs contain not only the rules content, but may also include:

[0338] Trigger conditions (such as triggering after the user enters a certain value);

[0339] The content and display method of the prompt information;

[0340] The names of the involved fields and the corresponding event listeners.

[0341] The front-end validation logic is made transparent, making it easier for developers to quickly understand the validation behavior of the current page;

[0342] Supports quick identification of problems when they occur, whether they are caused by the front-end verification logic itself or the back-end processing flow;

[0343] It can be used to build a unified front-end and back-end verification consistency comparison system to prevent invalid requests from entering the back-end due to missing or incorrect front-end verification.

[0344] Backend services are usually deployed with compiled bytecode or intermediate language code (such as Java class files and .NET DLL files). The original source code may not exist in the online environment.

[0345] In order to deeply understand the real business logic path behind the error prompt, the system uses decompilation tools (such as JD-GUI, CFR, dotPeek, etc.) to restore the compiled code into a more readable pseudo source code.

[0346] After the user submits the data, if the system returns an error message (such as "the reimbursement amount exceeds the budget"), the system can use the decompilation results to reversely find out how this error message is generated in the back-end code.

[0347] The specific process includes:

[0348] Locate the code location where the prompt information is output (such as an exception throwing point or log printing point);

[0349] Trace back the function call chain at that location, that is, all method calls from the interface entry to the final prompt generation;

[0350] Analyze the key logic involved in each step of the call, including parameter passing, condition judgment, database query, etc.

[0351] The system also analyzes the parameter flow of each node in the function call chain and records:

[0352] How user-entered data is received, converted, and validated;

[0353] The changing process of intermediate variables;

[0354] Database query conditions and their return results;

[0355] The key judgment condition that ultimately determines whether to throw an error prompt.

[0356] All the above analysis results will be integrated into a code logic report, which includes:

[0357] The source code segment of the error message;

[0358] Function call stack and parameter change process;

[0359] The business logic branches and judgment conditions involved;

[0360] There may be logic loopholes or boundary conditions that are not covered.

[0361] Help developers quickly locate the real logic path behind the error prompts;

[0362] Improve system debugging efficiency and reduce the time cost of manually checking code line by line;

[0363] Helps to discover problems such as inconsistent verification logic between the front-end and back-end, and missing boundary conditions;

[0364] Provide a basis for automated testing and regression testing, and improve the stability and maintainability of the system.

[0365] This technical solution combines front-end static code analysis with back-end decompilation logic tracing to achieve logical visibility and traceability throughout the entire process, from front-end input to back-end processing. This not only enhances the system's diagnostic capabilities when errors occur, but also provides strong technical support for front-end and back-end collaborative development, automated testing, and system optimization.

[0366] A second aspect of the present application provides a computer-readable storage medium having a program stored thereon, which, when executed by a processor, implements the method described in any one of the embodiments of the first aspect.

[0367] An embodiment of a third aspect of the present application provides an electronic device, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the method of any one of the embodiments of the second aspect when executing the program.

[0368] Figure 2 An example of a physical structure diagram of an electronic device is shown below. Figure 2 As shown, the electronic device may include: a processor 810, a communication interface 820, a memory 830, and a communication bus 840, wherein the processor 810, the communication interface 820, and the memory 830 communicate with each other via the communication bus 840. The processor 810 may call the logic instructions in the memory 830 to execute the method in any embodiment of the first aspect above, the method including:

[0369] Based on user input data, the corresponding business rules are obtained from the relational database through rule extraction and matching requests;

[0370] Perform error checking, business logic checking, and cross-field and cross-method checking on user input data and corresponding business rules to obtain verification results;

[0371] Based on the verification results, natural language feedback is generated through the large model to provide error prompts and improvement suggestions.

[0372] In addition, the logic instructions in the above-mentioned memory 830 can be implemented in the form of a software functional unit and can be stored in a computer-readable storage medium when sold or used as an independent product. Based on this understanding, the technical solution of the present invention, or the part that contributes to the prior art, or the part of the technical solution, can be embodied in the form of a software product. The computer software product is stored in a storage medium and includes several instructions for enabling a computer device (which can be a personal computer, server, or network device, etc.) to perform all or part of the steps of the method described in each embodiment of the present invention. The aforementioned storage medium includes: various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0373] Anything not described in this application can be achieved by adopting or drawing on existing technologies.

[0374] The various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referred to each other. Each embodiment focuses on the differences from other embodiments.

[0375] The foregoing is merely an embodiment of the present application and is not intended to limit the present application. For those skilled in the art, the present application may have various changes and variations. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present application should all be included within the scope of the claims of the present application.

Claims

1. An intelligent form processing method based on multimodal verification and large model feedback, characterized in that: include: Based on user input data, the corresponding business rules are obtained from the relational database through rule extraction and matching requests; Perform error checking, business logic checking, and cross-field and cross-method checking on user input data and corresponding business rules to obtain verification results; Based on the verification results, natural language feedback is generated through the large model to provide error prompts and improvement suggestions.

2. The method according to claim 1, characterized in that The corresponding structured rules obtained from the relational database through rule extraction and matching requests based on user input data are specifically: The user enters the relevant information of the bill on the front-end interface, and the relevant information includes text, numbers and options; Call the built-in rules for preliminary verification and initiate a query request to the relational database to obtain business rules.

3. The method according to claim 1, characterized in that The error check, business logic check, and cross-field and cross-method check of the user input data and the corresponding business rules are performed to obtain the check results, which are specifically: Use regular expressions and SQL constraints to perform real-time verification of user input data and corresponding business rules to generate error prompts; The semantic retrieval module is called to vectorize the user input using the BERT or bge-m3 model. The vector database is searched for similar historical tickets and solutions to generate modification suggestions. Use knowledge graph reasoning to analyze data matching issues across fields and methods, detect potential conflicts, and provide optimization suggestions; The verification results are based on error prompt information, modification suggestions and optimization suggestions.

4. The method according to claim 3, characterized in that The regular expressions and SQL constraints are used to perform real-time verification on user input data and corresponding business rules to generate error prompt information, specifically: Call the regular expression verification module to perform real-time verification on the format of each field of user input data, including date fields, amount fields, and required fields; If the field format does not conform to the format rules, a format error prompt is generated; If the field format complies with the format rules, the verified data is obtained; Based on the verified data and the corresponding business rules, SQL constraints are used to compare them. The comparison includes amount range verification, field association verification, and approval process verification. If the verified data violates the corresponding business rules, a logical error prompt will be generated; Merge format error prompts and logic error prompts to generate error prompt information; Error messages are categorized by field, sorted by error type, and prioritized for displaying critical errors.

5. The method according to claim 3, characterized in that The semantic retrieval module is called to vectorize the user input using the BERT or bge-m3 model, and the vector database is searched for similar historical work orders and solutions to generate modification suggestions. Specifically: Clean the user input data to generate input text, and encode the input text using the pre-trained BERT model or bge-m3 model; After the input text is processed by word segmentation and embedding layers, a vector of fixed dimension is generated; Perform L2 normalization on the generated fixed-dimensional vector to generate the semantic vector of the user input; Use the cosine similarity or Euclidean distance algorithm to match the semantic vector entered by the user with the historical case vectors in the preset vector database; Returns the top-K most similar historical cases, including case descriptions, solutions, and association rules; The matching results are sorted according to the similarity score, the cases with the highest similarity are prioritized, and irrelevant or outdated cases are filtered out to generate modification suggestions.

6. The method according to claim 3, characterized in that The use of knowledge graph reasoning to analyze cross-field and cross-method data matching issues, detect potential conflicts, and provide optimization suggestions, specifically: Standardize user input data, use a graph database to store entities and relationships, convert business rules into logical constraints in the graph, store common conflicts in historical cases as abnormal patterns in the graph, regularly synchronize the latest business rules and historical cases from the relational database and vector database, and update the knowledge graph to obtain a structured knowledge graph; Match the fields in the standardized user-entered data with the entities in the knowledge graph, use the query language of the graph database to analyze the associations between entities, and check whether the user-entered data violates the business rules in the knowledge graph to obtain the matched entity relationships and potential conflict points; Use the path search function of the graph database to analyze the propagation path of the conflict, compare the user-entered data with the business rules in the knowledge graph, determine whether there is a violation of business logic, and check whether the user-entered data matches the abnormal patterns pre-stored in the knowledge graph; According to the conflict type, the corresponding solution is extracted from the knowledge graph and combined with historical cases in the vector database to generate optimization suggestions.

7. The method according to claim 1, characterized in that Based on the verification results, the large model generates natural language feedback to provide error prompts and improvement suggestions, specifically: Map error messages, modification suggestions, and optimization suggestions into verification results described in natural language to supplement the contextual information of the user-entered data; Combine user input data, verification results, and business rules into structured context data; Feed structured contextual data into pre-trained large models to generate error warnings and improvement suggestions.

8. The method according to claim 1, characterized in that Also includes: Embed static code analysis tools in the front-end to extract verification rules and error code logic in real time and generate structured logs; On the back end, the business logic code is parsed through decompilation tools, the function call chain and parameter passing process corresponding to the error prompt are automatically located, and a code logic report is generated.

9. A computer-readable storage medium having a program stored thereon, characterized in that: When the program is executed by a processor, the steps in the method according to any one of claims 1 to 8 are implemented.

10. An electronic device comprising a memory, a processor, and a program stored in the memory and executable on the processor, wherein: When the processor executes the program, the steps in the method according to any one of claims 1 to 8 are implemented.

Images