Agent development system and method based on global variables and arbitrary hook types

Abstract

The application relates to an agent development system and method based on global variables and arbitrary hook types. The method comprises the following steps: analyzing externally input agent development configuration information to construct an initial graph structure of an agent; in the graph construction stage, sequentially traversing nodes and node relationships in the initial graph structure, gradually defining input variables and output variables of components, taking arbitrary input hook types as node input data types to support mutual calling of different types of nodes, and adopting a global variable mechanism to uniformly register and centrally manage the input variables and the output variables of the components; in the running construction stage, constructing execution point by point to complete value reference replacement of an agent development task and extraction of output structure variable values; and after the setting is completed, generating a graph structure corresponding to the agent to realize agent development. The application can improve the intuitiveness and maintainability of agent development, improve the development efficiency, and provide efficient development support for the industry.

Description

Technical Field

[0001] This application relates to the field of computer information processing, and more specifically, to a system and method for developing intelligent agents based on global variables and arbitrary attachment types. Background Technology

[0002] Traditional industries are accelerating their intelligent transformation, leading to a growing demand for automated task scheduling and complex business logic orchestration systems. These systems require a structured process framework to enable multi-module collaboration and data interaction, supporting the intelligent implementation of business scenarios. Currently, intelligent agent development is typically based on the open-source LangFlow system. While this type of system lowers the programming barrier to some extent by enabling data interaction and task orchestration between different components through a graphical interface, it still has the following shortcomings in practical applications:

[0003] Complex flowcharts, especially in task flows involving multiple nodes, often require numerous connections to ensure correct data transfer between nodes, resulting in a cumbersome overall structure. When the number of nodes is large, the flowchart becomes cluttered with connections, making it difficult for users to read and understand during use and maintenance.

[0004] The user threshold is relatively high. The existing LangFlow system is more suitable for technical personnel with certain development experience. For ordinary business users who lack programming background, it is difficult to get started and has a high usage threshold, which limits its promotion in a wider range of application scenarios.

[0005] The existing system has limitations; it lacks the ability to flexibly retrieve data across nodes, and the data retrieval methods between nodes are relatively simple, making it difficult to support the flexible arrangement of complex logic. This is a significant shortcoming when dealing with agent tasks that require multi-node collaboration and dynamic data interaction.

[0006] Therefore, a new intelligent agent development system and method based on global variables and arbitrary attachment types are needed.

[0007] The information disclosed in the background section is only intended to enhance the understanding of the background of this application, and therefore may include information that does not constitute prior art known to those skilled in the art. Summary of the Invention

[0008] In view of this, this application provides an intelligent agent development system and method based on global variables and arbitrary attachment types, which can improve the intuitiveness and maintainability of the intelligent agent development process, significantly improve the development efficiency of intelligent agents, and provide more efficient intelligent agent development support for the industry.

[0009] Other features and advantages of this application will become apparent from the following detailed description, or may be learned in part from practice of this application.

[0010] According to one aspect of this application, a method for developing intelligent agents based on global variables and arbitrary attachment types is proposed. This method includes: parsing externally input intelligent agent development configuration information to construct an initial graph structure for the intelligent agent; in the graph construction phase, sequentially traversing the nodes and node relationships in the initial graph structure, progressively defining the input and output variables of the components, while using arbitrary input attachment types as node input data types to support mutual calls between different types of nodes, and employing a global variable mechanism to uniformly register and centrally manage the input and output variables of the components; in the runtime construction phase, constructing and executing vertex-by-vertex to complete the value reference substitution and extraction of output structure variable values ​​for the intelligent agent development task; and generating the graph structure corresponding to the intelligent agent after the setup is completed to realize intelligent agent development.

[0011] Optionally, parsing externally input agent development configuration information to construct the agent's initial graph structure includes: obtaining an agent development task from a user; parsing the development task to describe it as graph domain-specific language data; and constructing the agent's initial graph structure based on the graph domain-specific language data.

[0012] Optionally, during the graph construction phase, the nodes and node relationships in the initial graph structure are traversed sequentially to gradually define the input and output variables of the components, including: during the graph construction phase, the nodes and node relationships in the initial graph structure are traversed sequentially; and the static architecture definition of the component input variables and output structure variables is completed step by step by identifying the dependencies between nodes and the data flow graph.

[0013] Optionally, any input hook type can be used as the node input data type to support mutual calls between different types of nodes, including: defining nodes with arbitrary input hook types; and specifying the node's input data type as an arbitrary input hook type during node execution to automatically adapt to any output data type of the upstream component.

[0014] Optionally, a global variable mechanism is adopted to uniformly register and centrally manage the input and output variables of the components, including: defining a global variable pool; defining component variables that can only access parent variables through system process components; defining global variable values ​​that can be accessed by all components within the system; and uniformly registering and centrally managing variables in the order of input variable definition, output variable definition, and value reference.

[0015] Optionally, a global variable pool is defined, including: dividing variables into component input variables, system variables, and component output structure variables; constructing the global variable pool through modular design; in the global variable pool, each variable is identified by a unique identifier and includes a variable name, variable type, and variable value.

[0016] Optionally, component variables that can only access parent variables are defined through system process components, including: the component variables being assigned values ​​during the component's runtime phase; and / or the component variables being assigned values ​​via external system transmission; and / or the component variables being assigned values ​​through direct user input; and / or the component variables being assigned values ​​through global variable references.

[0017] Optionally, the system defines global variable values ​​that are accessible to all components, including: assigning values ​​to the system variables externally; and / or assigning values ​​to the system variables using graph domain-specific language data; and / or assigning values ​​to the system variables during internal runtime.

[0018] Optionally, variables are uniformly registered and centrally managed in the order of input variable definition, output variable definition, and value reference. This includes: during the input variable definition process, the information for each input variable includes: variable name, variable type, input method, and variable description; during the output variable definition process, the information for each output variable includes: variable name, variable type, and variable description; when the output variable is data, only the required key-value pairs are defined through interface interaction and registered as structure variables; and the values ​​of the input and output variables are referenced through user input and / or global variable references.

[0019] Optionally, during the runtime build phase, vertex-by-vertex construction is performed to complete the value reference substitution and extraction of output structure variable values ​​for the agent development task. This includes: during the runtime build phase, constructing the execution context vertex by vertex through the node construction method; sequentially calling the compilation method of each vertex to trigger component instantiation, attribute setting, and result construction, thereby completing the value reference substitution and extraction of output structure variable values.

[0020] According to one aspect of this application, a smart agent development system based on global variables and arbitrary attachment types is proposed. This system includes: a configuration parsing module for parsing externally input smart agent development configuration information to construct an initial graph structure for the smart agent; a graph construction module for sequentially traversing the nodes and node relationships in the initial graph structure during the graph construction phase, progressively defining the input and output variables of the components, while using arbitrary input attachment types as node input data types to support mutual calls between different types of nodes, and employing a global variable mechanism to uniformly register and centrally manage the input and output variables of the components; a runtime construction module for constructing and executing vertex-by-vertex to complete the value reference substitution and extraction of output structure variable values ​​for the smart agent development task during the runtime construction phase; and a smart agent generation module for generating the graph structure corresponding to the smart agent after setup to realize smart agent development.

[0021] Optionally, the configuration parsing module is further configured to obtain an agent development task from the user; parse the development task to describe it as graph domain-specific language data; and construct the initial graph structure of the agent based on the graph domain-specific language data.

[0022] Optionally, the graph construction module includes: a traversal unit, used to sequentially traverse the nodes and node relationships in the initial graph structure during the graph construction phase; and a static architecture unit, used to gradually complete the static architecture definition of component input variables and output structure variables by identifying the dependencies between nodes and the data flow graph.

[0023] Optionally, the graphing module further includes: a hook type unit for defining nodes with arbitrary input hook types; and a node specification unit for specifying the input data type of a node as an arbitrary input hook type during node execution to automatically adapt to any output data type of the upstream component.

[0024] Optionally, the graphing module further includes: a variable pool unit for defining a global variable pool; a component variable unit for defining component variables that can only access parent variables through process components; a global variable unit for defining global variable values ​​that can be accessed by all components within the process system; and a variable management unit for uniformly registering and centrally managing variables in the order of input variable definition, output variable definition, and value reference.

[0025] Optionally, the variable pool unit is further used to divide variables into component input variables, system variables, and component output structure variables; to construct a global variable pool through modular design; in the global variable pool, each variable is identified by a unique identifier and includes a variable name, variable type, and variable value.

[0026] Optionally, the component variable unit is further used to assign values ​​to the component variables during the component runtime phase; and / or to assign values ​​to the component variables via external system transmission; and / or to assign values ​​to the component variables through direct user input; and / or to assign values ​​to the component variables through global variable references.

[0027] Optionally, the global variable unit is further used for assigning values ​​to the system variables externally; and / or assigning values ​​to the system variables through graph domain-specific language data; and / or assigning values ​​to the system variables internally during runtime.

[0028] Optionally, the variable management unit is further configured to, during the process of defining input variables, include the following information for each input variable: variable name, variable type, input method, and variable description; during the process of defining output variables, include the following information for each output variable: variable name, variable type, and variable description; when the output variable is data, define only the required key values ​​through interface interaction and register them as structure variables; and reference the values ​​of the input variables and the output variables through user input and / or global variable references.

[0029] Optionally, the running build module is also used to build the execution context for each vertex through the node build method during the running build phase; and to call the compilation method of each vertex in sequence to trigger component instantiation, property setting and result construction, thereby completing value reference substitution and extraction of output structure variable values.

[0030] According to one aspect of this application, an electronic device is provided, comprising: one or more processors; a storage device for storing one or more programs; and, when the one or more programs are executed by the one or more processors, causing the one or more processors to implement the method as described above.

[0031] According to one aspect of this application, a computer-readable medium is provided having a computer program stored thereon that, when executed by a processor, implements the method described above.

[0032] According to one aspect of this application, a computer program product is provided, comprising: a computer program / instructions that, when executed by a processor, implement the method as described above.

[0033] According to the intelligent agent development system and method based on global variables and arbitrary attachment types of this application, the initial graph structure of the intelligent agent is constructed by parsing the intelligent agent development configuration information input from the outside. In the graph construction stage, the nodes and node relationships in the initial graph structure are traversed sequentially, and the input variables and output variables of the components are defined step by step. At the same time, arbitrary input attachment types are used as node input data types to support mutual calls between different types of nodes, and a global variable mechanism is used to uniformly register and centrally manage the input variables and output variables of the components. In the runtime construction stage, the system is constructed and executed vertex by vertex to complete the value reference substitution and extraction of output structure variable values ​​for the intelligent agent development task. After the settings are completed, the graph structure corresponding to the intelligent agent is generated to realize the intelligent agent development method. This can improve the intuitiveness and maintainability of the intelligent agent development process, significantly improve the development efficiency of intelligent agents, and provide more efficient intelligent agent development support for the industry.

[0034] It should be understood that the above general description and the following detailed description are merely exemplary and do not limit this application. Attached Figure Description

[0035] The above and other objects, features, and advantages of this application will become more apparent from the detailed description of exemplary embodiments with reference to the accompanying drawings. The drawings described below are merely some embodiments of this application, and those skilled in the art can obtain other drawings based on these drawings without any inventive effort.

[0036] Figure 1 This is a flowchart illustrating an intelligent agent development method based on global variables and arbitrary attachment types, according to an exemplary embodiment.

[0037] Figure 2 This is a schematic diagram illustrating an intelligent agent development method based on global variables and arbitrary attachment types, according to an exemplary embodiment.

[0038] Figure 3 This is a schematic diagram illustrating an intelligent agent development method based on global variables and arbitrary attachment types, according to an exemplary embodiment.

[0039] Figure 4 This is a schematic diagram illustrating an intelligent agent development method based on global variables and arbitrary attachment types, according to an exemplary embodiment.

[0040] Figure 5 This is a schematic diagram illustrating an intelligent agent development method based on global variables and arbitrary attachment types, according to an exemplary embodiment.

[0041] Figure 6 This is a block diagram illustrating an intelligent agent development system based on global variables and arbitrary attachment types, according to an exemplary embodiment.

[0042] Figure 7 This is a block diagram illustrating an electronic device according to an exemplary embodiment. Detailed Implementation

[0043] Exemplary embodiments will now be described more fully with reference to the accompanying drawings. However, these exemplary embodiments can be implemented in many forms and should not be construed as limited to the embodiments set forth herein; rather, they are provided so that this application will be thorough and complete, and will fully convey the concept of the exemplary embodiments to those skilled in the art. The same reference numerals in the drawings denote the same or similar parts, and therefore repeated descriptions of them will be omitted.

[0044] The technical abbreviations used in this application are explained as follows:

[0045] LangFlow is an open-source agent development system that supports the visual construction and orchestration of agent tasks through a graphical interface. Developers can quickly build and deploy task logic on this platform by dragging and dropping components and configuring parameters.

[0046] Request: refers to a complete task interaction process, from the system receiving user input or external call to the system returning the processing result, which constitutes a complete request lifecycle.

[0047] Global variables are variables that can be accessed globally within the lifecycle of a single request. They are shared across multiple components of the same task and can be read or updated during task construction and execution, enabling data transfer and reuse across nodes.

[0048] Value-Ref: This refers to the mechanism of referencing registered global variables in user interface (UI) input fields. Through value-refs, users or components can directly access variable values ​​stored in the global variable pool, thereby avoiding duplicate input and ensuring parameter consistency.

[0049] The `anypool` type is a pointer to an arbitrary type of connection mechanism designed for Vertex inputs. This type allows node inputs to receive arbitrary data types from parent node outputs, enabling flexible connection and access of different data types between nodes, thereby simplifying data compatibility and type conversion operations between nodes.

[0050] In view of the technical deficiencies in existing technologies, this application proposes a method and system for developing intelligent agents based on global variables and arbitrary attachment types. This application is applicable to all intelligent agent development scenarios, such as system construction and deployment in the intelligent transformation process of traditional industries like finance, and can also be applied to the intelligent development needs of various ToB scenarios. This application uses directed acyclic graph (DAG) orchestration as its core, and through flexible connections of data, computing power, and applications, it achieves visualized configuration and automated execution of intelligent agent tasks. Compared with existing intelligent agent development methods, this application can significantly improve the development efficiency and maintainability of intelligent agents, providing industry users with more efficient intelligent agent development support.

[0051] This application addresses the numerous shortcomings of existing intelligent agent development platforms (such as the open-source LangFlow system) in practical applications, providing solutions to these shortcomings:

[0052] In existing technologies, data dependencies between nodes can only be achieved through connections. As the number of nodes increases, the number of connections grows exponentially, leading to an overly complex graph structure. This application introduces a global variable mechanism to uniformly register and centrally manage component input and output variables within the lifecycle of a single request. This allows different nodes to directly reference global variables without establishing redundant connections, thereby simplifying the graph structure and improving the intuitiveness and maintainability of the agent development process.

[0053] In existing platforms, node connections must ensure data consistency; otherwise, additional data conversion nodes are required, leading to an increase in the number of nodes and increased process complexity. This application introduces the anypool input type, allowing node inputs to support any type of connection. It can automatically adapt to different data types output by parent nodes, achieving unified storage and flexible retrieval of multiple data types. This avoids adding redundant nodes due to type incompatibility, thereby significantly improving the flexibility and execution efficiency of process orchestration.

[0054] The technical content and implementation of this application will be described in detail below with the help of specific embodiments.

[0055] Figure 1 This is a flowchart illustrating an agent development method based on global variables and arbitrary attachment types according to an exemplary embodiment. The agent development method 10 based on global variables and arbitrary attachment types includes at least steps S102 to S108.

[0056] like Figure 1As shown, in S102, externally input agent development configuration information is parsed to construct the agent's initial graph structure. For example, an agent development task from a user can be obtained; the development task can be parsed to describe it as graph domain-specific language data (e.g., graph DSL data); and the initial graph structure of the agent can be constructed based on the graph domain-specific language data.

[0057] Specifically, the system can acquire intelligent agent development tasks from users, including information such as the functional requirements, data input requirements, and logical dependencies of the intelligent agent; parse the development tasks, converting natural language descriptions or structured instructions into Graph DSL (Domain Specific Language) data; and automatically generate an initial graph structure corresponding to the task based on the Graph DSL data, providing a foundation for subsequent node traversal and variable registration.

[0058] In S104, during the graph construction phase, the nodes and node relationships in the initial graph structure are traversed sequentially, and the input and output variables of the components are defined step by step. At the same time, any input attachment type is used as the node input data type to support mutual calls between different types of nodes, and a global variable mechanism is used to uniformly register and centrally manage the input and output variables of the components.

[0059] Upon entering the graph construction phase, the system sequentially traverses the nodes and their relationships within the initial graph structure, progressively identifying dependency paths between nodes and defining the input and output variables of components. During this process, the system designates any input attachment type (anypool type) as the input data type for nodes, supporting unified storage and dynamic retrieval of different data types across nodes. This enables automatic adaptation of upstream node output data and free connection between nodes of different types. Simultaneously, the system employs a global variable mechanism for unified registration and centralized management of the component's input and output variables, ensuring consistent access and reuse of variables throughout the entire graph structure's lifecycle, avoiding redundant connections that complicate the graph structure.

[0060] In this application, the variable mechanism is implemented through component variables and system variables. Component variables are variables defined by the component itself and are used to store inputs, outputs, or intermediate processing results during component execution. Component variables can only be accessed by parent components and are prohibited from direct access by sibling components, thereby ensuring the security of variable scope and hierarchical isolation. Component variables can originate from system flow components (e.g., LangFlow-Component).

[0061] More specifically, it can be defined in the following ways: Ordinary variable definition: Input or output variables that are directly defined during component development; Structure variable definition (e.g., Schema variable): Attributes defined for specific output types, such as structured key-value pairs of output data.

[0062] Component variables are assigned values ​​during the component's runtime phase. Specifically, this can include: assignment by external systems, such as real-time data from external data sources or interfaces; assignment by direct input from the developer user, such as configuring input values ​​through the user interface; and assignment through global variable references, retrieving and binding values ​​from the global variable pool.

[0063] System variables are internal variables carried by the intelligent agent system itself, used for sharing system-level data or global state across components. System variables are visible to all components throughout the system's lifecycle, are not limited by component hierarchy, and can be directly accessed at any node. System variables are defined and maintained internally by the LangFlow system and can be generated through the following means: assignment by external configuration or interface calls; automatic generation and assignment during graph DSL data parsing; and dynamic calculation or generation during system execution.

[0064] In summary, component variables are explicitly defined by the user or the component, have a limited scope, and are only visible within the parent-child node chain. They are suitable for data transfer and storage within a node or locally. System variables are automatically generated and globally maintained by the system, are globally visible, and are not scope-restricted. They are suitable for data sharing and system state management across nodes and modules.

[0065] The specific prototyping method is as follows:

[0066] [Component] Define variables: apply to the "Start" component and the "Python Executor" component;

[0067] [Component] Define schema: Define the schema for Data output types;

[0068] [Component] Value Reference: Using variables;

[0069] [Component] Anypool type;

[0070] In one embodiment, during the graph construction phase, the nodes and node relationships in the initial graph structure are traversed sequentially; the static architecture definition of component input variables and output schema variables is completed step by step by identifying the dependencies between nodes and the data flow graph. The static architecture definition of component input variables and output schema variables is completed by identifying the dependencies between nodes and the data flow direction; a unique identifier is assigned to each node and its dependency path is recorded for subsequent runtime parameter parsing and variable substitution.

[0071] This application proposes a complete variable management design process to ensure that the input and output data of the intelligent agent development system are standardized and traceable during task orchestration and execution.

[0072] The process includes three main stages: input variable definition, output variable definition, and value referencing.

[0073] In the intelligent agent development system of this application, the input variables of each system node need to be standardized to ensure that complete and accurate parameter information can be obtained during the node execution process, thereby improving the reliability and scalability of the system.

[0074] During the input variable definition phase, the system provides a visual interactive interface for developers or business users to directly define input variables during the node configuration phase. Users can create variables, set attributes, and specify input methods in the interface. After submission, the system automatically performs validity checks and persistent storage.

[0075] Typical definition formats are shown in Table 1. Each input variable must contain at least the following attributes:

[0076] Variable name: Used to uniquely identify the variable and ensure that there are no name conflicts within the same graph structure;

[0077] Variable type: Limited to atomic types, including integers (int), strings (str), floating-point numbers (float), and booleans (bool), to ensure type consistency during subsequent data processing and cross-node transmission;

[0078] Required: Indicates whether this variable must provide a value during node execution, used for input parameter validation during runtime;

[0079] Input methods include direct user input or referencing output values ​​from other nodes (alias references) to support data reuse across nodes;

[0080] Variable description: Used to explain the purpose, value range or business logic of the variable, so as to facilitate subsequent maintenance and secondary development.

[0081] The following table shows examples of input variable definitions:

[0082]

[0083] This design ensures that all nodes can obtain complete, accurate, and type-safe input parameters during the process of system construction and operation, thereby effectively improving the reliability, scalability, and ease of later maintenance of the agent task.

[0084] In the intelligent agent development system of this application, output variables refer to the variables generated by the component during operation that can be directly called and used by downstream nodes to realize cross-node data transmission and task connection.

[0085] When the output type of a component is data, such as Data (a key-value data structure similar to Map), downstream nodes typically do not need to process the complete Data structure, but only need to use some of its key-value items.

[0086] To avoid redundant data transmission and subsequent complex parsing, the system provides a visual interactive method that allows users to define only the key values ​​they actually need during the configuration phase and register them as structure variables (such as schema variables).

[0087] In this way, downstream nodes can directly reference the defined key without processing the complete data dataset, thereby reducing data parsing overhead and improving system efficiency.

[0088] It should be noted that users do not need to define all key-value items in the Data structure, but only need to select and register the keys that need to be called in the actual business, thereby reducing redundant definitions and optimizing the storage and execution performance of the system.

[0089] Each output variable must include the following information during registration to ensure variable identifiability and consistency of cross-node references:

[0090] Variable name: Used to uniquely identify the output variable, ensuring that downstream nodes can reference it accurately;

[0091] Variable type: Specifies the data type of the variable, such as integer (int), string (str), boolean (bool), or complex structure type, so that the system can perform type validation during data transmission;

[0092] Variable description: This describes the specific meaning, value range, and business purpose of the variable, facilitating subsequent maintenance and expansion.

[0093] By standardizing the output variables as described above, this application achieves refined management of cross-node output data. This design not only reduces the parsing burden on downstream nodes but also avoids the redundant overhead of transmitting the complete data structure, thereby improving system operating efficiency and task execution stability.

[0094] In this application, the use of variables falls into two categories:

[0095] User-input manual input refers to the user directly entering specific numerical values ​​or content for variables. This method allows users to flexibly specify the parameter values ​​required for nodes according to actual needs, thus ensuring the system's operational freedom and flexibility in different usage scenarios.

[0096] Global variable referencing: This refers to obtaining the value of a variable by referencing a variable defined in the parent node or the system's global scope, enabling the transfer and reuse of variables between different nodes. This method ensures the consistency of parameters and the reusability of data between nodes, while avoiding duplicate definitions and manual input errors.

[0097] The combination of these two mechanisms ensures both the flexibility of variable assignment (achieved through manual user input) and the consistency and reusability of data across system nodes (achieved through global variable references), thereby improving the system's scalability and operational efficiency.

[0098] In one embodiment, nodes with arbitrary input attachment types are defined. During node execution, the node's input data type is specified as an arbitrary input attachment type to automatically adapt to any output data type of the upstream component. When building a node, an arbitrary input attachment type is specified for the node's input port. During node operation, the input data is automatically adapted and encapsulated according to the actual output data type of the upstream component to achieve dynamic parsing and calling of multiple data types.

[0099] The type design example of anypool is as follows: Figure 2 As shown, the introduction of the anypool node input type in this application, combined with the global variable mechanism, significantly improves the flexibility of agent orchestration, reduces graph complexity, and enhances the scalability and ease of use of the system.

[0100] In one embodiment, a global variable pool is defined; component variables that can only access parent variables are defined through LangFlow-Component; global variable values ​​that can be accessed by all components are defined internally within the LangFlow system; and variables are uniformly registered and centrally managed in the order of input variable definition, output variable definition, and value reference. The global variable pool is constructed according to a modular design, and variables are divided into three categories: component input variables, system variables, and component output schema variables. Each variable is identified by a unique ID, and attributes such as variable name, variable type, and variable value are recorded to ensure the traceability and type security of variables during process execution.

[0101] More specifically, a global variable pool is defined, including: dividing variables into component input variables, system variables, and component output schema variables; constructing the global variable pool through modular design; in the global variable pool, each variable is identified by a unique ID and includes the variable name, variable type, and variable value.

[0102] More specifically, component variables defined by LangFlow-Component that can only access parent variables also include: component variables being assigned values ​​during component runtime; and / or component variables being assigned values ​​via external system propagation; and / or component variables being assigned values ​​through direct user input; and / or component variables being assigned values ​​through global variable references. Component variables, defined by LangFlow-Component, are only accessible to their parent component and its sub-components, and can be assigned values ​​during component runtime via external system propagation, direct user input, or through global variable references.

[0103] More specifically, the system defines global variable values ​​that are accessible to all components within the LangFlow system, including: assigning values ​​to the system variables externally; and / or assigning values ​​to the system variables through graph DSL data; and / or assigning values ​​to the system variables during internal runtime.

[0104] More specifically, variables are uniformly registered and centrally managed through the sequence of input variable definition, output variable definition, and value reference. This includes: during the input variable definition process, the information for each input variable includes: variable name, variable type, input method, and variable description; during the output variable definition process, the information for each output variable includes: variable name, variable type, and variable description; when the output variable is "Data", only the required key is defined through interface interaction and registered as a schema variable; and the values ​​of the input and output variables are referenced through user input and / or global variable references.

[0105] In S106, during the runtime build phase, execution is performed vertex-by-vertex to complete value reference substitution and extract output schema variable values ​​for the agent development task. For example, during the runtime build phase, the `build_vertex` method builds the execution context vertex-by-vertex; the `build` method of each vertex is called sequentially to trigger component instantiation, attribute setting, and result construction, thereby completing value reference substitution and extracting output schema variable values. This runtime mechanism ensures correct data transfer and real-time updates between different nodes, thus improving the executability and scalability of the process.

[0106] In step S108, after the setup is complete, a graph structure corresponding to the agent is generated to realize agent development. This final graph structure contains all the components, variable definitions, and dependencies required for the agent task, and can be directly used for subsequent agent deployment and execution, thereby completing the agent development task.

[0107] According to the agent development method based on global variables and arbitrary attachment types in this application, the initial graph structure of the agent is constructed by parsing the externally input agent development configuration information. During the graph construction phase, the nodes and node relationships in the initial graph structure are traversed sequentially, and the input and output variables of the components are defined step by step. Simultaneously, arbitrary input attachment types are used as node input data types to support mutual calls between different types of nodes. A global variable mechanism is used to uniformly register and centrally manage the input and output variables of the components. During the runtime construction phase, vertex-by-vertex construction and execution are performed to complete the value reference substitution and extraction of output schema variable values ​​for the agent development task. After the settings are completed, the graph structure corresponding to the agent is generated to realize the agent development method. This approach improves the intuitiveness and maintainability of the agent development process, significantly enhances the development efficiency of agents, and provides more efficient agent development support for the industry.

[0108] It should be clearly understood that this application describes how specific examples are formed and used, but the principles of this application are not limited to any details of these examples. Rather, based on the teachings of the disclosure of this application, these principles can be applied to many other embodiments.

[0109] The variable management scheme in this application follows a hierarchical scoping mechanism. The core idea is that where a variable is defined determines who can subsequently access it, and access between different levels is strictly restricted. This design ensures the security and controllability of data flow in the intelligent agent development system, while reducing the complexity caused by redundant data interactions.

[0110] Figure 3 This is a schematic diagram illustrating an intelligent agent development method based on global variables and arbitrary attachment types, according to an exemplary embodiment. Figure 3 The preceding text exemplifies the design of the frontend process in this application. For example... Figure 3 As shown, the variable management process can be abstracted into a complete process from Begin to End, which goes through the following stages in sequence: variable definition stage (also known as alias registration) and variable reference stage (also known as alias reference).

[0111] As shown in the figure, the flowchart starts with Begin, goes through two key steps, "variable definition" and "variable reference", and finally reaches End, completing the registration of variables, scope confirmation and management of cross-node access.

[0112] The variable definition phase mainly includes the following processes:

[0113] Input variable definition: Before the component executes, the system identifies and registers input variables. Developers can set the variable name, type, required attributes, and source in the interface.

[0114] Component execution: After receiving input variables, the component performs logical processing and generates output results.

[0115] Output Schema Variable Definition: When the component output contains variables that conform to the schema structure, the system automatically identifies and registers these output Schema variables for subsequent nodes to call.

[0116] The core function of this stage is to form a clear variable pool through a unified registration mechanism, ensuring that variables can be quickly and accurately obtained in subsequent referencing stages.

[0117] The variable reference phase employs strict hierarchical access rules, as follows:

[0118] Allowed access: Each node can access variables defined in its parent node.

[0119] Forbidden access: Nodes at the same level (sibling nodes) are prohibited from accessing each other's defined variables to avoid data coupling and uncontrollable dependencies.

[0120] Hierarchical example:

[0121] Component variable 1: It contains component variables 2.1, 2.2, and 2.3. Component variables 2.1, 2.2, and 2.3 can all access component variable 1.

[0122] Component variables 3.2 and 3.3: 3.2 can access its parent component variable 1, but 3.2 and 3.3 cannot access each other.

[0123] Component variable 4.2: It can access the parent component variable 1, but cannot access the node variables at the same level as itself.

[0124] exist Figure 3 In the diagram, allowed access paths are indicated by black arrows, while prohibited access paths are indicated by red dashed lines with crosses, to visually distinguish the accessible areas.

[0125] In summary, during the variable definition phase, variables are registered in components using the input / output DSL, forming a variable pool and determining its scope. During the variable referencing phase, child nodes can reference variables of their parent nodes, but direct access to variables between sibling nodes is prohibited.

[0126] This hierarchical variable scoping mechanism is similar to the scope rules in programming languages, ensuring data availability while achieving controllability of data access and stability of the system structure.

[0127] The core of this application lies in achieving dynamic orchestration and efficient execution of complex processes through modularization and visualization. This method revolves around the collaborative interaction of three core objects: Graph, Vertex, and Component, completing the entire process from workflow definition and parameter management to final runtime construction. It is applicable to various scenarios requiring automated process execution, such as complex business logic processing, data processing pipelines, and the rapid development and deployment of artificial intelligence (AI) workflows.

[0128] The innovation of this application system lies in its dynamic variable management mechanism and hierarchical construction architecture:

[0129] The Graph object acts as the global manager, responsible for global control of the workflow and unified parameter management. It provides functions for registering system-level parameters (register_sys_g_param, register_g_param), assigning values ​​(assign_g_param), and querying (list_g_params) parameters, ensuring the visibility and consistency of parameters throughout the entire workflow lifecycle.

[0130] A Vertex object represents an execution node, responsible for receiving parameters and completing the specific construction logic. During runtime, the `build` method is called to instantiate components and execute tasks node by node.

[0131] The Component object, as an encapsulation of a functional unit, undertakes specific business logic processing. It supports dynamically resolving and retrieving parameters by reference name (ref_name) (get_g_param_value_by_ref_name), thereby achieving loose coupling between business logic and parameter input, and ensuring the independence and reusability of components.

[0132] Figure 4 This is a schematic diagram illustrating an intelligent agent development method based on global variables and arbitrary attachment types, according to an exemplary embodiment, such as... Figure 4 As shown, the entire workflow construction and execution can be divided into the following three main stages:

[0133] Step 1: Graph Structure Initialization

[0134] The system parses the externally input Domain Specific Language (DSL) data using the `from_payload` method to initialize the graph structure. During this phase, the system registers all system variables, providing a foundation for subsequent variable referencing and execution.

[0135] Step 2: Graph Completion

[0136] The system iterates through the edges and self_steps of the nodes in the graph to identify the dependencies and data flow between nodes.

[0137] During the traversal, the system gradually completes the static architecture definition of component input variables and output schema variables, and registers the variables to the global variable pool to achieve unified management of input and output.

[0138] Step 3: Run the build phase (Graph-Run)

[0139] The system constructs the execution context for each vertex using the build_vertex method and calls the build method of each vertex in turn in a loop.

[0140] This phase will trigger Component instantiation, attribute setting (set_attributes), and result building (build_results) operations in sequence, thereby achieving: passing and dynamic injection of global variables; value reference substitution; extraction and registration of output schema variable values.

[0141] Throughout the process, the Graph object provides global variable management and execution scheduling, the Vertex is responsible for node-by-node construction and execution, and the Component implements specific functional processing. The three work together to ensure the reusability and efficient execution of the workflow.

[0142] Through the above mechanism, this application achieves the following technical effects:

[0143] Visual orchestration: Users can visually design and configure complex workflows through a graphical interface, reducing the development threshold;

[0144] Dynamic parameter binding and reuse: The global variable mechanism supports unified registration, passing, and referencing of parameters, reducing redundant configuration;

[0145] Automated execution: Workflows can be automatically built and run after the graph structure is defined, greatly improving execution efficiency;

[0146] Flexible scalability: The modular design enables the system to adapt to various business needs and supports dynamic adjustment of node logic or variable definitions.

[0147] This application also introduces a global variable pool, which serves as the core data management module of the system. This pool provides a unified, dynamic, and type-safe variable storage and access mechanism for the construction and execution of workflows, ensuring efficient and traceable data management in complex processes involving multiple nodes and tasks.

[0148] The global variable pool is based on a modular design principle, dividing variables into the following three categories to achieve fine-grained management of variables from different sources and for different purposes:

[0149] Component variables (component input variables): Registered by the component input end, used to store parameter data required by each node before execution.

[0150] Sys variables (system variables): These are automatically generated by the system during workflow execution and are used to store system-level parameters such as global configuration and running status.

[0151] Schema variables (component output schema variables): Registered by the component output end, used to describe the structured key-value information (such as Message or Data type) in the component output results.

[0152] This hierarchical management approach ensures the security and efficiency of variable access across different logical levels, while providing a clear classification basis for variable retrieval and dynamic binding.

[0153] Each variable is identified by a unique ID value, and different generation strategies are used in conjunction with the variable type to strengthen the connection between the identifier and the data semantics:

[0154] System variables (sys): These are identified by a specific "SYS" prefix, used to quickly distinguish system-level parameters;

[0155] Component input variables: These variables are associated with the vertex ID (vertex_id) they belong to, to reflect their atomicity and relationship with their respective nodes;

[0156] Component outputs a structure variable (schema): This identifier records information about a specific data type (such as "Message" or "Data"), ensuring type consistency and structured access in complex data streams.

[0157] Through this type-driven identifier generation mechanism, the system can achieve efficient variable retrieval and secure access in a large-scale variable pool.

[0158] Figure 5This is a schematic diagram illustrating an intelligent agent development method based on global variables and arbitrary attachment types, according to an exemplary embodiment, such as... Figure 5 As shown, each variable entry in the global variable pool contains complete ternary information:

[0159] Variable name (var_name): Used to uniquely identify the variable;

[0160] Variable type (var_type): Indicates the type attribute and data range of the variable;

[0161] Variable value (var_value): Stores the current value of the variable or the result of the operation.

[0162] During system initialization, such as when loading externally input graph DSL data via the `from_payload` method, variable values ​​can be assigned default values, providing an initial data environment for workflow startup and early execution. During runtime, variable values ​​can be dynamically updated based on task execution results, external input, or global variable references, thereby enabling cross-node data transfer and parameter reuse.

[0163] The global variable pool introduced in this application deeply binds variable types with identification strategies, achieving a strong correlation between variable semantics and data management, thereby improving variable retrieval efficiency and access security. The entire process of variable registration, assignment, and invocation is managed by the system, ensuring data consistency and reliability during workflow execution.

[0164] Through the above design, this application not only simplifies parameter passing and component calling in complex processes, but also improves the dynamic injection capability and maintainability of variables, providing strong technical support for automated workflows in a visual programming environment.

[0165] In summary, this application effectively solves the problems of complex graph construction, limited cross-node data transmission, and high user threshold in existing technologies by introducing a global variable mechanism and the anypool type into the intelligent agent development platform, and has the following beneficial effects:

[0166] Reduced diagram complexity: Through the global variable mechanism, developers can achieve data sharing and access without establishing a large number of connections between different nodes, thereby reducing the generation of redundant connections, making the overall flowchart clearer and simpler, and significantly improving the readability and maintainability of the workflow.

[0167] Enhance cross-node data reuse capability: After introducing the anypool type, the system can flexibly manage and call different types of data resources, support free access to cross-node variables, break through the limitation of "data must be transmitted through connections" in the traditional LangFlow system, and significantly enhance the flexibility and scalability of agent task orchestration.

[0168] Lowering the barrier to entry for users: Leveraging the global variable mechanism and the `anypool` type, users can quickly configure and debug agents without requiring complex programming skills or data flow management experience. This not only improves the development efficiency of professional developers but also allows business personnel lacking programming backgrounds to easily get started, expanding the platform's user base.

[0169] Improved system performance and scalability: By reducing unnecessary node connections and redundant data transmissions, the message processing pressure on the server side is effectively alleviated, improving the overall system throughput and operating efficiency. Meanwhile, the design of global variables and the `anypool` type provides strong technical support for subsequent functional integration and horizontal scaling of the platform, ensuring the stability and maintainability of the system in large-scale application scenarios.

[0170] In summary, by introducing a global variable mechanism and the anypool type, this application not only simplifies the development process of intelligent agents and lowers the barrier to entry for users, but also effectively improves the platform's overall performance in terms of performance, flexibility, and scalability, demonstrating outstanding technological advancement and practical application value.

[0171]

[0172] Those skilled in the art will understand that all or part of the steps of the above embodiments are implemented as a computer program executed by a CPU. When the computer program is executed by the CPU, it performs the functions defined by the method provided in this application. The program can be stored in a computer-readable storage medium, such as a read-only memory, a magnetic disk, or an optical disk.

[0173] Furthermore, it should be noted that the above figures are merely illustrative representations of the processes included in the method according to exemplary embodiments of this application, and are not intended to be limiting. It is readily understood that the processes shown in the above figures do not indicate or limit the temporal order of these processes. Additionally, it is readily understood that these processes may be executed synchronously or asynchronously, for example, in multiple modules.

[0174] The following are embodiments of the apparatus described in this application, which can be used to execute the embodiments of the method described in this application. For details not disclosed in the apparatus embodiments of this application, please refer to the embodiments of the method described in this application.

[0175] Figure 6 This is a block diagram illustrating an intelligent agent development system based on global variables and arbitrary attachment types, according to an exemplary embodiment. For example... Figure 6 As shown, the intelligent agent development system 60 based on global variables and arbitrary attachment types includes: a configuration parsing module 602, a graphing module 604, a runtime building module 606, and an intelligent agent generation module 608.

[0176] The configuration parsing module 602 is used to parse externally input agent development configuration information to construct the initial graph structure of the agent; the configuration parsing module 602 is used to obtain agent development tasks from users; parse the development tasks to describe the development tasks as graph domain-specific language data; and construct the initial graph structure of the agent based on the graph domain-specific language data.

[0177] The graph construction module 604 is used to sequentially traverse the nodes and node relationships in the initial graph structure during the graph construction phase, gradually define the input variables and output variables of the components, and at the same time, use any input attachment type as the node input data type to support mutual calling between different types of nodes, and adopt a global variable mechanism to uniformly register and centrally manage the input variables and output variables of the components.

[0178] The graph construction module 604 includes a traversal unit, used to sequentially traverse the nodes and node relationships in the initial graph structure during the graph construction phase.

[0179] Static architecture units are used to progressively define the static architecture of component input variables and output structure variables by identifying dependencies between nodes and data flow graphs.

[0180] The attachment type unit is used to define nodes with arbitrary input attachment types;

[0181] The node specification unit is used to specify the node's input data type as an arbitrary input hook type during node execution to automatically adapt to any output data type of the upstream component.

[0182] The variable pool unit is used to define the global variable pool; the variable pool unit is also used to divide variables into component input variables, system variables, and component output structure variables; the global variable pool is constructed through modular design; in the global variable pool, each variable is identified by a unique identifier and includes variable name, variable type, and variable value.

[0183] The component variable unit is used to define component variables that can only access parent variables through process components; the component variable unit is also used to assign values ​​to the component variables during the component's runtime phase; and / or to assign values ​​to the component variables via external system transmission; and / or to assign values ​​to the component variables through direct user input; and / or to assign values ​​to the component variables through global variable references.

[0184] A global variable unit is used to define global variable values ​​that are accessible to all components within the process system; the global variable unit is also used for assigning values ​​to system variables externally; and / or assigning values ​​to system variables using graph domain-specific language data; and / or assigning values ​​to system variables during internal runtime.

[0185] The variable management unit is used for unified registration and centralized management of variables in the order of input variable definition, output variable definition, and value reference. During the input variable definition process, each input variable includes information such as variable name, variable type, input method, and variable description; during the output variable definition process, each output variable includes information such as variable name, variable type, and variable description; when the output variable is data, only the required key-value pairs are defined through user interface interaction and registered as structure variables; and the values ​​of the input and output variables are referenced through user input and / or global variable references.

[0186] The runtime construction module 606 is used to construct and execute vertex-by-vertex during the runtime construction phase to complete the value reference substitution and extraction of output structure variable values ​​for the agent development task; the runtime construction module 606 is also used to construct and execute the execution context vertex-by-vertex through the node construction method during the runtime construction phase; and sequentially call the compilation method of each vertex to trigger component instantiation, attribute setting and result construction, thereby completing the value reference substitution and extraction of output structure variable values.

[0187] The agent generation module 608 is used to generate the graph structure corresponding to the agent after the settings are completed, so as to realize agent development.

[0188] According to the intelligent agent development system based on global variables and arbitrary attachment types of this application, the initial graph structure of the intelligent agent is constructed by parsing the intelligent agent development configuration information input from the outside. In the graph construction phase, the nodes and node relationships in the initial graph structure are traversed sequentially, and the input variables and output variables of the components are defined step by step. At the same time, arbitrary input attachment types are used as node input data types to support mutual calls between different types of nodes, and a global variable mechanism is used to uniformly register and centrally manage the input variables and output variables of the components. In the runtime construction phase, the system is constructed and executed vertex by vertex to complete the value reference substitution and extraction of output structure variable values ​​for the intelligent agent development task. After the settings are completed, the graph structure corresponding to the intelligent agent is generated to realize the intelligent agent development method. This method can improve the intuitiveness and maintainability of the intelligent agent development process, significantly improve the development efficiency of intelligent agents, and provide more efficient intelligent agent development support for the industry.

[0189] like Figure 7 As shown, this application provides an electronic device including a processor 710, a communication interface 720, a memory 730, and a bus 740, wherein the processor 710 and the memory 730 communicate with each other through the bus 740.

[0190] Memory 730 is used to store computer programs;

[0191] When the processor 710 executes the program stored in the memory 730, it implements the agent development method based on global variables and arbitrary attachment types of any of the above embodiments.

[0192] The communication interface 720 is used for communication between the aforementioned electronic device and other devices.

[0193] The memory 730 may include random access memory (RAM) or non-volatile memory, such as at least one disk storage device. Optionally, the memory 730 may also be at least one storage device located remotely from the aforementioned processor 710.

[0194] If the methods described in this application are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments of this application can be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms.

[0195] This application provides a computer-readable storage medium storing one or more programs, which can be executed by one or more processors to implement the agent development method based on global variables and arbitrary attachment types described in any of the above embodiments. For example, it parses externally input agent development configuration information to construct an initial graph structure for the agent; in the graph construction phase, it sequentially traverses the nodes and node relationships in the initial graph structure, progressively defining the input and output variables of the components, while using arbitrary input attachment types as node input data types to support mutual calls between different types of nodes, and employing a global variable mechanism to uniformly register and centrally manage the input and output variables of the components; in the runtime construction phase, it constructs and executes vertex-by-vertex to complete the value reference substitution and extraction of output structure variable values ​​for the agent development task; after the setup is completed, it generates the graph structure corresponding to the agent to realize agent development.

[0196] Exemplary embodiments of this application have been specifically shown and described above. It should be understood that this application is not limited to the detailed structures, arrangements, or implementation methods described herein; rather, this application is intended to cover various modifications and equivalent arrangements contained within the spirit and scope of the appended claims.

Claims

1. An intelligent agent development system based on global variables and arbitrary input attachment types, applied to an intelligent agent development platform, characterized in that, include: The configuration parsing module is used to parse the externally input agent development configuration information to construct the initial graph structure of the agent; The graph construction module is used to sequentially traverse the nodes and node relationships in the initial graph structure during the graph construction phase, and progressively define the input and output variables of the components. The graphing module further includes: a hook type unit for defining nodes with arbitrary input hook types; and a node specification unit for specifying the input data type of a node as an arbitrary input hook type during node execution to automatically adapt to any output data type of the upstream component, thereby avoiding the addition of redundant nodes due to type incompatibility. The graphing module further includes: a variable pool unit for defining a global variable pool; a component variable unit for defining component variables that can only access parent variables through system process components; a global variable unit for defining global variable values ​​that can be accessed by all components through internal system definition; and a variable management unit for unified registration and centralized management of variables through the order of input variable definition, output variable definition, and value reference, so that different nodes can directly reference global variables without establishing redundant connections. The variable pool unit is also used to divide variables into component input variables, system variables, and component output structure variables; a global variable pool is constructed through modular design; in the global variable pool, each variable is identified by a unique identifier and includes variable name, variable type, and variable value; The runtime build module is used to perform value reference substitution and extraction of output structure variable values ​​on a vertex-by-vertex basis during the runtime build phase to complete the agent development task. The agent generation module is used to generate the graph structure corresponding to the agent after the settings are completed, so as to realize agent development.

2. The system as described in claim 1, characterized in that, The configuration parsing module is also used to obtain the agent development task from the user; parse the development task to describe it as graph domain-specific language data; and construct the initial graph structure of the agent based on the graph domain-specific language data.

3. The system as described in claim 1, characterized in that, The composition module includes: A traversal unit is used to sequentially traverse the nodes and node relationships in the initial graph structure during the graph construction phase. Static architecture units are used to progressively define the static architecture of component input variables and output structure variables by identifying dependencies between nodes and data flow graphs.

4. The system as described in claim 1, characterized in that, The component variable unit is also used to assign values ​​to the component variables during the component runtime phase; and / or to assign values ​​to the component variables via external system transmission; and / or to assign values ​​to the component variables through direct user input; and / or to assign values ​​to the component variables through global variable references.

5. The system as described in claim 1, characterized in that, The global variable unit is also used for assigning values ​​to the system variables externally; and / or assigning values ​​to the system variables through graph domain-specific language data; and / or assigning values ​​to the system variables during internal runtime.

6. The system as described in claim 1, characterized in that, The variable management unit is also used to, during the process of defining input variables, include information for each input variable including: variable name, variable type, input method, and variable description; during the process of defining output variables, include information for each output variable including: variable name, variable type, and variable description; when the output variable is data, define only the required key values ​​through interface interaction and register them as structure variables; and reference the values ​​of the input variables and the output variables through user input and / or global variable references.

7. The system as described in claim 1, characterized in that, The runtime construction module is also used to construct the execution context for each vertex through the node construction method during the runtime construction phase; and to call the compilation method of each vertex in sequence to trigger component instantiation, attribute setting and result construction, thereby completing value reference substitution and extraction of output structure variable values.

8. A method for developing intelligent agents based on global variables and arbitrary input attachment types, applied to an intelligent agent development platform, characterized in that... include: Parse the externally input agent development configuration information to construct the initial graph structure of the agent; During the graph construction phase, the nodes and node relationships in the initial graph structure are traversed sequentially, and the input and output variables of the components are defined step by step, while nodes of arbitrary input attachment types are defined. During node execution, the input data type of the node is specified as any input hook type to automatically adapt to any output data type of the upstream component, avoiding the addition of redundant nodes due to type incompatibility. Variables are divided into component input variables, system variables, and component output structure variables. A global variable pool is constructed through modular design. In the global variable pool, each variable is identified by a unique identifier and includes the variable name, variable type, and variable value. Component variables that can only access parent variables are defined through system process components. Global variable values ​​that can be accessed by all components are defined internally by the system. Variables are uniformly registered and centrally managed through the order of input variable definition, output variable definition, and value reference, allowing different nodes to directly reference global variables without establishing redundant connections. During the build phase, vertex-by-vertex build execution is performed to complete the value reference substitution and extraction of output structure variable values ​​for the agent development task. After the settings are completed, the graph structure corresponding to the agent is generated to realize agent development.

9. The method as described in claim 8, characterized in that, Parse externally input agent development configuration information to construct the initial graph structure of the agent, including: Obtain intelligent agent development tasks from users; The development task is parsed to describe it as graph domain-specific language data; The agent's initial graph structure is constructed based on the graph domain-specific language data.

10. The method as described in claim 8, characterized in that, During the graph construction phase, the nodes and node relationships in the initial graph structure are traversed sequentially, and the input and output variables of the components are defined step by step, including: During the graph construction phase, the nodes and node relationships in the initial graph structure are traversed sequentially. By gradually identifying the dependencies between nodes and the data flow graph, the static architecture definition of component input variables and output structure variables is completed.

11. The method as described in claim 8, characterized in that, Component variables that can only access parent variables are defined through system process components, including: The component variables are assigned values ​​during the component's runtime phase; and / or The component variables are assigned values ​​via external system transmission; and / or The component variables are assigned values ​​through direct user input; and / or The component variables are assigned values ​​through global variable references.

12. The method as described in claim 8, characterized in that, Global variable values ​​defined internally by the system and accessible to all components include: The system variables are assigned values ​​externally; and / or The system variables are assigned values ​​using graph domain-specific language data; and / or The system variables are assigned values ​​during internal runtime.

13. The method as described in claim 8, characterized in that, Variables are registered and centrally managed in a unified manner through the order of input variable definition, output variable definition, and value reference, including: During the process of defining input variables, the information for each input variable includes: variable name, variable type, input method, and variable description; During the definition of output variables, the information for each output variable includes: variable name, variable type, and variable description; When the output variable is data, only the required key values ​​are defined through the interface interaction, and they are registered as structure variables; The input variables and output variables are referenced by user input and / or global variable references.

14. The method as described in claim 8, characterized in that, During the build phase, vertex-by-vertex build execution is performed to complete the agent development task of value reference substitution and extraction of output structure variable values, including: During the runtime build phase, the execution context is built vertex by vertex using the node build method; The compilation methods of each vertex are called sequentially to trigger component instantiation, property setting, and result construction, thereby completing value reference substitution and extracting the values ​​of output structure variables.

Images