Data processing method, task processing method

Abstract

The embodiment of the present specification provides a data processing method and a task processing method. The data processing method comprises: determining execution trajectory data of a target task, wherein the execution trajectory data is generated by a first agent depending on a first model; generating a smart component library according to the execution trajectory data and system constraints by using the first agent, wherein the system constraints are determined according to a model configuration of a second model on which a second agent depends; generating a reference workflow according to the execution trajectory data and the smart component library by using the first agent; executing a test task according to the reference workflow and the smart component library by using the second agent, and determining a target workflow set according to a task execution result; and constructing an efficient and stable target workflow suitable for the second agent by collecting execution trajectory data generated by the first agent in executing the target task, so that the second agent can execute the same type of target task at low cost and high efficiency based on the target workflow.

Description

Technical Field

[0001] The embodiments in this specification relate to the field of computer technology, and in particular to a data processing method and a task processing method. Background Technology

[0002] Large models, due to their powerful learning and reasoning capabilities, have been widely applied to various tasks in the field of dialogue analysis. Through dialogue analysis, they can help customer service and sales industries achieve in-depth tasks such as improving customer service skills, optimizing systems, and increasing conversion rates. For complex in-depth analysis tasks, agent systems based on strong models (such as LLM) are generally used to achieve good results through dynamic programming of execution paths. However, strong models are very expensive, with high costs for each complex task call. Furthermore, while agents are flexible and can automatically explore feasible paths, this becomes a disadvantage when performing repetitive tasks. Each execution requires re-exploring feasible paths, generating a large amount of unnecessary token consumption and redundant computation, prolonging inference time, leading to inefficiency. Moreover, the uncertainty of dynamic paths also significantly reduces the stability of agent systems. Summary of the Invention

[0003] In view of this, embodiments of this specification provide a data processing method. One or more embodiments of this specification also relate to a data processing apparatus, a task processing method, a task processing device, a data processing method applied to a dialogue analysis task, a data processing device applied to a dialogue analysis task, a computing device, an electronic device, a computer-readable storage medium, and a computer program product, to address the technical shortcomings of existing technologies, such as high cost, low efficiency, and weak stability, when using strong model-based agent systems to perform complex deep analysis tasks.

[0004] According to a first aspect of the embodiments of this specification, a data processing method is provided, comprising:

[0005] Determine the execution trajectory data of the target task, wherein the execution trajectory data is the trajectory data generated by the first intelligent agent relying on the first model to execute the target task;

[0006] Using the first intelligent agent, an intelligent component library is generated based on the execution trajectory data and system constraints, wherein the system constraints are determined based on the model configuration of the second model on which the second intelligent agent depends, and the model configuration of the first model is greater than the model configuration of the second model;

[0007] Using the first intelligent agent, a reference workflow is generated based on the execution trajectory data and the intelligent component library;

[0008] Using the second intelligent agent, test tasks are executed according to the reference workflow and the intelligent component library, and a target workflow set is determined based on the task execution results, wherein the test tasks are determined according to the target tasks.

[0009] According to a second aspect of the embodiments of this specification, a data processing apparatus is provided, comprising:

[0010] The trajectory determination module is configured to determine the execution trajectory data of the target task, wherein the execution trajectory data is trajectory data generated by the first agent relying on the first model to execute the target task;

[0011] The component library generation module is configured to use the first intelligent agent to generate an intelligent component library based on the execution trajectory data and system constraints, wherein the system constraints are determined based on the model configuration of the second model on which the second intelligent agent depends, and the model configuration of the first model is greater than the model configuration of the second model.

[0012] The reference workflow generation module is configured to use the first intelligent agent to generate a reference workflow based on the execution trajectory data and the intelligent component library;

[0013] The workflow set generation module is configured to use the second intelligent agent to execute test tasks based on the reference workflow and the intelligent component library, and determine the target workflow set based on the task execution results, wherein the test tasks are determined based on the target tasks.

[0014] According to a third aspect of the embodiments of this specification, a task processing method is provided, including:

[0015] Receive the task to be executed, use the second intelligent agent to parse the task to be executed, and determine the execution workflow from the target workflow set based on the parsing result;

[0016] Using the second intelligent agent, the task to be executed is performed according to the execution workflow and the intelligent component library, wherein the target workflow set and the intelligent component library are generated according to the above data processing method.

[0017] According to a fourth aspect of the embodiments of this specification, a task processing apparatus is provided, comprising:

[0018] The task receiving module is configured to receive tasks to be executed, parse the tasks to be executed using a second intelligent agent, and determine the execution workflow from the target workflow set based on the parsing results.

[0019] The task execution module is configured to use the second intelligent agent to execute the task to be executed according to the execution workflow and the intelligent component library, wherein the target workflow set and the intelligent component library are generated according to the above data processing method.

[0020] According to a fifth aspect of the embodiments of this specification, a data processing method for a dialogue analysis task is provided, comprising:

[0021] Determine the execution trajectory data of the target dialogue analysis task, wherein the execution trajectory data is the trajectory data generated by the first agent relying on the first model to execute the target dialogue analysis task;

[0022] Using the first intelligent agent, an intelligent component library is generated based on the execution trajectory data and system constraints, wherein the system constraints are determined based on the model configuration of the second model on which the second intelligent agent depends, and the model configuration of the first model is greater than the model configuration of the second model;

[0023] Using the first intelligent agent, a dialogue analysis reference workflow is generated based on the execution trajectory data and the intelligent component library;

[0024] Using the second intelligent agent, a dialogue analysis test task is executed according to the dialogue analysis reference workflow and the intelligent component library, and a dialogue analysis target workflow set is determined according to the task execution results, wherein the dialogue analysis test task is determined according to the target dialogue analysis task.

[0025] According to a sixth aspect of the embodiments of this specification, a data processing apparatus for a dialogue analysis task is provided, comprising:

[0026] The first determining module is configured to determine the execution trajectory data of the target dialogue analysis task, wherein the execution trajectory data is the trajectory data generated by the first agent relying on the first model to execute the target dialogue analysis task;

[0027] The first generation module is configured to use the first intelligent agent to generate an intelligent component library based on the execution trajectory data and system constraints, wherein the system constraints are determined based on the model configuration of the second model on which the second intelligent agent depends, and the model configuration of the first model is greater than the model configuration of the second model.

[0028] The second generation module is configured to use the first intelligent agent to generate a dialogue analysis reference workflow based on the execution trajectory data and the intelligent component library;

[0029] The second determining module is configured to utilize the second intelligent agent to execute a dialogue analysis test task based on the dialogue analysis reference workflow and the intelligent component library, and to determine a dialogue analysis target workflow set based on the task execution results, wherein the dialogue analysis test task is determined based on the target dialogue analysis task.

[0030] According to a seventh aspect of the embodiments of this specification, a computing device is provided, comprising:

[0031] Memory and processor;

[0032] The memory is used to store computer programs / instructions, and the processor is used to execute the computer programs / instructions. When the computer programs / instructions are executed by the processor, they implement the steps of the above-described data processing method, task processing method, or data processing method applied to a dialogue analysis task.

[0033] According to an eighth aspect of the embodiments of this specification, an electronic device is provided, comprising:

[0034] A memory and a processor, the memory and the processor being connected via a bus;

[0035] The memory is used to store computer programs / instructions, and the processor is used to execute the computer programs / instructions. When the computer programs / instructions are executed by the processor, they implement the steps of the above-described data processing method, task processing method, or data processing method applied to a dialogue analysis task.

[0036] According to a ninth aspect of the embodiments of this specification, a computer-readable storage medium is provided that stores a computer program / instructions, which, when executed by a processor, implement the steps of the above-described data processing method, task processing method, or data processing method applied to a dialogue analysis task.

[0037] According to a tenth aspect of the embodiments of this specification, a computer program product is provided, including a computer program / instructions that, when executed by a processor, implement the steps of the above-described data processing method, task processing method, or data processing method applied to a dialogue analysis task.

[0038] One embodiment of this specification implements a data processing method, comprising: determining execution trajectory data of a target task, wherein the execution trajectory data is trajectory data generated by a first intelligent agent executing the target task using a first model; using the first intelligent agent, generating an intelligent component library based on the execution trajectory data and system constraints, wherein the system constraints are determined based on the model configuration of a second model used by a second intelligent agent, and the model configuration of the first model is greater than the model configuration of the second model; using the first intelligent agent, generating a reference workflow based on the execution trajectory data and the intelligent component library; using the second intelligent agent, executing a test task based on the reference workflow and the intelligent component library, and determining a target workflow set based on the task execution results, wherein the test task is determined based on the target task.

[0039] This data processing method collects execution trajectory data of a first agent relying on a first model (i.e., a strong model) to perform a target task. Using this execution trajectory data and system constraints determined by the model configuration of a second model (i.e., a weak model) relied upon by the first agent of the strong model, a library of intelligent components adapted to the weak model is generated. These independently reusable intelligent components adapted to the weak model allow the strong model's intelligent components to be directly reused by the weak model without additional training, ensuring that the task execution capabilities of the strong model can be reused at high quality despite low cost for the second agent relying on the weak model. Simultaneously, using the first agent of the strong model, a reference workflow is generated based on the execution trajectory data and the intelligent component library, standardizing the task execution path. This allows the second agent of the weak model to efficiently perform test tasks based on this reference workflow, eliminating the dynamic search redundancy caused by the flexibility of the first agent of the strong model, reducing inference time, and improving efficiency and stability. Finally, using the second agent of the weak model, test tasks are executed based on the reference workflow and the intelligent component library. The final target workflow set is then precipitated based on the task execution results. Through the closed-loop test and verification mechanism of the second agent of the weak model, boundary risks are intercepted to ensure output consistency and improve the stability of the second agent of the weak model in task execution. Attached Figure Description

[0040] Figure 1 This is a schematic diagram illustrating an application scenario of a data processing method provided in one embodiment of this specification;

[0041] Figure 2 This is a flowchart illustrating a data processing method provided in one embodiment of this specification;

[0042] Figure 3This is a flowchart illustrating the processing procedure of a data processing method provided in one embodiment of this specification.

[0043] Figure 4 This is a schematic diagram of the structure of a data processing apparatus provided in one embodiment of this specification;

[0044] Figure 5 This is a structural block diagram of a computing device provided in one embodiment of this specification;

[0045] Figure 6 This is a structural block diagram of an electronic device provided in one embodiment of this specification. Detailed Implementation

[0046] Many specific details are set forth in the following description to provide a full understanding of this specification. However, this specification can be implemented in many other ways than those described herein, and those skilled in the art can make similar extensions without departing from the spirit of this specification. Therefore, this specification is not limited to the specific implementations disclosed below.

[0047] The terminology used in one or more embodiments of this specification is for the purpose of describing particular embodiments only and is not intended to be limiting of the one or more embodiments of this specification. The singular forms “a,” “described,” and “the” as used in one or more embodiments of this specification and the appended claims are also intended to include the plural forms unless the context clearly indicates otherwise. It should also be understood that the term “and / or” as used in one or more embodiments of this specification refers to and includes any or all possible combinations of one or more associated listed items.

[0048] It should be understood that although the terms first, second, etc., may be used to describe various information in one or more embodiments of this specification, such information should not be limited to these terms. These terms are only used to distinguish information of the same type from one another. For example, first may also be referred to as second without departing from the scope of one or more embodiments of this specification, and similarly, second may also be referred to as first. Depending on the context, the word "if" as used herein may be interpreted as "when," "when," or "in response to a determination."

[0049] Furthermore, it should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, stored data, displayed data, etc.) involved in one or more embodiments of this specification are all information and data authorized by the user or fully authorized by all parties. Moreover, the collection, use and processing of related data must comply with the relevant laws, regulations and standards of the relevant countries and regions, and corresponding operation entry points are provided for users to choose to authorize or refuse.

[0050] In one or more embodiments of this specification, a large model refers to a deep learning model with a large number of model parameters, typically containing hundreds of millions, tens of billions, hundreds of billions, trillions, or even tens of trillions of model parameters. A large model can also be called a foundation model. It is pre-trained using large-scale unlabeled corpora to produce a pre-trained model with hundreds of millions of parameters. Such models can adapt to a wide range of downstream tasks and have good generalization ability. Examples include Large Language Models (LLMs) and multi-modal pre-training models.

[0051] In practical applications, large models only require a small number of samples to fine-tune the pre-trained model before they can be applied to different tasks. Large models can be widely used in fields such as Natural Language Processing (NLP) and Computer Vision. Specifically, they can be applied to computer vision tasks such as Visual Question Answering (VQA), Image Captioning (IC), and Image Generation, as well as natural language processing tasks such as text-based sentiment classification, text summarization, and machine translation. The main application scenarios of large models include digital assistants, intelligent robots, search, online education, office software, e-commerce, and intelligent design.

[0052] First, the terms and concepts used in one or more embodiments of this specification will be explained.

[0053] MCP: ModelContextProtocol is an open standard protocol in the field of large models, designed to solve compatibility and interoperability issues between models and external tools / data sources.

[0054] Agent: In the fields of computer science and information technology, especially in artificial intelligence and software engineering, an agent generally refers to an entity or program that can perceive the environment, understand input information, and make decisions and take actions according to preset goals and rules.

[0055] LLMAgent: Large Language Model-based Agent.

[0056] Strong and weak models: Strong models typically have high complexity, can capture subtle patterns in the data, have a large hypothesis space, can represent relatively complex functional relationships, and have strong expressive and reasoning abilities. Weak models are relatively simple, generally only capturing relatively obvious or basic patterns in the data. Compared with strong models, weak models have a smaller hypothesis space, can only represent relatively simple functional relationships, and have weaker expressive and reasoning abilities.

[0057] Token: The meaning of a token varies depending on the specific application scenario. For example, in text processing and natural language processing tasks, tokenization is the process of segmenting text into words, punctuation marks, or other meaningful fragments. Each such fragment is a "token." For instance, the sentence "I like cats." can be segmented into three tokens: "I," "like," and "cat."

[0058] To address the aforementioned technical problems, this specification provides a data processing method. This specification also relates to a data processing apparatus, a computing device, an electronic device, a computer-readable storage medium, and a computer program product, which will be described in detail in the following embodiments.

[0059] Considering the large number of model parameters in large models and the limited computing resources of mobile terminals, the data processing method provided in this application can be applied to, for example, Figure 1 The application scenarios shown are not limited to these. See also Figure 1 , Figure 1 This is a schematic diagram illustrating an application scenario of a data processing method provided in one embodiment of this specification. Figure 1 In the application scenario shown, the large model is deployed on server 10. Server 10 can connect to one or more client devices 20 via a local area network (LAN), wide area network (WAN), internet connection, or other types of data network. These client devices 20 may include, but are not limited to, smartphones, tablets, laptops, PDAs, personal computers, smart home devices, and in-vehicle devices. Client devices 20 can interact with users through a graphical user interface to access the large model, thereby implementing the methods provided in the embodiments of this specification.

[0060] In the embodiments described in this specification, the system consisting of a client device and a server can perform the following steps: The client device performs the following steps:

[0061] Receive the target workflow set generation task sent by the user through the graphical user interface of the client device, and send the target workflow set generation task to the server.

[0062] The server executes a data processing method provided in one embodiment of this specification to complete the task of generating a target workflow set. The specific implementation steps are as follows:

[0063] Determine the execution trajectory data of the target task, wherein the execution trajectory data is the trajectory data generated by the first intelligent agent relying on the first model to execute the target task;

[0064] Using the first intelligent agent, an intelligent component library is generated based on the execution trajectory data and system constraints, wherein the system constraints are determined based on the model configuration of the second model on which the second intelligent agent depends, and the model configuration of the first model is greater than the model configuration of the second model;

[0065] Using the first intelligent agent, a reference workflow is generated based on the execution trajectory data and the intelligent component library;

[0066] Using the second intelligent agent, test tasks are executed according to the reference workflow and the intelligent component library, and a target workflow set is determined based on the task execution results, wherein the test tasks are determined according to the target tasks.

[0067] Specifically, the first agent that relies on the first model can be understood as an agent that relies on a strong model; the second agent that relies on the second model can be understood as an agent that relies on a weak model.

[0068] It should be noted that, provided that the client device's operating resources can meet the deployment and operation conditions of the large model, the embodiments of this application can be performed on the client device.

[0069] The data processing method provided in one or more embodiments of this specification uses the execution trajectory data of a strong model agent in a target task (such as a complex deep analysis task) and combines it with system constraints determined according to the model configuration of a weak model to generate an intelligent component library containing independent, reusable intelligent components adapted to the weak model agent. This allows the strong model agent to automatically generate a reference workflow corresponding to the target task based on the execution trajectory data and the intelligent components in the intelligent component library. At the same time, the closed-loop testing and verification mechanism based on the weak model agent precipitates the final target workflow set containing the target workflow. This enables the weak model agent to efficiently and stably complete tasks that are the same as or similar to the target task when it subsequently executes such tasks, effectively reducing the cost of using large models and improving the stability and execution efficiency of weak model-based agents.

[0070] See Figure 2 , Figure 2A flowchart of a data processing method according to an embodiment of this specification is shown, which specifically includes the following steps.

[0071] Step 202: Determine the execution trajectory data of the target task.

[0072] The execution trajectory data refers to the trajectory data generated by the first intelligent agent in executing the target task using the first model.

[0073] The data processing method provided in one or more embodiments of this specification can be applied to various in-depth analysis application scenarios, such as customer service and sales, including customer service satisfaction analysis and customer churn analysis. Of course, this data processing method is not only applicable to customer service and sales, but also to fields with in-depth analysis needs, such as finance and insurance (risk analysis scenarios) and healthcare (treatment plan analysis scenarios). For ease of understanding, the data processing method provided in one or more embodiments of this specification is described in detail using an in-depth analysis application scenario in the customer service field as an example.

[0074] Specifically, the target task varies depending on the application scenario of deep analytics. For example, if the application scenario is customer service, the target task could be a customer service satisfaction analysis task; if the application scenario is finance and insurance, the target task could be a risk analysis task for abnormal transactions, and so on. For ease of understanding, this specification uses customer service satisfaction analysis as an example in one or more embodiments.

[0075] In this context, the first model can be understood as the large model, such as the strong model mentioned above. The first agent that depends on the first model can be understood as the agent of the strong model. Therefore, when the first agent that depends on the first model is the agent of the strong model, the execution trajectory data of the target task can be understood as the complete trajectory data of the target task collected when the agent of the strong model completes the execution of the target task in the target task set. In specific implementations, the target task set may include multiple target tasks, such as, but not limited to, satisfaction analysis tasks and customer churn analysis tasks. This specification uses satisfaction analysis as an example in one or more embodiments. The processing of other target tasks in the target task set can be referred to this target task, and will not be elaborated upon here.

[0076] In practical applications, there are two main methods for collecting execution trajectory data of a target task. One method is to use a strong model agent to actually execute the target task once, recording each step and its underlying execution details in real time during the process. The other method is to obtain the historical logs of the target task, replace them with the historical logs, and re-execute the task, retrieving the real-time execution details of each step during the strong model agent's execution of the target task. The specific implementation methods are as follows:

[0077] The execution trajectory data for determining the target task includes:

[0078] Determine a set of target tasks, wherein the set of target tasks includes the target tasks;

[0079] The first intelligent agent is used to execute the target task to obtain the execution trajectory data of the target task;

[0080] or

[0081] The execution trajectory data of the target task is obtained from the historical execution log of the first intelligent agent executing the target task.

[0082] Specifically, the first step is to define the set of target tasks. This set can include multiple target tasks, which should cover the typical difficulties and diversity in the target application scenario. For example, in the customer service field, multiple target tasks could be satisfaction analysis, customer churn analysis, customer complaint analysis, etc. In practical applications, each target task can be iterated over, and the strong model's agent can be used to execute each target task to obtain the execution trajectory data for each target task; alternatively, the execution trajectory data for each target task can be obtained from the historical execution logs of the strong model's agent executing each target task.

[0083] Suppose that one of the target tasks in the defined set of target tasks is "to write a satisfaction analysis report that meets the specific format requirements based on the given data (satisfaction analysis.xlsx) and format requirements (report_format_requirements.txt)".

[0084] The strong model agent is used to execute the target task. During the execution of the target task, the thinking and operation process of the strong model agent at each step is recorded completely and in detail. This record can be understood as the execution trajectory data of the target task. The execution trajectory data of the target task includes the execution flow (Traj0) of the strong model agent when actually executing the target task, as well as the decisions and operations that the strong model agent makes when actually executing each step of the execution flow. That is, it includes the triple information of the strong model agent's internal detailed reasoning process (reasoning, rj), tool call (action, aj), tool feedback (observation, oj) when executing each step.

[0085] For example, the execution flow (Traj0) includes the following steps:

[0086] (1) View and extract the data in the file "Satisfaction Analysis.xlsx", including dialogue ID, dialogue content, project scenario, satisfaction, date ID and nickname, and provide a data overview.

[0087] (2) Review and extract the report format requirements from the "report_format_requirements.txt" file to ensure you understand the specific structure and content requirements of the report.

[0088] (3) Analyze the satisfaction data, calculate the overall satisfaction rate and the daily dimension satisfaction rate change trend, and generate the corresponding trend chart.

[0089] (4) Identify and analyze the project scenarios that need to be focused on, including calculating the satisfaction rate, dissatisfaction rate and contribution of each project scenario, and generating detailed indicator data tables.

[0090] (5) Conduct in-depth analysis of key project scenarios, analyze the reasons for customer dissatisfaction (product dissatisfaction, service dissatisfaction), customer service solution types (unmet needs, delayed satisfaction, satisfied needs), customer service satisfaction rate and evaluation status.

[0091] (6) Based on the analysis results above and the format requirements in report_format_requirements.txt, write a complete satisfaction analysis report, including the achievement of the satisfaction rate target, key project scenarios and their in-depth interpretation.

[0092] Therefore, for step (3), analyzing the satisfaction data, calculating the overall satisfaction rate and the daily dimension satisfaction rate trend, and generating the corresponding trend chart, the information of a certain triplet may include the following:

[0093] Reasoning process: "The user requests to calculate the overall satisfaction rate. I need to read the 'Satisfaction Analysis.xlsx' file first. The file path is known to be '. / data / Satisfaction Analysis.xlsx'. I will use the aa tool to read it."

[0094] Tool call: call_tool(name="aa", arguments={"file_path": ". / data / satisfaction analysis.xlsx"}).

[0095] Tool Feedback: {"status": "success", "content": {"columns": ["dialogue ID", "dialogue content", "project scenario", "satisfaction", "date ID", "nickname"], "data": [[1, "dialogue text 1...", "scenario A", "satisfied", 20240101, "customer service 1"], [2, "dialogue text 2...", "scenario B", "unsatisfied", 20240101, "customer service 2"], ... ]}}.

[0096] The data processing method provided in one or more embodiments of this specification can be implemented in at least two ways to collect execution trajectory data of a target task. One approach is to use a strong model agent to re-execute the target task, thereby collecting the execution trajectory data. When re-executing the target task, the strong model agent can generate appropriate execution trajectory data reflecting the current environment and model state, and may explore different execution trajectory data of the target task based on changes in the model or environment. The other approach is to obtain the execution trajectory data of the target task from historical execution logs when the strong model agent has already completed the target task. This eliminates the need for additional computing resources and time costs to re-execute the target task, improving the data collection time and overall efficiency of the data processing method.

[0097] Step 204: Using the first intelligent agent, generate an intelligent component library based on the execution trajectory data and system constraints.

[0098] The system constraints are determined based on the model configuration of the second model that the second agent depends on, and the model configuration of the first model is greater than the model configuration of the second model.

[0099] Specifically, after collecting the execution trajectory data of the target task using a strong model agent, the strong model agent can then be used to construct an intelligent component library containing multiple intelligent components based on the execution trajectory data and system constraints. The purpose of this step is to transform the collected execution trajectory data of the target task, under system constraints, into multiple modular, reusable intelligent components that can be understood and executed by a weak model, thereby generating the intelligent component library.

[0100] In practical implementation, the second model can also be understood as the larger model, such as the weak model mentioned above. The second agent that depends on the second model can then be understood as the agent of the weak model. System constraints are determined based on the model configuration of the weak model; for example, system constraints can be defined based on the weak model's maximum context length, maximum output token limit, available tool list, or memory limit. The model configuration of the first model is greater than that of the second model; this can be understood as the strong model's model configuration being greater than that of the weak model. Here, model configuration includes, but is not limited to, model parameters, maximum processing context length, and maximum output token limit.

[0101] In practical applications, the intelligent component library can include multiple intelligent components. Each intelligent component can be understood as an MCP, which is an independent functional module that encapsulates specific logic or operations. It encapsulates the complex reasoning and operational capabilities of the strong model agent in the execution trajectory data into a standardized component that the weak model agent can understand and execute reliably. That is, for each execution trajectory data, the logic of each subtask (such as specific tool calls, information extraction, etc.) will be encapsulated into an independent MCP.

[0102] Specifically, the generation of the intelligent component library involves two steps: first, a set of intelligent components is generated using a strong model agent; then, the strong model agent performs structuring processing on multiple intelligent components in the intelligent component set; and finally, the intelligent component library is generated based on these structured intelligent components. The specific implementation method is as follows:

[0103] The step of generating an intelligent component library using the first intelligent agent based on the execution trajectory data and system constraints includes:

[0104] Using the first intelligent agent, a set of intelligent components is generated based on the execution trajectory data and system constraints, wherein the set of intelligent components includes multiple intelligent components;

[0105] Using the first intelligent agent, the plurality of intelligent components are structured to obtain the processed plurality of intelligent components, and the intelligent component library is generated based on the processed plurality of intelligent components.

[0106] In practice, the generation of the intelligent component library is achieved through two steps. First, a strong model agent is used to design the generation process and overall control of intelligent components based on the execution trajectory data of the target task and system constraints. Multiple intelligent components are generated according to the generation process and overall control. Second, the strong model agent is used to perform structured processing on the multiple generated intelligent components, and the processed intelligent components are put into the intelligent component library to realize the generation of the intelligent component library.

[0107] Of course, in a fixed, single scenario (such as daily reports that are exactly the same), a strong model agent can be used to design the generation process and overall control of intelligent components based on the execution trajectory data of the target task and system constraints. After generating multiple intelligent components according to the generation process and overall control of the intelligent components, the multiple intelligent components are no longer structured and are directly put into the intelligent component library to realize the generation of the intelligent component library.

[0108] The data processing method provided in one or more embodiments of this specification generates a set of intelligent components based on the execution trajectory data of the target task and system constraints using a strong model agent. Then, the strong model agent performs structured processing on multiple intelligent components in the set, generating an intelligent component library based on these structured components. This method refines and integrates scattered sets of intelligent components, which may contain redundancy or specific task details, into a general, parameterized intelligent component library. This allows the intelligent component library to be flexibly applied to different tasks within the same domain (such as generating monthly reports or satisfaction reports for different products), and is not limited to generating target tasks (such as writing a satisfaction analysis report that meets specific format requirements based on given data (satisfaction analysis.xlsx) and format requirements (report_format_requirements.txt).

[0109] The generation of the smart component collection is also achieved through two execution steps, as detailed below:

[0110] The step of generating a set of intelligent components using the first intelligent agent based on the execution trajectory data and system constraints includes:

[0111] Using the first intelligent agent, multiple intelligent component generation tasks are generated based on the execution trajectory data and system constraints;

[0112] Using the first intelligent agent, tasks are generated based on the multiple intelligent components, and multiple intelligent components are constructed to generate the intelligent component set.

[0113] Each intelligent component generation task can be understood as a detailed plan for the strong model agent to generate intelligent components for the next step, based on the execution trajectory data of the target task and system constraints. This plan includes at least the following: identifying logically independent or reusable sub-task units that repeatedly appear in the trajectory based on the analysis of the target task's execution trajectory data; defining the input and output interface specifications for each intelligent component; defining the generation strategy and constraints for each intelligent component; and ensuring that each generated intelligent component meets the system constraints.

[0114] Specifically, firstly, the Planner, using a strong model agent, designs the intelligent component generation process (i.e., how to analyze execution trajectory data, how to identify encapsulated subtasks, etc.), overall control (e.g., guiding the intelligent component generator, receiving environmental feedback, and dynamically adjusting the generation strategy based on feedback), and considers constraints (e.g., ensuring that the generated intelligent components and their combined workflows can operate effectively under system constraints), based on the execution trajectory data of the target task and system constraints (such as the maximum context length of the weak model, the maximum output token limit, the list of available tools, and memory limitations). Then, with the intelligent component generation process, overall control, and constraints considered, multiple executable intelligent component generation plans are generated, i.e., multiple intelligent component generation tasks. Next, the Planner sends these multiple intelligent component generation tasks to the Intelligent Component Generator (MCP Creator). The Intelligent Component Generator then uses the strong model agent to generate intelligent components corresponding to these tasks and adds them to the intelligent component set, thus achieving the generation of the intelligent component set.

[0115] Continuing with the previous example, using the first intelligent agent, based on execution trajectory data and system constraints, multiple intelligent component generation tasks can be generated, including but not limited to:

[0116] 1. Obtain the MCP (Mean Choice) for overall satisfaction rate;

[0117] 2. Obtain the daily satisfaction rate (MCP);

[0118] 3. Calculate the MCP of satisfaction data indicators for each project scenario;

[0119] 4. Identify MCPs (Multi-Channel Programming Processes) that require special attention in specific scenarios;

[0120] 5. MCPs that provide in-depth analysis of key project scenarios;

[0121] 6. When writing the MCP report, the output length limit of the weak model needs to be considered.

[0122] Of course, in practical applications, each smart component generation task contains more than just the information shown in the example. For details, please refer to the detailed explanation of smart component generation tasks above. This is just an example.

[0123] The data processing method provided in one or more embodiments of this specification first utilizes a strong model agent to generate multiple intelligent component generation tasks based on execution trajectory data and system constraints; then, the strong model agent utilizes these intelligent component generation tasks to construct multiple intelligent components, thereby generating an intelligent component set. By splitting the generation of the intelligent component set into two implementation steps, each implemented through a different module, such as through the collaborative work of a planner and an intelligent component generator, the intelligent component set generation can be achieved. This allows the planner to focus on the reusability design of the intelligent components, while the intelligent component generator can focus on the robustness implementation of the intelligent components, thus generating a highly reusable and robust intelligent component set.

[0124] Furthermore, to ensure the availability and stability of the generated intelligent components, during the process of generating multiple intelligent components using a strong model agent based on multiple intelligent component generation tasks, corresponding component scripts can be generated first based on each intelligent component generation task. Then, each component script is input into a virtual environment for execution, and the intelligent component is constructed based on the script execution results. The specific implementation method is as follows:

[0125] The step of utilizing the first intelligent agent to generate tasks based on the multiple intelligent components and constructing multiple intelligent components includes:

[0126] Using the first intelligent agent, generate component scripts corresponding to each component generation task according to each component generation task in the plurality of intelligent component generation tasks;

[0127] The component scripts corresponding to the generation tasks of each component are input into the virtual environment for execution, the script execution results of each component script are obtained, and multiple intelligent components are constructed based on the script execution results of each component script.

[0128] Specifically, for each intelligent component generation task among multiple intelligent component generation tasks, a strong model agent is used to analyze the reasoning process and tool calls, extracting tool call patterns and data processing logic, and then generating a basic component script corresponding to each intelligent component generation task. After generating the basic component script for each intelligent component generation task, a virtual environment is created, and the basic component script for each intelligent component generation task is input into the virtual environment for execution and verification. The script execution results for each intelligent component generation task are obtained, and multiple intelligent components are constructed based on the script execution results. Furthermore, following the previous example, this step can be implemented by executing an intelligent component generator.

[0129] The data processing method provided in one or more embodiments of this specification, in the process of constructing multiple intelligent components by generating tasks based on multiple intelligent components using a strong model agent, breaks down the generation process of each intelligent component into two steps: first, generating a component script; second, inputting it into a virtual environment for execution; and third, constructing the intelligent component based on the execution result. During the component script generation stage, core logic can be centrally implemented, improving the code quality and reusability of the component scripts. Furthermore, testing the component scripts in an isolated virtual environment effectively verifies their feasibility and robustness, identifies potential problems early, and reduces risks in subsequent use. This separation of development and verification facilitates the debugging and optimization of intelligent components, improving the overall controllability and maintainability of the intelligent component construction.

[0130] Specifically, the implementation method for executing component scripts in a virtual environment and constructing multiple smart components based on the script execution results is as follows:

[0131] The step involves inputting the component scripts corresponding to the component generation tasks into a virtual environment for execution, obtaining the script execution results of each component script, and constructing multiple intelligent components based on the script execution results of each component script, including:

[0132] The target component script corresponding to the target component generation task is input into the virtual environment for execution to obtain the script execution result of the target component script, wherein the target component generation task is any one of the plurality of intelligent component generation tasks;

[0133] If the execution result of the target component script determines that the target component script has been executed successfully, the target component script is encapsulated to construct a target intelligent component, wherein the target intelligent component is any one of the plurality of intelligent components;

[0134] If, based on the script execution result of the target component script, it is determined that the target component script has failed to execute, the target component script is updated using the script execution result of the target component script, and the step of inputting the target component script corresponding to the target component generation task into the virtual environment for execution to obtain the script execution result of the target component script continues to be executed.

[0135] In practice, for each component generation task, a corresponding component script is generated. This component script is then input into a virtual environment for execution, and the execution result is obtained. Each component script input into the virtual environment can be understood as a target component script. If the execution result of the target component script confirms successful execution, the target component script is then encapsulated to generate a target intelligent component. This target intelligent component can be understood as any one of the multiple intelligent components subsequently constructed.

[0136] If the execution result of the target component script indicates that the script failed, it is necessary to analyze the reason for the failure based on the script execution result and classify the error (such as logical error, dependency problem, performance limit exceeding, etc.). Then, the target component script is updated according to the error situation (e.g., by correcting the script through a strong model agent). After the update is successful, the updated target component script is executed again in a virtual environment until the updated target component script executes successfully in the virtual environment. Of course, in rare cases, after iterating and executing a target component script multiple times, in order to ensure the stability of the production environment, the target component script that meets the iteration number can be encapsulated and constructed into a target intelligent component.

[0137] The data processing method provided in one or more embodiments of this specification, in order to ensure the reliability of the constructed intelligent components, requires that after generating the component script corresponding to each component generation task, the component script be input into a virtual environment for execution. If the execution result of the component script is successful, it is encapsulated to realize the intelligent component construction. If the execution result of the component script fails, the script is corrected using a strong model agent, and then executed again in the virtual environment. Through this verification and multiple iterations of correction, until the corrected component script can be successfully executed, it is encapsulated to realize the intelligent component construction, thus ensuring the quality of the constructed intelligent components and improving the usability and reliability of the intelligent components.

[0138] After generating a set of intelligent components based on multiple intelligent components, to ensure the set's versatility and flexibility, it's necessary to perform structuring on these components to obtain structured intelligent components. Based on these structured components, a highly reusable, universal, and easily managed intelligent component library can then be generated. The specific implementation method is as follows:

[0139] The step of using the first intelligent agent to perform structured processing on the plurality of intelligent components to obtain the processed plurality of intelligent components includes:

[0140] Using the first intelligent agent, the plurality of intelligent components are abstracted to obtain the plurality of abstracted intelligent components;

[0141] Using the first intelligent agent, clustering is performed on the multiple intelligent components after abstraction to obtain multiple intelligent components after clustering.

[0142] Using the first intelligent agent, the multiple intelligent components after clustering are merged to obtain multiple intelligent components after merging, thus obtaining multiple intelligent components after processing.

[0143] Specifically, the first intelligent agent is used to abstract the multiple intelligent components to obtain multiple abstract intelligent components. This can be understood as using a strong model agent to analyze the specific implementation code of each intelligent component, and performing abstraction processes such as parameterization, removal of task-specific dependencies, retention of general strategies, and improvement of reusability on each intelligent component to obtain multiple abstract intelligent components, making each intelligent component a callable module with clearly defined parameters.

[0144] Using the previous example, the intelligent component MCP1 (which calculates the overall satisfaction rate) may have a fixed file path ". / data / satisfaction analysis.xlsx" in its underlying implementation code.

[0145] After abstraction, MCP1 is rewritten by the strong model LLM, replacing the hard-coded file path with an input parameter, enabling MCP1 to calculate the overall satisfaction rate in any specified file. That is, the underlying code implementation of each intelligent component is extracted, and the LLM is called to rewrite the implementation code into a parameterized, reusable form, removing task-specific dependencies and retaining only general strategies.

[0146] Using the first intelligent agent, clustering is performed on the abstracted intelligent components to obtain clustered intelligent components. This can be understood as using a strong model agent to analyze the core function of each abstracted intelligent component. Based on functional similarity or correlation, the abstracted intelligent components are grouped. For example, the strong model agent identifies intelligent components with the same or similar functions, or those frequently used together, and clusters these components together to prepare for the next merging step. For instance, if two abstracted intelligent components both calculate satisfaction rates, they will be clustered together. In other words, all abstracted MCPs are clustered by function to obtain a grouped set.

[0147] Using the first intelligent agent, the clustered intelligent components are merged to obtain merged intelligent components. This can be understood as using the agent of a strong model to analyze all intelligent components within each group, merging multiple similar intelligent components within a group into a single, universal interface intelligent component. However, for intelligent components that need to be merged, such as two intelligent components whose core function is to calculate satisfaction rate, simply merging file parameters is insufficient because the two intelligent components may have different calculation dimensions besides file paths. Therefore, when merging intelligent components, the strong model needs to fuse and expand the parameters, not only covering the functions of the two intelligent components but also enabling the merged intelligent component to have the extended capability of calculating satisfaction rate according to any specified dimension. That is, for each group of MCPs after clustering, MCPs with similar kinetic energy are merged into a parameterized universal interface, generating the final intelligent component library.

[0148] The data processing method provided in one or more embodiments of this specification utilizes a strong model agent to abstract, merge, and cluster multiple intelligent components sequentially, transforming and merging them into a more powerful and configurable general-purpose intelligent component. By merging intelligent components with similar functions, the number of intelligent components in the subsequent intelligent component library is reduced, making the intelligent component library easier to manage and use. Through parameterized design, a single intelligent component can be applied to various specific needs, improving the reusability and flexibility of intelligent components. The weak model agent also does not need to call multiple intelligent components to complete a logical function, reducing task execution complexity and the probability of errors. Furthermore, based on the intelligent components in the structured intelligent component library, workflows for solving complex tasks can be combined more efficiently and clearly.

[0149] Step 206: Using the first intelligent agent, a reference workflow is generated based on the execution trajectory data and the intelligent component library.

[0150] Specifically, after the intelligent component library is built, a strong model agent can be used to generate a reference workflow for the target task based on execution trajectory data and the intelligent component library. The specific implementation method is as follows:

[0151] The step of generating a reference workflow using the first intelligent agent based on the execution trajectory data and the intelligent component library includes:

[0152] Using the first intelligent agent, the execution trajectory data is analyzed, and based on the analysis results of the execution trajectory data and the component capabilities of the intelligent components in the intelligent component library, a reference workflow corresponding to the target task is generated.

[0153] In practice, the execution trajectory data of the target task and the intelligent component library generated in the above steps are input into the agent of the strong model. The agent of the strong model will analyze each step of the execution process in the execution trajectory data and, in combination with the capabilities of each intelligent component in the intelligent component library, generate a corresponding reference workflow for the target task.

[0154] Continuing with the previous example, the strong model's agent, based on the execution trajectory data of the target task and the intelligent component library generated in the above steps, produces the following reference workflow:

[0155] 1. Obtain the overall satisfaction rate;

[0156] 2. Obtain the daily satisfaction rate trend;

[0157] 3. Calculate the satisfaction data indicators for each project scenario;

[0158] 4. Identify the scenes that require special attention;

[0159] 5. Conduct in-depth analysis of key project scenarios;

[0160] 6. Report writing.

[0161] Of course, the actual implementation of the reference workflow will also include the calling information of smart components in the smart component library in each step. The above reference workflow is only an illustrative example.

[0162] The data processing method provided in one or more embodiments of this specification utilizes a strong model agent to analyze the execution trajectory data of a target task, and combines the component capabilities of intelligent components in an intelligent component library to transform the unstructured inference chain of the strong model agent for the target task into a structured sequence of operation instructions (i.e., a reference workflow) that a weak model agent can implement. In other words, the dynamic search capability of the strong model agent is transformed into a standardized scheme that the weak model agent can execute, so that the reference workflow of the target task retains the breakthrough capability of the strong model agent while obtaining the scalability benefits of the weak model agent.

[0163] Step 208: Using the second intelligent agent, execute the test task according to the reference workflow and the intelligent component library, and determine the target workflow set based on the task execution results.

[0164] The test task is determined based on the target task.

[0165] In practice, test tasks can be either the target task or test tasks generated by sampling the target task. To test the robustness of the reference workflow and intelligent component library under different data distributions and task requirements, expose potential boundary conditions, missing error handling, and model comprehension biases, and provide rich feedback data sources for closed-loop optimization, the target task can be sampled in various ways to generate multiple variants of smaller-scale test tasks. By simulating the diversity and boundary conditions of real-world scenarios, a superior set of target workflows can be derived. The specific implementation method is as follows:

[0166] The step of utilizing the second intelligent agent to execute test tasks according to the reference workflow and the intelligent component library, and determining the target workflow set based on the task execution results, includes:

[0167] The target task is sampled to generate the test task;

[0168] The reference workflow and the test task are input into the second agent to obtain the task execution result of the second agent calling the intelligent components in the intelligent component library based on the reference workflow to execute the test task;

[0169] Based on the task execution results and the reference workflow, determine the target workflow set.

[0170] This involves sampling the target task, including but not limited to randomly sampling the original data file corresponding to the target task (e.g., taking only 50% of the data from the original data file); performing time slicing (e.g., analyzing only data from a specific week); constructing specific scenarios (e.g., including only data from a particular project scenario, constructing data missing / anomalies, etc.); and modifying the requirements of the target task (e.g., requiring the report to include specific metrics). Through diverse sampling of the target task, multiple test tasks are generated.

[0171] For each test task, the test task, its corresponding data, and a reference workflow are input into the weak model's agent. The weak model's agent, combined with components from the intelligent component library, executes each test task and generates the task execution result. Based on the task execution result and the reference workflow, a suitable target workflow is derived and added to the target workflow set to generate the target workflow set.

[0172] The data processing method provided in one or more embodiments of this specification generates diverse test tasks, generates reference workflows, executes each test task using a strong model agent combined with an intelligent component library, and generates a target workflow set based on the task execution results of each test task and the reference workflow. Through repeated trial and error and optimization on diverse test tasks, this method ensures that the final target workflow set and intelligent component library can cover various real-world scenarios and can be stably and reliably executed by a weak model agent.

[0173] Furthermore, when the weak model's agent can stably and successfully execute the corresponding reference workflow or optimized reference workflow on all test tasks, the reference workflow or optimized reference workflow can be considered mature and can be added to the target workflow set for subsequent task execution. The specific implementation method is as follows:

[0174] The step of determining the target workflow set based on the task execution results and the reference workflow includes:

[0175] If the test task is determined to have been successfully executed based on the task execution result, the reference workflow is determined as the target workflow for the target task.

[0176] If, based on the task execution result, it is determined that the test task has failed, the intelligent component library and / or the reference workflow are updated, and the step of inputting the reference workflow and the test task into the second intelligent agent to obtain the task execution result of the second intelligent agent calling the intelligent components in the intelligent component library based on the reference workflow to execute the test task is continued.

[0177] Based on the target workflow, determine the target workflow set.

[0178] In practical applications, each target task can be sampled into multiple test tasks. When each test task is executed, the corresponding reference workflow can be understood as the reference workflow generated by the agent using a strong model based on the execution trajectory data of its corresponding target task and the intelligent component library.

[0179] Specifically, if the test task is successfully executed based on the task execution results, then the reference workflow can be designated as the target workflow for the target task. However, in practice, a target task may sample multiple test tasks. There are two possibilities for designating the reference workflow corresponding to the target task as the target workflow: one is that the agent of the strong model can successfully execute the reference workflow on all test tasks corresponding to the target task; the other is that the agent of the strong model can successfully execute the reference workflow on more than 80% of the test tasks corresponding to the target task.

[0180] If the test task fails based on the execution results, it is necessary to analyze the cause of the failure and update the intelligent component library accordingly (e.g., the MCP did not consider empty data, non-existent files, changed field names (e.g., "Date ID" became "date"), or numerical overflow, etc. Modify the internal logic of the MCP according to the specific error, adding input validation, error handling branches, default values, and compatibility handling; or if the weak model cannot understand the complex parameters or internal logic of a certain MCP, it can be simplified or split into smaller MCPs) and / or refer to the workflow (e.g., modify the step order or dependencies: find that some steps require preconditions that are not met, add necessary steps: if it is found that data cleaning is often required first, add a "data pre-cleaning" step in the Workflow and map it to the corresponding intelligent component library, etc.). Then, based on the updated intelligent component library and / or reference workflow, continue to execute the test steps until the above two successful execution conditions are met.

[0181] The data processing method provided in one or more embodiments of this specification, based on the success or failure of the test task execution result and in conjunction with a reference workflow, generates a low-cost target workflow for each target task by directly accumulating or adjusting the intelligent component library or reference workflow according to the task execution result. This workflow is stably executed by a weak-model agent. Subsequently, when the weak-model agent executes tasks of the same type as the target task, it can directly execute the high-quality, complete task according to the target workflow matched in the target workflow set, ensuring low-cost and highly stable operation.

[0182] Specifically, this data processing method collects execution trajectory data of a first agent relying on a first model (i.e., a strong model) to perform a target task. Using the first agent of the strong model, and based on this execution trajectory data and system constraints determined by the model configuration of the second agent relying on the second model (i.e., a weak model), a library of intelligent components adapted to the weak model is generated. Through these independently reusable intelligent components adapted to the weak model, the intelligent components of the strong model can be directly reused by the weak model subsequently, allowing for the reuse of the strong model's task execution capabilities without additional training. This ensures that the second agent relying on the weak model can still perform complex deep analysis tasks with high quality at low cost. Simultaneously, using the first agent of the strong model, a reference workflow is generated based on the execution trajectory data and the intelligent component library, standardizing the task execution path. This allows the second agent of the weak model to efficiently execute tasks based on this reference workflow, eliminating the dynamic search redundancy caused by the flexibility of the first agent of the strong model, reducing inference time, and improving efficiency and stability. Finally, using the second agent of the weak model, test tasks are executed based on the reference workflow and the intelligent component library. The final target workflow set is then precipitated based on the task execution results. Through the closed-loop test and verification mechanism of the second agent of the weak model, boundary risks are intercepted to ensure output consistency and improve the stability of the second agent of the weak model in task execution.

[0183] Furthermore, after the target workflow set is constructed, when a new task arrives, the weak model agent can be used in conjunction with the matching target workflows in the target workflow set to execute the new task at low cost and high efficiency. The specific implementation method is as follows:

[0184] A task processing method, comprising:

[0185] Receive the task to be executed, use the second intelligent agent to parse the task to be executed, and determine the execution workflow from the target workflow set based on the parsing result;

[0186] Using the second intelligent agent, the task to be executed is performed according to the execution workflow and the intelligent component library, wherein the target workflow set and the intelligent component library are generated according to the above data processing method.

[0187] The task to be executed can be understood as a task of the same type as the target task. For example, if the target task is "to write a satisfaction analysis report that meets specific format requirements based on given data (satisfaction analysis.xlsx) and format requirements (report_format_requirements.txt)," the task to be executed could also be a satisfaction analysis report task based on other given data and format requirements. The execution workflow can be understood as the target workflow contained in the target workflow set that matches the task to be executed.

[0188] Specifically, upon receiving a task to be executed, the weak model's agent first parses the task to obtain the parsing results, which determine the task description, the task data it carries, and the requirements. Then, based on the parsing results, it matches the task with all target workflows in the target workflow set. This matching is typically done using parameters such as task type, input data structure, and output requirements. If a matching target workflow is found in the target workflow set, that workflow is identified as the execution workflow corresponding to the task to be executed. Next, the weak model's agent executes the task based on this execution workflow and the intelligent components in the attached intelligent component library.

[0189] In practical applications, generally, when the task to be executed has a high degree of matching with a target workflow in the target workflow set, that target workflow can be directly selected as the execution workflow corresponding to the task to be executed. Alternatively, when the task to be executed does not match any target workflows in the target workflow set, a target workflow with a high degree of matching can be fine-tuned. For example, if the core logic is the same but the parameters are different, the parameter configuration in the target workflow with a high degree of matching can be extended or modified. If the task to be executed is a combination of multiple existing target tasks, a new target workflow can be constructed by combining the steps of multiple existing target workflows or calling intelligent components from multiple intelligent component libraries. However, if the construction of a new target workflow is triggered, it needs to be treated as a new target task, and according to the specific implementation described above, the complete process of "trajectory collection, intelligent component library construction, reference workflow construction, and target workflow construction" should be executed.

[0190] The data processing method provided in one or more embodiments of this specification, after receiving a task to be executed and determining the execution workflow corresponding to the task, inputs the task to be executed, the execution workflow, and the intelligent component library into the weak model's agent. The weak model's agent understands the structure of the target workflow corresponding to the task to be executed (such as step sequence, dependencies, etc.). For each step in the execution workflow, the weak model's agent determines the intelligent component in the intelligent component library that needs to be called. Based on the execution workflow and the current state, it provides accurate input parameters for the determined intelligent component, executes the calls to these intelligent components, and receives the results after the execution of these intelligent components. It executes the task to be executed step by step according to the logic of the execution workflow. In this way, during the entire execution process of the task to be executed, the weak model's agent does not need to perform complex task planning and multi-step reasoning. It only needs to understand and execute each relatively simple step instruction (such as calling intelligent components) defined in the execution workflow corresponding to the task to be executed, and handle the data transfer between steps, thereby achieving low-cost and high-efficiency task execution.

[0191] Simultaneously, to achieve closed-loop optimization and continuous evolution, when using the weak model agent to execute the task, the target workflows in the intelligent component library and / or target workflow set are also tuned based on the task execution results. The specific implementation is as follows:

[0192] After executing the task to be executed, the process also includes:

[0193] If, based on the execution result of the task to be executed, it is determined that the task to be executed has failed, the intelligent component library and / or the execution workflow are updated.

[0194] Specifically, when using a weak model agent to execute tasks through an execution workflow, the execution results of the tasks can be collected, as well as their execution trajectory data. If the tasks fail to execute (cannot be completed, results are biased, or efficiency is low), the tasks can be processed and feedback collected, and the intelligent components in the intelligent component library and / or the execution workflow can be updated based on the above implementation.

[0195] The data processing method provided in one or more embodiments of this specification determines the reason for the failure of an execution task by analyzing the execution result of the task, and updates the intelligent components in the intelligent component library and / or the execution workflow according to the reason for the failure, so that the intelligent component library and the target workflow set continuously evolve, with a wider coverage and stronger robustness, and achieve closed-loop optimization and continuous evolution.

[0196] The following is in conjunction with the appendix Figure 3Taking the data processing method provided in this specification as an example of its application in in-depth analysis within the customer service field, the data processing method will be further explained. Figure 3 A flowchart illustrating the processing procedure of a data processing method according to an embodiment of this specification is shown, specifically including the following steps.

[0197] Step 302: Define a set of target tasks, input each target task in the target task set into the agent of the strong model, use the agent of the strong model to execute each target task, and obtain the execution trajectory data of each target task.

[0198] The target task set includes multiple target tasks of the same type, such as all of them being tasks for generating satisfaction analysis.

[0199] Step 304: Construct the MCP set.

[0200] Specifically, the steps for constructing the MCP set are as follows:

[0201] 1. Set system constraints based on the weak model agent used subsequently, and input the system constraints and each target task into the planner. The planner uses the strong model agent to generate multiple MCP generation tasks based on the system constraints and each target task, and sends the multiple MCP generation tasks to the MCP generator.

[0202] 2. The MCP generator generates an MCP script for each of the multiple MCP generation tasks. Then, it executes each MCP script in a virtual environment and optimizes the MCP script based on the execution results to generate multiple MCPs.

[0203] 3. Construct an MCP set based on multiple MCPs.

[0204] Step 306: Use the agent of the strong model to abstract, cluster, and merge multiple MCPs in the MCP set, and build the processed multiple MCPs into an MCP toolbox.

[0205] Step 308: Construct the target workflow set.

[0206] Specifically, the steps for constructing the target workflow set are as follows:

[0207] 1. Sample each target task to obtain multiple test tasks.

[0208] 2. Using a strong model agent, a reference workflow is generated based on the execution trajectory data of each target task and the MCP toolkit.

[0209] 3. Using a strong model agent, execute the test task corresponding to each target task based on the reference workflow of each target task and the MCP toolkit. If the execution is successful, the reference workflow is converted into a target workflow to build a target workflow set.

[0210] Step 310: In the event of execution failure, update the MCP in the MCP toolbox based on the execution result.

[0211] Specifically, in the event of execution failure, the system will feed back the execution result to the planner, and the MCP and / or reference workflow in the MCP toolbox will be tuned and retested to obtain the reference workflow that finally executes successfully and store it in the target workflow set.

[0212] Step 312: Run online.

[0213] Specifically, the online implementation steps are as follows: When there is a new task, the weak model agent can be used to match the new task with the target workflow in the target workflow set. After finding the matching target workflow, the weak model agent can execute the new task based on the weak model agent and the MCP toolkit, referring to the target workflow.

[0214] The data processing method provided in one or more embodiments of this specification firstly automatically generates independent and reusable MCPs for the target task type using the execution trajectory data of a strong model agent in the target task and system constraints, eliminating the need for manual design of complex processes and significantly reducing development costs. Secondly, the MCPs generated using strong model agents can be directly used by weak model agents, reusing the problem-solving capabilities of strong models without additional training, ensuring that weak model agents can still complete tasks with high quality at low cost, thus solving the high dependence on model performance. Simultaneously, by accumulating target workflows to support task requirements, it avoids the uncontrollable problems brought about by highly flexible strong model agents, effectively ensuring the stability and reliability of weak model agents executing tasks based on target workflows, further reducing costs. In other words, this data processing method automatically constructs efficient and stable target workflows suitable for weak model agents by collecting the execution trajectory data generated by strong model agents executing target tasks, enabling weak model agents to subsequently execute similar target tasks at low cost and high efficiency based on these target workflows, greatly reducing inference costs and improving execution stability.

[0215] Corresponding to the above method embodiments, this specification also provides data processing apparatus embodiments. Figure 4 A schematic diagram of the structure of a data processing apparatus according to one embodiment of this specification is shown. Figure 4As shown, the device includes:

[0216] The trajectory determination module 402 is configured to determine the execution trajectory data of the target task, wherein the execution trajectory data is generated by the first intelligent agent, which depends on the first model, executing the target task in the target task set;

[0217] The component library generation module 404 is configured to generate an intelligent component library using the first intelligent agent based on the execution trajectory data and system constraints, wherein the system constraints are determined based on the model configuration of the second model on which the second intelligent agent depends, and the model configuration of the first model is greater than the model configuration of the second model.

[0218] The reference workflow generation module 406 is configured to generate a reference workflow using the first intelligent agent, based on the execution trajectory data and the intelligent component library.

[0219] The workflow set generation module 408 is configured to use the second intelligent agent to execute test tasks based on the reference workflow and the intelligent component library, and determine the target workflow set based on the task execution results, wherein the test tasks are determined based on the target tasks.

[0220] Optionally, the trajectory determination module 402 is further configured to:

[0221] Determine a set of target tasks, wherein the set of target tasks includes the target tasks;

[0222] The first intelligent agent is used to execute the target task to obtain the execution trajectory data of the target task;

[0223] or

[0224] The execution trajectory data of the target task is obtained from the historical execution log of the first intelligent agent executing the target task.

[0225] Optionally, the component library generation module 404 is further configured to:

[0226] Using the first intelligent agent, a set of intelligent components is generated based on the execution trajectory data and system constraints, wherein the set of intelligent components includes multiple intelligent components;

[0227] Using the first intelligent agent, the plurality of intelligent components are structured to obtain the processed plurality of intelligent components, and the intelligent component library is generated based on the processed plurality of intelligent components.

[0228] Optionally, the component library generation module 404 is further configured to:

[0229] Using the first intelligent agent, multiple intelligent component generation tasks are generated based on the execution trajectory data and system constraints;

[0230] Using the first intelligent agent, tasks are generated based on the multiple intelligent components, multiple intelligent components are constructed, and the set of intelligent components is generated based on the multiple intelligent components.

[0231] Optionally, the component library generation module 404 is further configured to:

[0232] Using the first intelligent agent, the plurality of intelligent components are abstracted to obtain the plurality of abstracted intelligent components;

[0233] Using the first intelligent agent, clustering is performed on the multiple intelligent components after abstraction to obtain multiple intelligent components after clustering.

[0234] Using the first intelligent agent, the clustered intelligent components are merged to obtain a merged set of intelligent components.

[0235] Optionally, the reference workflow generation module 406 is further configured to:

[0236] Using the first intelligent agent, the execution trajectory data is analyzed, and a reference workflow corresponding to the target task is generated based on the component capabilities of the intelligent components in the intelligent component library.

[0237] Optionally, the workflow set generation module 408 is further configured to:

[0238] The target task is sampled to generate the test task;

[0239] The reference workflow and the test task are input into the second agent to obtain the task execution result of the second agent calling the intelligent components in the intelligent component library based on the reference workflow to execute the test task;

[0240] Based on the task execution results and the reference workflow, determine the target workflow set.

[0241] Optionally, the workflow set generation module 408 is further configured to:

[0242] If the test task is determined to have been successfully executed based on the task execution result, the reference workflow is determined as the target workflow for the target task.

[0243] If, based on the task execution result, it is determined that the test task has failed, the intelligent component library and / or the reference workflow are updated, and the step of inputting the reference workflow and the test task into the second intelligent agent to obtain the task execution result of the second intelligent agent calling the intelligent components in the intelligent component library based on the reference workflow to execute the test task is continued.

[0244] Based on the target workflow, determine the target workflow set.

[0245] Optionally, the component library generation module 404 is further configured to:

[0246] Using the first intelligent agent, generate component scripts corresponding to each component generation task according to each component generation task in the plurality of intelligent component generation tasks;

[0247] The component scripts corresponding to the generation tasks of each component are input into the virtual environment for execution, the script execution results of each component script are obtained, and multiple intelligent components are constructed based on the script execution results of each component script.

[0248] Optionally, the component library generation module 404 is further configured to:

[0249] The target component script corresponding to the target component generation task is input into the virtual environment for execution to obtain the script execution result of the target component script, wherein the target component generation task is any one of the plurality of intelligent component generation tasks;

[0250] If the execution result of the target component script determines that the target component script has been executed successfully, the target component script is encapsulated to construct a target intelligent component, wherein the target intelligent component is any one of the plurality of intelligent components;

[0251] If, based on the script execution result of the target component script, it is determined that the target component script has failed to execute, the target component script is updated using the script execution result of the target component script, and the step of inputting the target component script corresponding to the target component generation task into the virtual environment for execution to obtain the script execution result of the target component script continues to be executed.

[0252] Optionally, the device further includes:

[0253] The task execution module is configured as follows:

[0254] Receive the task to be executed, use the second intelligent agent to parse the task to be executed, and determine the execution workflow from the target workflow set based on the parsing result;

[0255] Using the second intelligent agent, the task to be executed is performed according to the execution workflow and the intelligent component library.

[0256] Optionally, the device further includes:

[0257] The update module is configured as follows:

[0258] If, based on the execution result of the task to be executed, it is determined that the task to be executed has failed, the intelligent component library and / or the target workflow are updated.

[0259] The data processing apparatus provided in one or more embodiments of this specification collects execution trajectory data of a first agent that relies on a first model (i.e., a strong model) to perform a target task. Using the first agent of the strong model, and based on the execution trajectory data and system constraints determined by the model configuration of a second model (i.e., a weak model) relied upon by the second agent, a library of intelligent components adapted to the weak model is generated. Through these independently reusable intelligent components adapted to the weak model in the library, the intelligent components of the strong model can be directly reused by the weak model subsequently, allowing for the reuse of the strong model's task execution capabilities without additional training. This ensures that the second agent relying on the weak model can still perform complex deep analysis tasks with high quality at low cost. Simultaneously, using the first agent of the strong model, a reference workflow is generated based on the execution trajectory data and the intelligent component library, standardizing the task execution path. This allows the second agent of the weak model to efficiently perform tasks based on the reference workflow, eliminating dynamic search redundancy caused by the flexibility of the first agent of the strong model, reducing inference time, and improving efficiency and stability. Finally, using the second agent of the weak model, test tasks are executed based on the reference workflow and the intelligent component library. The final target workflow set is then precipitated based on the task execution results. Through the closed-loop test and verification mechanism of the second agent of the weak model, boundary risks are intercepted to ensure output consistency and improve the stability of the second agent of the weak model in task execution.

[0260] The above is an illustrative scheme of a data processing apparatus according to this embodiment. It should be noted that the technical solution of this data processing apparatus and the technical solution of the data processing method described above belong to the same concept. For details not described in detail in the technical solution of the data processing apparatus, please refer to the description of the technical solution of the data processing method described above.

[0261] Corresponding to the above-described task processing method embodiments, this specification also provides a task processing apparatus embodiment, which includes:

[0262] The task receiving module is configured to receive tasks to be executed, parse the tasks to be executed using a second intelligent agent, and determine the execution workflow from the target workflow set based on the parsing results.

[0263] The task execution module is configured to use the second intelligent agent to execute the task to be executed according to the execution workflow and the intelligent component library, wherein the target workflow set and the intelligent component library are generated according to the above data processing method.

[0264] The above is an illustrative scheme of a task processing device according to this embodiment. It should be noted that the technical solution of this task processing device and the technical solution of the task processing method described above belong to the same concept. For details not described in detail in the technical solution of the task processing device, please refer to the description of the technical solution of the task processing method described above.

[0265] In addition, this specification also provides a data processing method for dialogue analysis tasks, including:

[0266] Determine the execution trajectory data of the target dialogue analysis task, wherein the execution trajectory data is the trajectory data generated by the first agent relying on the first model to execute the target dialogue analysis task;

[0267] Using the first intelligent agent, an intelligent component library is generated based on the execution trajectory data and system constraints, wherein the system constraints are determined based on the model configuration of the second model on which the second intelligent agent depends, and the model configuration of the first model is greater than the model configuration of the second model;

[0268] Using the first intelligent agent, a dialogue analysis reference workflow is generated based on the execution trajectory data and the intelligent component library;

[0269] Using the second intelligent agent, a dialogue analysis test task is executed according to the dialogue analysis reference workflow and the intelligent component library, and a dialogue analysis target workflow set is determined according to the task execution results, wherein the dialogue analysis test task is determined according to the target dialogue analysis task.

[0270] In practice, the specific implementation of the data processing method applied to the dialogue analysis task is the same as the specific implementation of the data processing method described above, and will not be repeated here.

[0271] Corresponding to the above-described data processing method embodiments for dialogue analysis tasks, this specification also provides embodiments of a data processing apparatus for dialogue analysis tasks, the apparatus comprising:

[0272] The first determining module is configured to determine the execution trajectory data of the target dialogue analysis task, wherein the execution trajectory data is the trajectory data generated by the first agent relying on the first model to execute the target dialogue analysis task;

[0273] The first generation module is configured to use the first intelligent agent to generate an intelligent component library based on the execution trajectory data and system constraints, wherein the system constraints are determined based on the model configuration of the second model on which the second intelligent agent depends, and the model configuration of the first model is greater than the model configuration of the second model.

[0274] The second generation module is configured to use the first intelligent agent to generate a dialogue analysis reference workflow based on the execution trajectory data and the intelligent component library;

[0275] The second determining module is configured to utilize the second intelligent agent to execute a dialogue analysis test task based on the dialogue analysis reference workflow and the intelligent component library, and to determine a dialogue analysis target workflow set based on the task execution results, wherein the dialogue analysis test task is determined based on the target dialogue analysis task.

[0276] The above is an illustrative scheme of a data processing apparatus applied to a dialogue analysis task according to this embodiment. It should be noted that the technical solution of this data processing apparatus applied to a dialogue analysis task belongs to the same concept as the technical solution of the data processing method applied to a dialogue analysis task described above. Details not described in detail in the technical solution of the data processing apparatus applied to a dialogue analysis task can be found in the description of the technical solution of the data processing method applied to a dialogue analysis task described above.

[0277] Figure 5 A structural block diagram of a computing device 500 provided according to one embodiment of this specification is shown.

[0278] The computing device 500 includes:

[0279] Memory 510 and processor 520;

[0280] The memory 510 is used to store computer programs / instructions, and the processor 520 is used to execute the computer programs / instructions. When the computer programs / instructions are executed by the processor 520, they implement the steps of the data processing method, task processing method, or data processing method applied to a dialogue analysis task.

[0281] In one or more embodiments of this specification, the computing device can be understood as an integrated smart terminal, including but not limited to a server, desktop computer, PC (Personal Computer), all-in-one model machine, mobile phone, tablet computer or other portable smart terminal, etc., and the computing device may have the model described in the above embodiments of this application pre-installed.

[0282] Specifically, this computing device can pre-install various types of models, including but not limited to models in natural language processing, visual processing, speech processing, code processing, and multimodal task processing, thus providing diverse model selection. In different product forms, this computing device can support one or more model usage methods, including but not limited to model training, model invocation, model fine-tuning, model deployment, model inference, and application. In some product forms, this computing device also supports model management, including but not limited to multi-type model management (supporting the management of discriminative, generative, and other model types), model version control (supporting the control of different model versions), and model evaluation (evaluating model performance and effectiveness based on model evaluation tools). In other product forms, this computing device can also create applications based on models, providing API (Application Programming Interface) calling capabilities. Users can call models into created applications through the API interface, and application management tools are also provided to manage and monitor the applications.

[0283] Furthermore, the computing device can also include data management (supporting the creation and management of model tuning datasets), a training center (providing abundant training resources to help users learn and master AI (Artificial Intelligence) technology), and basic control capabilities (providing enterprise-level basic control capabilities to ensure the security and efficient operation of the system). Through the above functions, it provides a comprehensive and integrated device for AI development, training, deployment, and application.

[0284] Figure 6 A structural block diagram of an electronic device 600 provided according to one embodiment of this specification is shown.

[0285] The memory 610 and the processor 620 are connected via a bus 630.

[0286] The memory 610 is used to store computer programs / instructions, and the processor 620 is used to execute the computer programs / instructions. When the computer programs / instructions are executed by the processor 620, they implement the steps of the data processing method, task processing method, or data processing method applied to a dialogue analysis task.

[0287] Specifically, the components of the electronic device 600 include, but are not limited to, a memory 610 and a processor 620. The processor 620 is connected to the memory 610 via a bus 630, and the database 650 is used to store data.

[0288] Electronic device 600 also includes access device 640, which enables electronic device 600 to communicate via one or more networks 660. Examples of these networks include Public Switched Telephone Network (PSTN), Local Area Network (LAN), Wide Area Network (WAN), Personal Area Network (PAN), or combinations of communication networks such as the Internet. Access device 640 may include one or more of any type of wired or wireless network interface (e.g., network interface card (NIC)), such as an IEEE 802.11 Wireless Local Area Network (WLAN) wireless interface, a Wi-MAX (Worldwide Interoperability for Microwave Access) interface, an Ethernet interface, a Universal Serial Bus (USB) interface, a cellular network interface, a Bluetooth interface, a Near Field Communication (NFC) interface, and so on.

[0289] In one embodiment of this specification, the above-described components of the electronic device 600 and Figure 6 Other components, not shown, can also be connected to each other, for example, via a bus. It should be understood that... Figure 6 The block diagram of the electronic device shown is for illustrative purposes only and is not intended to limit the scope of this specification. Those skilled in the art can add or replace other components as needed.

[0290] Electronic device 600 can be any type of stationary or mobile electronic device, including mobile computers or mobile electronic devices (e.g., tablet computers, personal digital assistants, laptop computers, notebook computers, netbooks, etc.), mobile phones (e.g., smartphones), wearable electronic devices (e.g., smartwatches, smart glasses, etc.) or other types of mobile devices, or stationary electronic devices such as desktop computers or personal computers (PCs). Electronic device 600 can also be a mobile or stationary server.

[0291] The above is an illustrative scheme of an electronic device according to this embodiment. It should be noted that the technical solution of this electronic device belongs to the same concept as the technical solution of the data processing method, task processing method or data processing method applied to dialogue analysis task described above. For details not described in detail in the technical solution of the electronic device, please refer to the description of the technical solution of the data processing method, task processing method or data processing method applied to dialogue analysis task described above.

[0292] An embodiment of this specification also provides a computer-readable storage medium storing a computer program / instructions that, when executed by a processor, implement the steps of the above-described data processing method, task processing method, or data processing method applied to a dialogue analysis task.

[0293] The above is an illustrative scheme of a computer-readable storage medium according to this embodiment. It should be noted that the technical solution of this storage medium belongs to the same concept as the technical solution of the data processing method, task processing method or data processing method applied to dialogue analysis task described above. For details not described in detail in the technical solution of the storage medium, please refer to the description of the technical solution of the data processing method, task processing method or data processing method applied to dialogue analysis task described above.

[0294] An embodiment of this specification also provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of the above-described data processing method, task processing method, or data processing method applied to a dialogue analysis task.

[0295] The above is an illustrative scheme of a computer program product according to this embodiment. It should be noted that the technical solution of this computer program product belongs to the same concept as the above-described data processing method, task processing method, or data processing method applied to dialogue analysis tasks. For details not described in detail in the technical solution of the computer program product, please refer to the description of the above-described data processing method, task processing method, or data processing method applied to dialogue analysis tasks.

[0296] The foregoing has described specific embodiments of this specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recited in the claims may be performed in a different order than that shown in the embodiments and may still achieve the desired result. Furthermore, the processes depicted in the drawings do not necessarily require the specific or sequential order shown to achieve the desired result. In some embodiments, multitasking and parallel processing are possible or may be advantageous.

[0297] The computer program / instructions include computer program code, which may be in the form of source code, object code, executable file, or certain intermediate forms. The computer-readable medium may include: any entity or device capable of carrying the computer program code, recording media, USB flash drive, portable hard drive, magnetic disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in the computer-readable medium may be appropriately added or removed according to the requirements of patent practice. For example, in some regions, according to patent practice, computer-readable media may not include electrical carrier signals and telecommunication signals.

[0298] It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that the embodiments in this specification are not limited to the described order of actions, because according to the embodiments in this specification, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in this specification are all preferred embodiments, and the actions and modules involved are not necessarily essential to the embodiments in this specification.

[0299] In the above embodiments, the descriptions of each embodiment have different focuses. For parts not described in detail in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0300] The preferred embodiments disclosed above are merely illustrative of this specification. The optional embodiments do not exhaustively describe all details, nor do they limit the invention to the specific implementations described. Clearly, many modifications and variations can be made based on the embodiments described herein. These embodiments are selected and specifically described in this specification to better explain the principles and practical applications of the embodiments, thereby enabling those skilled in the art to better understand and utilize this specification. This specification is limited only by the claims and their full scope and equivalents.

Claims

1. A data processing method, comprising: Determine the execution trajectory data of the target task, wherein the execution trajectory data is the trajectory data generated by the first intelligent agent relying on the first model to execute the target task; Using the first intelligent agent, an intelligent component library is generated based on the execution trajectory data and system constraints. The system constraints are determined based on the model configuration of the second model on which the second intelligent agent depends. The model configuration of the first model is greater than that of the second model. The step of generating the intelligent component library using the first intelligent agent based on the execution trajectory data and system constraints includes: using the first intelligent agent to convert the execution trajectory data into multiple intelligent components under system constraints, and generating the intelligent component library based on the multiple intelligent components. Using the first intelligent agent, a reference workflow is generated based on the execution trajectory data and the intelligent component library; Using the second intelligent agent, test tasks are executed according to the reference workflow and the intelligent component library, and a target workflow set is determined based on the task execution results, wherein the test tasks are determined according to the target tasks.

2. The data processing method according to claim 1, wherein determining the execution trajectory data of the target task includes: Determine a set of target tasks, wherein the set of target tasks includes the target tasks; The first intelligent agent is used to execute the target task to obtain the execution trajectory data of the target task; or The execution trajectory data of the target task is obtained from the historical execution log of the first intelligent agent executing the target task.

3. The data processing method according to claim 1, wherein generating an intelligent component library using the first intelligent agent based on the execution trajectory data and system constraints includes: Using the first intelligent agent, a set of intelligent components is generated based on the execution trajectory data and system constraints, wherein the set of intelligent components includes multiple intelligent components; Using the first intelligent agent, the plurality of intelligent components are structured to obtain the processed plurality of intelligent components, and the intelligent component library is generated based on the processed plurality of intelligent components.

4. The data processing method according to claim 3, wherein generating a set of intelligent components using the first intelligent agent based on the execution trajectory data and system constraints includes: Using the first intelligent agent, multiple intelligent component generation tasks are generated based on the execution trajectory data and system constraints; Using the first intelligent agent, tasks are generated based on the multiple intelligent components, and multiple intelligent components are constructed to generate the intelligent component set.

5. The data processing method according to claim 3, wherein the step of using the first intelligent agent to perform structured processing on the plurality of intelligent components to obtain the processed plurality of intelligent components includes: Using the first intelligent agent, the plurality of intelligent components are abstracted to obtain the plurality of abstracted intelligent components; Using the first intelligent agent, clustering is performed on the multiple intelligent components after abstraction to obtain multiple intelligent components after clustering. Using the first intelligent agent, the multiple intelligent components after clustering are merged to obtain multiple intelligent components after merging, thus obtaining multiple intelligent components after processing.

6. The data processing method according to claim 1, wherein generating a reference workflow using the first intelligent agent based on the execution trajectory data and the intelligent component library includes: Using the first intelligent agent, the execution trajectory data is analyzed, and based on the analysis results of the execution trajectory data and the component capabilities of the intelligent components in the intelligent component library, a reference workflow corresponding to the target task is generated.

7. The data processing method according to claim 1, wherein the step of utilizing the second intelligent agent to execute a test task based on the reference workflow and the intelligent component library, and determining the target workflow set based on the task execution result, comprises: The target task is sampled to generate the test task; The reference workflow and the test task are input into the second agent to obtain the task execution result of the second agent calling the intelligent components in the intelligent component library based on the reference workflow to execute the test task; Based on the task execution results and the reference workflow, determine the target workflow set.

8. The data processing method according to claim 7, wherein determining the target workflow set based on the task execution result and the reference workflow includes: If the test task is determined to have been successfully executed based on the task execution result, the reference workflow is determined as the target workflow for the target task. If, based on the task execution result, it is determined that the test task has failed, the intelligent component library and / or the reference workflow are updated, and the step of inputting the reference workflow and the test task into the second intelligent agent to obtain the task execution result of the second intelligent agent calling the intelligent components in the intelligent component library based on the reference workflow to execute the test task is continued. Based on the target workflow, determine the target workflow set.

9. The data processing method according to claim 4, wherein the step of using the first intelligent agent to generate tasks based on the plurality of intelligent components and constructing a plurality of intelligent components includes: Using the first intelligent agent, the component scripts corresponding to each component generation task are generated according to the component generation tasks in the plurality of intelligent component generation tasks. The component scripts corresponding to the generation tasks of each component are input into the virtual environment for execution, the script execution results of each component script are obtained, and multiple intelligent components are constructed based on the script execution results of each component script.

10. The data processing method according to claim 9, wherein the step of inputting the component scripts corresponding to the component generation tasks into a virtual environment for execution, obtaining the script execution results of each component script, and constructing multiple intelligent components based on the script execution results of each component script, includes: The target component script corresponding to the target component generation task is input into the virtual environment for execution to obtain the script execution result of the target component script, wherein the target component generation task is any one of the plurality of intelligent component generation tasks; If the execution result of the target component script determines that the target component script has been executed successfully, the target component script is encapsulated to construct a target intelligent component, wherein the target intelligent component is any one of the plurality of intelligent components; If, based on the script execution result of the target component script, it is determined that the target component script has failed to execute, the target component script is updated using the script execution result of the target component script, and the step of inputting the target component script corresponding to the target component generation task into the virtual environment for execution to obtain the script execution result of the target component script continues to be executed.

11. A task processing method, comprising: Receive the task to be executed, use the second intelligent agent to parse the task to be executed, and determine the execution workflow from the target workflow set based on the parsing result; Using the second intelligent agent, the task to be executed is performed according to the execution workflow and the intelligent component library, wherein the target workflow set and the intelligent component library are generated according to any one of the data processing methods of claims 1-10.

12. A data processing method for dialogue analysis tasks, comprising: Determine the execution trajectory data of the target dialogue analysis task, wherein the execution trajectory data is the trajectory data generated by the first agent relying on the first model to execute the target dialogue analysis task; Using the first intelligent agent, an intelligent component library is generated based on the execution trajectory data and system constraints. The system constraints are determined based on the model configuration of the second model on which the second intelligent agent depends. The model configuration of the first model is greater than that of the second model. The step of generating the intelligent component library using the first intelligent agent based on the execution trajectory data and system constraints includes: using the first intelligent agent to convert the execution trajectory data into multiple intelligent components under system constraints, and generating the intelligent component library based on the multiple intelligent components. Using the first intelligent agent, a dialogue analysis reference workflow is generated based on the execution trajectory data and the intelligent component library; Using the second intelligent agent, a dialogue analysis test task is executed according to the dialogue analysis reference workflow and the intelligent component library, and a dialogue analysis target workflow set is determined according to the task execution results, wherein the dialogue analysis test task is determined according to the target dialogue analysis task.

13. An electronic device, comprising: A memory and a processor, the memory and the processor being connected via a bus; The memory is used to store computer programs / instructions, and the processor is used to execute the computer programs / instructions, which, when executed by the processor, implement the steps of the method according to any one of claims 1 to 12.

14. A computer-readable storage medium storing a computer program / instructions that, when executed by a processor, implement the steps of the method according to any one of claims 1 to 12.

Images