A Method and System for Building a Rapid AI Agent Development Platform Based on Low-Code Visualization
The low-code, visual AI agent rapid development platform solves the problems of high development threshold and long development cycle in existing technologies, realizes an efficient AI agent development process, reduces development costs and simplifies the integration and debugging process.
Patent Information
- Application Number
- CN202611627575.5
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-10-21
- Publication Date
- 2026-11-17
AI Technical Summary
Current AI agent development relies on manual coding by professional developers, resulting in high development thresholds, long development cycles, high costs, and complex integration and debugging.
We employ a low-code, visual AI agent rapid development platform. By dragging and dropping and configuring, we can build AI agents, including defining the set of functional elements, abstracting them into a set of functional components, establishing a component library and backend mapping relationship, using the component panel area, canvas arrangement area and parameter configuration area for arrangement and analysis, generating executable code and enabling online debugging and deployment.
It lowers the development threshold of AI agents, improves development efficiency, and realizes a one-stop solution from design to deployment.
Smart Images

Figure CN123114448A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of artificial intelligence application development technology, and in particular to a method and system for building a rapid AI agent development platform based on low-code visualization. Background Technology
[0002] AI agents are intelligent applications that can autonomously perceive their environment, plan tasks, and invoke tools to perform operations to achieve specific goals. With the rapid development of large language model technology, AI agents are being used more and more widely in fields such as intelligent customer service, office automation, data analysis, and business process orchestration.
[0003] Currently, AI agent development primarily relies on professional developers manually writing code. However, this existing method has many shortcomings. Manual coding requires high levels of technical expertise from developers, has a long development cycle, is costly, and the coding, integration, and debugging of each functional module are tedious and complex. Therefore, lowering the development threshold and improving the efficiency of AI agent development has become an urgent problem to be solved. Summary of the Invention
[0004] This invention provides a method for building a rapid AI agent development platform based on low-code visualization and a computer-readable storage medium. Its main purpose is to reduce the development threshold of AI agents and improve their construction efficiency.
[0005] To achieve the above objectives, this invention provides a method for building a rapid AI agent development platform based on low-code visualization, comprising: Once the set of functional elements is determined, it is abstracted to obtain the set of functional components. The component library and backend mapping relationship set are determined based on the functional component set; Based on the component library, the component panel area, canvas arrangement area, and parameter configuration area are determined. Utilize the component panel area, canvas arrangement area, and parameter configuration area to construct visual arrangement units; The visual orchestration unit is analyzed to obtain multiple component nodes and the connection relationships between multiple nodes. The executable code set is determined based on multiple component nodes and backend mapping relationships; The compilation and build unit is determined based on the connection relationships between multiple nodes and the executable code set; The runtime instance is determined based on the compilation build unit; Extract parameters from the running instance to obtain the status of multiple nodes; Multiple visual debugging feedback identifiers are determined based on the status of multiple nodes; An online debugging unit is constructed using multiple visual debugging feedback indicators; The release configuration set is determined based on the compilation and build units; The deployment and release units are determined based on the compilation and build units and the release configuration sets; By integrating the visual orchestration unit, compilation and building unit, online debugging unit, and deployment and release unit, we obtain the AI agent rapid development platform and complete the construction of the AI agent rapid development platform.
[0006] Optionally, the abstraction of the functional element set to obtain a functional component set includes: Perform the following operation on each functional element in the functional element set: Dependency determination is performed on functional elements to obtain dependency determination results, where the dependency determination results are: service call elements or process control elements; If the dependency judgment result is a service call element, then information is extracted from the service call element to obtain multiple service call description information; The functional components are obtained by encapsulating multiple service call descriptions using a pre-defined unified component description structure. If the decision result is a process control element, then information is extracted from the process control element to obtain multiple control flow description information. A unified component description structure is used to encapsulate multiple control flow description information to obtain functional components; Summarize the functional components to obtain a set of functional components.
[0007] Optionally, determining the component library and backend mapping relationship set based on the functional component set includes: Perform the following operation on each functional component in the functional component set: Metadata is extracted from the functional components to obtain component metadata, which includes: component identifier, component name, component type, input port description and output port description; A front-end rendering description is generated for the functional components to obtain the front-end rendering description, wherein the front-end rendering description includes: component icon and component default size; Associate component metadata with front-end rendering descriptions to obtain component description records; The backend execution unit is identified based on the functional components; Establish a mapping relationship between functional components and backend execution units to obtain mapping relationship entries; By summarizing the component description records and mapping relationship entries, the component library and backend mapping relationship set are obtained.
[0008] Optionally, the step of performing orchestration analysis on the visual orchestration unit to obtain multiple component nodes and multiple node connection relationships includes: The orchestration status of the visual orchestration unit is read to obtain the orchestration status data; Construct a directed dependency graph based on orchestration state data; Loop detection is performed on the directed dependency graph to obtain the loop detection result, where the loop detection result is: a loop exists or a loop does not exist; If the loop detection result indicates the existence of a loop, then the directed dependency graph is used to locate the loop, resulting in multiple loop vertices; A corrected directed dependency graph was identified based on multiple loop vertices and the directed dependency graph. If the loop detection result indicates that no loop exists, then the directed dependency graph will be used as the corrected directed dependency graph. Perform topological sorting on the modified directed dependency graph to obtain the node execution sequence, wherein the node execution sequence includes: multiple nodes to be executed; For each node to be executed in the node execution sequence, perform the following operation: Use the node to be executed as the target node; The downstream nodes are identified based on the target node; The output port type and output hierarchy depth are determined based on the target node; The input port type and input level depth are determined based on the downstream nodes; Type feature vector mapping is performed on the output port type and the input port type respectively to obtain the output type feature vector and the input type feature vector; The port matching confidence is calculated based on the output type feature vector, the input type feature vector, the output layer depth, and the input layer depth, using the following formula:
[0009] in, Indicates the port match confidence level. Indicates the output type as a feature vector. Represents the input type feature vector. Indicates the output hierarchy depth. Indicates the input hierarchy depth. Represents the dot product of vectors. Represents the magnitude of a vector. This indicates taking the absolute value. This indicates the preset maximum level depth. This represents the preset first weighting coefficient. This represents the preset second weighting coefficient; Summarize the port match confidence scores to obtain multiple port match confidence scores; Multiple consistent confidence levels were identified based on the matching confidence levels of multiple ports and the preset matching confidence threshold. Multiple component nodes were identified based on multiple nodes to be executed and multiple consistent confidence levels; Multiple node connections were determined based on the modified directed dependency graph.
[0010] Optionally, determining the executable code set based on multiple component nodes and backend mapping relationship sets includes: Perform the following operation on each of the multiple component nodes: Perform node type identification on component nodes to obtain the target node type identifier; The target backend execution unit is obtained by matching the backend mapping relationship set based on the target node type identifier. The parameters of the component nodes are parsed to obtain the parameter binding table, which includes multiple key-value pairs. The validation parameter binding table is determined based on the component nodes and parameter binding table; The execution code template is obtained by loading the call template based on the target backend execution unit; The executable code template is instantiated and populated using a validation parameter binding table to obtain the component's executable code; Perform a syntax self-check on the component's executable code to obtain the self-checked component code; Summarize the self-test component code to obtain the executable code set.
[0011] Optionally, the step of determining the verification parameter binding table based on component nodes and parameter binding tables includes: Perform the following operation on each of the multiple key-value pairs in the parameter binding table: The target port constraints are determined based on component nodes and key values; The key value is validated according to the target port constraint to obtain the required validation result, the type validation result, and the range validation result. Based on the results of mandatory field validation, type validation, and range validation, the mandatory field result value, type result value, and range result value are determined. Calculate the individual verification score based on the required result value, type result value, and range result value; Summarize the individual verification scores to obtain multiple individual verification scores; The overall verification score is calculated based on multiple individual verification scores. Determine whether the overall verification score is equal to the preset single value. If the overall verification score is equal to the single value, then use the parameter binding table as the verification parameter binding table. Otherwise, the validation parameter binding table is determined based on the parameter binding table, required result values, type result values, and range result values.
[0012] Optionally, the step of performing a syntax self-check on the executable code of the component to obtain the self-checked component code includes: Perform a lexical scan on the executable code of the component to obtain a sequence of lexical units; The lexical unit sequence is parsed to obtain the parsing result, which is either parsing successful or parsing unsuccessful. If the syntax parsing result is successful, then the component's executable code will be used as the self-check component code; If the parsing result is that the parsing fails, then the parsing result is used to locate the errors and obtain multiple syntax error locations; For each of the multiple syntax error locations, perform the following operation: The component's executable code is syntax-corrected based on the location of syntax errors to obtain the corrected syntax location. Summarize the corrected syntax locations to obtain multiple corrected syntax locations; The corrected component executable code was identified based on multiple correction syntax locations and component executable code. Perform a syntax backcheck on the executable code of the modified component to obtain the syntax backcheck result, which is either a pass or a fail. If the syntax check result is a pass, the corrected component executable code will be used as the self-check component code; If the syntax check fails, the component's executable code is marked as an exception to obtain the exception component code, which is then used as the self-check component code.
[0013] Optionally, the step of extracting parameters from the running instance to obtain multiple node states includes: The running instances are collected according to a preset time window to obtain current running data and historical running data. Statistical analysis of historical operational data yields baseline characteristics for multiple historical nodes. These baseline characteristics include: the mean of historical input fields, the variance of historical input fields, the mean of historical output fields, and the variance of historical output fields. The nodes of the currently running data are traversed to obtain multiple node running records; Perform the following operation on each node's execution record across multiple node execution records: Extract status information from node operation records to obtain node identifier, node execution status, node input data, and node output data; Based on node identifiers, feature matching is performed on the baseline features of multiple historical nodes to obtain the baseline features of the target node. Based on the baseline features of the target node, the mean of the target input field, the variance of the target input field, the mean of the target output field, and the variance of the target output field are identified. The node input data and node output data are quantized to obtain the input quantized value and the output quantized value. Calculate the node offset based on the input quantized value, output quantized value, target input field mean, target input field variance, target output field mean, and target output field variance; Determine if the node offset is greater than a preset offset threshold. If the node offset is greater than the offset threshold, mark the node's running record as abnormal to obtain a node abnormal identifier. Use the node anomaly identifier as the node status identifier; If the node offset is not greater than the offset threshold, the node's running record is marked normally to obtain the node's normal identifier; Use the node's normal status identifier as the node's status identifier; The node status is obtained by encapsulating the node identifier, node execution status, node input data, node output data, and node status identifier. Summarize the node states to obtain the states of multiple nodes.
[0014] Optionally, the determination of multiple visual debugging feedback identifiers based on multiple node states includes: For each of the multiple node states, perform the following operation: The node status is parsed to obtain the status category identifier, which is: waiting for execution, executing, execution completed, or execution error. Perform a data field scan on the node status to obtain the number of valid input fields, the number of valid output fields, the total number of input fields, and the total number of output fields. Calculate the node data completeness based on the number of valid input fields, the number of valid output fields, the total number of input fields, and the total number of output fields. State weights are obtained by mapping state weights based on state category identifiers; The node health score is calculated based on the state weight and node data completeness, using the following formula:
[0015] in, This represents the node's health score. Represents the state weights. Indicates the integrity of node data. Indicates the preset state weights. This indicates the preset data weights. Represents the natural constant; The target feedback level is determined based on the node health score, the preset first-level threshold, and the preset second-level threshold. The feedback rendering style is determined based on the status category identifier and the target feedback level. The feedback rendering style includes: feedback color identifier and feedback prompt text. The node identifier, status category identifier, node health score, and feedback rendering style are encapsulated to obtain a visual debugging feedback identifier; The visual debugging feedback identifiers are summarized to obtain multiple visual debugging feedback identifiers.
[0016] To achieve the above objectives, the present invention also provides a low-code, visual AI agent rapid development platform construction system, comprising: The basic area generation module is used to determine the set of functional elements, abstract the set of functional elements to obtain the set of functional components, determine the component library and backend mapping relationship set based on the set of functional components, and determine the component panel area, canvas arrangement area and parameter configuration area based on the component library. The compilation unit construction module is used to construct visual orchestration units using the component panel area, canvas orchestration area and parameter configuration area, perform orchestration analysis on the visual orchestration units, obtain multiple component nodes and multiple node connection relationships, determine the executable code set based on multiple component nodes and backend mapping relationship set, and determine the compilation construction unit based on multiple node connection relationships and executable code set. The debugging unit construction module is used to determine the running instance based on the compilation construction unit, extract parameters from the running instance to obtain multiple node states, determine multiple visual debugging feedback identifiers based on the multiple node states, and construct an online debugging unit using the multiple visual debugging feedback identifiers; The development platform building module is used to determine the release configuration set based on the compilation build unit, and to determine the deployment and release unit based on the compilation build unit and the release configuration set. It integrates the visual orchestration unit, compilation build unit, online debugging unit and deployment and release unit to obtain the AI agent rapid development platform, thus completing the construction of the AI agent rapid development platform.
[0017] To address the above problems, the present invention also provides an electronic device, the electronic device comprising: Memory, storing at least one instruction; The processor executes the instructions stored in the memory to implement the aforementioned method for building a rapid AI agent development platform based on low-code visualization.
[0018] To address the aforementioned issues, the present invention also provides a computer-readable storage medium storing at least one instruction, which is executed by a processor in an electronic device to implement the aforementioned method for constructing a rapid AI agent development platform based on low-code visualization.
[0019] To address the problems described in the background art, this invention identifies a set of functional elements, abstracts this set to obtain a set of functional components. This invention, by decomposing business functions into reusable component units, lays the foundation for subsequent visual orchestration. Based on the functional component set, a component library and a backend mapping relationship set are determined. This invention establishes a component library and maintains the mapping between components and backend logic, facilitating automatic association with backend services when dragging and dropping components. Based on the component library, a component panel area, a canvas orchestration area, and a parameter configuration area are determined. This invention divides the interface into three functional areas: component display, workflow orchestration, and parameter configuration, forming the basic layout of the visual development interface. The component panel area, canvas orchestration area, and... The parameter configuration area constructs a visual orchestration unit. This embodiment of the invention integrates three areas into a unified orchestration environment, allowing developers to design business processes through drag-and-drop and configuration. Orchestration analysis of the visual orchestration unit yields multiple component nodes and their connections. This embodiment of the invention extracts component nodes and their connections by parsing user orchestration operations on the canvas, forming process structure data. Based on multiple component nodes and the backend mapping relationship set, an executable code set is determined. This embodiment of the invention obtains backend code fragments from the mapping relationship based on the component type corresponding to the node, combines them into an executable code set, and determines the compilation and build unit based on the multiple node connections and the executable code set. This invention organizes code according to the node connection order to form compileable and buildable units, which are used to generate runnable applications. Based on these compilation and build units, a running instance is determined. This invention deploys and runs these compilation and build units to generate an executable running instance for testing and verifying orchestration results. Parameters are extracted from the running instance to obtain multiple node states. This invention collects the execution status and parameters of each node from the running instance to locate problems and analyze behavior. Based on these multiple node states, multiple visual debugging feedback indicators are determined. This invention maps node states to visual indicators (such as colors and icons) to intuitively display the running results of each node, facilitating rapid problem identification. This invention constructs online debugging units using multiple visual debugging feedback identifiers. As can be seen, this embodiment integrates debugging identifiers into the orchestration interface to form online debugging units, supporting developers to directly debug and correct processes in a visual environment. Based on the compilation and build units, a release configuration set is determined. This embodiment extracts the configuration information required for application deployment, such as environment parameters and service addresses, to form a release configuration set. Based on the compilation and build units and the release configuration set, a deployment and release unit is determined. This embodiment combines the compilation and build units with the release configuration to generate directly deployable release units. Integrating the visual orchestration unit, compilation and build unit, online debugging unit, and deployment and release unit yields the AIagent rapid development platform.The completion of the AI agent rapid development platform demonstrates that this invention integrates orchestration, building, debugging, and deployment into a single, comprehensive AI agent development platform, enabling developers to complete the entire process from design to deployment in one stop. Therefore, this invention lowers the development threshold for AI agents and improves their construction efficiency. Attached Figure Description
[0020] Figure 1 This is a flowchart illustrating a method for building a rapid AI agent development platform based on low-code visualization, according to an embodiment of the present invention. Figure 2 A functional module diagram of a low-code, visual AI agent rapid development platform construction system provided in an embodiment of the present invention; Figure 3 This is a schematic diagram of the structure of an electronic device that implements the method for building a rapid AI agent development platform based on low-code visualization, according to an embodiment of the present invention.
[0021] Explanation of reference numerals in the attached figures: 10. Electronic device; 11. Processor; 12. Memory; 13. Bus.
[0022] The realization of the objective, functional features and advantages of the present invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation
[0023] It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.
[0024] This application provides a method for constructing a rapid AI agent development platform based on low-code visualization. The execution entity of this method includes, but is not limited to, at least one electronic device that can be configured to execute the method provided in this application, such as a server or a terminal. In other words, the method can be executed by software or hardware installed on a terminal device or server device, and the software may be a blockchain platform. The server includes, but is not limited to, a single server, a server cluster, a cloud server, or a cloud server cluster.
[0025] Reference Figure 1 The diagram shown is a flowchart illustrating a method for building a rapid AI agent development platform based on low-code visualization, according to an embodiment of the present invention. In this embodiment, the method for building a rapid AI agent development platform based on low-code visualization includes: S1. Determine the set of functional elements, and abstract the set of functional elements to obtain the set of functional components.
[0026] For example, Zhang is an engineer at an AI agent company and needs to develop a development platform for quickly building AI agents. Zhang identifies a set of functional elements to facilitate subsequent processing, thereby constructing the AI agent rapid development platform. The set of functional elements refers to the collection of functional elements required for developing the AI agent, including: large language model invocation function, prompt word processing function, knowledge base retrieval function, tool invocation function, logic control function, and input / output function. The large language model invocation function refers to the function of the AI agent initiating inference requests to the large language model and obtaining inference results during operation. The inference request refers to the request issued by the AI agent to perform task processing, and the inference result refers to the data returned by the large language model after processing the inference request. The prompt word processing function refers to the function of organizing the prompt words input to the large language model. The knowledge base retrieval function refers to the function of obtaining information related to the current task from external materials (e.g., databases) and providing it to the large language model. The tool invocation function refers to the function of the AI agent using external programs to complete operations that it cannot perform directly. Logical control functions refer to the functions that arrange the execution order and conditions of various functions within the AI agent. Input / output functions refer to the functions that allow the AI agent to exchange data with external users (e.g., users).
[0027] In detail, the abstraction of the functional element set to obtain the functional component set includes: Perform the following operation on each functional element in the functional element set: Dependency determination is performed on functional elements to obtain dependency determination results, where the dependency determination results are: service call elements or process control elements; If the dependency judgment result is a service call element, then information is extracted from the service call element to obtain multiple service call description information; The functional components are obtained by encapsulating multiple service call descriptions using a pre-defined unified component description structure. If the decision result is a process control element, then information is extracted from the process control element to obtain multiple control flow description information. A unified component description structure is used to encapsulate multiple control flow description information to obtain functional components; Summarize the functional components to obtain a set of functional components.
[0028] It should be explained that the dependency determination of functional elements refers to the process of determining whether a functional element needs to call an external service to obtain an execution result. If the functional element needs to call an external service to obtain an execution result, the service call element is taken as the dependency determination result; otherwise, the flow control element is taken as the dependency determination result. The information extraction of service call elements refers to the process of extracting multiple structured information required for the service call element to interact with external services. The structured information is the service call description information.
[0029] It is understood that the encapsulation of multiple service call descriptions using a pre-defined unified component description structure refers to mapping each service call description to its corresponding field position within the unified component description structure, thereby generating a component with complete fields and a unified format. This component with complete fields and a unified format is the functional component. The structured template is as follows: component identifier, component name, component type identifier, input parameter description list, output parameter description list, and service endpoint configuration. The component type identifier distinguishes whether the functional component belongs to a service call type or a flow control type. The input parameter description list and output parameter description list describe the parameters the functional component needs to receive and the results it produces when called, respectively. The service endpoint configuration records the addresses of external services that the functional component needs to access during runtime.
[0030] It should be understood that the method for extracting information from process control elements to obtain multiple control flow descriptions is the same as the method for extracting information from service call elements to obtain multiple service call descriptions, and will not be repeated here. The method for encapsulating multiple control flow descriptions using a unified component description structure to obtain functional components is the same as the method for encapsulating multiple service call descriptions and multiple control flow descriptions using a preset unified component description structure to obtain functional components, and will not be repeated here. A functional component set is a collection of multiple functional components.
[0031] S2. Based on the functional component set, determine the component library and backend mapping relationship set, and based on the component library, determine the component panel area, canvas arrangement area and parameter configuration area.
[0032] It should be explained that determining the component panel area, canvas layout area, and parameter configuration area based on the component library refers to the process of generating three front-end areas with different functions, using the component library as the data source and based on the component metadata and front-end rendering descriptions contained in the component description records of each component in the component library. Specifically: The component panel area is a list-style area generated based on the component names, component types, and component icons contained in the component description records of each component in the component library, allowing developers to browse and select functional components. Detailed explanations of the component names, component types, and component icons can be found in subsequent embodiments. The canvas layout area is generated based on the front-end rendering descriptions, input port descriptions, and output port descriptions contained in the component description records of each component in the component library, allowing developers to layout functional components. Detailed explanations of the front-end rendering descriptions, input port descriptions, and output port descriptions can be found in subsequent embodiments. The parameter configuration area is generated based on the input port descriptions contained in the component description records of each component in the component library, allowing developers to fill in and adjust the input parameters of the functional components in the canvas layout area. Detailed explanations of the input port descriptions can be found in subsequent embodiments.
[0033] Specifically, determining the component library and backend mapping relationship set based on the functional component set includes: Perform the following operation on each functional component in the functional component set: Metadata is extracted from the functional components to obtain component metadata, which includes: component identifier, component name, component type, input port description and output port description; A front-end rendering description is generated for the functional components to obtain the front-end rendering description, wherein the front-end rendering description includes: component icon and component default size; Associate component metadata with front-end rendering descriptions to obtain component description records; The backend execution unit is identified based on the functional components; Establish a mapping relationship between functional components and backend execution units to obtain mapping relationship entries; By summarizing the component description records and mapping relationship entries, the component library and backend mapping relationship set are obtained.
[0034] It should be explained that the metadata extraction of the functional component refers to reading the information used to describe the basic attributes of the functional component from the unified component description structure of the functional component. The information used to describe the basic attributes of the functional component is the component metadata, which includes: component identifier, component name, component type, input port description, and output port description. The component identifier is a string that uniquely identifies a functional component in the component library. The component name is the name of the functional component for developers. The component type is an identifier used to identify the category to which the functional component belongs. The input port description is a description of the parameters that the functional component needs to receive when it is called by other components. The output port description is a description of the results that the functional component sends to subsequent components after execution.
[0035] It is understood that generating a front-end rendering description for a functional component refers to the process of generating system configuration information that controls how the functional component is presented in the canvas layout area using the component metadata of the functional component. This system configuration information controlling how the functional component is presented in the canvas layout area is the front-end rendering description. The front-end rendering description includes: the component icon and the component's default size. The component icon refers to the icon used to represent the functional component in the component panel area and the canvas layout area as a graphic symbol. The component's default size refers to the default width and default height of the functional component when it is dragged to the canvas layout area.
[0036] It should be understood that associating component metadata with front-end rendering description means binding component metadata with front-end rendering description to obtain a data record that fully describes all the information required for a functional component. This data record that fully describes all the information required for a functional component is the component description record. A back-end execution unit refers to a program related to the execution of a functional component, responsible for actually executing the operation represented by that functional component during AI agent runtime. Mapping relationship entries contain entries of mapping relationships between functional components and back-end execution units. The component library is a visual component library (VCL) composed of multiple component description records, and the back-end mapping relationship set is a collection of multiple mapping relationship entries.
[0037] S3. Construct a visual arrangement unit using the component panel area, canvas arrangement area, and parameter configuration area. Perform arrangement analysis on the visual arrangement unit to obtain multiple component nodes and multiple node connection relationships.
[0038] It should be explained that the construction of a visual arrangement unit using the component panel area, canvas arrangement area, and parameter configuration area refers to integrating these areas to form a front-end where developers can layout and configure functional components through drag-and-drop and input methods. This front-end, which allows developers to layout and configure functional components through drag-and-drop and input methods, is the visual arrangement unit. Furthermore, the method of integrating the component panel area, canvas arrangement area, and parameter configuration area to form a front-end where developers can layout and configure functional components through drag-and-drop and input methods is existing technology and will not be elaborated upon here.
[0039] In detail, the orchestration analysis of the visual orchestration unit to obtain multiple component nodes and the connection relationships between multiple nodes includes: The orchestration status of the visual orchestration unit is read to obtain the orchestration status data; Construct a directed dependency graph based on orchestration state data; Loop detection is performed on the directed dependency graph to obtain the loop detection result, where the loop detection result is: a loop exists or a loop does not exist; If the loop detection result indicates the existence of a loop, then the directed dependency graph is used to locate the loop, resulting in multiple loop vertices; A corrected directed dependency graph was identified based on multiple loop vertices and the directed dependency graph. If the loop detection result indicates that no loop exists, then the directed dependency graph will be used as the corrected directed dependency graph. Perform topological sorting on the modified directed dependency graph to obtain the node execution sequence, wherein the node execution sequence includes: multiple nodes to be executed; For each node to be executed in the node execution sequence, perform the following operation: Use the node to be executed as the target node; The downstream nodes are identified based on the target node; The output port type and output hierarchy depth are determined based on the target node; The input port type and input level depth are determined based on the downstream nodes; Type feature vector mapping is performed on the output port type and the input port type respectively to obtain the output type feature vector and the input type feature vector; The port matching confidence is calculated based on the output type feature vector, the input type feature vector, the output layer depth, and the input layer depth, using the following formula:
[0040] in, Indicates the port match confidence level. Indicates the output type as a feature vector. Represents the input type feature vector. Indicates the output hierarchy depth. Indicates the input hierarchy depth. Represents the dot product of vectors. Represents the magnitude of a vector. This indicates taking the absolute value. This indicates the preset maximum level depth. This represents the preset first weighting coefficient. This represents the preset second weighting coefficient; Summarize the port match confidence scores to obtain multiple port match confidence scores; Multiple consistent confidence levels were identified based on the matching confidence levels of multiple ports and the preset matching confidence threshold. Multiple component nodes were identified based on multiple nodes to be executed and multiple consistent confidence levels; Multiple node connections were determined based on the modified directed dependency graph.
[0041] It should be explained that the process of reading the arrangement status of the visual arrangement unit refers to the process of collecting all functional components within the canvas arrangement area and the connection information between all functional components from the visual arrangement unit. The arrangement status data refers to all functional components within the canvas arrangement area and the connection information between all functional components. The construction of a directed dependency graph based on the arrangement status data refers to using each functional component recorded in the arrangement status data as the vertices of the directed graph, and the connection relationships between nodes of the functional components as the directed edges of the directed graph. The direction of the directed edges points from the output port of the upstream functional component to the input port of the downstream functional component, thereby constructing a directed graph that can represent the execution order and data flow relationship between each functional component. This directed graph that can represent the execution order and data flow relationship between each functional component is called a directed dependency graph. The directed edge refers to an arc in the directed graph; the upstream functional component is the functional component that is executed first, and the downstream functional component is the functional component that is executed subsequently.
[0042] Understandably, loop detection in a directed dependency graph refers to determining whether a closed path exists in the graph, consisting of several directed edges connected end-to-end. If a closed path exists, the existence of a loop is considered a loop detection result; otherwise, the absence of a loop is considered a loop detection result. Loop localization in a directed dependency graph refers to the process of identifying multiple vertices that constitute the closed path from the graph. These multiple vertices constituting the closed path are the multiple loop vertices. The process of identifying a corrected directed dependency graph based on multiple loop vertices and a directed dependency graph refers to: for a closed path formed by multiple loop vertices in the directed dependency graph, locating the directed edge that allows the closed path to be formed, and removing the directed edge from the directed dependency graph to obtain the corrected directed dependency graph. The directed edge that allows the closed path to be formed refers to a directed edge that connects two loop vertices, whose removal breaks the closed path without interrupting the directed dependency graph. For example, if the directed dependency graph contains four vertices: A, B, C, and D, and the directed edges are A→B, B→C, C→D, and D→B respectively, the closed path is B→C→D→B. The directed edge D→B connects loop vertex D and loop vertex B. Removing it breaks the closed path, and the connectivity between vertices B, C, and D remains A→B, B→C, and C→D, without interrupting the directed dependency graph. Therefore, removing the directed edge D→B from the directed dependency graph results in a directed graph containing only three directed edges: A→B, B→C, and C→D, which is the corrected directed dependency graph.
[0043] It should be understood that the topological sorting of the modified directed dependency graph refers to sorting multiple vertices in the modified directed dependency graph in order from front to back according to the execution order represented by the directed edges. The node execution sequence is the sequence obtained after sorting multiple vertices in order from front to back according to the execution order represented by the directed edges, and the vertices are the nodes to be executed. The downstream node refers to the node to be executed that is adjacent to and lagging behind the target node among the multiple nodes to be executed in the node execution sequence. The process of determining the output port type and output level depth based on the target node refers to reading the data type identifier used by the functional component when transmitting the result to the downstream node and the index of the data type in the preset type level system from the output port description in the component metadata of the functional component corresponding to the target node. The data type identifier is the output port type, and the index of the level is the output level depth. Optionally, the type level system is: Level 0: arbitrary type, Level 1: basic type, structured type, Level 2: string, number, boolean value, Level 3: ordinary text, prompt text.
[0044] It is understood that determining the input port type and input level depth based on the downstream node refers to the process of reading the data type identifier required by the functional component when receiving the input result from the target node and the sequence number of the data type in the type hierarchy from the input port description in the component metadata of the functional component corresponding to the downstream node. The data type identifier is the input port type, and the sequence number of the level is the input level depth.
[0045] It should be explained that the type feature vector mapping for the output port type and input port type respectively refers to querying the type feature code corresponding to the output port type and the type feature code corresponding to the input port type from a preset type feature mapping table, and then converting the type feature code corresponding to the output port type into a vector that can represent the output port type, and the type feature code corresponding to the input port type into a vector that can represent the input port type. The vector that can represent the output port type is the output type feature vector, and the vector that can represent the input port type is the input type feature vector. Furthermore, the methods for converting the type feature code corresponding to the output port type into a vector that can represent the output port type and the methods for converting the type feature code corresponding to the input port type into a vector that can represent the input port type are existing technologies and will not be elaborated here.
[0046] It should be understood that port matching confidence refers to the degree of data type matching between the output port of the target node and the input port of the downstream node. The higher the port matching confidence, the higher the degree of data type matching between the output port of the target node and the input port of the downstream node. The maximum level depth is a value manually set by the AI agent company's engineers based on the maximum number of layers in the type hierarchy system. For example, if the maximum number of layers in the type hierarchy system is 3, then the maximum level depth is 3. The first weighting coefficient is used to measure the proportion of the type feature vector in the port matching confidence calculation, and the second weighting coefficient is used to measure the proportion of the level depth in the port matching confidence calculation. Optionally, the first and second weighting coefficients can be obtained by fitting historical experimental data.
[0047] It is understood that determining multiple consistent confidence levels based on multiple port matching confidence levels and a preset matching confidence threshold means: selecting all port matching confidence levels greater than or equal to the matching confidence threshold from the multiple port matching confidence levels; these port matching confidence levels greater than or equal to the matching confidence threshold are the consistent confidence levels. A component node refers to the node to be executed that corresponds to the consistent confidence level among multiple nodes to be executed. Multiple node connection relationships refer to correcting multiple directed edges in the directed dependency graph.
[0048] S4. The executable code set is determined based on multiple component nodes and backend mapping relationship sets, and the compilation and build unit is determined based on multiple node connection relationships and executable code set sets.
[0049] It should be explained that determining the compilation build unit based on multiple node connection relationships and executable code set means: assembling multiple independent self-test component codes in the executable code set into a program according to multiple node connection relationships. The method of assembling multiple independent self-test component codes in the executable code set into a program according to multiple node connection relationships is existing technology and will not be described in detail here. The program is the compilation build unit.
[0050] Specifically, the determination of the executable code set based on multiple component nodes and backend mapping relationships includes: Perform the following operation on each of the multiple component nodes: Perform node type identification on component nodes to obtain the target node type identifier; The target backend execution unit is obtained by matching the backend mapping relationship set based on the target node type identifier. The parameters of the component nodes are parsed to obtain the parameter binding table, which includes multiple key-value pairs. The validation parameter binding table is determined based on the component nodes and parameter binding table; The execution code template is obtained by loading the call template based on the target backend execution unit; The executable code template is instantiated and populated using a validation parameter binding table to obtain the component's executable code; Perform a syntax self-check on the component's executable code to obtain the self-checked component code; Summarize the self-test component code to obtain the executable code set.
[0051] It should be explained that the node type identification of the component node refers to the process of reading the node type identifier from the node data structure of the component node. The node type identifier read from the node data structure of the component node is the target node type identifier. The execution unit matching based on the target node type identifier of the backend mapping relationship set refers to comparing multiple mapping relationship entries in the backend mapping relationship set to find the mapping relationship entries whose component type matches the target node type identifier. The backend execution unit corresponding to the mapping relationship entries whose component type matches the target node type identifier is the target backend execution unit.
[0052] It is understood that the parameter parsing of component nodes refers to reading the parameters input by the developer one by one from the node parameter configuration of the component nodes, organizing each input parameter into a key-value pair, and finally summarizing the key-value pairs to obtain the parameter binding table. The method of organizing each input parameter into a key-value pair is existing technology and will not be elaborated here. The loading of the call template based on the target backend execution unit refers to the process of retrieving the skeleton of the code corresponding to the target backend execution unit from a preset template repository according to the type of the target backend execution unit. The skeleton of the code corresponding to the backend execution unit retrieved from the template repository is the execution code template. The template repository refers to a pre-built database that stores the skeletons of the code corresponding to different types of target backend execution units.
[0053] It should be understood that the instantiation and population of the executable code template using the validated parameter binding table refers to the process of replacing each key-value pair in the validated parameter binding table with the corresponding positions in the executable code template. The component executable code refers to the executable code template after instantiation and population using the validated parameter binding table. The executable code set is a collection composed of multiple self-checked component executable codes.
[0054] Specifically, the step of determining the validation parameter binding table based on component nodes and parameter binding tables includes: Perform the following operation on each of the multiple key-value pairs in the parameter binding table: The target port constraints are determined based on component nodes and key values; The key value is validated according to the target port constraint to obtain the required validation result, the type validation result, and the range validation result. Based on the results of mandatory field validation, type validation, and range validation, the mandatory field result value, type result value, and range result value are determined. The individual verification score is calculated based on the required field value, type value, and range value, using the following formula:
[0055] in, This indicates the score for a single verification item. This indicates a required result value. Indicates the type result value, Indicates a range of result values. This represents the logical AND operation; Summarize the individual verification scores to obtain multiple individual verification scores; The overall verification score is calculated based on multiple individual verification scores, using the following formula:
[0056] in, This indicates the overall verification result. This indicates the number of individual verification scores out of multiple individual verification scores. Indicates the score of the first item among multiple individual verification scores. Individual verification score; Determine whether the overall verification score is equal to the preset single value. If the overall verification score is equal to the single value, then use the parameter binding table as the verification parameter binding table. Otherwise, the validation parameter binding table is determined based on the parameter binding table, required result values, type result values, and range result values.
[0057] It should be explained that identifying the target port constraint based on the component node and key value means locating the input port corresponding to the key in the input port description of the component node according to the key in the key value, and reading the information declared by the input port. The information declared by the input port is the target port constraint, which includes: whether the input port is required, the types of data allowed by the input port, and the range of values allowed by the input port. The key in the key value refers to the element used to represent the parameter name in the key value.
[0058] Understandably, the process of validating key values according to target port constraints to obtain mandatory, type, and range validation results refers to the following: First, determining whether the key value meets the requirements of the input port declared in the target port constraint. Specifically, if the input port is declared mandatory and the key value is not empty, or if the input port is not declared mandatory, then the mandatory validation result is "passed"; otherwise, it is "failed". Next, determining whether the key value's type matches the data type allowed by the input port in the target port constraint. If the key value's type matches the data type allowed by the input port constraint, then the type validation result is "passed"; otherwise, it is "failed". Finally, determining whether the key value falls within the value range allowed by the input port constraint. If the key value falls within the value range allowed by the input port constraint, then the range validation result is "passed"; otherwise, it is "failed".
[0059] It should be understood that determining the required, type, and range result values based on the required, type, and range validation results refers to mapping these three types of validation results to numerical values that can participate in logical operations. Specifically, if the required validation result is "passed," the required result value is 1; otherwise, it is 0. If the type validation result is "passed," the type result value is 1; otherwise, it is 0. If the range validation result is "passed," the range result value is 1; otherwise, it is 0. Therefore, a key value's individual validation score is 1 only when all three values (required, type, and range) are 1. If any one of them is 0, the key value's individual validation score is 0. In other words, a key value is considered valid only if it passes all three validations.
[0060] It should be explained that the overall validation score is a parameter used to reflect the result of validating the parameter binding table. Since each individual validation score can only take the value of 0 or 1, the overall validation score can also only take the value of 0 or 1. Specifically, the overall validation score is 1 only when all individual validation scores for all key values are 1; if any key value has an individual validation score of 0, the overall validation score is 0. The individual value is 1. The validation parameter binding table refers to the parameter binding table when the overall validation score equals the individual value.
[0061] It should be understood that the process of determining the validation parameter binding table based on the parameter binding table, required result value, type result value, and range result value refers to: locating the key values that failed validation based on the required result value, type result value, and range result value corresponding to each key value, and performing correction processing on the key values that failed validation to obtain the validation parameter binding table. The correction processing includes: for key values that failed validation due to a required result value of 0, completing the key value according to the default value configured for the input port in its target port constraint; for key values that failed validation due to a type result value of 0, converting the type of the key value according to the data types allowed in its target port constraint; and for key values that failed validation due to a range result value of 0, truncating the key value according to the value range allowed in its target port constraint. The truncation means: if the key value is greater than the maximum value in the value range, then the maximum value is used as the key value; if the key value is less than the minimum value in the value range, then the minimum value is used as the key value.
[0062] In detail, the step of performing a syntax self-check on the executable code of the component to obtain the self-checked component code includes: Perform a lexical scan on the executable code of the component to obtain a sequence of lexical units; The lexical unit sequence is parsed to obtain the parsing result, which is either parsing successful or parsing unsuccessful. If the syntax parsing result is successful, then the component's executable code will be used as the self-check component code; If the parsing result is that the parsing fails, then the parsing result is used to locate the errors and obtain multiple syntax error locations; For each of the multiple syntax error locations, perform the following operation: The component's executable code is syntax-corrected based on the location of syntax errors to obtain the corrected syntax location. Summarize the corrected syntax locations to obtain multiple corrected syntax locations; The corrected component executable code was identified based on multiple correction syntax locations and component executable code. Perform a syntax backcheck on the executable code of the modified component to obtain the syntax backcheck result, which is either a pass or a fail. If the syntax check result is a pass, the corrected component executable code will be used as the self-check component code; If the syntax check fails, the component's executable code is marked as an exception to obtain the exception component code, which is then used as the self-check component code.
[0063] It should be explained that the lexical scanning of the component's executable code refers to the process of segmenting the executable code character by character into multiple smallest syntactic units with independent meanings according to the lexical rules of the programming language to which the component's executable code belongs. These smallest syntactic units with independent meanings are called lexical units. For example, in the C language, a lexical analyzer is used to complete this segmentation process. The sequence formed by arranging multiple lexical units according to their order of appearance in the component's executable code is called the lexical unit sequence. The syntax parsing of the lexical unit sequence refers to the process of determining whether the structure formed by the lexical unit sequence conforms to the syntax rules of the programming language to which the component's executable code belongs. If the structure formed by the lexical unit sequence conforms to the syntax rules of the programming language, the parsing is considered successful; otherwise, the parsing is considered unsuccessful.
[0064] Understandably, locating errors in the syntax parsing results refers to the process of identifying the line number of the lexical unit causing the parsing failure within the component's executable code. This line number is the syntax error location. Correcting the syntax in the component's executable code based on the syntax error location refers to the process of supplementing or replacing missing or incorrect syntax units in the component's executable code at the syntax error location according to the syntax rules of the programming language. The corrected syntax error location is the corrected syntax location. This supplementation includes: supplementing missing delimiters, matching mismatched parentheses, and replacing incorrect keywords. Corrected component executable code refers to the component executable code after correcting multiple syntax errors.
[0065] It should be understood that the syntax back-checking of the modified component executable code refers to re-executing lexical scanning and syntax parsing of the modified component executable code to determine whether it conforms to the syntax rules of the programming language. If the modified component executable code conforms to the syntax rules of the programming language, the back-check is considered successful; otherwise, the back-check is considered unsuccessful. The exception marking of the component executable code refers to the process of attaching a flag to the component executable code to indicate that the component executable code contains syntax errors that cannot be automatically corrected. Component executable code with the attached flag is considered exception component executable code. Self-checking component code refers to the component executable code after syntax self-checking.
[0066] S5. Based on the compilation and building units, determine the running instance, extract parameters from the running instance, and obtain the status of multiple nodes.
[0067] It should be explained that determining the runtime instance based on the compilation build unit refers to the process of loading the compilation build unit into a preset runtime environment, thereby deploying the compilation build unit and making it executable, thus forming a runnable AI agent. The runnable AI agent is the runtime instance. Furthermore, the method of loading the compilation build unit into the preset runtime environment is existing technology and will not be elaborated here. The runtime environment refers to the software environment required for the execution of the runtime instance.
[0068] In detail, the parameter extraction of the running instance to obtain multiple node states includes: The running instances are collected according to a preset time window to obtain current running data and historical running data. Statistical analysis of historical operational data yields baseline characteristics for multiple historical nodes. These baseline characteristics include: the mean of historical input fields, the variance of historical input fields, the mean of historical output fields, and the variance of historical output fields. The nodes of the currently running data are traversed to obtain multiple node running records; Perform the following operation on each node's execution record across multiple node execution records: Extract status information from node operation records to obtain node identifier, node execution status, node input data, and node output data; Based on node identifiers, feature matching is performed on the baseline features of multiple historical nodes to obtain the baseline features of the target node. Based on the baseline features of the target node, the mean of the target input field, the variance of the target input field, the mean of the target output field, and the variance of the target output field are identified. The node input data and node output data are quantized to obtain the input quantized value and the output quantized value. The node offset is calculated based on the input quantized value, output quantized value, target input field mean, target input field variance, target output field mean, and target output field variance. The calculation formula is as follows:
[0069] in, Indicates node offset. Indicates the input quantization value. This represents the mean of the target input field. This represents the variance of the target input field. This indicates the output quantization value. This indicates the mean of the target output field. This indicates the variance of the target output field. Indicates taking the absolute value; Determine if the node offset is greater than a preset offset threshold. If the node offset is greater than the offset threshold, mark the node's running record as abnormal to obtain a node abnormal identifier. Use the node anomaly identifier as the node status identifier; If the node offset is not greater than the offset threshold, the node's running record is marked normally to obtain the node's normal identifier; Use the node's normal status identifier as the node's status identifier; The node status is obtained by encapsulating the node identifier, node execution status, node input data, node output data, and node status identifier. Summarize the node states to obtain the states of multiple nodes.
[0070] It should be explained that the collection of runtime data from the running instance according to the preset time window means: first, collecting information related to the execution of each functional component generated during the initial execution of the running instance; then, after an interval of one time window (e.g., 5 minutes), collecting information related to the execution of each functional component generated during subsequent executions of the running instance, and stopping the collection of runtime data from the running instance. The information related to the execution of each functional component generated during the initial execution is the historical runtime data, and the information related to the execution of each functional component generated during subsequent executions is the current runtime data. The information related to the execution of the functional components includes: input field values and output field values. The input field values refer to the values of the fields input to the functional component, and the output field values refer to the values of the fields output by the functional component. The statistical analysis of the historical runtime data means: calculating the average and variance of the multiple input field values based on the multiple input field values corresponding to multiple functional components in the historical runtime data; and calculating the average and variance of the multiple output field values based on the multiple output field values corresponding to multiple functional components in the historical runtime data. The average value of the multiple input fields is the historical input field mean, and the variance of the multiple input field values is the historical input field variance. Similarly, the average value of the multiple output fields is the historical output field mean, and the variance of the multiple output field values is the historical output field variance. Combining the historical input field mean, historical input field variance, historical output field mean, and historical output field variance yields the historical node baseline features. Finally, the historical node baseline features of each functional component are summarized to obtain multiple historical node baseline features.
[0071] It should be understood that the node traversal of the current running data refers to: sequentially reading the information generated by each functional component in the current running data during this run, and finally summarizing the information generated by each functional component in this run to obtain multiple node running records. The information generated by the functional component in this run is the node running record. A detailed explanation of the information generated by the functional component in this run can be found in subsequent embodiments. The extraction of state information from the node running records refers to the process of reading information describing the functional component during runtime from the node running records. The information describing the functional component during runtime includes: node identifier, node execution status, node input data, and node output data. The node identifier refers to the component identifier of the functional component; the node execution status refers to the identifier of the execution stage the functional component is in during runtime (e.g., waiting to execute, executing, execution completed, or execution exception); the node input data refers to the parameters actually received by the functional component during execution; and the node output data refers to the actual output result after the functional component completes execution.
[0072] Understandably, the target node baseline feature refers to the node baseline feature corresponding to the functional component represented by the node identifier among multiple historical node baseline features. The target input field mean refers to the historical input field mean in the target node baseline features; the target input field variance refers to the historical input field variance in the target node baseline features; the target output field mean refers to the historical output field mean in the target node baseline features; and the target output field variance refers to the historical output field variance in the target node baseline features. The quantization processing of node input data and node output data refers to converting node input data into numerical values that can participate in numerical calculations according to preset quantization rules (e.g., taking field length), and converting node output data into numerical values that can participate in numerical calculations according to quantization rules (e.g., taking field length). The input quantized value refers to the value obtained after quantizing the node input data, and the output quantized value refers to the value obtained after quantizing the node output data.
[0073] It should be explained that node offset reflects the degree of deviation between the current running state of a component node and its historical normal running state. The larger the node offset, the greater the deviation between the current running state and the historical normal running state. The offset threshold is a value manually set by the engineers of the AI agent company based on the maximum value of the node offset of historically normally running instances. For example, if the maximum value of the node offset of historically normally running instances is 0.4, then the offset threshold is 0.4.
[0074] It should be noted that during the operation of a component node, differences in the node's input data or errors in the component node's own operation can cause the component node to deviate from its historical normal operating state. Marking a node's operation record as abnormal means adding an identifier to the node's operation record to indicate that the component node's current operating state deviates from its historical normal level; this identifier is the node's abnormal identifier. Marking a node's operation record as normal means adding an identifier to the node's operation record to indicate that the component node's current operating state is within the historical normal range; this identifier is the node's normal identifier.
[0075] Understandably, encapsulating node identifier, node execution status, node input data, node output data, and node status identifier means combining these elements into a complete data record according to a preset data structure. The resulting complete record is the node status. Optionally, the data structure can be: node identifier, node execution status, node input data, node output data, and node status identifier.
[0076] S6. Based on the status of multiple nodes, determine multiple visual debugging feedback identifiers, and use the multiple visual debugging feedback identifiers to construct an online debugging unit.
[0077] It should be explained that the construction of an online debugging unit using multiple visual debugging feedback identifiers refers to rendering multiple visual debugging feedback identifiers onto the corresponding component nodes in the canvas arrangement area according to their corresponding node identifiers, thereby forming a front-end that allows developers to observe the execution status of each functional component in real time during the execution of the running instance. The front-end that allows developers to observe the execution status of each functional component in real time during the execution of the running instance is the online debugging unit.
[0078] Specifically, the determination of multiple visual debugging feedback identifiers based on the states of multiple nodes includes: For each of the multiple node states, perform the following operation: The node status is parsed to obtain the status category identifier, which is: waiting for execution, executing, execution completed, or execution error. Perform a data field scan on the node status to obtain the number of valid input fields, the number of valid output fields, the total number of input fields, and the total number of output fields. The node data completeness is calculated based on the number of valid input fields, the number of valid output fields, the total number of input fields, and the total number of output fields. The calculation formula is as follows:
[0079] in, Indicates the integrity of node data. Indicates the number of valid input fields. Indicates the number of valid output fields. This indicates the total number of input fields. Indicates the total number of output fields; State weights are obtained by mapping state weights based on state category identifiers; The node health score is calculated based on the state weight and node data completeness, using the following formula:
[0080] in, This represents the node's health score. Represents the state weights. Indicates the integrity of node data. Indicates the preset state weights. This indicates the preset data weights. Represents the natural constant; The target feedback level is determined based on the node health score, the preset first-level threshold, and the preset second-level threshold. The feedback rendering style is determined based on the status category identifier and the target feedback level. The feedback rendering style includes: feedback color identifier and feedback prompt text. The node identifier, status category identifier, node health score, and feedback rendering style are encapsulated to obtain a visual debugging feedback identifier; The visual debugging feedback identifiers are summarized to obtain multiple visual debugging feedback identifiers.
[0081] It should be explained that the execution status parsing of the node status refers to the process of reading the node execution status from the node status data structure and classifying the node execution status into corresponding status category identifiers. These status category identifiers are: waiting for execution, in execution, execution completed, or execution exception. Specifically, the waiting for execution identifier indicates a state waiting for the task to start; the in execution identifier indicates a state currently executing the task; the execution completed identifier indicates a state where the task execution has been completed; and the execution exception identifier indicates a state where the task execution has encountered an exception. The data field scanning of the node status refers to counting the number of non-empty fields and the total number of fields in the node input data of the node status, and counting the number of non-empty fields and the total number of fields in the node output data of the node status. The number of non-empty fields in the node input data of the node status is the number of valid input fields, and the total number of fields in the node input data of the node status is the total number of input fields. The number of fields with non-empty values in the node output data of the node status is the number of valid output fields, and the total number of all fields in the node output data of the node status is the total number of output fields.
[0082] Understandably, node data completeness reflects the degree of data filling in the input and output of functional components during runtime. The greater the node data completeness, the higher the degree of data filling in the input and output of functional components during runtime, indicating a more complete data flow of the functional components. The state weight mapping based on state category identifiers refers to the process of converting state category identifiers into numerical values that can participate in calculations according to a preset mapping relationship. Optionally, the state weight corresponding to the waiting execution identifier in the state category identifiers is 0, the state weight corresponding to the executing identifier in the state category identifiers is 0.5, the state weight corresponding to the executing completed identifier in the state category identifiers is 1, and the state weight corresponding to the executing abnormal identifier in the state category identifiers is -1. It should be noted that the state weight is a parameter used to calculate the node health score, and the calculation formula for the node health score is essentially a sigmoid function with the weighted sum of the state weight and the node data completeness as the independent variable. Its value increases monotonically with the increase of the independent variable. Therefore, the value of the state weight needs to be able to distinguish the health level of the node operation reflected by each node execution state in order from low to high. Specifically, the weight of the "Completed" status is set to 1. This is because the "Completed" status indicates that the component node has completed its task without any anomalies, thus assigning it the highest weight and maximizing its positive impact on the independent variable, thereby pushing the node's health score to the highest level. The weight of the "In Progress" status is set to 0.5. This is because the "In Progress" status indicates that the component node is currently processing a task, and its successful completion is uncertain. Its health level is between "Waiting to Execute" and "Completed," so it is assigned a weight between 0 and 1, placing the node's health score at a moderate level and distinguishing it from the "Completed" and "Waiting to Execute" statuses. The weight of the "Waiting to Execute" status is set to 0. This is because the "Waiting to Execute" status indicates that the component node has not yet started processing the task, has not produced any execution results, and there are no anomalies. Therefore, it is assigned a weight of 0, ensuring that the weight in this state has neither a positive nor a negative impact on the independent variable, thus allowing the node's health score to be determined solely by the node's data integrity. The execution exception flag is set to -1 because the execution exception flag indicates that the component node has encountered an error during runtime. Therefore, it is given a negative state weight, which makes the state weight in this state have a negative impact on the independent variable, thereby pulling the node health score to the lowest level. The positive impact means that the node health score is increased, and the negative impact means that the node health score is decreased.
[0083] It should be understood that the node health score is a parameter used to comprehensively reflect the execution status and data integrity of a functional component during runtime. The higher the node health score, the healthier the execution status and the higher the data integrity of the functional component during runtime, indicating that the functional component is running healthier.
[0084] The determination of the target feedback level based on node health scores, preset first-level thresholds, and preset second-level thresholds refers to: comparing the node health score with the first-level threshold and the second-level threshold. If the node health score is greater than or equal to the first-level threshold, the normal level is used as the target feedback level; if the node health score is less than or equal to the second-level threshold, the abnormal level is used as the target feedback level; otherwise, the warning level is used as the target feedback level. The first-level threshold is a value manually set by engineers from the AI agent company based on the minimum node health score of historically normally functioning node components. For example, if the minimum node health score of a historically normally functioning node component is 0.8, then the first-level threshold is 0.8. The second-level threshold is a value manually set by engineers from the AI agent company based on the maximum node health score of historically abnormal node components. For example, if the maximum node health score of a historically abnormal node component is 0.3, then the second-level threshold is 0.3.
[0085] It should be explained that the process of determining the feedback rendering style based on the status category identifier and target feedback level refers to the process of determining the feedback rendering style used to intuitively present the node's running status in the canvas arrangement area based on the status category identifier and the target feedback level. The feedback rendering style includes: feedback color identifiers and feedback prompt text. The feedback color identifiers are used to distinguish the node's running status by color (e.g., green for normal, yellow for warning, and red for abnormal). The feedback prompt text is used to describe the node's current execution status and the reason for any abnormality. The process of encapsulating the node identifier, status category identifier, node health score, and feedback rendering style refers to the process of mapping the above information to the corresponding field positions according to a preset visual debugging feedback identifier data structure, thereby generating a data object with complete fields and a unified format. This data object is the visual debugging feedback identifier. Optionally, the visual debugging feedback identifier data structure is: node identifier, status category identifier, node health score, and feedback rendering style.
[0086] S7. Determine the release configuration set based on the compilation build unit, and determine the deployment release unit based on the compilation build unit and the release configuration set.
[0087] It should be explained that determining the release configuration set based on the compilation build unit refers to reading multiple system configuration information required by the compilation build unit when it is deployed to the runtime environment. The release configuration set is a collection of these multiple system configuration information. The method for reading these multiple system configuration information from the compilation build unit is existing technology and will not be elaborated here. Determining the deployment release unit based on the compilation build unit and the release configuration set refers to encapsulating the compilation build unit according to the multiple system configuration information in the release configuration set, thereby forming software that can be loaded into the runtime environment. The software that can be loaded into the runtime environment is the deployment release unit. The method for encapsulating the compilation build unit according to the multiple system configuration information in the release configuration set is existing technology and will not be elaborated here.
[0088] S8. Integrate the visual orchestration unit, compilation and building unit, online debugging unit, and deployment and release unit to obtain the AI agent rapid development platform, thus completing the construction of the AI agent rapid development platform.
[0089] It should be explained that the integration of the visual orchestration unit, compilation and build unit, online debugging unit, and deployment and release unit refers to the process of encapsulating these units into a single development platform. Furthermore, the method of encapsulating these units into a single development platform is existing technology and will not be elaborated upon here. The AI agent rapid development platform refers to a development platform that can be used to build AI agents, obtained by integrating the visual orchestration unit, compilation and build unit, online debugging unit, and deployment and release unit.
[0090] For example, once Xiao Zhang obtains the AI agent rapid development platform, he can use the platform to quickly build the AI agent, thereby completing the construction of the AI agent rapid development platform. To address the problems described in the background art, this invention identifies a set of functional elements, abstracts this set to obtain a set of functional components. This invention, by decomposing business functions into reusable component units, lays the foundation for subsequent visual orchestration. Based on the functional component set, a component library and a backend mapping relationship set are determined. This invention establishes a component library and maintains the mapping between components and backend logic, facilitating automatic association with backend services when dragging and dropping components. Based on the component library, a component panel area, a canvas orchestration area, and a parameter configuration area are determined. This invention divides the interface into three functional areas: component display, workflow orchestration, and parameter configuration, forming the basic layout of the visual development interface. The component panel area, canvas orchestration area, and... The parameter configuration area constructs a visual orchestration unit. This embodiment of the invention integrates three areas into a unified orchestration environment, allowing developers to design business processes through drag-and-drop and configuration. Orchestration analysis of the visual orchestration unit yields multiple component nodes and their connections. This embodiment of the invention extracts component nodes and their connections by parsing user orchestration operations on the canvas, forming process structure data. Based on multiple component nodes and the backend mapping relationship set, an executable code set is determined. This embodiment of the invention obtains backend code fragments from the mapping relationship based on the component type corresponding to the node, combines them into an executable code set, and determines the compilation and build unit based on the multiple node connections and the executable code set. This invention organizes code according to the node connection order to form compileable and buildable units, which are used to generate runnable applications. Based on these compilation and build units, a running instance is determined. This invention deploys and runs these compilation and build units to generate an executable running instance for testing and verifying orchestration results. Parameters are extracted from the running instance to obtain multiple node states. This invention collects the execution status and parameters of each node from the running instance to locate problems and analyze behavior. Based on these multiple node states, multiple visual debugging feedback indicators are determined. This invention maps node states to visual indicators (such as colors and icons) to intuitively display the running results of each node, facilitating rapid problem identification. This invention constructs online debugging units using multiple visual debugging feedback identifiers. As can be seen, this embodiment integrates debugging identifiers into the orchestration interface to form online debugging units, supporting developers to directly debug and correct processes in a visual environment. Based on the compilation and build units, a release configuration set is determined. This embodiment extracts the configuration information required for application deployment, such as environment parameters and service addresses, to form a release configuration set. Based on the compilation and build units and the release configuration set, a deployment and release unit is determined. This embodiment combines the compilation and build units with the release configuration to generate directly deployable release units. Integrating the visual orchestration unit, compilation and build unit, online debugging unit, and deployment and release unit yields the AIagent rapid development platform.The completion of the AI agent rapid development platform demonstrates that this invention integrates orchestration, building, debugging, and deployment into a single, comprehensive AI agent development platform, enabling developers to complete the entire process from design to deployment in one stop. Therefore, this invention lowers the development threshold for AI agents and improves their construction efficiency. like Figure 2 The diagram shown is a functional block diagram of a low-code visualization-based AI agent rapid development platform construction system provided in an embodiment of the present invention.
[0091] The AI agent rapid development platform construction system 100 based on low-code visualization described in this invention can be installed in an electronic device. Depending on the functions implemented, the AI agent rapid development platform construction system 100 based on low-code visualization may include a basic region generation module 101, a compilation unit construction module 102, a debugging unit construction module 103, and a development platform construction module 104. The modules described in this invention can also be referred to as units, which are a series of computer program segments that can be executed by the processor of an electronic device and can perform a fixed function, and are stored in the memory of the electronic device.
[0092] The basic area generation module 101 is used to determine the functional element set, abstract the functional element set to obtain the functional component set, determine the component library and backend mapping relationship set based on the functional component set, and determine the component panel area, canvas arrangement area and parameter configuration area based on the component library. The compilation unit construction module 102 is used to construct a visual arrangement unit using the component panel area, the canvas arrangement area and the parameter configuration area, perform arrangement analysis on the visual arrangement unit to obtain multiple component nodes and multiple node connection relationships, determine the executable code set based on the multiple component nodes and the backend mapping relationship set, and determine the compilation construction unit based on the multiple node connection relationships and the executable code set. The debugging unit construction module 103 is used to determine the running instance based on the compilation construction unit, extract parameters from the running instance to obtain multiple node states, determine multiple visual debugging feedback identifiers based on the multiple node states, and construct an online debugging unit using the multiple visual debugging feedback identifiers. The development platform construction module 104 is used to determine the release configuration set based on the compilation construction unit, determine the deployment and release unit based on the compilation construction unit and the release configuration set, and integrate the visualization orchestration unit, compilation construction unit, online debugging unit and deployment and release unit to obtain the AI agent rapid development platform and complete the construction of the AI agent rapid development platform.
[0093] In detail, the modules in the low-code visualization-based AI agent rapid development platform construction system 100 described in this embodiment of the invention adopt the same approach as described above when in use. Figure 1 The method used is the same as the low-code visualization-based AI agent rapid development platform construction method described in the article, and can produce the same technical effect, so it will not be repeated here.
[0094] like Figure 3 The diagram shown is a structural schematic of an electronic device that implements a method for building a rapid AI agent development platform based on low-code visualization, according to an embodiment of the present invention.
[0095] The electronic device 1 may include a processor 10, a memory 11 and a bus 12, and may also include a computer program stored in the memory 11 and capable of running on the processor 10, such as a method program for building a rapid development platform for AI agents based on low-code visualization.
[0096] The memory 11 includes at least one type of readable storage medium, such as flash memory, portable hard drive, multimedia card, card-type memory (e.g., SD or DX memory), magnetic memory, magnetic disk, optical disk, etc. In some embodiments, the memory 11 can be an internal storage unit of the electronic device 1, such as the portable hard drive of the electronic device 1. In other embodiments, the memory 11 can be an external storage device of the electronic device 1, such as a plug-in portable hard drive, smart media card (SMC), secure digital card (SD), flash card, etc., equipped on the electronic device 1. Furthermore, the memory 11 includes both internal storage units and external storage devices of the electronic device 1. The memory 11 can be used not only to store application software and various types of data installed on the electronic device 1, such as the code of a method program for building a low-code visual AI agent rapid development platform, but also to temporarily store data that has been output or will be output.
[0097] In some embodiments, the processor 10 may be composed of integrated circuits, such as a single packaged integrated circuit or multiple integrated circuits with the same or different functions, including combinations of one or more central processing units (CPUs), microprocessors, digital processing chips, graphics processors, and various control chips. The processor 10 is the control unit of the electronic device, connecting various components of the entire electronic device through various interfaces and lines. It executes programs or modules stored in the memory 11 (e.g., a method for building a rapid development platform for low-code visual AI agents), and calls data stored in the memory 11 to perform various functions of the electronic device 1 and process data.
[0098] The bus 12 can be a peripheral component interconnect (PCI) bus or an extended industry standard architecture (EISA) bus, etc. The bus 12 can be divided into an address bus, a data bus, a control bus, etc. The bus 12 is configured to realize the connection and communication between the memory 11 and at least one processor 10, etc.
[0099] Figure 3 Only electronic devices with components are shown; it will be understood by those skilled in the art that... Figure 3 The structure shown does not constitute a limitation on the electronic device 1, and may include fewer or more components than shown, or combine certain components, or have different component arrangements.
[0100] For example, although not shown, the electronic device 1 may also include a power supply (such as a battery) to power the various components. Preferably, the power supply can be logically connected to the at least one processor 10 through a power management device, thereby enabling functions such as charging management, discharging management, and power consumption management. The power supply may also include one or more DC or AC power supplies, recharging devices, power fault detection circuits, power converters or inverters, power status indicators, and other arbitrary components. The electronic device 1 may also include various sensors, Bluetooth modules, Wi-Fi modules, etc., which will not be described in detail here.
[0101] Furthermore, the electronic device 1 may also include a network interface. Optionally, the network interface may include a wired interface and / or a wireless interface (such as a Wi-Fi interface, a Bluetooth interface, etc.), which is typically used to establish communication connections between the electronic device 1 and other electronic devices.
[0102] Optionally, the electronic device 1 may further include a user interface, which may be a display, an input unit (such as a keyboard), and optionally, a standard wired interface or a wireless interface. Optionally, in some embodiments, the display may be an LED display, a liquid crystal display, a touch-sensitive liquid crystal display, or an OLED (Organic Light-Emitting Diode) touchscreen, etc. The display may also be appropriately referred to as a screen or display unit, used to display information processed in the electronic device 1 and to display a visual user interface.
[0103] The program for building a rapid AI agent development platform based on low-code visualization, stored in the memory 11 of the electronic device 1, is a combination of multiple instructions. When run in the processor 10, it can achieve the following: Once the set of functional elements is determined, it is abstracted to obtain the set of functional components. The component library and backend mapping relationship set are determined based on the functional component set; Based on the component library, the component panel area, canvas arrangement area, and parameter configuration area are determined. Utilize the component panel area, canvas arrangement area, and parameter configuration area to construct visual arrangement units; The visual orchestration unit is analyzed to obtain multiple component nodes and the connection relationships between multiple nodes. The executable code set is determined based on multiple component nodes and backend mapping relationships; The compilation and build unit is determined based on the connection relationships between multiple nodes and the executable code set; The runtime instance is determined based on the compilation build unit; Extract parameters from the running instance to obtain the status of multiple nodes; Multiple visual debugging feedback identifiers are determined based on the status of multiple nodes; An online debugging unit is constructed using multiple visual debugging feedback indicators; The release configuration set is determined based on the compilation and build units; The deployment and release units are determined based on the compilation and build units and the release configuration sets; By integrating the visual orchestration unit, compilation and building unit, online debugging unit, and deployment and release unit, we obtain the AI agent rapid development platform and complete the construction of the AI agent rapid development platform.
[0104] Specifically, the processor 10's implementation method for the above instructions can be found in [reference needed]. Figures 1 to 3The descriptions of the relevant steps in the corresponding embodiments are not repeated here.
[0105] Furthermore, if the modules / units integrated in the electronic device 1 are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. The computer-readable storage medium can be volatile or non-volatile. For example, the computer-readable medium may include: any entity or device capable of carrying the computer program code, a recording medium, a USB flash drive, a portable hard drive, a magnetic disk, an optical disk, a computer memory, or a read-only memory (ROM).
[0106] The present invention also provides a computer-readable storage medium storing a computer program, which, when executed by a processor of an electronic device, can perform the following: Once the set of functional elements is determined, it is abstracted to obtain the set of functional components. The component library and backend mapping relationship set are determined based on the functional component set; Based on the component library, the component panel area, canvas arrangement area, and parameter configuration area are determined. Utilize the component panel area, canvas arrangement area, and parameter configuration area to construct visual arrangement units; The visual orchestration unit is analyzed to obtain multiple component nodes and the connection relationships between multiple nodes. The executable code set is determined based on multiple component nodes and backend mapping relationships; The compilation and build unit is determined based on the connection relationships between multiple nodes and the executable code set; The runtime instance is determined based on the compilation build unit; Extract parameters from the running instance to obtain the status of multiple nodes; Multiple visual debugging feedback identifiers are determined based on the status of multiple nodes; An online debugging unit is constructed using multiple visual debugging feedback indicators; The release configuration set is determined based on the compilation and build units; The deployment and release units are determined based on the compilation and build units and the release configuration sets; By integrating the visual orchestration unit, compilation and building unit, online debugging unit, and deployment and release unit, we obtain the AI agent rapid development platform and complete the construction of the AI agent rapid development platform.
[0107] In the embodiments provided by this invention, it should be understood that the disclosed devices, systems, and methods can be implemented in other ways. For example, the system embodiments described above are merely illustrative, and actual implementations may have other classification methods.
[0108] The modules described as separate components may or may not be physically separate. The components shown as modules may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.
[0109] Furthermore, the functional modules in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or in the form of hardware plus software functional modules.
[0110] It will be apparent to those skilled in the art that the present invention is not limited to the details of the exemplary embodiments described above, and that the present invention can be implemented in other specific forms without departing from the spirit or essential characteristics of the present invention.
[0111] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention.
Claims
1. A low-code visualization-based AI agent rapid development platform construction method, characterized in that, The method includes: Once the set of functional elements is determined, it is abstracted to obtain the set of functional components. The component library and backend mapping relationship set are determined based on the functional component set; Based on the component library, the component panel area, canvas arrangement area, and parameter configuration area are determined. Utilize the component panel area, canvas arrangement area, and parameter configuration area to construct visual arrangement units; The visual orchestration unit is analyzed to obtain multiple component nodes and the connection relationships between multiple nodes. The executable code set is determined based on multiple component nodes and backend mapping relationships; The compilation and build unit is determined based on the connection relationships between multiple nodes and the executable code set; The runtime instance is determined based on the compilation build unit; Extract parameters from the running instance to obtain the status of multiple nodes; Multiple visual debugging feedback identifiers are determined based on the status of multiple nodes; An online debugging unit is constructed using multiple visual debugging feedback indicators; The release configuration set is determined based on the compilation and build units; The deployment and release units are determined based on the compilation and build units and the release configuration sets; By integrating the visual orchestration unit, compilation and building unit, online debugging unit, and deployment and release unit, the AIagent rapid development platform is obtained, thus completing the construction of the AI agent rapid development platform.
2. The low-code-visualization-based AI agent rapid development platform construction method of claim 1, wherein, The abstraction of the functional element set to obtain the functional component set includes: Perform the following operation on each functional element in the functional element set: Dependency determination is performed on functional elements to obtain dependency determination results, where the dependency determination results are: service call elements or process control elements; If the dependency judgment result is a service call element, then information is extracted from the service call element to obtain multiple service call description information; The functional components are obtained by encapsulating multiple service call descriptions using a pre-defined unified component description structure. If the decision result is a process control element, then information is extracted from the process control element to obtain multiple control flow description information. A unified component description structure is used to encapsulate multiple control flow description information to obtain functional components; Summarize the functional components to obtain a set of functional components.
3. The low-code-visualization-based AI agent rapid development platform construction method of claim 2, wherein, The determination of the component library and backend mapping relationship set based on the functional component set includes: Perform the following operation on each functional component in the functional component set: Metadata is extracted from the functional components to obtain component metadata, which includes: component identifier, component name, component type, input port description and output port description; A front-end rendering description is generated for the functional components to obtain the front-end rendering description, wherein the front-end rendering description includes: component icon and component default size; Associate component metadata with front-end rendering descriptions to obtain component description records; The backend execution unit is identified based on the functional components; Establish a mapping relationship between functional components and backend execution units to obtain mapping relationship entries; By summarizing the component description records and mapping relationship entries, the component library and backend mapping relationship set are obtained.
4. The low-code-visualization-based AI agent rapid development platform construction method of claim 3, wherein, The arrangement analysis of the visual arrangement unit yields multiple component nodes and their connection relationships, including: The orchestration status of the visual orchestration unit is read to obtain the orchestration status data; Construct a directed dependency graph based on orchestration state data; Loop detection is performed on the directed dependency graph to obtain the loop detection result, where the loop detection result is: a loop exists or a loop does not exist; If the loop detection result indicates the existence of a loop, then the directed dependency graph is used to locate the loop, resulting in multiple loop vertices; A corrected directed dependency graph was identified based on multiple loop vertices and the directed dependency graph. If the loop detection result indicates that no loop exists, then the directed dependency graph will be used as the corrected directed dependency graph. Perform topological sorting on the modified directed dependency graph to obtain the node execution sequence, wherein the node execution sequence includes: multiple nodes to be executed; For each node to be executed in the node execution sequence, perform the following operation: Use the node to be executed as the target node; The downstream nodes are identified based on the target node; The output port type and output hierarchy depth are determined based on the target node; The input port type and input level depth are determined based on the downstream nodes; Type feature vector mapping is performed on the output port type and the input port type respectively to obtain the output type feature vector and the input type feature vector; The port matching confidence is calculated based on the output type feature vector, the input type feature vector, the output layer depth, and the input layer depth, using the following formula: wherein, denotes a port matching confidence, denotes an output type feature vector, denotes an input type feature vector, denotes an output level depth, denotes an input level depth, denotes a dot product of vectors, denotes a modulus of a vector, denotes taking an absolute value, denotes a preset maximum level depth, denotes a preset first weight coefficient, denotes a preset second weight coefficient; Summarize the port match confidence scores to obtain multiple port match confidence scores; Multiple consistent confidence levels were identified based on the matching confidence levels of multiple ports and the preset matching confidence threshold. Multiple component nodes were identified based on multiple nodes to be executed and multiple consistent confidence levels; Multiple node connections were determined based on the modified directed dependency graph.
5. The low-code-visualization-based AI agent rapid development platform construction method of claim 4, wherein, The executable code set determined based on multiple component nodes and backend mapping relationships includes: Perform the following operation on each of the multiple component nodes: Perform node type identification on component nodes to obtain the target node type identifier; The target backend execution unit is obtained by matching the backend mapping relationship set based on the target node type identifier. The parameters of the component nodes are parsed to obtain the parameter binding table, which includes multiple key-value pairs. The validation parameter binding table is determined based on the component nodes and parameter binding table; The execution code template is obtained by loading the call template based on the target backend execution unit; The executable code template is instantiated and populated using a validation parameter binding table to obtain the component's executable code; Perform a syntax self-check on the component's executable code to obtain the self-checked component code; Summarize the self-test component code to obtain the executable code set.
6. The low-code-visualization-based AI agent rapid development platform construction method of claim 5, wherein, The process of determining the verification parameter binding table based on component nodes and parameter binding tables includes: Perform the following operation on each of the multiple key-value pairs in the parameter binding table: The target port constraints are determined based on component nodes and key values; The key value is validated according to the target port constraint to obtain the required validation result, the type validation result, and the range validation result. Based on the results of mandatory field validation, type validation, and range validation, the mandatory field result value, type result value, and range result value are determined. Calculate the individual verification score based on the required result value, type result value, and range result value; Summarize the individual verification scores to obtain multiple individual verification scores; The overall verification score is calculated based on multiple individual verification scores. Determine whether the overall verification score is equal to the preset single value. If the overall verification score is equal to the single value, then use the parameter binding table as the verification parameter binding table. Otherwise, the validation parameter binding table is determined based on the parameter binding table, required result values, type result values, and range result values.
7. The low-code-visualization-based AI agent rapid development platform construction method of claim 6, wherein, The syntax self-check of the component's executable code, resulting in self-checked component code, includes: Perform a lexical scan on the executable code of the component to obtain a sequence of lexical units; The lexical unit sequence is parsed to obtain the parsing result, which is either parsing successful or parsing unsuccessful. If the syntax parsing result is successful, then the component's executable code will be used as the self-check component code; If the parsing result is that the parsing fails, then the parsing result is used to locate the errors and obtain multiple syntax error locations; For each of the multiple syntax error locations, perform the following operation: The component's executable code is syntax-corrected based on the location of syntax errors to obtain the corrected syntax location. Summarize the corrected syntax locations to obtain multiple corrected syntax locations; The corrected component executable code was identified based on multiple correction syntax locations and component executable code. Perform a syntax backcheck on the executable code of the modified component to obtain the syntax backcheck result, which is either a pass or a fail. If the syntax check result is a pass, the corrected component executable code will be used as the self-check component code; If the syntax check fails, the component's executable code is marked as an exception to obtain the exception component code, which is then used as the self-check component code.
8. The low-code-visualization-based AI agent rapid development platform construction method of claim 7, wherein, The parameter extraction of the running instance yields multiple node states, including: The running instances are collected according to a preset time window to obtain current running data and historical running data. Statistical analysis of historical operational data yields baseline characteristics for multiple historical nodes. These baseline characteristics include: the mean of historical input fields, the variance of historical input fields, the mean of historical output fields, and the variance of historical output fields. The nodes of the currently running data are traversed to obtain multiple node running records; Perform the following operation on each node's execution record across multiple node execution records: Extract status information from node operation records to obtain node identifier, node execution status, node input data, and node output data; Based on node identifiers, feature matching is performed on the baseline features of multiple historical nodes to obtain the baseline features of the target node. Based on the baseline features of the target node, the mean of the target input field, the variance of the target input field, the mean of the target output field, and the variance of the target output field are identified. The node input data and node output data are quantized to obtain the input quantized value and the output quantized value. Calculate the node offset based on the input quantized value, output quantized value, target input field mean, target input field variance, target output field mean, and target output field variance; Determine if the node offset is greater than a preset offset threshold. If the node offset is greater than the offset threshold, mark the node's running record as abnormal to obtain a node abnormal identifier. Use the node anomaly identifier as the node status identifier; If the node offset is not greater than the offset threshold, the node's running record is marked normally to obtain the node's normal identifier; Use the node's normal status identifier as the node's status identifier; The node status is obtained by encapsulating the node identifier, node execution status, node input data, node output data, and node status identifier. Summarize the node states to obtain the states of multiple nodes. 9.The low-code-visualization-based AI agent rapid development platform construction method of claim 8, wherein, The determination of multiple visual debugging feedback identifiers based on the status of multiple nodes includes: For each of the multiple node states, perform the following operation: The node status is parsed to obtain the status category identifier, which is: waiting for execution, executing, execution completed, or execution error. Perform a data field scan on the node status to obtain the number of valid input fields, the number of valid output fields, the total number of input fields, and the total number of output fields. Calculate the node data completeness based on the number of valid input fields, the number of valid output fields, the total number of input fields, and the total number of output fields. State weights are obtained by mapping state weights based on state category identifiers; The node health score is calculated based on the state weight and node data completeness, using the following formula: wherein, denotes a node health score, denotes a state weight, denotes a node data completeness, denotes a preset state weight, denotes a preset data weight, denotes a natural constant; The target feedback level is determined based on the node health score, the preset first-level threshold, and the preset second-level threshold. The feedback rendering style is determined based on the status category identifier and the target feedback level. The feedback rendering style includes: feedback color identifier and feedback prompt text. The node identifier, status category identifier, node health score, and feedback rendering style are encapsulated to obtain a visual debugging feedback identifier; The visual debugging feedback identifiers are summarized to obtain multiple visual debugging feedback identifiers. 10.A low-code visual-based AI agent rapid development platform construction system, characterized in that, The system includes: The basic area generation module is used to determine the set of functional elements, abstract the set of functional elements to obtain the set of functional components, determine the component library and backend mapping relationship set based on the set of functional components, and determine the component panel area, canvas arrangement area and parameter configuration area based on the component library. The compilation unit construction module is used to construct visual orchestration units using the component panel area, canvas orchestration area and parameter configuration area, perform orchestration analysis on the visual orchestration units, obtain multiple component nodes and multiple node connection relationships, determine the executable code set based on multiple component nodes and backend mapping relationship set, and determine the compilation construction unit based on multiple node connection relationships and executable code set. The debugging unit construction module is used to determine the running instance based on the compilation construction unit, extract parameters from the running instance to obtain multiple node states, determine multiple visual debugging feedback identifiers based on the multiple node states, and construct an online debugging unit using the multiple visual debugging feedback identifiers. The development platform building module is used to determine the release configuration set based on the compilation build unit, and to determine the deployment and release unit based on the compilation build unit and the release configuration set. It integrates the visual orchestration unit, compilation build unit, online debugging unit and deployment and release unit to obtain the AI agent rapid development platform, thus completing the construction of the AI agent rapid development platform.
