Execution system and implementation method for constructing complex data development task Agent

Abstract

The invention discloses an execution system and implementation method for constructing a complex data development task Agent, and the method specifically comprises the steps: a reasoning model module analyzes a task demand, and generates task planning information; the task planning Agent determines execution steps and tool requirements according to the planning information; the MCP Client module receives task steps, interacts with the MCP Server module through an event flow protocol, and executes tool calling; the MCP Server module registers a tool, analyzes the instruction and returns an execution result; the task execution Agent calls a model to execute the task according to the instruction and returns a result; the task summarization Agent summarizes task processes and results and generates a summarization report; and the Chat interface module receives a user task demand and feeds back progress and a result. And the reasoning model and the generation model realize decision making and content generation through the task planning Agent and the task execution Agent to form closed-loop circulation.

Description

Technical Field

[0001] This invention relates to the field of data development technology, and mainly to an execution system and implementation method for constructing complex data development task agents. Background Technology

[0002] Against the backdrop of the rapid development of large-scale models, the field of data development is undergoing significant changes. Previously, the implementation of data development SQL tasks often relied on professional developers who used their solid expertise and rich experience to write SQL statements and construct data development tasks. With the rise of large-scale model technology, some methods have emerged that utilize large models to assist in constructing data development SQL tasks, alleviating the burden on developers to some extent. However, these methods all have obvious limitations and cannot truly enable users with no prior experience to independently construct data development SQL tasks.

[0003] This method overcomes this limitation by innovatively utilizing the MCP protocol and combining it with the powerful planning and function call capabilities of large models to create an agent capable of autonomous planning and automatic execution in the data development field. This agent significantly lowers the barrier to entry for data development, enabling even users with no prior experience to successfully complete data development tasks, bringing entirely new possibilities to the field.

[0004] Current data development agents have significant limitations in capabilities, mostly remaining at the stage of assisting in task completion. They can only provide support to developers to a certain extent, such as automatically completing SQL statements and checking for syntax errors, but they cannot completely solve the problem of users with no experience building data development tasks. These users often lack professional database knowledge and SQL programming skills, and existing agents cannot provide them with a fully autonomous service from task requirements analysis to final task implementation.

[0005] Currently, there is considerable research within the industry regarding intelligent agents in the data development field. Some companies and research institutions are attempting to leverage large-scale modeling techniques to enhance the agent's auxiliary capabilities, such as using natural language processing to translate user task requirements into preliminary SQL logic. However, most of these explorations are still in their early stages. They primarily focus on optimizing individual steps and have not yet developed into an autonomous system that covers the entire process of task planning, execution, and summarization. Moreover, when dealing with complex data development tasks, these explorations often encounter problems such as unclear planning and low execution efficiency, making it difficult to meet the needs of practical applications. Summary of the Invention

[0006] This invention, based on the MCP protocol, constructs an MCP Server and MCP Client for a data development platform, and implements multi-agent interaction through a Multi-Agent architecture. The overall system framework mainly includes an MCP Server, an MCP Client, and three core agents (planning agent, execution agent, and summarizing agent), which collaborate to complete complex data development tasks. According to a first aspect of this invention, an execution system for constructing agents for complex data development tasks is proposed, with the following specific steps:

[0007] The inference model module is used to parse user task requirement descriptions and generate task planning information;

[0008] The task planning agent is used to determine the task execution steps and the required set of tools based on the task planning information.

[0009] The MCP Client module is used to receive the task execution steps and MCP tool call requests output by the task planning agent, and maintain real-time interaction with the tool execution agent through the server event stream protocol.

[0010] The MCP Server module is used to register MCP tools, parse tool call instructions, and return the execution results to the MCP Client module.

[0011] The task execution agent is used to invoke the corresponding generative model to execute the task and return the execution result according to the step instructions and tool call request issued by the MCP Client module;

[0012] The task summary agent is used to summarize the task execution process and results to generate a summary report;

[0013] The Chat interface module is used to receive user input of task requirements and output task execution progress and results.

[0014] The reasoning model module and the generation model module respectively realize the reasoning decision and content generation of the task through the task planning agent and the task execution agent, and form a closed loop through the MCP Client module and the MCP Server module.

[0015] Preferably, the MCP Server module is built on the Model Context Protocol and is used to dynamically encapsulate the external API interfaces of the data development platform into MCP Tools that can be recognized by large models, and create a tool registration list. When the data development platform detects that a new or updated API is added, the corresponding tool description is automatically generated based on the OpenAPI description file and the registration is completed, so as to realize the dynamic expansion and automatic updating of tool knowledge and ensure that the MCP Server has self-evolution capabilities.

[0016] Preferably, the MCP Client module and the MCP Server module maintain consistent tool status through a polling synchronization mechanism. Each time a user queries a task, the MCP Client module transmits the user's natural language input and the latest tool list to the task planning agent via a function call. After receiving the task execution plan, the module calls the corresponding MCP Tool step by step according to the Agent's output until the large model no longer generates tool call instructions. Then, the module sends the complete execution result and user input to the task summary agent to complete the task loop.

[0017] Prior to this, the task planning agent automatically generates a task plan list and MCP Tool invocation scheme based on the understanding of the user's natural language description, and outputs it in XML structure. The application parses the structured result to extract the task steps and tool list, and then dynamically matches the corresponding tool description from MCP Tools according to the tool name.

[0018] Preferably, the task execution agent generates a corresponding MCP Tool invocation instruction each time a step is executed, based on the planned steps and tool descriptions returned by the task planning agent. It automatically adjusts the next invocation strategy or generates supplementary invocation instructions based on the tool execution result feedback, thereby realizing dynamic adaptive business process execution based on the context understanding capability of the generative model.

[0019] Preferably, the task summary agent compares and analyzes user input, task planning list and task execution results to determine whether the execution effect of the automated process meets the expected goal. If a deviation is detected, a process adjustment instruction is generated and fed back to the task planning agent to trigger replanning, thereby realizing a task execution closed loop with supervision and self-correction capabilities under the collaboration of multiple agents.

[0020] According to a second aspect of the present invention, a method for constructing a complex data development task agent is proposed, the specific steps of which include:

[0021] The task planning information is generated by parsing the natural language task description input by the user through an inference model.

[0022] The task planning agent determines the task execution steps and the required set of MCP tools based on the task planning information.

[0023] The MCP Client module obtains the list of available tools from the MCP Server module and keeps polling and synchronizing with the MCP Server module.

[0024] The MCP Client module passes the user's task request and tool list to the task execution agent. The task execution agent calls the generation model to execute external system operations based on the step description and tool call information, and returns the execution result.

[0025] The task summary agent generates an execution summary based on user input, the task planning list, and the execution results, and then displays the results to the user.

[0026] According to a third aspect of the present invention, a computer program product is provided, on which one or more computer programs are stored, which, when executed by a computer processor, implement the method described above.

[0027] The above-described one or more technical solutions in the embodiments of this application have at least one of the following technical effects:

[0028] Lowering the barrier to data development: This invention enables autonomous planning and automatic execution of agents in the field of data development, allowing users with no prior experience to complete data development tasks simply by inputting task requirements, without needing professional database knowledge or SQL programming skills. This greatly lowers the barrier to data development and allows more people to participate in data development work.

[0029] Improved Development Efficiency: The Multi-Agent architecture breaks down tasks into planning, execution, and summarization stages. With each agent collaborating, complex data development tasks can be completed quickly and efficiently. Compared to traditional methods relying on manual operation by developers, this significantly shortens the development cycle and improves efficiency.

[0030] Improving task execution accuracy: The planning agent can make scientific plans based on rich information, and the execution agent can execute the plans accurately according to the plans, reducing errors caused by human operation and improving the accuracy of data development task execution. Attached Figure Description

[0031] The accompanying drawings are included to provide a further understanding of the embodiments and are incorporated in and constitute a part of this specification. The drawings illustrate embodiments and, together with the description, serve to explain the principles of the invention. Other embodiments and many anticipated advantages of the embodiments will be readily recognized as they become better understood through reference to the following detailed description. Elements in the drawings are not necessarily to scale. The same reference numerals refer to corresponding similar parts.

[0032] Figure 1 An execution system architecture diagram for constructing a complex data development task agent according to an embodiment of the present invention is shown.

[0033] Figure 2 This is a schematic diagram of the structure of a computer system suitable for implementing the electronic devices of the present application embodiments. Detailed Implementation

[0034] The present application will now be described in further detail with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and not intended to limit it. Furthermore, it should be noted that, for ease of description, only the parts relevant to the invention are shown in the accompanying drawings.

[0035] It should be noted that, unless otherwise specified, the embodiments and features described in this application can be combined with each other. This application will now be described in detail with reference to the accompanying drawings and embodiments.

[0036] Figure 1 The following is a diagram illustrating the execution system architecture for constructing a complex data development task agent according to an embodiment of the present invention, such as... Figure 1 As shown, the system includes a planning agent, an execution agent, and a summarizing agent:

[0037] The planning agent is built using the capabilities of inference models. It can receive task requirements input by the user and, combined with relevant information from Mcp Tools, comprehensively and meticulously plan the data development task, formulating clear execution steps. During the planning process, the planning agent fully considers factors such as task complexity, data correlation, and tool availability to ensure the feasibility and efficiency of the planned execution steps.

[0038] The executing agent is built using the capabilities of generative models. Its main responsibility is to invoke the corresponding McP Tools to complete the specific tool invocation operations according to the execution steps defined by the planning agent. During execution, the executing agent can monitor the status of tool invocations in real time, and will promptly adjust the tool invocation operations and fix any abnormalities that occur.

[0039] The summary agent is also built upon an inference model. It collects all information during the execution of the agent's planned steps, including the operations performed, the results generated, the problems encountered, and their solutions. This information is then organized and analyzed to output a detailed task summary and feedback. The task summary includes the task's completion status and the results produced by the tool, while the feedback primarily provides suggestions for improvement regarding problems encountered during task execution.

[0040] like Figure 1 As shown, the specific execution process of the system is as follows:

[0041] The inference model module receives natural language task descriptions from the Chat interface (e.g., "Help me create a task that automatically cleans the database and generates reports every night"). It uses contextual semantics to infer the task intent (data cleaning + report generation), extract the operation objects and constraints (time, data source, target location, etc.), and convert the task semantics into structured instruction templates for the "task planning agent" to further generate a specific execution plan. While the task planning agent is responsible for "generating the plan," its core logic is driven by the inference model. The inference model module can form a "chain of thought" style intermediate reasoning through multiple rounds of interaction.

[0042] MCP Server Construction and Operation: Based on the Model Context Protocol, a data development MCP Server is built to empower MCP Clients with "action," enabling them to operate external systems and automate business processes. Internally, the MCP Server encapsulates the data development platform API into MCP Tools and maintains a registry of MCP Tools. When a new API interface is added to the data development platform, a corresponding tool description is generated based on the OpenAPI description and registered in the MCP Tools list. This serves as knowledge for large model recognition tools. Upon receiving a call command from the MCP Client, the server invokes the data development platform API to automate the data development business process.

[0043] The MCP Client's construction and operation: The MCP Client acts as a bridge between the LLM and the MCP Server. It obtains a list of available tools from the MCP Server and synchronizes with it via a polling mechanism to get the latest tool list and status. Each time a user queries, the MCP Client sends the user's natural language query information along with the latest tool list to the "Task Planning Agent" via Function Calling. The Task Execution Plan and related toolset descriptions returned by the Agent are sent to the "Task Execution Agent." Based on the tool call information output by the Agent, the Client calls the corresponding tools on the MCP Server and returns the tool call results to the Agent. This continues until the LLM stops returning tool call information. Then, the MCP Client sends the task execution results along with the user input to the "Task Summary Agent." The Agent summarizes the results based on the user input and task execution, thus ending the current task construction process. This process uses the SSE protocol to display the interaction between multiple Agents and the MCP Server to the user in real time.

[0044] The task planning agent is responsible for understanding the natural language descriptions inputted by the user, compiling a detailed plan list based on the steps required to achieve the goal, and rationally planning the use of MCP tools to acquire external operational capabilities based on the operational requirements of the external environment. The task planning agent will communicate the plan and the list of MCP tools involved in the plan via XML tags (...). <plan> <steps> <step>< / step> < / steps> <tools> <tool>< / tool> < / tools> < / plan> This information is returned to the application, which then parses the XML text to extract the corresponding plan steps and tool name list, and retrieves the corresponding MCP Tool description from MCP Tools based on the tool name.

[0045] The task execution agent is responsible for executing the steps in the plan list step by step based on the plan list and MCP Tools. The application will pass the plan steps and tool list parsed from the results returned by the task planning agent to the task execution agent in sequence, one step at a time and the list of MCP Tools. The task execution agent generates MCP Tool invocation instructions based on the step description information and the description of MCP Tools. Based on the feedback of the MCP Tool invocation results, the agent adjusts the tool invocation instructions or continues to execute the next plan step, realizing automated business process execution based on tool result feedback and the contextual understanding capabilities of the generation model.

[0046] The Task Summary Agent is responsible for judging the execution results of business processes based on user input, task planning lists, and task execution results. It summarizes and provides feedback on whether the execution results of the current automated business processes meet the user's expected goals, thus fulfilling the supervisory function and adjusting and providing feedback on the execution status of business processes in a timely manner.

[0047] The Chat interface module serves as the entry point for user interaction with the system. It receives natural language input and converts it into structured task requests. Through context parsing and semantic encapsulation mechanisms, it packages user input, historical task states, and tool lists before sending them to the MCP Client, achieving a seamless mapping from natural language to automated execution instructions. Simultaneously, this module uses the SSE protocol to monitor the state flow of the task planning, execution, and summary phases in real time, dynamically displaying the inference chain and execution feedback of multiple agents, forming a traceable and interpretable task context. Furthermore, the Chat interface module supports a human-machine collaborative task feedback mechanism. When the task summary agent returns correction suggestions, the module can receive the user's natural language feedback and update the task context in real time, re-triggering task planning. This enables adaptive adjustment and continuous optimization of the automated process, thereby improving the system's interactivity, controllability, and intelligent collaboration capabilities.

[0048] According to an embodiment of the present invention, intelligent data development based on the MCP protocol is automated. This embodiment runs in an enterprise-level data development platform, including: one MCP Server; one MCP Client; three agents embedded in the LLM context scheduling framework: task planning agent, task execution agent, and task summary agent; and external systems including: a data ETL engine, a task scheduling engine, and a visualization reporting engine. The specific steps are as follows:

[0049] Step S1: MCP Server Construction and Tool Registration

[0050] The MCP Server is started based on the Model Context Protocol (MCP), and the OpenAPI interface description file of the data development platform is loaded into it;

[0051] The system parses the OpenAPI file and automatically generates MCP Tool description objects for each API interface, including the tool name, input parameter type, output parameter mode, and calling address.

[0052] MCP Server generates a global MCP Tools registry upon startup, where each tool is registered in JSON format, as shown in the example below:

[0053]

[0054]

[0055] When a new API is detected on the data development platform, the MCP Server automatically registers the module based on the OpenAPI event trigger, generates a new tool description and adds it to the MCP Tools registry, without manual intervention.

[0056] When the MCP Client issues a call command, the MCP Server automatically generates an HTTP request to call the target API based on the tool description, and encapsulates the API result into a unified response object and returns it.

[0057] Step S2: MCP Client Task Synchronization and Invocation Scheduling

[0058] During runtime, the MCP Client periodically (e.g., every 30 seconds) sends polling requests to the MCP Server to synchronize the latest MCP Tools status through the / tools / list interface;

[0059] After receiving a user's natural language task description (e.g., "Generate an automated task to synchronize from database A to data warehouse B"), the MCP Client encapsulates the text along with the current tool list as Function Calling input.

[0060] The MCP Client calls the / plan interface of the Task Planning Agent to generate a task planning scheme;

[0061] The MCP Client passes the planning results and the relevant MCP Tool description to the task execution agent for execution.

[0062] Step S3: Task Planning Agent Execution Process

[0063] The task planning agent performs semantic parsing on the natural language task, identifies the target intent ("synchronous task construction"), and infers the execution steps:

[0064] Step 1: Create a data synchronization pipeline;

[0065] Step 2: Configure the data source;

[0066] Step 3: Start the scheduling task;

[0067] During the inference process, the Agent automatically matches the relevant tools in MCP Tools: create_data_pipeline, config_data_source, and start_task_scheduler;

[0068] The agent returns the planning results in an XML structure:

[0069]

[0070] The application parses the XML structure and extracts the plan steps and tool list.

[0071] Step S4: Adaptive execution of the task execution agent

[0072] The application passes "Step S1" and the corresponding tool list to the task execution agent;

[0073] The task execution agent generates MCP Tool invocation instructions based on the tool description:

[0074]

[0075] MCP Server executes the call and returns the result: {"pipeline_id":"PL1234","status":"success"};

[0076] The task execution agent dynamically adjusts the second step call parameters based on the returned results and writes the returned pipeline_id into the context;

[0077] When the task reaches the third step, if an API delay or abnormal return is detected, the task execution agent will automatically trigger a retry mechanism and correct the input parameters based on the context memory.

[0078] All execution results are streamed back to the user interface in real time via the SSE channel.

[0079] Step S5: Task Summary and Agent Self-Supervision Feedback

[0080] When the LLM stops returning tool call information, the MCP Client sends the user input, task planning list, and execution results to the Task Summary Agent.

[0081] The Agent summarizes the comparison of planned steps and execution logs, generates an execution report, and automatically generates a replanning prompt if an incomplete step is detected (e.g., "failed to start scheduled task").

[0082] Final summary of Agent output:

[0083] Task result: Partially successful;

[0084] Recommendation: Check the scheduler credentials and then re-execute the startup procedure;

[0085] The system can export compliant PDF / A reports with one click, achieving a self-monitoring closed loop throughout the entire process.

[0086] This implementation has proven highly efficient in practical applications. Through a Server-Client-Agent collaborative framework under the MCP protocol, it achieves a closed loop from natural language to automated task execution, possessing features such as dynamic tool registration and invocation, interpretability of task planning and execution, adaptive adjustment of execution feedback, and finally, export of compliant result reports. With the deepening application of data-driven decision-making across various industries, this invention is expected to play a significant role in multiple fields such as finance, e-commerce, and healthcare, promoting the popularization and development of data development.

[0087] In summary, this invention innovatively combines the MCP protocol with the planning and function call capabilities of large models to construct a complex data development task agent system based on a Multi-Agent architecture. By dividing the agent into a planning agent, an execution agent, and a summarizing agent, it achieves fully autonomous processing of the data development task process. The planning agent can perform accurate task planning based on user input and Mcp Tools information; the execution agent can efficiently call Mcp Tools according to the planning steps to complete the tool calls; and the summarizing agent can comprehensively summarize and provide feedback on the execution process and results.

[0088] Compared to existing technologies, the solution of this invention enables users with no prior experience to build data development tasks, significantly lowering the barrier to entry for data development. Simultaneously, the Multi-Agent architecture ensures clear division of labor and collaborative work among the agents, improving the processing efficiency and accuracy of data development tasks. Furthermore, the use of the MCP protocol ensures efficient communication and data interaction between the data development platform MCP Server and MCP Client, providing a reliable guarantee for the stable operation of the agents.

[0089] The following is for reference. Figure 2 It shows a schematic diagram of the structure of a computer system 200 suitable for implementing electronic devices according to embodiments of the present application. Figure 2 The electronic device shown is merely an example and should not impose any limitation on the functionality and scope of use of the embodiments of this application.

[0090] like Figure 2As shown, the computer system 200 includes a central processing unit (CPU) 201, which can perform various appropriate actions and processes based on programs stored in read-only memory (ROM) 202 or programs loaded from storage section 208 into random access memory (RAM) 203. The RAM 203 also stores various programs and data required for the operation of the system 200. The CPU 201, ROM 202, and RAM 203 are interconnected via a bus 204. An input / output (I / O) interface 205 is also connected to the bus 204.

[0091] The following components are connected to I / O interface 205: an input section 206 including a keyboard, mouse, etc.; an output section 207 including a liquid crystal display (LCD) and speakers, etc.; a storage section 208 including a hard disk, etc.; and a communication section 209 including a network interface card such as a LAN card and a modem, etc. The communication section 209 performs communication processing via a network such as the Internet. A drive 210 is also connected to I / O interface 205 as needed. A removable medium 211, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., is installed on drive 210 as needed so that computer programs read from it can be installed into storage section 208 as needed.

[0092] Specifically, according to embodiments of this disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments of this disclosure include a computer program product comprising a computer program carried on a computer-readable storage medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication section 209, and / or installed from removable medium 211. When the computer program is executed by central processing unit (CPU) 201, it performs the functions defined in the methods of this application. It should be noted that the computer-readable storage medium of this application can be a computer-readable signal medium or a computer-readable storage medium or any combination thereof. The computer-readable storage medium can be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this application, a computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in connection with an instruction execution system, apparatus, or device. In this application, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium can also be any computer-readable storage medium other than a computer-readable storage medium that can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. Program code contained on a computer-readable storage medium may be transmitted using any suitable medium, including but not limited to: wireless, wire, optical fiber, RF, etc., or any suitable combination thereof.

[0093] Computer program code for performing the operations of this application can be written in one or more programming languages ​​or a combination thereof. Programming languages ​​include object-oriented programming languages—such as Java, Smalltalk, and C++—as well as conventional procedural programming languages—such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0094] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0095] The modules described in the embodiments of this application can be implemented in software or in hardware.

[0096] In another aspect, this application also provides a computer-readable storage medium, which may be included in the electronic device described in the above embodiments; or it may exist independently and not assembled into the electronic device. The aforementioned computer-readable storage medium carries one or more programs. When these programs are executed by the electronic device, the electronic device enables the following: a reasoning model module for parsing user task requirement descriptions and generating task planning information; a task planning agent for determining task execution steps and the required tool set based on the task planning information; an MCP client module for receiving task execution steps and MCP tool call requests output by the task planning agent, and maintaining real-time interaction with the tool execution agent through a server-side event flow protocol; an MCP server module for registering MCP tools, parsing tool call instructions, and returning execution results to the MCP client module; a task execution agent for calling the corresponding generation model to execute the task and returning execution results based on the step descriptions and tool call requests issued by the MCP client module; a task summary agent for summarizing the task execution process and results and generating a summary report; and a chat interface module for receiving user-input task requirements and outputting task execution progress and results. The reasoning model module and the generation model module respectively implement task reasoning decisions and content generation through the task planning agent and the task execution agent, and are transmitted via the MCP client module and the MCP... The Server module forms a closed-loop flow.

[0097] The above description is merely a preferred embodiment of this application and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of the invention involved in this application is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the above-described inventive concept. For example, technical solutions formed by substituting the above features with (but not limited to) technical features with similar functions disclosed in this application.

Claims

1. An execution system for constructing agents for complex data development tasks, characterized in that, include: The inference model module is used to parse user task requirement descriptions and generate task planning information; The task planning agent is used to determine the task execution steps and the required set of tools based on the task planning information. The MCP Client module is used to receive the task execution steps and MCP tool call requests output by the task planning agent, and maintain real-time interaction with the tool execution agent through the server event stream protocol. The MCP Server module is used to register MCP tools, parse tool call instructions, and return the execution results to the MCPClient module. The task execution agent is used to invoke the corresponding generative model to execute the task and return the execution result according to the step instructions and tool call request issued by the MCP Client module; The task summary agent is used to summarize the task execution process and results to generate a summary report; The Chat interface module is used to receive user input of task requirements and output task execution progress and results. The reasoning model module and the generation model module respectively realize the reasoning decision and content generation of the task through the task planning agent and the task execution agent, and form a closed loop through the MCP Client module and the MCP Server module.

2. The execution system according to claim 1, characterized in that, The MCP Server module is built on the ModelContext Protocol and is used to dynamically encapsulate the external API interfaces of the data development platform into MCP Tools that can be recognized by large models. It also creates a tool registration list. When the data development platform detects that a new or updated API has been added, the corresponding tool description is automatically generated based on the OpenAPI description file and the registration is completed. This enables dynamic expansion and automatic updating of tool knowledge and ensures that the MCP Server has self-evolution capabilities.

3. The execution system according to claim 1, characterized in that, The MCP Client module and the MCP Server module maintain consistent tool status through a polling synchronization mechanism. Each time a user queries a task, the MCP Client module passes the user's natural language input and the latest tool list to the task planning agent via a function call. After receiving the task execution plan, the module calls the corresponding MCP Tool step by step according to the Agent's output until the large model no longer generates tool call instructions. Then, the module sends the complete execution result and user input to the task summary agent to complete the task loop.

4. The execution system according to claim 1, characterized in that, The task planning agent automatically generates a task plan list and MCP Tool invocation scheme based on the user's natural language description, and outputs it in XML structure. The application parses the structured result to extract the task steps and tool list, and then dynamically matches the corresponding tool description from MCP Tools according to the tool name.

5. The execution system according to claim 1, characterized in that, The task execution agent generates corresponding MCP Tool invocation instructions each time a step is executed, based on the planned steps and tool descriptions returned by the task planning agent. It automatically adjusts the next invocation strategy or generates supplementary invocation instructions based on the tool execution results, thereby realizing dynamic and adaptive business process execution based on the context understanding capabilities of the generative model.

6. The execution system according to claim 1, characterized in that, The task summary agent compares and analyzes user input, task planning list and task execution results to determine whether the execution effect of the automated process meets the expected goal. If a deviation is detected, a process adjustment instruction is generated and fed back to the task planning agent to trigger replanning, thereby realizing a task execution closed loop with supervision and self-correction capabilities under the collaboration of multiple agents.

7. A method for constructing a complex data development task agent, characterized in that, Implemented using the execution system as described in any one of claims 1-6, the specific steps include: The task planning information is generated by parsing the natural language task description input by the user through an inference model. The task planning agent determines the task execution steps and the required set of MCP tools based on the task planning information. The MCP Client module obtains the list of available tools from the MCP Server module and keeps polling and synchronizing with the MCP Server module. The MCP Client module passes the user's task request and tool list to the task execution agent. The task execution agent calls the generation model to execute external system operations based on the step description and tool call information, and returns the execution result. The task summary agent generates an execution summary based on user input, the task planning list, and the execution results, and then displays the results to the user.

8. A computer program product, characterized in that, It stores a computer program that, when executed by a processor, implements the system as described in any one of claims 1-6.

Images