Information processing method based on multi-agent cooperation, client interaction method

Abstract

This application discloses a multi-agent collaborative information processing method and a client interaction method. The former includes: requirement parsing and solution generation: receiving user natural language requirements, parsing the requirement intent, and generating a structured collection plan; dynamic interactive collection: driving multi-round question answering based on the structured collection plan, extracting and verifying structured data, with the verification process including runtime constraint verification and anti-deadlock control; automated analysis and report generation: cleaning structured data, statistically aggregating and aggregating the cleaned data, and generating an analysis report; knowledge base construction: distilling knowledge triples from structured data, deduplicating and merging them, and writing them into the knowledge base; and feedback optimization: obtaining performance indicators for dynamic interactive collection, calculating rewards for each branch, and generating weights based on reward-updated plans. This method embeds deterministic verification and anti-deadlock mechanisms into the collection process, significantly reducing the field illusion rate, ensuring process controllability, and enabling system self-evolution through feedback optimization.

Description

Technical Field

[0001] This application relates to the field of artificial intelligence technology, and in particular to a method and system for information collection, processing and knowledge management based on multi-agent collaboration. Background Technology

[0002] With the rapid development of Large Language Model (LLM) technology, conversational information collection systems based on LLM have gradually emerged. However, existing technical solutions generally suffer from the following problems: (1) Uncontrollable data quality: Pure LLM-driven dialogue is prone to "field illusion", that is, generating false information that does not conform to the preset format or logic, resulting in low compliance rate of structured data. (2) Process deadlock: LLM is prone to getting stuck in a dead loop of "infinite questioning" or "repackaging" in dialogue, resulting in uncontrolled collection rounds, poor user experience, and uncontrollable costs. (3) Data cannot be reused: The unstructured data collected needs to be manually cleaned, encoded, and analyzed afterward before it can be precipitated into reusable knowledge, resulting in a fragmented process and low efficiency. (4) The system has no self-evolution capability: Existing systems are mostly one-time tasks and cannot learn and improve from historical tasks, so the quality of solution generation cannot increase with the number of uses. Therefore, there is an urgent need for an information processing method and system that can solve the above problems, with a closed-loop end-to-end and self-optimizable capability. Summary of the Invention

[0003] To address the aforementioned technical problems, this application proposes an information processing method based on multi-agent cooperation, applied to an information processing server, comprising:

[0004] Requirements analysis and solution generation steps: Receive user natural language requirements, analyze the intent of the requirements, and generate a structured data collection solution;

[0005] Dynamic interactive data collection steps: Drive multiple rounds of question and answer according to the structured data collection scheme, extract and verify structured data, wherein the extraction and verification process includes runtime constraint verification and anti-deadlock control;

[0006] Automated analysis and report generation steps: Clean the structured data, statistically aggregate the cleaned data, and generate an analysis report;

[0007] Knowledge base construction steps: Distill the structured data to obtain knowledge triples, deduplicate and merge the knowledge triples, and write them into the knowledge base;

[0008] Feedback optimization steps: Obtain performance indicators of the dynamic interactive data collection process, calculate the rewards for each branch, and generate weights based on the reward update scheme.

[0009] It solves the problems of uncontrollable data quality, easy process deadlock, and inability to learn from historical tasks caused by the lack of runtime constraints in existing solutions; Technical effect: By embedding deterministic verification and anti-deadlock mechanism into the collection process, the field illusion rate is significantly reduced, the process is ensured to be controllable, and the system self-evolution is achieved through feedback optimization.

[0010] Furthermore, the dynamic interactive acquisition step includes:

[0011] Contract constraints and round-by-round validation sub-steps: Load a data contract for each topic node of the decision tree. The data contract defines the field type, the set of legal values, the threshold, and the exit strategy. After extracting the field increment in each round, perform legal value validation on the enumerated type fields. Illegal field values ​​are prohibited from being written into the data structure.

[0012] Anti-stalemate gate sub-step: At least three independent gates are executed sequentially during the acquisition process. If any gate is triggered, the process is forced to proceed to the next topic node.

[0013] It solves the problems of high field illusion rate and uncontrollable quality and cost due to endless follow-up questions in the pure LLM solution; Technical effect: field illusion rate is reduced by 90%, structured compliance rate reaches 100%, and the round has a clear upper bound to avoid cost runaway.

[0014] Furthermore, the feedback optimization step includes:

[0015] Performance data collection sub-step: Collect completion rate, follow-up effective conversion rate, and respondent bounce rate for each branch of the decision tree as performance indicators;

[0016] Reward calculation sub-step: The performance indicators are weighted and linearly combined into branch rewards;

[0017] Weight update sub-step: Using the global branch reward average as the baseline, increase the recommendation weight of high-quality branches that are above the baseline with an exponential factor, decrease the recommendation weight of inefficient branches that are below the baseline with an exponential factor, and eliminate persistently inefficient branches.

[0018] This solves the problem that solution generation cannot learn and improve from historical tasks; technical effect: the system has the ability to evolve autonomously, the quality of solution generation increases with the number of times it is used, and inefficient strategies are automatically eliminated.

[0019] Furthermore, the weight update sub-step includes:

[0020] Sampling probability mapping sub-step: When generating a new decision tree, the recommendation weights of each branch are converted into sampling probabilities through Boltzmann mapping, where the temperature parameter T controls the balance between exploration and utilization;

[0021] Natural elimination sub-step: For inefficient branches whose rewards are lower than the global baseline for j consecutive rounds, their weights decay geometrically toward 0, and the corresponding generation probability approaches 0, thus achieving natural elimination of the branch, where j is a preset positive integer.

[0022] This solves the problem that simple linear weight updates cannot achieve exploration-exploitation balance and cannot automatically eliminate ineffective strategies. Technical benefits: Through Boltzmann mapping and geometrical decay, the system can more intelligently balance exploring new strategies with utilizing known efficient strategies, and automatically eliminate inefficient branches, improving self-optimization efficiency.

[0023] Furthermore, the anti-stalemate gate sub-step includes:

[0024] Round limit detection sub-step: Detect whether the number of question-and-answer rounds in the current node has reached the preset hard limit of rounds;

[0025] The continuous no-progress detection sub-step: detects whether no new field increments have been extracted within a consecutive preset number of rounds;

[0026] 3-gram duplicate detection sub-step: Based on character-level 3-gram Jaccard similarity, detect user answers for a preset number of consecutive rounds. When the similarity exceeds a preset threshold, it is determined to be a duplicate answer.

[0027] It solves the problems of dialogue deadlock and cost overrun that are common in pure LLM solutions, such as "endless follow-up questions" and "repackaging and restating". Technical effect: By using three orthogonal deterministic gates, it completely eliminates dialogue deadlock from the three levels of rounds, progress and content, ensuring that the process is efficient and controllable.

[0028] Furthermore, the requirement analysis and solution generation steps include:

[0029] Intent clarification sub-step: Confirm the details of the requirements with the user through multiple rounds of interaction to obtain a clear description of the requirements;

[0030] The decision tree construction sub-steps are as follows: Based on the historical knowledge base, relevant domain cases are retrieved, and retrieval enhancement generation technology is used to generate a decision tree that includes jump logic and follow-up questioning strategies;

[0031] Schema mapping sub-step: Bind each field f in the decision tree to the three-element mapping function μ(f)=(cls) of the domain knowledge graph. f ,prop f ,g f ), where cls f For the target entity class described by field f, prop f For the attribute of this entity class, g f A value normalization function is used to create a structured configuration file.

[0032] It solves the problems that solution design relies on human experience, cannot reuse historical data, and the generated data cannot be directly precipitated into structured knowledge; technical effect: standardized solutions are automatically generated with zero human intervention, and "collection is precipitation" is achieved through formal schema mapping, so that unstructured answers are directly transformed into knowledge graph triples.

[0033] Furthermore, the automated analysis and report generation steps include: a passive error correction sub-step: in response to the completion of the collection session, excluding incomplete session data, statistically analyzing the frequency distribution of each value for enumeration type fields, calculating statistics for numeric type fields and filtering non-numeric contaminated data, and calculating the must field coverage rate MustCoverage(n) for each topic node.

[0034] Active error correction sub-step: Based on MustCoverage(n) calculated by the passive error correction sub-step, construct a structure-aware cue word-driven large language model to generate an analysis report summary. The cue word requires priority to the must field, grouping by topic nodes and labeling field criticality. When MustCoverage(n) is lower than a preset threshold, the large language model is instructed to add a data limitation declaration to the summary.

[0035] It solves the problem that automatically generated reports are susceptible to contamination by incomplete, illegal, and extreme data, and cannot automatically identify data gaps; Technical effect: By passively correcting errors as a baseline and actively correcting errors to improve, and by automatically marking incomplete data, it ensures the transparency and reliability of reports.

[0036] Furthermore, following the schema mapping sub-step, the process also includes:

[0037] The instantiation of triples generation sub-steps: During the dynamic interactive data collection process, after each round of extracting field increments, the corresponding knowledge triples are immediately generated according to the mapping function μ(f). The knowledge triples are then written into a dynamic knowledge base; whereby, For the respondent s, the corresponding entity class cls f The entity instance (multiple fields of the same s and the same entity class are mounted to the same instance), prop f The representative attribute (Property) is the predicate part of a knowledge graph triple, used to describe the entity cls. f A specific feature dimension; g f(v) The normalization function represents the value of a field, which is used to convert the collected field value v into a standardized format required by the knowledge graph.

[0038] It solves the problem of data synchronization delay and process fragmentation caused by the separation of data collection and knowledge accumulation in traditional solutions; Technical effect: It realizes "collection as accumulation", transforming unstructured answers into structured knowledge in real time during the question-and-answer process, which greatly improves data utilization efficiency.

[0039] Furthermore, the knowledge base construction step is followed by:

[0040] Ecosystem Integration Step: In response to the completion of the writing of at least one knowledge entry into the hybrid retrieval index in the knowledge base construction step, the knowledge entry is encapsulated into a standardized tool interface based on MCP through a pre-configured ecosystem integration gateway, so that external large models or business systems can retrieve and call the knowledge entry in real time through the gateway during or after the execution of the feedback optimization step.

[0041] It solves the problem of accumulated knowledge being unable to be utilized by external systems, forming data silos; Technical effect: Breaking down data silos, knowledge assets can directly empower external LLM and business systems, realizing the automation of knowledge consumption.

[0042] Accordingly, embodiments of this application also provide a client interaction method for information collection, applied to a user device, including:

[0043] Request sending steps: Obtain the user's natural language survey request, preprocess the request, encapsulate it into a request and send it to the server;

[0044] Solution demonstration and confirmation steps: Receive the structured data collection solution returned by the server, display the solution on the user interface, and receive the user's confirmation instruction for the solution;

[0045] Data collection triggering steps: Verify the validity of the confirmation instruction, convert the verified confirmation instruction into a start request, and send the start request to the server to start the data collection session;

[0046] Question and answer interaction steps: During the data collection session, the current question pushed by the server is received round by round, the question is presented to the user, the user's answer is obtained and sent to the server;

[0047] Report receiving steps: Receive the analysis report pushed by the server, parse the report content, and present it on the user interface.

[0048] Technical issues: Provide an interactive interface between users and the system, supporting natural language input and multi-turn question-and-answer; Technical effects: Enable users to initiate complex surveys in natural language and complete questions and answers in real time, without requiring professional knowledge.

[0049] Furthermore, the demand sending step includes:

[0050] Text receiving sub-step: Acquire natural language text entered by the user through the input device;

[0051] Intent extraction sub-step: Invoke natural language processing services to identify the research topic, target audience, and constraints in the text;

[0052] The request encapsulation sub-step involves assembling the requirement information and identified structured data into a request message that conforms to the API specification and sending it.

[0053] Improve the accuracy and semantic understanding of user input; Technical effect: Enable the server to more accurately parse user intent, reducing subsequent clarification rounds.

[0054] Furthermore, the solution demonstration and confirmation steps include:

[0055] Solution receiving sub-step: Receive the structured decision tree JSON configuration pushed by the server;

[0056] The visualization sub-step involves displaying the decision tree's question logic and fields in the interactive interface using a tree diagram or questionnaire preview format.

[0057] Confirm Input Sub-step: Receive user confirmation, modification, or supplementary instructions for the scheme, and send the modified content back to the server to regenerate the scheme.

[0058] Technical issues: Improve users' controllability and understanding of the generated solutions; Technical effects: Users can review and adjust the solutions before data collection begins to ensure they meet expectations.

[0059] Furthermore, the question-and-answer interaction steps include:

[0060] Issue receiving sub-step: Receive issues pushed by the server for the current node via a long connection or polling method;

[0061] Answer the following sub-step: Display the question on the user interface and wait for the user to enter their answer;

[0062] Answer return sub-step: Encapsulate the user input and send it to the server, then wait for the next round of questions or an end signal.

[0063] Technical challenges: Achieving stable and reliable multi-turn question-and-answer interaction; Technical benefits: Ensuring timely and reliable transmission of user responses, and supporting uninterrupted long conversations.

[0064] Compared with the prior art, this application has the following beneficial effects:

[0065] 1. Significantly improve data quality: By embedding the "contractual constraint and round-by-round verification" mechanism into the dynamic collection process, the field illusion rate is reduced by 90%, and the structured data compliance rate reaches 100%, ensuring the data reliability for subsequent analysis and knowledge base construction.

[0066] 2. Ensure process controllability and efficiency: By using "three anti-stalemate gates" (round limit, continuous no progress, and 3-gram repetition detection), dialogue stalemates are prevented from multiple dimensions, the average number of collection rounds is reduced by 64.5%, the task completion rate is increased by 15.9%, and the operating cost is effectively controlled.

[0067] 3. Achieving "collection and accumulation": Through formal knowledge graph schema mapping, unstructured answers are transformed into structured knowledge triples in real time during the question-and-answer process and directly written into the knowledge base, realizing a seamless connection between data collection and knowledge accumulation, which greatly improves data utilization efficiency.

[0068] 4. Empowering the system with self-evolution capabilities: Through exponential weight updates based on the "data flywheel" and the Boltzmann sampling mechanism, the system can learn from historical tasks, automatically optimize the solution generation strategy, and eliminate inefficient strategies. The solution recommendation accuracy improves by 15% after 10 iterations.

[0069] 5. Breaking down data silos: By using a standardized ecosystem gateway based on the MCP protocol, the knowledge base is encapsulated as a standard tool, enabling real-time empowerment of knowledge assets to external LLM and business systems, thereby enhancing the reusability of knowledge. Attached Figure Description

[0070] Figure 1 This is a schematic diagram of the architecture of an information processing system based on multi-agent collaboration, according to an embodiment of this application.

[0071] Figure 2 This is a general flowchart of the information processing method based on multi-agent cooperation according to an embodiment of this application.

[0072] Figure 3 This is a flowchart illustrating the contract constraints and anti-deadlock control in the dynamic interactive acquisition step of this application embodiment.

[0073] Figure 4 This is a flowchart of the data flywheel self-optimization process in the feedback optimization step provided in the embodiments of this application.

[0074] Explanation of proper nouns

[0075] Multi-Agent: Refers to a system in which multiple intelligent agents, each with independent functions and objectives, work together to accomplish complex tasks. In this application, the intelligent agent can be a software module, algorithm, or service.

[0076] Data Contract: A formal data structure definition used to constrain the output of an LLM. It defines field types, the set of valid values, thresholds, and exit strategies, and forms the basis for runtime validation.

[0077] Anti-Deadlock Gate: A deterministic control mechanism used to force the process forward when an LLM dialogue gets stuck in an infinite loop. This scheme includes three orthogonal gates: round limit, continuous no progress, and 3-gram duplicate detection.

[0078] Data Flywheel: A self-optimizing feedback loop mechanism. In this application, it refers to a closed loop of "collection → analysis → feedback → optimization," where data generated by each task is used to optimize the generation of solutions for the next task, forming a positive cycle.

[0079] The ReACT framework (Reasoning-Action Framework) is an agent working mode that combines reasoning and action to achieve complex task planning and execution.

[0080] RAG (Retrieval-Augmented Generation) mechanism: Retrieval-enhanced generation is a technology that combines information retrieval and text generation to improve the accuracy and timeliness of generated content.

[0081] Boltzmann mapping: A method for transforming a set of numerical values ​​(such as weights) into a probability distribution. The "steepness" of the distribution is controlled by a temperature parameter T, used to balance exploration and exploitation.

[0082] MCP (ModelContextProtocol): A model context protocol, an open protocol for standardized interaction between large language models and external tools and data sources. In this application, it is used to implement an ecosystem gateway.

[0083] 3-gram Jaccard similarity: A Jaccard similarity calculation method based on a set of character-level 3-grams, used to measure the degree of local repetition between two texts. Detailed Implementation

[0084] To make the purpose, technical solution, and advantages of this application clearer, the following will be described in conjunction with the appendix. Figures 1-4The present application will be further described in detail below with reference to embodiments. 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 application. All other embodiments obtained by those skilled in the art without inventive effort are within the scope of protection of this application.

[0085] Example 1: Basic Scheme.

[0086] This embodiment provides an information processing method based on multi-agent collaboration, applied to an information processing server. This method aims to solve the technical problems in existing information acquisition processes, such as uncontrollable data quality, easy process stagnation, and inability to learn from historical tasks due to a lack of runtime constraints.

[0087] like Figure 1 and Figure 2 As shown, the method includes the following steps:

[0088] Requirements Analysis and Solution Generation Steps: The information processing server receives natural language requirements (e.g., "Investigate the current status of postoperative pain management") input by users through client devices (such as smartphones and personal computers). The server first invokes a Natural Language Processing (NLP) service to semantically analyze the requirements, identifying the research topic, target audience, and potential constraints. Then, based on the analysis results, a structured data collection plan is generated. This plan can be a JSON-formatted configuration file defining the framework for subsequent data collection processes.

[0089] Dynamic interactive data collection steps: Based on the generated structured data collection scheme, the server drives multi-round question-and-answer sessions with respondents (i.e., surveyed users). In each round, the server pushes questions to the respondents, receives their answers, and extracts structured data from them. Crucially, the extraction and validation process in this step includes runtime constraint validation and anti-deadlock control. Runtime constraint validation ensures that the extracted data conforms to a predefined format and value range; for example, for enumerated type fields (such as "gender"), only "male" or "female" values ​​are allowed to be extracted. Anti-deadlock control prevents the dialogue from entering an infinite loop or repeated questioning; for example, when the number of question-and-answer rounds reaches a preset limit, the dialogue at the current node is forcibly terminated. By embedding deterministic validation and anti-deadlock mechanisms into the data collection process, this method significantly reduces the field illusion rate and ensures the controllability of the process.

[0090] Automated analysis and report generation steps: After data collection, the server cleans the collected structured data, removing invalid or abnormal data. Then, the cleaned data undergoes statistical aggregation, such as calculating the frequency distribution of each option and the average value of numerical fields. Finally, an analysis report is automatically generated based on the statistical results. The report may include charts, data summaries, and preliminary insights.

[0091] The knowledge base construction steps are as follows: The server distills the collected structured data into knowledge triples (e.g., "Patient A" - "Pain Score" - "7 points"). Then, the generated knowledge triples are deduplicated and merged to avoid knowledge redundancy. Finally, the processed knowledge entries are written into a dynamic knowledge base that supports both full-text and vector-based retrieval.

[0092] Feedback optimization steps: The server records and analyzes performance metrics during this dynamic interaction data collection process, such as the completion rate of each branch, the effective conversion rate of follow-up questions, and the bounce rate of respondents. Based on these metrics, a reward value is calculated for each branch. Then, these reward values ​​are used to update the weights of the solution generation model, so that in subsequent tasks, the system is more inclined to generate solutions that have performed well historically, thereby achieving self-evolution of the system.

[0093] Through the above steps, this method compresses the research work that traditionally takes several days or even weeks to minutes, realizing a fully automated closed loop from demand input to report output and knowledge accumulation.

[0094] Example (II): Refinement of dynamic interactive data collection steps.

[0095] Based on Example (I), this embodiment provides specific limitations on runtime constraint verification and anti-deadlock control in the dynamic interactive acquisition step.

[0096] like Figure 3 As shown, the extraction and verification process in the dynamic interactive acquisition step specifically includes:

[0097] Contract Constraints and Round-by-Round Validation Sub-Steps: Before data collection begins, the server loads a data contract for each topic node in the decision tree. This data contract is a formal data structure that defines detailed information about all fields to be collected under that node, including:

[0098] Field type: such as text, enum, number, boolean.

[0099] Valid value set (options): For enumeration type fields, this set explicitly lists all allowed values, such as ["male", "female"].

[0100] Criticality: Divided into three levels: "must", "should", and "optional", it is used to drive the priority of follow-up inquiries and report coverage alerts.

[0101] Exit strategy: Defines the conditions under which the Q&A session for this node can be terminated, such as "after all required fields have been collected" or "after the maximum number of rounds has been reached".

[0102] In each round of question-and-answer, the server invokes the Large Language Model (LLM) to extract a field increment (ΔX) from the respondent's answer. Before writing ΔX to the session state, runtime enumeration validation must be performed: for fields of type enumeration, it is checked whether their values ​​belong to the valid value set O for that field. i If a value is invalid (e.g., extracting "runs fast even under Martian gravity" as a stability score), the value is rejected, and the LLM is prompted to re-extract the value or the respondent is asked to answer again. Through this "validate first, write later" mechanism, invalid enumeration values ​​are eliminated at the source and never enter subsequent data processing flows. Real-world testing shows that this mechanism can reduce the Field Illusion Rate (FHR) from 14.4% in a pure LLM solution to 1.6%, and achieve a Structured Compliance Rate (SDC) of 100%.

[0103] Anti-stalemate gate sub-step: During the data collection process, the server executes at least three independent, dimensionally orthogonal anti-stalemate gates sequentially. If any gate is triggered, the question-and-answer session of the current topic node is forcibly terminated, proceeding to the next topic node or ending the entire data collection session.

[0104] The first gatekeeper: Round limit detection. This checks whether the number of question-and-answer rounds within the current node has reached a preset hard limit (e.g., 10 rounds). If it has, the node is forced to exit.

[0105] The second checkpoint: Continuous No Progress Detection. This checks whether no new field increments have been extracted within a preset number of rounds (e.g., 3 rounds). If there is continuous no progress, it indicates a deadlock in the dialogue, and the user is forced to exit.

[0106] The third gate: 3-gram duplicate detection. Based on character-level 3-gram Jaccard similarity, it detects user responses in a preset number of rounds (e.g., 3 rounds). When the similarity exceeds a preset threshold (e.g., 0.78), it is determined that the user is giving a duplicate response, the conversation is not progressing, and the user is forced to exit.

[0107] These three gates, from the perspectives of rounds, progress, and content, completely eliminate dialogue deadlocks through deterministic rules, ensure efficient and controllable processes, and avoid cost overruns and data pollution caused by LLM's "endless questioning" or "repackaging."

[0108] Example (3): Refinement of Feedback Optimization Steps

[0109] This embodiment, based on embodiment (I), provides specific limitations on the feedback optimization steps.

[0110] like Figure 4 As shown, the feedback optimization step specifically includes:

[0111] Performance collection sub-step: For each branch of a decision tree, collect the following performance metrics:

[0112] Completion Rate: The percentage of sessions under this branch that successfully completed the collection of all required fields.

[0113] Follow-up Conversion Rate: The percentage of valid new fields generated by follow-up questions under this branch.

[0114] Dropout Rate: The percentage of respondents who abandon a session midway through the session.

[0115] Reward calculation sub-step: Perform a weighted linear combination of the above performance indicators to calculate the reward value for each branch. For example, reward value = w1 * completion rate + w2 * effective conversion rate of follow-up inquiries - w3 * bounce rate, where w1, w2, and w3 are preset weight coefficients.

[0116] To further quantify the collection efficiency of each branch, the system calculates the reward value r of branch b in the k-th round of the task according to the following linear weighted formula. b (k) After each round of data collection task k is completed, the execution performance index—completion rate c—is collected for each branch b that was actually used. b Follow up with the effective conversion rate q b bounce rate of respondents b —And converted into scalar reward:

[0117] ;

[0118] Where, r b (k) This is the completion rate for that branch. The completion rate (q) represents the percentage of sessions that successfully complete the collection of all required fields under branch b in the k-th round of the task. b (k) The effective conversion rate for this branch (Follow-up Conversion Rate); d b (k) The bounce rate for the branch is denoted as α, β, and γ, which are preset non-negative weighting coefficients representing the weighting coefficients for completion rate, effective conversion rate, and bounce rate, respectively. For example, α = 0.5, β = 0.3, and γ = 0.2.b (k) A higher value indicates better data collection quality for that branch; forceful follow-up questions leading to numerous invalid answers will increase d. b (k) , suppress r b (k) .

[0119] Furthermore, by weighting and combining three orthogonal performance metrics—completion rate, follow-up conversion rate, and bounce rate—into a single reward value, the system can comprehensively evaluate the overall data collection quality of each branch, avoiding one-sided incentives caused by a single metric (such as only looking at the completion rate). For example, if a branch has a high completion rate but an extremely low follow-up conversion rate, its reward value will still be reduced, thus guiding the system to abandon "simple but inefficient" questioning strategies.

[0120] The weight update sub-step uses the global mean of rewards across all branches as the baseline. For high-quality branches with rewards above the baseline, their recommended weights are increased by an exponential factor (e.g., 1.1); for inefficient branches with rewards below the baseline, their recommended weights are decreased by an exponential factor (e.g., 0.9). For branches whose rewards are consistently below the baseline for multiple rounds (e.g., j=3 rounds), their weights decrease geometrically towards 0, thus achieving natural elimination of these branches. In this way, the system can evolve autonomously, the quality of generated solutions increases with the number of uses, and inefficient strategies are automatically eliminated.

[0121] Example (4): Algorithm refinement for weight update sub-step.

[0122] This embodiment further defines the algorithm in the weight update sub-step based on embodiment (III).

[0123] The weight update sub-step further includes:

[0124] Weight index update rule definition (decay penalty and positive incentive) sub-step: After calculating the reward value of each branch, the system updates the recommendation weight of each branch using the following index rule:

[0125] ;

[0126] in, The recommended weight of branch b before the start of the k-th round of tasks; This represents the reward value for branch b after the k-th round of tasks. for The global mean of the reward values ​​of all branches in the k-th round of the task, i.e., the baseline; η is the learning rate, controlling the step size of the weight adjustment, for example, η=0.1. The update strategy is: when > When (high-quality branches) the exponential factor is greater than 1, the weight increases (positive incentive); when < When there is an inefficient branch, the exponent factor is less than 1, and the weight is reduced (decay penalty). The exponent mechanism of this application can respond more sensitively to changes in efficiency and achieve a more efficient exploration-exploitation balance.

[0127] Furthermore, by replacing the linear weight adjustment in the comparison document 1 (CN121525885A) with an exponential update rule, the following unexpected technical effects were produced: (1) The weight of high-quality branches is amplified at an exponential rate, making their probability of being sampled in subsequent tasks grow non-linearly and faster, thereby shortening the number of iterations in which high-quality strategies dominate; (2) The weight of inefficient branches decays at an exponential rate, especially when continuously inefficient, it accelerates to zero geometrically, realizing automatic and efficient elimination of invalid strategies without the need for manually setting thresholds or manual removal; (3) The introduction of the global baseline r̄ makes the weight adjustment adaptive, avoiding the problem of fixed thresholds failing in different task scenarios.

[0128] The sampling probability mapping sub-step: When generating a new decision tree, the recommendation weights of each branch are transformed into sampling probabilities using a Boltzmann mapping. Specifically, the sampling probability of branch i is:

[0129] ;

[0130] Among them, W i Let T be the recommended weight for branch i, and T be the temperature parameter. The temperature parameter T is used to regulate the balance between exploration and exploitation: when the T value is high, the sampling probability of each branch tends to be uniform, which is conducive to exploring new strategies; when the T value is low, the sampling probability of high-weight branches is higher, which is conducive to exploiting known efficient strategies.

[0131] Natural elimination sub-step: For inefficient branches whose rewards are consistently lower than the global baseline for j consecutive rounds (j is a preset positive integer, preferably 3 to 5 rounds), their weights decay geometrically towards 0, and their corresponding generation probabilities also tend towards 0, thus achieving natural elimination of the branch. For example, if branch i is lower than the baseline for 3 consecutive rounds, its weight is updated to W. i =W i *0.5 3 This causes it to decay rapidly.

[0132] By employing Boltzmann mapping and geometrical decay, the system can more intelligently balance the exploration of new strategies with the utilization of known efficient strategies, and automatically eliminate inefficient branches, thereby improving self-optimization efficiency. This differs from the simple linear weight adjustment (new weight = old weight × (1 + feedback adjustment coefficient)) disclosed in Reference 1 (CN121525885A). The exponential update and natural elimination mechanism of this application bring about a better exploration-utilization balance and a faster speed of eliminating ineffective strategies.

[0133] Based on Example (I), this embodiment further specifies the dual error correction mechanism in the automated analysis and report generation steps to address the technical problem that automatically generated reports are susceptible to contamination by incomplete, illegal, or extreme data and cannot automatically identify data gaps.

[0134] The automated analysis and report generation steps specifically include passive error correction sub-steps and active error correction sub-steps, which are executed in a fixed order to form a "passive first, active later" defense-in-depth architecture.

[0135] Passive error correction sub-step: In response to the completion of the data collection session, the server first performs passive error correction on the collected raw data. This process is entirely based on deterministic rules and does not rely on a large language model. Specifically, it includes:

[0136] Sample filtering: Incomplete or fragmented session data is excluded. Sessions that are abandoned or abnormally interrupted are not included in any statistics to avoid incomplete data contaminating the distribution.

[0137] Field type constraint validation: For enumeration type fields, calculate the frequency distribution of each valid value; for numeric type fields, calculate statistics such as minimum, maximum, and average values, and filter out non-numeric contaminating data (such as text content incorrectly filled in by respondents) to ensure that the statistical mean is not contaminated.

[0138] Must field coverage calculation: To quantitatively evaluate the data completeness of each topic node, the system calculates the following Must field coverage metric:

[0139] ;

[0140] Where: n is the target topic node; sessions is the set of all completed and unfiltered sessions; The set of all `must` fields under node `n`; | represents the number of `must` fields for this node; `s` represents a single session, i.e., one complete record collected by a respondent at this node; `sessions`: the set of sessions included in the statistics (Note: incomplete sessions that were abandoned or abnormally interrupted have been removed during the sample filtering stage and are not included); `|sessions|`: the total number of sessions included in the statistics; X s For the data collection results of session s (field → value mapping); X s (f) represents the collection result of field f in session s; X s(f) ≠⊥: Field f was successfully collected as a valid value in session s (i.e., "collected"); 1[] is an indicator function, which takes the value 1 when field f is successfully collected as a valid value in session s, and 0 otherwise; |Φ n {must} | and |sessions| represent the cardinality of the set, respectively.

[0141] Active error correction sub-step: Based on MustCoverage(n) calculated by the passive error correction sub-step, the server constructs structure-aware prompt words to drive the large language model to generate an analysis report summary. The prompt words require priority to the must field, grouping by topic nodes and labeling the field criticality (must / should / optional), so that the large language model can automatically determine which information is worth highlighting and which can be ignored when summarizing, thereby achieving implicit outlier suppression - the extreme answers of a single respondent will not be amplified indiscriminately, but will be summarized into the higher-level expression of "core features".

[0142] When MustCoverage(n) is lower than a preset threshold (e.g., 80%), the large language model adds a data limitation statement to the summary, clearly informing the report user that the data coverage of the topic node is incomplete and the conclusion may be biased, rather than concealing the data gap. This forms a closed loop of "coverage measurement → automatic annotation of data gaps", ensuring the transparency and reliability of the report.

[0143] This application employs a defense-in-depth architecture of "passive error correction + active error correction" during the report generation phase. The two are not simply superimposed, but rather complement each other with a fixed order:

[0144] 1. Passive Error Correction (Deterministic Fallback): Through deterministic rules such as sample filtering, type constraint validation, and statistical aggregation filtering, it specifically intercepts structural errors that can be characterized by rules—incomplete sessions, illegal enumeration values, non-numerical contamination, etc.—providing a hard guarantee of the "quality lower limit" for the final report. This step does not rely on the self-restraint capabilities of the LLM, and its overhead is bounded and auditable.

[0145] 2. Proactive Error Correction (Adaptive Refinement): Through LLM structure-aware summarization and quality control, it specifically handles semantic problems that cannot be exhaustively enumerated by fixed rules, such as noise suppression, extreme value summarization, and natural language annotation of data gaps, thereby raising the "quality ceiling" of the report.

[0146] 3. Fixed order (passive first, then active): Passive correction uses deterministic rules to eliminate illegal, incomplete, and contaminated data at the source, ensuring that the LLM entering active correction always reasons on clean and compliant data, avoiding misinterpretation or amplification of phantom values ​​or incomplete distributions by the LLM. At the same time, the triggering and content of active correction directly use the statistical output (MustCoverage(n)) of passive correction as input, so the order of the two is irreversible in the data flow.

[0147] Through the above mechanism, the system can simultaneously obtain a reliable lower limit of quality and an adaptively improved upper limit of quality within a calculable cost upper limit, achieving a technical effect that a single error correction mechanism (whether pure rule constraints or pure LLM self-correction) cannot achieve.

[0148] Example (5): Parameterization of the Anti-Grip Gate Sub-Step

[0149] This embodiment, based on embodiment (II), specifies the specific parameters in the anti-stalemate gate sub-step.

[0150] The anti-stalemate gate sub-steps include:

[0151] Round limit detection sub-step: The preset hard limit for rounds is 10 rounds.

[0152] Continuous no-progress detection sub-step: The preset number of consecutive rounds is 3.

[0153] The 3-gram duplicate detection sub-step involves using character-level 3-gram Jaccard similarity to detect duplicate user responses across three consecutive rounds, with a preset threshold of 0.78. Responses exceeding 0.78 are considered duplicates.

[0154] This parameter combination (0.78 threshold and 3-round sliding window) has been verified through extensive experiments to achieve an optimal balance between effectively identifying duplicate responses and avoiding false positives. In other embodiments, the preset threshold can be adjusted within the range of 0.7 to 0.85, and the number of consecutive preset rounds can be adjusted within the range of 2 to 5 rounds, all achieving similar technical effects.

[0155] Example (6): Refinement of the requirements analysis and solution generation steps.

[0156] This embodiment, based on embodiment (I), provides specific limitations on the steps of requirement analysis and solution generation.

[0157] The requirements analysis and solution generation steps include:

[0158] The intent clarification sub-step involves the server confirming the details of the requirements with the user (i.e., the survey initiator) through multiple rounds of interaction. For example, when a user enters "Investigate the current status of postoperative pain management," the server might ask, "Do you want to survey doctors or patients?" or "Is the type of pain you are concerned about acute or chronic pain?" Through this ReACT framework-driven interaction, a clear and unambiguous description of the requirements is obtained.

[0159] The decision tree construction process involves the following steps: After the intent is clarified, the server uses RAG technology to retrieve successful cases in relevant fields (such as "chronic pain management") based on a historical knowledge base. Then, combined with the current needs, a large model is used to reorganize these discrete knowledge points into a personalized decision tree that includes jump logic and follow-up questioning strategies. For example, if the respondent answers "pain score > 5 points," the decision tree automatically expands to a sub-branch on "follow-up questioning about medication use."

[0160] Schema mapping sub-step: To achieve "collection as accumulation", the server binds each field f to be collected in the decision tree to the three-element mapping function μ(f)=(cls) of the domain knowledge graph. f ,prop f ,g f ). Among them, cls f For the target entity class described by field f (such as "patient"), prop f For attributes of this entity class (such as "pain rating"), g f This is a value normalization function (e.g., mapping "7 points" to the numerical value 7). Through this formalized mapping, a structured configuration file is formed, allowing subsequent unstructured responses to be directly mapped to knowledge graph triples.

[0161] It should be noted that in this application, "structured data collection scheme" is a broad concept, encompassing a unified definition of the logic, process, and rules of the entire information collection process. A "structured configuration file" (e.g., a JSON-formatted configuration file) is a specific, machine-executable instance of the "structured data collection scheme." In a preferred embodiment, the "structured configuration file" is generated through a schema mapping sub-step. Its content includes decision tree logic, probing strategies, field contracts, and most importantly—the mapping relationship that binds each field to the domain knowledge graph, thus constituting a complete "structured data collection scheme" that can be directly parsed by downstream engines. In this embodiment, the configuration file not only includes the front-end display logic of the questionnaire (UISchema), but more importantly, defines the back-end data storage structure (DataSchema) and knowledge extraction rules, enabling subsequently collected unstructured answers to be directly mapped to knowledge graph triples.

[0162] Example (7): Instantiation of triple generation.

[0163] This embodiment further defines the steps after schema mapping, based on embodiment (VI).

[0164] During the dynamic interactive data acquisition process, after each round of field increment extraction, the server immediately generates the corresponding knowledge triples based on the mapping function μ(f). For example, for the field "pain score", if the entity instance in the current session s is "patient A" and the extracted value is "7 points", then a triple is generated. =(Patient A, Pain Score, 7). This triple is written to the dynamic knowledge base in real time. In this way, true "collection and accumulation" is achieved, transforming unstructured answers into structured knowledge in real time during the question-and-answer process, greatly improving data utilization efficiency.

[0165] in, For the respondent s, the corresponding entity class cls f The entity instance (multiple fields of the same s and the same entity class are mounted to the same instance), prop f The representative attribute (Property) is the predicate part of a knowledge graph triple, used to describe the entity cls. f A specific feature dimension; g f(v) The Normalization Function represents the function that converts the collected field values ​​v into the standardized format required by the knowledge graph.

[0166] Example (8): Ecological Integration Steps.

[0167] This embodiment, based on any of the above embodiments, also includes an ecological integration step.

[0168] The server encapsulates knowledge entries from the dynamic knowledge base into standard tools through a gateway based on the Model Context Protocol (MCP). External large language models or business systems can use this gateway to retrieve and access knowledge from the knowledge base in real time using the standard MCP protocol interface. For example, a product design-related LLMAgent can call the "Patient Needs Database" tool to obtain the latest user pain point data to assist in the definition of new products. Through this ecosystem integration, data silos are broken down, enabling accumulated knowledge assets to directly empower external systems and automate knowledge consumption.

[0169] It should be understood that the ecosystem integration step in this application is not a separate step strictly sequential between the knowledge base construction step and the feedback optimization step. In fact, the ecosystem integration step is a persistent asynchronous service that starts during system initialization. Once the dynamic knowledge base construction center writes the first knowledge entry into the full-text + vector hybrid index, the ecosystem integration gateway can register that knowledge entry as a standard MCP tool. Therefore, there is no temporal dependency between the ecosystem integration step and the feedback optimization step; they can be executed concurrently during system operation: the feedback optimization step focuses on internal strategy iteration, while the ecosystem integration step focuses on opening up external service capabilities.

[0170] Example (9): Client interaction method.

[0171] This embodiment provides a client-side interaction method for information collection, applied to a user's client device (such as a mobile phone or computer). This method corresponds to the server-side methods in embodiments (I) to (VIII), together forming a complete interaction process.

[0172] The request sending process is as follows: The client obtains the user's natural language survey request, preprocesses the request (such as removing extra spaces), encapsulates it into a request message that conforms to the API specification, and sends it to the server.

[0173] Solution Presentation and Confirmation Steps: The client receives the structured data collection solution (e.g., a decision tree configuration in JSON format) returned by the server and displays it in the user interface as a tree diagram or questionnaire preview. Users can confirm, modify, or supplement the solution. The client receives the user's confirmation instruction and sends the modified content (if any) back to the server.

[0174] Data collection triggering steps: The client verifies the validity of the confirmation instruction (e.g., checks whether the "agree" option has been checked), and then converts the verified confirmation instruction into a start request and sends it to the server to start the data collection session.

[0175] Question-and-answer interaction steps: During the data collection session, the client receives the current question pushed by the server round by round via a long connection (such as WebSocket) or polling, and displays it in the user interface. After the user enters an answer, the client encapsulates the answer and sends it to the server, then waits for the next round of questions or an end signal.

[0176] Report receiving steps: After data collection is completed, the client receives the analysis report pushed by the server, parses the report content (such as HTML, PDF or JSON format), and presents it to the user in the user interface.

[0177] Through the aforementioned client-side interaction methods, users can initiate complex surveys using natural language and complete question-and-answer sessions in real time, requiring no specialized knowledge and significantly lowering the barrier to entry. The collaborative work between the client and server enables end-to-end automation from requirement input to report retrieval.

[0178] Experimental evidence

[0179] To verify the technical effectiveness of this application, we conducted a comparative experiment. The experimental environment is as follows:

[0180] Hardware environment: Server: Intel Xeon Gold 6248R CPU, 256GB RAM, NVIDIA 100 GPU.

[0181] Software environment: Operating system: Ubuntu 20.04; LLM model: qwen3.7-plus; Knowledge base: Elasticsearch + MySQL.

[0182] Test data: Simulated 1000 survey sessions on "Current Status of Postoperative Pain Management", with each session containing approximately 15 fields.

[0183] Experimental group and control group:

[0184] Control group A (pure LLM scheme): only uses LLM to drive the dialogue, without any constraints or verification mechanisms.

[0185] Control group B (fixed questionnaire): generated using a fixed questionnaire template, without dynamic decision tree and in-depth follow-up questioning mechanism.

[0186] Experimental Group C (Scheme of this application): The method described in embodiments (I) to (VIII) of this application is adopted, including all features such as contract constraints, anti-deadlock gate, and data flywheel.

[0187] Comparison table of experimental results:

[0188] Table 1 Comparison of Experimental Results

[0189] Field Illusion Rate (FHR) 14.4% 8.2% 1.6% Reduced by 90% (vsA) Structured Compliance Rate (SDC) 72.3% 91.5% 100% Increased to 100% Average data collection time (minutes) 8.5 5.2 4.8 Shortened by 43.5% (vsA) User bounce rate 18.7% 12.1% 5.3% A decrease of 71.7% (vsA) Knowledge Triple Automatic Generation Rate 0% 0% 100% Achieving "collection as sedimentation" System self-optimization effect (after 10 rounds) none none The quality of the solution improved by 15%. Possessing the ability to evolve independently

[0190] Results analysis:

[0191] 1. Field illusion rate: The field illusion rate of the proposed scheme (experimental group C) was only 1.6%, which was 90% lower than that of the pure LLM scheme (control group A). ​​This directly proves the significant effect of the "contract constraint and round-by-round verification" mechanism in suppressing LLM illusion.

[0192] 2. Structured Compliance Rate: This application achieves a 100% structured compliance rate, meaning that all collected data conforms to the predefined schema and can be directly stored and used. This is thanks to the strict control of data quality through runtime enumeration verification and anti-deadlock gates.

[0193] 3. Average data collection time and user bounce rate: This application's solution optimizes the dialogue process through dynamic decision trees and anti-stalemate gates, avoiding ineffective follow-up questions, thereby shortening the data collection time and reducing the user bounce rate.

[0194] 4. Automatic generation rate of knowledge triples: The solution in this application achieves "collection and accumulation" through schema mapping, automatically generating 100% of knowledge triples, while the control group could not achieve this.

[0195] 5. System self-optimization effect: After 10 rounds of tasks, the proposed solution improved the quality of solution generation by 15% through the data flywheel mechanism, proving that it has the ability to evolve autonomously.

[0196] In summary, the technical solution of this application has achieved unexpected technical effects in terms of data quality, process controllability, user experience, and system self-evolution capability, and has made significant progress compared with the existing technology.

[0197] Furthermore, those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM), etc.

[0198] Furthermore, a portion of this application can be applied as a computer program product, such as computer program instructions, which, when executed by a computer, can invoke or provide the methods and / or technical solutions according to this application through the operation of the computer. The program instructions invoking the methods of this application may be stored in a fixed or removable recording medium, and / or transmitted via data streams in broadcast or other signal carrying media, and / or stored in the working memory of a computer device operating according to the program instructions. Here, one embodiment of this application includes an apparatus comprising a memory for storing computer program instructions and a processor for executing the program instructions, wherein, when the computer program instructions are executed by the processor, the apparatus is triggered to operate the methods and / or technical solutions based on the foregoing embodiments of this application.

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

Claims

1. An information processing method based on multi-agent cooperation, applied to an information processing server, characterized in that, include: Requirements analysis and solution generation steps: Receive user natural language requirements, analyze the intent of the requirements, and generate a structured data collection solution; Dynamic interactive data collection steps: Drive multiple rounds of question and answer according to the structured data collection scheme, extract and verify structured data, wherein the extraction and verification process includes runtime constraint verification and anti-deadlock control; Automated analysis and report generation steps: Clean the structured data, statistically aggregate the cleaned data, and generate an analysis report; Knowledge base construction steps: Distill the structured data to obtain knowledge triples, deduplicate and merge the knowledge triples, and write them into the knowledge base; Feedback optimization steps: Obtain performance indicators of the dynamic interactive data collection process, calculate the rewards for each branch, and generate weights based on the reward update scheme.

2. The method according to claim 1, characterized in that, The dynamic interactive data acquisition steps include: Contract constraints and round-by-round validation sub-steps: Load a data contract for each topic node of the decision tree. The data contract defines the field type, the set of legal values, the threshold, and the exit strategy. After extracting the field increment in each round, perform legal value validation on the enumerated type fields. Illegal field values ​​are prohibited from being written into the data structure. Anti-stalemate gate sub-step: At least three independent gates are executed sequentially during the acquisition process. If any gate is triggered, the process is forced to proceed to the next topic node.

3. The method according to claim 1, characterized in that, The feedback optimization steps include: Performance data collection sub-step: Collect completion rate, follow-up effective conversion rate, and respondent bounce rate for each branch of the decision tree as performance indicators; Reward calculation sub-step: The performance indicators are weighted and linearly combined into branch rewards; Weight update sub-step: Using the global branch reward average as the baseline, increase the recommendation weight of high-quality branches that are above the baseline with an exponential factor, decrease the recommendation weight of inefficient branches that are below the baseline with an exponential factor, and eliminate persistently inefficient branches.

4. The method according to claim 3, characterized in that, The weight update sub-step includes: Sampling probability mapping sub-step: When generating a new decision tree, the recommendation weights of each branch are converted into sampling probabilities through Boltzmann mapping, where the temperature parameter T controls the balance between exploration and utilization; Natural elimination sub-step: For inefficient branches whose rewards are lower than the global baseline for j consecutive rounds, their weights decay geometrically toward 0, and the corresponding generation probability approaches 0, thus achieving natural elimination of the branch, where j is a preset positive integer.

5. The method according to claim 2, characterized in that, The anti-stalemate gate sub-steps include: Round limit detection sub-step: Detect whether the number of question-and-answer rounds in the current node has reached the preset hard limit of rounds; The continuous no-progress detection sub-step: detects whether no new field increments have been extracted within a consecutive preset number of rounds; 3-gram duplicate detection sub-step: Based on character-level 3-gram Jaccard similarity, detect user answers for a preset number of consecutive rounds. When the similarity exceeds a preset threshold, it is determined to be a duplicate answer.

6. The method according to claim 1, characterized in that, The requirements analysis and solution generation steps include: Intent clarification sub-step: Confirm the details of the requirements with the user through multiple rounds of interaction to obtain a clear description of the requirements; The decision tree construction sub-steps are as follows: Based on the historical knowledge base, relevant domain cases are retrieved, and retrieval enhancement generation technology is used to generate a decision tree that includes jump logic and follow-up questioning strategies; Schema mapping sub-step: Bind each field f in the decision tree to the three-element mapping function μ(f)=(cls) of the domain knowledge graph. f ,prop f ,g f ), where cls f For the target entity class described by field f, prop f For the attribute of this entity class, g f A value normalization function is used to create a structured configuration file.

7. The method according to claim 1, characterized in that, The automated analysis and report generation steps include: Passive error correction sub-step: In response to the completion of the collection session, exclude incomplete session data, count the frequency distribution of each value for the enumeration type field, calculate the statistics for the numeric type field and filter out non-numeric contamination data, and calculate the must field coverage rate MustCoverage(n) for each topic node. Active error correction sub-step: Based on MustCoverage(n) calculated by the passive error correction sub-step, construct a structure-aware cue word-driven large language model to generate an analysis report summary. The cue word requires priority to the must field, grouping by topic nodes and labeling field criticality. When MustCoverage(n) is lower than a preset threshold, the large language model is instructed to add a data limitation declaration to the summary.

8. The method according to any one of claims 1 to 7, characterized in that, The knowledge base construction step is followed by: Ecosystem Integration Step: In response to the completion of the writing of at least one knowledge entry into the hybrid retrieval index in the knowledge base construction step, the knowledge entry is encapsulated into a standardized tool interface based on MCP through a pre-configured ecosystem integration gateway, so that external large models or business systems can retrieve and call the knowledge entry in real time through the gateway during or after the execution of the feedback optimization step.

9. A client-side interaction method for information collection, applied to a user device, characterized in that, include: Request sending steps: Obtain the user's natural language survey request, preprocess the request, encapsulate it into a request and send it to the server; Solution demonstration and confirmation steps: Receive the structured data collection solution returned by the server, display the solution on the user interface, and receive the user's confirmation instruction for the solution; Data collection triggering steps: Verify the validity of the confirmation instruction, convert the verified confirmation instruction into a start request, and send the start request to the server to start the data collection session; Question and answer interaction steps: During the data collection session, the current question pushed by the server is received round by round, the question is presented to the user, the user's answer is obtained and sent to the server; Report receiving steps: Receive the analysis report pushed by the server, parse the report content, and present it on the user interface.

10. The method according to claim 9, characterized in that, The request sending step includes: Text receiving sub-step: Acquire natural language text entered by the user through the input device; Intent extraction sub-step: Invoke natural language processing services to identify the research topic, target audience, and constraints in the text; The request encapsulation sub-step involves assembling the requirement information and identified structured data into a request message that conforms to the API specification and sending it.

Images