Directed acyclic graph-based agent arrangement debugging method and related device

Abstract

The invention discloses an agent arrangement debugging method based on a directed acyclic graph and a related device, and belongs to the technical field of agent arrangement. The method comprises the following steps: selecting required agent nodes based on an agent node library, creating edges among the agent nodes, and constructing to obtain a DAG; performing single-step debugging, executing the agent nodes one by one according to a DAG sequence, and outputting a result to a preset file; in the single-step debugging process, state information of the agent nodes is monitored in real time; and generating an execution debugging log based on the state information, and when the output result does not conform to the preset expectation, performing backtracking adjustment by executing the debugging log. The whole agent flow arrangement process is visual and easy to understand, the arrangement complexity is reduced, the development efficiency is improved, and convenience and accuracy are high.

Description

Technical Field

[0001] The present invention belongs to the technical field of intelligent agent orchestration, and relates to an intelligent agent orchestration debugging method based on a directed acyclic graph and related devices. Background Art

[0002] In today's era of rapid digitalization and intelligent development, intelligent agent technology has been widely applied in numerous fields. As entities capable of autonomously perceiving their environment, making decisions, and executing corresponding actions, intelligent agents often need to collaborate with other intelligent agents or external systems to complete complex tasks. To coordinate the interactions between these intelligent agents, agent orchestration is required: combining multiple intelligent agents into a complete system according to certain logical relationships.

[0003] However, traditional agent orchestration relies heavily on code to achieve logical combinations and interactions between agents. This requires developers to possess deep programming knowledge and skills, including proficiency in programming languages, algorithm design, and system architecture. However, for many individuals who are familiar with business logic but lack professional programming skills, orchestrating agents using traditional methods presents numerous challenges. Furthermore, code writing is error-prone, making troubleshooting and fixing logical or syntactic errors time-consuming and laborious. Especially in large-scale projects, the sheer volume of complex code makes locating errors like finding a needle in a haystack, significantly increasing development costs and difficulty.

[0004] Agent orchestration systems involve numerous interconnected and interdependent components and dependencies, making debugging extremely complex. The output of one component can affect the input of another, and errors in any link can cause system misoperation. For example, in an orchestration system for data collection, processing, analysis, and decision-making, the data format of the data collection agent can affect the logic of the data processing agent, which in turn affects the analysis and decision-making results. When results deviate, it's difficult to determine whether the problem stems from data collection accuracy, processing algorithm logic, or component interactions. This increases debugging difficulty and problem-solving time, impacting project progress and quality.

[0005] The debugging capabilities of existing agent orchestration platforms have many shortcomings in practical applications. Some platforms only provide fragmented, non-intuitive log information, requiring developers to spend a considerable amount of time sorting and interpreting it to understand system operation. This can also lead to missing key information, making it difficult to pinpoint the root cause of problems. Other platforms, while offering visualization capabilities, lack the crucial single-step debugging feature. Single-step debugging allows developers to meticulously observe input and output data, execution time, and changes in intermediate variables during agent node execution. Without this feature, developers cannot delve into specific steps to identify issues, hindering the resolution of underlying logic and performance issues.

[0006] In summary, traditional agent orchestration methods and the debugging capabilities of existing orchestration platforms are no longer able to meet the application needs of agent development. There is an urgent need to develop efficient, intuitive, and easy-to-debug agent orchestration and debugging technologies. Summary of the Invention

[0007] The purpose of the present invention is to provide an intelligent agent orchestration debugging method and related devices based on a directed acyclic graph to solve the technical problems in the prior art that the intelligent agent orchestration efficiency is low and the debugging function is difficult to meet the requirements.

[0008] In order to achieve the above object, the present invention adopts the following technical solutions: In a first aspect, the present invention provides an agent orchestration debugging method based on a directed acyclic graph, comprising the following steps: Selecting required agent nodes based on the agent node library, creating edges between the agent nodes, and constructing a DAG; Perform single-step debugging, execute agent nodes one by one in the order of DAG, and output the results to the preset file; During the single-step debugging process, the status information of the intelligent node is monitored in real time; Generate execution debug logs based on status information. When the output results do not meet preset expectations, perform retrospective adjustments through the execution debug logs.

[0009] Furthermore, the steps of selecting required agent nodes based on the agent node library, creating edges between the agent nodes, and constructing a DAG specifically include: In the visual orchestration interface, select the data collection agent, data cleaning agent, data analysis agent, and result output agent from the agent node library and place them in the work area; Create edges to connect the data collection agent, data cleaning agent, data analysis agent, and result output agent to build a DAG; Configure the node information of the data collection agent, data cleaning agent, data analysis agent and result output agent.

[0010] Furthermore, the information contained in the edge includes data type, data format and control conditions.

[0011] Furthermore, the step of configuring the node information of the data collection agent, the data cleaning agent, the data analysis agent, and the result output agent specifically includes: Set the data source, data collection frequency and timestamp format of the data collection agent; Set the cleaning rules and exception handling methods of the data cleaning agent; Set the analysis algorithm and analysis cycle of the data analysis agent; Set the output format and output destination address of the result output agent.

[0012] Furthermore, the step of performing single-step debugging, executing agent nodes one by one in the order of DAG, and outputting the results to a preset file specifically includes: Select single-step debugging mode and execute agent nodes one by one in the order of DAG. First, execute the data acquisition agent to collect time series data from the specified sensor and pass it to the data cleaning agent. The data cleaning agent processes the collected data according to the preset cleaning rules; after the processing is completed, the cleaned data is passed to the data analysis agent; The cleaned data is analyzed by the data analysis agent, and the analysis results are passed to the result output agent, which outputs the analysis results to a preset file in a preset chart format.

[0013] Furthermore, it also includes: setting a breakpoint in the data analysis agent, and when executing to the node, pausing execution and displaying the node status information and node internal variables.

[0014] Furthermore, it also includes: visually displaying the data flow between each intelligent agent node; using lines with arrows to indicate the direction of data flow, and the direction of the arrows indicates the direction of data transmission; using different line colors to indicate different digital types; the thickness of the line indicates the amount of data, the larger the amount of data, the thicker the line.

[0015] In a second aspect, the present invention provides an agent orchestration and debugging system based on a directed acyclic graph, comprising: A DAG construction module is used to select required agent nodes based on the agent node library, create edges between the agent nodes, and construct a DAG; The single-step debugging module is used for single-step debugging, executing agent nodes one by one in the order of DAG and outputting the results to a preset file; The monitoring module is used to monitor the status information of the intelligent agent node in real time during the single-step debugging process; The log and backtrace module is used to generate execution debug logs based on status information. When the output results do not meet the preset expectations, backtrace adjustments are made through the execution debug logs.

[0016] In a third aspect, the present invention provides a computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein when the processor executes the computer program, the steps of the directed acyclic graph-based intelligent agent orchestration and debugging method are implemented.

[0017] In a fourth aspect, the present invention provides a computer-readable storage medium storing a computer program, which, when executed by a processor, implements the steps of a directed acyclic graph-based intelligent agent orchestration and debugging method.

[0018] Compared with the prior art, the present invention has the following beneficial effects: This invention discloses a directed acyclic graph (DAG)-based agent orchestration and debugging method and related apparatus. By selecting and connecting agent nodes through a visual orchestration interface to construct a Directed Acyclic Graph (DAG), the orchestration of the entire agent process is intuitive and easy to understand, reducing orchestration complexity and improving development efficiency. It also supports a single-step debugging mode, executing agent nodes one by one in the DAG sequence, allowing developers to gradually check the execution status of each node and promptly identify problems. During the single-step debugging process, the status information of agent nodes is monitored in real time, enabling developers to understand the system's operating status in real time, identify potential problems promptly, and ensure stable system operation.

[0019] Furthermore, by setting breakpoints in the data analysis agent, execution is paused when the node is reached and the node status information and internal variables are displayed, which makes it easier for developers to gain an in-depth understanding of the internal operation of the node and carefully debug the complex data analysis process, which helps to discover deep-seated problems and optimize algorithms.

[0020] Furthermore, the data flow between each intelligent agent node is visualized, using lines with arrows to indicate the direction of data flow, different colors to indicate different types of numbers, and line thickness to indicate the amount of data. This makes the data flow more intuitive and clear, making it easier for developers to understand the flow and processing of data in the system, and helps to optimize system performance and troubleshoot data-related issues. BRIEF DESCRIPTION OF THE DRAWINGS

[0021] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the following briefly introduces the drawings required for use in the embodiments. It should be understood that the following drawings only illustrate certain embodiments of the present invention and therefore should not be regarded as limiting the scope. For ordinary technicians in this field, other relevant drawings can be obtained based on these drawings without paying any creative work.

[0022] Figure 1 is a flow chart of the method of the present invention; Figure 2 is a schematic diagram of the system of the present invention; Figure 3 is a system architecture diagram of an embodiment of the present invention; Figure 4 A schematic diagram of a visual arrangement interface according to an embodiment of the present invention; Figure 5 This is a single-step debugging flow chart of an embodiment of the present invention; Figure 6 This is a diagram of the data flow visualization interface of an embodiment of the present invention. DETAILED DESCRIPTION

[0023] The present invention will be described in detail below with reference to the accompanying drawings and in combination with embodiments. It should be noted that, unless there is a conflict, the embodiments and features in the embodiments of the present application can be combined with each other.

[0024] The following detailed description is all exemplary description, and is intended to provide further detailed description of the present invention. Unless otherwise indicated, all technical terms adopted in the present invention have the same meaning as commonly understood by those of ordinary skill in the art to which this application belongs. The terms used in the present invention are only for describing specific embodiments, and are not intended to limit the exemplary embodiments according to the present invention.

[0025] See also Figure 1 The embodiment of the present invention discloses a directed acyclic graph-based intelligent agent orchestration debugging method, comprising the following steps: S1, select the required agent nodes based on the agent node library, create edges between the agent nodes, and construct a DAG; S101, in the visual arrangement interface, select the data collection agent, data cleaning agent, data analysis agent and result output agent from the agent node library to the work area; see Figure 4 The visual orchestration interface provides users with a graphical operating environment, significantly lowering the technical barriers to agent orchestration. It features an agent node library, displaying various agent nodes with intuitive icons. Users drag the required nodes from the library to the workspace and use the connection tool to create edges between nodes, thereby constructing the agent orchestration process represented as a directed acyclic graph (DAG). When creating an edge, a pop-up window appears for users to enter edge properties, such as data type, data format, and control conditions. The interface also features function buttons such as save, load, run, and debug, allowing users to conveniently manage the orchestration process throughout its lifecycle. As users construct DAGs in the visual orchestration interface, the system performs rigorous real-time checks on the DAG structure. If a user operation could potentially create a loop, a prompt will pop up to warn the user and prevent the operation. For example, if a user attempts to connect two nodes that could create a data or control flow loop, the system will clearly indicate, "This connection will result in a directed acyclic graph structure error. Please check the connection logic." This ensures that the DAG structure remains consistent and the system's operational logic is correct.

[0026] In the system, each agent is represented as a node in the DAG, which is implemented by defining the DAGNode class in code. The node has the following key properties: 1) node_id: It is a unique identifier of a node and is in the form of a string. It is used to accurately identify and manage each agent node in the system.

[0027] 2) agent_type: specifies the agent type, recorded as a string to facilitate users to understand node functions and perform classification management.

[0028] 3) Configuration: Stores the detailed configuration information of the agent in JSON format, covering various parameters and algorithm settings required for the agent to run, ensuring that the agent works according to the predetermined logic.

[0029] 4) input_ports: is a list of input ports, each element of which is a Port class instance. It is used to manage input port related information, such as the port unique identifier port_id, data type data_type, data format data_format, etc., to standardize data input.

[0030] 5) output_ports: Similar to input_ports, it is a list of output ports, responsible for managing data output related information and ensuring that data is accurately output to other intelligent nodes.

[0031] 6) Breakpoints: Record breakpoint information in a list format, making it easier for users to set breakpoints during debugging and pause node execution to check the status.

[0032] S102: Create edges to connect the data collection agent, data cleaning agent, data analysis agent, and result output agent to construct a DAG; Connect each node in sequence to form a DAG. Connect the edge between the "Data Collection Agent" and the "Data Cleaning Agent," setting the data type to "Time Series Data" and the data format to "CSV." Connect the edge between the "Data Analysis Agent" and the "Result Output Agent."

[0033] The edges represent the interactions between agents in the DAG and are implemented by defining specialized classes. Edges contain the following important information: 1) Data type: Clarify the type of data passed between agents, such as integers, strings, JSON, etc., to ensure that data is processed correctly between different nodes.

[0034] 2) Data format: Specifies the format of data, such as CSV, XML, etc., to ensure data consistency and compatibility.

[0035] 3) Control conditions: Set the control conditions for data transmission or execution logic between agents. Only when specific conditions are met will data or control flow be transmitted along the edge, realizing complex logical interaction between agents.

[0036] S103, configuring the node information of the data collection agent, the data cleaning agent, the data analysis agent and the result output agent.

[0037] 1) Set the data source, data collection frequency and timestamp format of the data collection agent; "Data Collection Agent": Set the data source to a sensor device, the collection frequency to once per minute, and the timestamp format to "YYYY - MM - DD HH:MM:SS"; 2) Set the cleaning rules and exception handling methods of the data cleaning agent; "Data cleaning agent": formulate cleaning rules, remove duplicate values, correct obvious erroneous data, and set the outlier processing method to fill in with adjacent values; 3) Set the analysis algorithm and analysis cycle of the data analysis agent; "Data Analysis Agent": Select the moving average analysis algorithm and set the analysis period to 10 time steps to smooth time series data and discover trends.

[0038] 4) Set the output format and output target address of the result output agent.

[0039] "Result Output Agent": Determine the output format as a chart and the output target as a local file address.

[0040] S2, perform single-step debugging, execute the agent nodes one by one in the order of DAG, and output the results to the preset file; Figure 5 shown.

[0041] S201, select single-step debugging mode, execute agent nodes one by one according to the order of DAG, first execute the data acquisition agent, collect time series data from the specified sensor, and pass it to the data cleaning agent; S202, the data cleaning agent processes the collected data according to the preset cleaning rules; after the processing is completed, the cleaned data is passed to the data analysis agent; S203, analyzing the cleaned data through the data analysis agent, passing the analysis results to the result output agent, and outputting the analysis results to a preset file in a preset chart format.

[0042] This step utilizes an event-driven mechanism. After the user clicks the Start Single-Step Debugging button in the visual interface, the debugging module determines the precise execution order of the agent nodes based on the topological order of the DAG. The debugging module then enters a waiting state. Upon receiving a single-step execution instruction from the user, it immediately calls the execution method of the next node to be executed. For example, if the first node to be executed in the DAG is a data acquisition agent node, the debugging module precisely calls the data acquisition method for that node. Upon completion, it promptly feeds node status information to the monitoring and logging modules and waits again for the next single-step execution instruction from the user, enabling precise control and monitoring of the execution process of each node.

[0043] S3, during the single-step debugging process, monitors the status information of the agent node in real time; The monitoring module continuously monitors the operational status of intelligent nodes, obtaining real-time information such as input data, output data, and execution time, and feeds this information to the visualization interface. It also monitors node performance indicators such as CPU usage and memory usage, and issues alerts if any anomalies are detected. The monitoring module feeds this information back to the visualization interface in real time, presenting it to the user in an intuitive manner. For example, it displays input and output data values ​​next to the node icon and displays execution time as a progress bar.

[0044] S4, generates an execution debugging log based on the status information. When the output result does not meet the preset expectations, backtracking adjustments are made through the execution debugging log.

[0045] During the execution of the intelligent node, the execution log and debugging information of each node are recorded in detail in a structured manner, and an index is added to each record, so that users can quickly locate the required log based on conditions such as node ID and time range through the log query function of the visual interface.

[0046] The present invention also features a log analysis function. Users can click the Log Analysis button on the visual interface to access the feature-rich Log Analysis page. This page offers a variety of powerful query and analysis capabilities. For example, it supports queries by time range, allowing users to enter a start and end time to quickly filter log records within that time period; queries by node ID, directly locating relevant logs for a specific agent node; and queries by error type, quickly finding all log records for the same error. The system intelligently analyzes log data, such as counting key metrics such as the number of executions per node, average execution time, and error frequency, and displays them visually in graphical form. For example, a bar chart displays the error frequency for different nodes, allowing users to intuitively identify which nodes are most likely to experience problems, helping them quickly locate the issue.

[0047] S5, setting a breakpoint in the data analysis agent, when executing to the node, pausing execution and displaying the node status information and node internal variables.

[0048] On the visual interface, users can simply click on the agent node icon to pop up the node settings menu, which includes breakpoint setting options. Users can easily choose to set a breakpoint at the node or cancel an already set breakpoint. When a breakpoint is set, a clear breakpoint indicator, such as a red solid circle, will appear on the node icon. When the debugging module executes to the node where the breakpoint is set, execution is immediately paused, and detailed status information of the node is sent to the visual interface for display to the user. At this time, the user clicks the dedicated variable view button to pop up the variable view window, which clearly displays all variables and their values ​​of the agent node when the breakpoint is executed in a list format.

[0049] A backtrack button is set up on the visual interface. When the user clicks it, the debugging module accurately restores the system state to a previous execution step based on log records and execution context information. Users can choose to backtrack to the previous step or precisely backtrack to a specific location by selecting a specific time point or execution step number.

[0050] S6, see Figure 6 Design a data flow visualization area to graphically present the data transfer process between agent nodes. Use lines with arrows to intuitively represent the data flow. The arrow direction clearly indicates the data transfer direction. The line color is differentiated by data type, such as blue for numeric data and green for character data, making it easier for users to intuitively identify data types. The thickness of the line indicates the amount of data. The larger the amount of data, the thicker the line, giving users an intuitive sense of the data volume.

[0051] See also Figure 2 and Figure 3 The embodiment of the present invention discloses an agent orchestration debugging system based on a directed acyclic graph, including a DAG construction module, a single-step debugging module, a monitoring module, and a log and backtracking module: Among them, the DAG construction module is used to select the required intelligent agent nodes based on the intelligent agent node library, create edges between the intelligent agent nodes, and construct the DAG; the single-step debugging module is used to perform single-step debugging, execute the intelligent agent nodes one by one in the order of DAG, and output the results to a preset file; the monitoring module is used to monitor the status information of the intelligent agent nodes in real time during the single-step debugging process; the log and backtracking module is used to generate an execution debugging log based on the status information. When the output result does not meet the preset expectations, backtracking adjustments are made through the execution debugging log.

[0052] In a feasible implementation manner of the present invention, the system further includes a data flow visualization module and a power-off setting and variable viewing module.

[0053] In the Data Flow Visualization module, click the "Data Flow Visualization" button to clearly see how data collected by the "Data Collection Agent" flows in CSV format to the "Data Cleansing Agent." The cleaned data then flows to the "Data Analysis Agent," and the analysis results ultimately flow to the "Result Output Agent." As the data flows, you can see changes in data volume and format.

[0054] In the Power Off Settings and Variable Viewing module, set a breakpoint in the "Data Analysis Agent." When execution reaches that node, the system pauses and displays the node's status information. Users can view the node's input variable values, such as cleaned data content and analysis algorithm parameters. They can also view the node's internal variables, such as intermediate results during the moving average calculation process, to assist in analyzing algorithm execution.

[0055] 1. Hardware environment of the system in this embodiment: A computer equipped with a multi-core processor, 32GB of memory, and a 512GB solid-state drive is used as the operating platform, and the Windows 10 operating system is installed.

[0056] 2. System Architecture Components Visual Orchestration Interface: Built using HTML5, CSS3, and JavaScript, and developed on the Vue.js framework, ensuring interactivity and responsiveness. It communicates with the backend server in real time via the WebSocket protocol.

[0057] Agent nodes: Implemented in Python, classes are used to define the data structure and behavior of each agent node. For example, the "Data Processing Agent" class inherits from the base "AgentNode" class and contains data processing methods and interfaces for interacting with other nodes.

[0058] Edges: Represented as a Python dictionary, storing information such as the edge's source node ID, target node ID, data type, data format, and control conditions. During data transfer, data validation and processing are performed based on edge attributes.

[0059] Debugging Module: This module implements an event-driven mechanism based on Python's asyncio library, efficiently managing the execution order and event responses of agent nodes. It collaborates with the monitoring and logging modules to control the debugging process.

[0060] Monitoring module: This module uses the Python psutil library to obtain node performance metrics such as CPU usage and memory usage. It also uses a custom data interception function to obtain node input and output data and execution time. Monitoring information is sent to the visual orchestration interface via a message queue.

[0061] Logging module: This module uses Python's logging library to log data and stores it in a MySQL database. Each log record is indexed with timestamps, node IDs, and event types to facilitate quick query and analysis.

[0062] 3. System operation process Users construct a DAG in a visual orchestration interface and send this information to the backend server via the frontend. Upon receiving this information, the backend server initializes components such as agent nodes, edges, and the debugging engine. When debugging is initiated, the debugging module sequentially triggers agent node execution events based on the DAG structure and single-step debugging mode. The monitoring module collects node status information in real time and sends it to the frontend. The logging module records node execution logs, and the visual orchestration interface displays node status, data flow, and other information in real time. Users can set breakpoints, view variables, and perform log analysis. This information is sent from the frontend to the backend, where the corresponding components process and return the results.

[0063] In one embodiment of the present invention, a computer device is provided, comprising a processor and a memory, wherein the memory is configured to store a computer program, the computer program including program instructions, and the processor is configured to execute the program instructions stored in the computer storage medium. The processor may be a central processing unit (CPU), or may be another general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), or other programmable logic device, discrete gate or transistor logic device, discrete hardware component, etc. It is the computing core and control core of the terminal and is suitable for implementing one or more instructions, specifically loading and executing one or more instructions in the computer storage medium to implement a corresponding method flow or corresponding function. The processor described in this embodiment of the present invention can be used to operate a directed acyclic graph-based intelligent agent orchestration and debugging method.

[0064] The present invention also provides a storage medium, specifically a computer-readable storage medium (Memory). This computer-readable storage medium is a memory device within a computer device, used to store programs and data. It is understood that the computer-readable storage medium herein may include both built-in storage media within the computer device and, of course, extended storage media supported by the computer device. The computer-readable storage medium provides storage space, which stores the terminal's operating system. Furthermore, this storage space stores one or more instructions suitable for being loaded and executed by a processor. These instructions may be one or more computer programs (including program code). The program includes multiple modules, such as a visual orchestration interface module, an agent node processing module, a debugging engine module, a monitoring module, and a logging module. Each module consists of multiple Python files, implementing corresponding functions. The visual orchestration interface module implements a graphical interface based on the Tkinter library, providing an interface for user interaction with the system and supporting functions such as DAG construction and debugging operation triggering. The agent node processing module defines the data structure and behavior logic of agent nodes, implementing functions such as data processing and interaction. The debugging engine module uses Python's asyncio library to implement event-driven debugging process control, precisely scheduling the execution of agent nodes. The monitoring module utilizes the psutil library and custom functions to obtain node performance metrics and status information. The logging module uses the logging library for log recording and management, enabling log classification, storage, and querying. To use it, connect a removable hard drive to a computer and read the program files. On a computer with Python 3.10 or later installed, launch the program using the command line or shortcut. After the program launches, a visual orchestration interface loads, allowing users to perform debugging operations based on the visual agent orchestration platform, such as building a DAG, starting debugging, and viewing node status. During program execution, the various modules work together to implement agent orchestration and debugging, and record relevant information in log files on the storage medium for subsequent analysis and troubleshooting. It should be noted that the computer-readable storage medium here can be high-speed RAM or non-volatile memory, such as at least one disk drive. The processor may load and execute one or more instructions stored in a computer-readable storage medium to implement the corresponding steps of the above-mentioned embodiment regarding a directed acyclic graph-based intelligent agent orchestration and debugging method.

[0065] Those skilled in the art will appreciate that embodiments of the present invention may be provided as methods, systems, or computer program products. Thus, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to magnetic disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0066] The present invention is described with reference to flowcharts and / or block diagrams of methods, devices (systems), and computer program products according to embodiments of the present invention. It should be understood that each process and / or block in the flowcharts and / or block diagrams, as well as combinations of processes and / or blocks in the flowcharts and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the processes in the flowcharts and / or block diagrams. Figure 1 a process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0067] These computer program instructions may also be stored in a computer readable memory that can direct a computer or other programmable data processing device to work in a specific manner, so that the instructions stored in the computer readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1 a process or multiple processes and / or boxes Figure 1 The function specified in one or more boxes.

[0068] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operational steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing the instructions executed on the computer or other programmable device for implementing the process. Figure 1 a process or multiple processes and / or boxes Figure 1 A step that specifies a function in one or more boxes.

[0069] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and not to limit it. Although the present invention has been described in detail with reference to the above embodiments, ordinary technicians in the field should understand that the specific implementation methods of the present invention can still be modified or replaced by equivalents. Any modification or equivalent replacement that does not depart from the spirit and scope of the present invention should be covered by the scope of protection of the claims of the present invention.

Claims

1. A directed acyclic graph-based agent orchestration and debugging method, characterized in that: The following steps are involved: Selecting required agent nodes based on the agent node library, creating edges between the agent nodes, and constructing a DAG; Perform single-step debugging, execute agent nodes one by one in the order of DAG, and output the results to the preset file; During the single-step debugging process, the status information of the intelligent node is monitored in real time; Generate execution debug logs based on status information. When the output results do not meet preset expectations, perform retrospective adjustments through the execution debug logs.

2. The method for agent orchestration and debugging based on directed acyclic graph according to claim 1, characterized in that: The steps of selecting required agent nodes based on the agent node library, creating edges between the agent nodes, and constructing a DAG specifically include: In the visual orchestration interface, select the data collection agent, data cleaning agent, data analysis agent, and result output agent from the agent node library and place them in the work area; Create edges to connect the data collection agent, data cleaning agent, data analysis agent, and result output agent to build a DAG; Configure the node information of the data collection agent, data cleaning agent, data analysis agent and result output agent.

3. The agent orchestration and debugging method based on directed acyclic graph according to claim 2, characterized in that: The information contained in the edge includes data type, data format and control conditions.

4. The method for agent orchestration and debugging based on directed acyclic graph according to claim 2, characterized in that: The step of configuring the node information of the data collection agent, the data cleaning agent, the data analysis agent, and the result output agent specifically includes: Set the data source, data collection frequency and timestamp format of the data collection agent; Set the cleaning rules and exception handling methods of the data cleaning agent; Set the analysis algorithm and analysis cycle of the data analysis agent; Set the output format and output destination address of the result output agent.

5. The agent orchestration and debugging method based on directed acyclic graph according to claim 2, characterized in that: The step of performing single-step debugging, executing agent nodes one by one in the order of DAG, and outputting the results to a preset file specifically includes: Select single-step debugging mode and execute agent nodes one by one in the order of DAG. First, execute the data acquisition agent to collect time series data from the specified sensor and pass it to the data cleaning agent. The data cleaning agent processes the collected data according to the preset cleaning rules; after the processing is completed, the cleaned data is passed to the data analysis agent; The cleaned data is analyzed by the data analysis agent, and the analysis results are passed to the result output agent, which outputs the analysis results to a preset file in a preset chart format.

6. The agent orchestration and debugging method based on directed acyclic graph according to claim 2, characterized in that: Also includes: A breakpoint is set in the data analysis agent. When the node is executed, the execution is paused and the node status information and internal variables of the node are displayed.

7. The agent orchestration and debugging method based on directed acyclic graph according to claim 1, characterized in that: Also includes: The data flow between each intelligent agent node is visualized; lines with arrows are used to represent the direction of data flow, and the direction of the arrows represents the direction of data transmission; different line colors are used to represent different digital types; the thickness of the line represents the amount of data; the larger the amount of data, the thicker the line.

8. An agent orchestration and debugging system based on a directed acyclic graph, characterized in that: include: A DAG construction module is used to select required agent nodes based on the agent node library, create edges between the agent nodes, and construct a DAG; The single-step debugging module is used for single-step debugging, executing agent nodes one by one in the order of DAG and outputting the results to a preset file; The monitoring module is used to monitor the status information of the intelligent agent node in real time during the single-step debugging process; The log and backtrace module is used to generate execution debug logs based on status information. When the output results do not meet the preset expectations, backtrace adjustments are made through the execution debug logs.

9. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the processor executes the computer program, the steps of the directed acyclic graph-based agent orchestration and debugging method as described in any one of claims 1 to 7 are implemented.

10. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the steps of the directed acyclic graph-based agent orchestration and debugging method as described in any one of claims 1 to 7 are implemented.

Images