A method, device, and medium for configuring intelligent agents based on front-end interaction.

Abstract

This application discloses a method, device, and medium for configuring intelligent agents based on front-end interaction, relating to the field of computer technology. The method includes: receiving user interaction behavior through a front-end interactive interface, analyzing the user interaction behavior, and generating corresponding response instructions; executing the response instructions, creating multiple intelligent agent nodes, and configuring corresponding role information; determining the task dependencies between intelligent agent nodes, and constructing an intelligent agent node relationship graph through preset task execution rules; receiving and parsing tasks to be executed, extracting the required intelligent agent role information, determining the intelligent agent nodes to be executed, and determining the execution order of the intelligent agent nodes to be executed according to the intelligent agent node relationship graph; sequentially calling the intelligent agent models corresponding to the intelligent agent nodes to be executed, executing the tasks to be executed, and updating the state parameters. Through the deep integration of front-end visual interaction and automated process orchestration, the intuitiveness and efficiency of the configuration process are improved.

Description

Technical Field

[0001] This application relates to the field of computer technology, specifically to a method, device, and medium for configuring intelligent agents based on front-end interaction. Background Technology

[0002] With the rapid development and iteration of Large Language Models (LLM), distributed collaborative systems centered on agents have been widely used. Currently, multi-agent collaborative platforms are widely used to schedule multiple agents with specific capabilities to achieve complex functions such as information extraction, task planning, and distributed decision-making. They have been widely applied in scenarios such as intelligent customer service, automated office, and data analysis, becoming a key carrier connecting large language models with actual business needs.

[0003] However, existing multi-agent platforms generally rely on Python scripts or complex JSON structures to define agent attributes and collaboration logic. This not only demands highly specialized programming skills from developers, but also requires code rewriting, script testing, and environment deployment for adjustments, making rapid iteration, debugging, and deployment difficult. This results in very high development costs and poor compatibility. Especially when configuring critical aspects such as dependencies between multiple agents, message passing rules, and prompt word templates, rewriting scripts is inefficient and prone to errors. Summary of the Invention

[0004] To address the aforementioned issues, this application proposes a method for configuring intelligent agents based on front-end interaction, comprising: The system receives user interaction behavior through a front-end interactive interface, analyzes the user interaction behavior, and generates corresponding response instructions. Execute the response command to create multiple intelligent agent nodes and configure their corresponding role information; Based on the connection relationships between the agent nodes, the task dependencies between the agent nodes are determined. Through preset task execution rules, the execution order of the agent nodes is assigned based on the task dependencies, and an agent node relationship graph is constructed. Receive and parse the task to be executed, extract the required agent role information, determine the agent node to be executed, and determine the execution order corresponding to the agent node to be executed according to the agent node relationship graph; Based on the execution order, the agent models corresponding to the agent nodes to be executed are called sequentially to execute the tasks to be executed, the execution results are obtained, and the state parameters of the agent nodes to be executed are updated.

[0005] On the other hand, this application also proposes an intelligent agent configuration device based on front-end interaction, comprising: At least one processor; and, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform, for example, a front-end interaction-based agent configuration method as described in the above example.

[0006] On the other hand, this application also proposes a non-volatile computer storage medium storing computer-executable instructions, wherein the computer-executable instructions are configured as: the intelligent agent configuration method based on front-end interaction described in the above example.

[0007] The intelligent agent configuration method based on front-end interaction proposed in this application can bring the following beneficial effects: By deeply integrating front-end visual interaction with automated process orchestration, the technical barriers of traditional agent configuration, which relies on coding or complex structure editing, are effectively overcome. Users do not need programming knowledge to create agent nodes, configure roles, and define relationships through intuitive interactive behaviors. This not only significantly lowers the barrier for non-technical personnel to participate in the construction of agent systems but also improves the intuitiveness and efficiency of the configuration process. At the same time, based on the connection relationship, task dependencies are automatically resolved and execution order is assigned, avoiding the tediousness and chaos of manually sorting out dependency logic in the traditional method, and ensuring the standardization and consistency of multi-agent collaboration processes.

[0008] Furthermore, the closed-loop design of task parsing, node matching, and sequential execution enhances the operability and maintainability of the intelligent agent system. The task parsing phase extracts role requirements and determines the execution order based on the node relationship diagram, ensuring the compatibility between the task and the agent's capabilities. During execution, node status parameters are updated in real time, providing users with clear process tracking and result feedback, facilitating rapid problem identification and configuration optimization. This addresses the pain points of traditional intelligent agent systems, such as difficult debugging and slow iteration, significantly improving the system's usability, reliability, and iteration efficiency, providing strong support for the rapid deployment and continuous optimization of multi-agent collaborative tasks. Attached Figure Description

[0009] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings: Figure 1 This is a flowchart illustrating a front-end interaction-based intelligent agent configuration method in an embodiment of this application. Figure 2 This is a schematic diagram of the system architecture of the front-end visual interaction system in the embodiments of this application; Figure 3This is a schematic diagram of the user's operation process on the front-end interactive interface in the embodiments of this application; Figure 4 This is a schematic diagram of an intelligent agent configuration device based on front-end interaction in an embodiment of this application. Detailed Implementation

[0010] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below in conjunction with specific embodiments and corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0011] The technical solutions provided by the various embodiments of this application are described in detail below with reference to the accompanying drawings.

[0012] like Figure 1 As shown in the figure, this application provides a method for configuring an intelligent agent based on front-end interaction, including: S101: Receive user interaction behavior through the front-end interactive interface, analyze the user interaction behavior, and generate corresponding response instructions.

[0013] Specifically, the visual front-end interactive interface includes a drag-and-drop canvas, form input areas, button controls, etc. Users interact with the interface by clicking, dragging, entering text, or selecting options. The front-end captures these interactions through an event listener mechanism, converting them into structured data, including behavior type, operation object, and parameter information, and then transmits this data to the back-end. The back-end parses this structured data and, based on predefined behavior instruction mapping rules, generates corresponding response instructions to ensure that the instructions accurately reflect the user's configuration intent.

[0014] In this embodiment of the application, the specific process of generating response instructions based on user interaction behavior is as follows: receiving the interaction behavior triggered by the user on the front-end interactive interface, analyzing the interaction behavior, determining the operation type and operation object corresponding to the interaction behavior, the operation type includes node operation behavior, connection operation behavior, attribute editing behavior, debugging control behavior, and generating corresponding response instructions based on the operation type and operation object.

[0015] Specifically, when the operation type is a node operation, if the operation object is adding a node, a new node instruction containing the node type, initial coordinates, and default attributes is generated; if the operation object is deleting a node, a node removal instruction containing the target node identifier and dependency cleanup flags is generated. When the operation type is a connection operation, if the operation object is creating a connection, a dependency creation instruction containing the source node identifier, target node identifier, and triggering conditions is generated; if the operation object is deleting a connection, a dependency removal instruction containing the connection identifier and graph structure update flags is generated. When the operation type is an attribute editing operation, if the operation object is a prompt word template, an associated attribute editing instruction is generated; if the operation object is an input / output parameter, a configuration attribute editing instruction is generated. When the operation type is a debug control operation, if the operation object is process start / stop, a modulation control instruction containing start, pause, and continue states is generated; if the operation object is a breakpoint, a breakpoint injection instruction containing the target node identifier and interception strategy is generated.

[0016] It should be noted that the configuration of the intelligent agent is achieved through a front-end visual interaction system. The system architecture of the front-end visual interaction system is as follows: Figure 2 As shown, the system comprises a front-end interface layer, a business logic layer, and a platform integration layer. The front-end interface layer includes an Agent node graphical modeling interface, an Agent attribute configuration panel, a flow control module, and a simulation debugging window. The Agent node graphical modeling interface allows users to create agent nodes and define topological relationships using low-code methods such as drag-and-drop and connecting lines, enabling intuitive task flow orchestration. The Agent attribute configuration panel provides parameter adjustment capabilities, covering Prompt template editing, tool binding, and variable mapping, supporting precise setting of agent behavior rules. The flow control module and the debugging window constitute a collaborative feedback mechanism, providing observability support for flow verification. Essentially, it builds a mapping bridge between user intent and system logic, lowering the technical threshold for agent configuration.

[0017] The business logic layer includes a task dependency orchestration engine, a rendering and variable resolver, a debug execution controller, and an export compilation module. The task dependency orchestration engine generates a task execution dependency graph based on the front-end topology using a directed graph traversal algorithm, clarifying the sequential constraints and parallel logic between nodes to achieve structured modeling of the process. The rendering and variable resolver integrates context awareness and variable parsing, relying on a dynamic placeholder replacement strategy to transform static templates into dynamic instructions adapted to the scenario, addressing the personalized needs of intelligent agent interaction. The debug execution controller constructs a closed-loop feedback for process verification through breakpoint management, log collection, and result simulation. The export compilation module maps visual configurations to executable code through domain-specific language or general format conversion, essentially achieving the engineering translation of user intent and providing logical support for intelligent agent collaboration.

[0018] The platform integration layer includes a backend agent scheduling service, a variable execution interface, and a deployment and version control service. The backend scheduling service integrates a multi-agent framework, assigning runtime instances to abstract nodes to achieve the engineered instantiation of agent roles. The variable execution interface relies on the interface calls of the large model service to build a natural language interaction capability channel, transforming symbolic instructions into the cognitive output of the agent. The deployment and version control module, through configuring version management and rollback mechanisms, ensures the continuous delivery and stability of agent processes. Essentially, it integrates computing resources, large model capabilities, and engineering control to provide an execution foundation for agent collaboration.

[0019] S102: Execute the response command to create multiple intelligent agent nodes and configure the corresponding role information.

[0020] Specifically, when executing instructions, the backend scheduling service creates multiple intelligent agent node entities in the underlying data structure (such as in-memory graphs, graph databases, etc.), assigns a unique identifier to each node for differentiation, and binds corresponding role attributes to each node according to the default role configuration information carried in the instructions. For example, if the user specifies a node as a "text analysis role," then the node's attributes will be set to "Function: Text classification and sentiment analysis," "Input format: String text," "Output format: Analysis results JSON," etc.

[0021] Furthermore, when a user performs an attribute editing operation on a target agent node, the canvas's event handler captures information such as the operation type and the target node ID, triggering a configuration attribute editing event. After the event is triggered, the front-end interface displays the attribute configuration panel, which includes configuration items such as the agent's role information (e.g., function description, domain), running parameters (e.g., maximum task duration, resource quota), and interaction rules (e.g., Prompt template, variable binding relationships). When the user inputs configuration information by filling in text, selecting options, or uploading files, the panel's form component captures the input data in real time and converts fragmented user actions into standardized key-value pairs.

[0022] It should be noted that, as Figure 3 As shown, the user's operation flow in the front-end interactive interface is as follows: The user adds agent nodes to the editing area by dragging and dropping, clicks on the node to bring up the attribute panel, and configures the following: agent name (e.g., Agent_Researcher), role description (e.g., information retrieval expert), system prompt (Prompt), tool binding (Tool such as browser, search engine, etc.), input and output parameter definitions (e.g., input_text, summary), etc. All configured node information is stored in the front-end state management in real time for subsequent dependency identification and configuration export.

[0023] S103: Based on the connection relationship between the intelligent agent nodes, determine the task dependency relationship between the intelligent agent nodes, allocate the execution order of the intelligent agent nodes according to the task dependency relationship through preset task execution rules, and construct an intelligent agent node relationship graph.

[0024] Specifically, the connection operation event is triggered through the front-end interactive interface, the dependency relationship creation instruction is executed, the connection operation behavior of the user by dragging and dropping nodes in the front-end interface is received, the connection operation behavior is parsed, the connection nodes and connection direction are extracted, and the dependency relationship between the connection nodes is defined according to the node triggering condition and connection direction in the configuration attributes of the connection nodes.

[0025] Furthermore, the system invokes preset task execution rules to assign execution order to nodes, integrates information such as nodes, dependencies, and execution order into an agent node relationship graph, stores it in a graph database, and displays it as an intuitive flowchart through a front-end visualization component, making it easy for users to view and adjust.

[0026] It's important to note that the task dependency orchestration engine is used to model the task flow and define the dependency logic between agents. Users can create task dependencies between nodes by connecting them with a mouse, supporting types such as "one-way triggering," "parallel," and "conditional dependency." Each connection's data structure records metadata such as the source node ID, target node ID, and triggering conditions (e.g., always, onSuccess, onFail). Upon receiving connection updates, the orchestration engine automatically constructs a complete task dependency graph, analyzes the task flow path using topological sorting or state machine principles, and assigns an execution order to each node. Furthermore, the orchestration engine supports process simulation in debug mode, gradually simulating the execution path of agent nodes, facilitating developers to verify the correctness of the process.

[0027] S104: Receive and parse the task to be executed, extract the required agent role information, determine the agent node to be executed, and determine the execution order corresponding to the agent node to be executed according to the agent node relationship diagram.

[0028] Specifically, after receiving the task to be executed through the interface, the task parsing module is invoked to perform semantic analysis on the task and extract key requirements. Among the created agent nodes, agent nodes with corresponding role attributes are matched to determine the agent nodes to be executed. Based on the agent node relationship graph, the dependencies and preset execution order between the nodes to be executed are queried to determine the actual execution sequence logic.

[0029] In this embodiment, the user initiates a debugging request through the debugging control component of the front-end interface. After capturing this debugging control event, the front-end interface converts it into standardized debugging control instructions and transmits them to the back-end. Upon receiving the instructions, the back-end starts the debugging process and enters the task processing stage. It receives the user-input task to be executed, which can be in the form of text description, form data, or API request parameters, etc., and parses the task content using a natural language processing algorithm. During the parsing process, key information is identified and extracted from the task description, including role requirements, such as the need for a data analysis role or text generation capabilities, as well as domain keywords, such as the financial field, medical data, and real-time processing. This key information is then integrated into structured requirement tags.

[0030] Furthermore, based on the structured requirement tags, the agent node matching process is initiated. The constructed agent node relationship graph is traversed, pre-configured role field information for each agent node is extracted, and node role keywords are extracted from it. A text similarity calculation algorithm is used to perform quantitative calculations on the matching between the structured requirement tags and the node role keywords.

[0031] For example, if the demand tags include "finance" and "data analysis," and a node's role keywords also contain these two terms, the matching degree is high; if the node keywords and demand tags have little overlap, the matching degree is low. The calculation results are compared with a preset threshold, and intelligent agent nodes with a matching degree higher than the threshold are selected as intelligent agent nodes to be executed, providing accurate target objects for subsequent task allocation and execution.

[0032] Furthermore, when a node role keyword matches multiple candidate agent nodes, the optimal node to be executed is selected through a quantitative evaluation of the execution path length. Specifically, based on the constructed agent node relationship graph, the position and relationship of each candidate agent node in the overall task flow are clarified. For each candidate node, starting from the current task's starting node or process entry node, a path traversal is performed according to the pointing relationships between nodes, and the number of nodes or edges required to reach the candidate node from the starting point is calculated as the execution path length of that node.

[0033] The execution path lengths of all candidate agent nodes are compared, and the node with the shortest path length is selected. Shorter execution paths typically correspond to fewer dependencies and lower coordination costs, reducing information transmission loss and latency during task execution and improving overall process efficiency. The shortest candidate node is then selected as the final agent node to be executed and added to its corresponding position in the sequence of agent nodes according to the task execution logic. This provides a clear basis for node selection for subsequent sequential invocation of agent models and advancement of task execution.

[0034] S105: Based on the order of execution, the agent models corresponding to the agent nodes to be executed are called sequentially to execute the tasks to be executed, the execution results are obtained, and the state parameters of the agent nodes to be executed are updated.

[0035] Specifically, based on the execution order, the bound intelligent agent model is called through the interface, and the corresponding task is executed by the model. During model execution, a real-time monitoring mechanism captures the execution status and results. The model's running process and output execution results are recorded, and the results are temporarily stored in an intermediate storage area, such as a memory cache or temporary database, for subsequent node calls or final feedback to the user.

[0036] It should be noted that when the intelligent agent model is invoked, the system will encapsulate the output results or initial task parameters of the preceding node according to the pre-configured input format requirements of that node, and use them as the input data of the model to ensure that the model can accurately execute the task based on the context information.

[0037] Furthermore, the state parameters of each agent node to be executed are dynamically updated. These state parameters include, but are not limited to, execution status, execution duration, result identifier, and error messages. Updating these state parameters not only serves the real-time display on the front-end interface but also provides data support for subsequent process optimization.

[0038] It should be noted that by sequentially calling the model, accurately capturing results, and dynamically updating the state, the task to be executed can be efficiently advanced in the collaboration of intelligent agents. At the same time, the traceability of task execution is achieved through state tracking, which provides a guarantee for the stability and maintainability of the system.

[0039] This application effectively overcomes the technical barriers of traditional agent configuration, which relies on coding or complex structure editing, through the deep integration of front-end visual interaction and automated process orchestration. Users do not need programming knowledge to create agent nodes, configure roles, and define relationships through intuitive interactive behavior. This not only significantly lowers the barrier for non-technical personnel to participate in the construction of agent systems but also reduces oversights caused by manual coding, improving the intuitiveness and efficiency of the configuration process. Simultaneously, it automatically resolves task dependencies and assigns execution order based on connection relationships, avoiding the tediousness and chaos of manually sorting out dependency logic in traditional methods, ensuring the standardization and consistency of multi-agent collaboration processes.

[0040] Furthermore, the closed-loop design of task parsing, node matching, and sequential execution enhances the operability and maintainability of the intelligent agent system. The task parsing phase extracts role requirements and determines the execution order based on the node relationship diagram, ensuring the compatibility between the task and the agent's capabilities. During execution, node status parameters are updated in real time, providing users with clear process tracking and result feedback, facilitating rapid problem identification and configuration optimization. This addresses the pain points of traditional intelligent agent systems, such as difficult debugging and slow iteration, significantly improving the system's usability, reliability, and iteration efficiency, providing strong support for the rapid deployment and continuous optimization of multi-agent collaborative tasks.

[0041] like Figure 4 As shown in the embodiments of this application, an intelligent agent configuration device based on front-end interaction is also proposed, including: At least one processor; and, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, which, when executed by the at least one processor, enables the at least one processor to perform a front-end interaction-based agent configuration method as described in any of the above embodiments.

[0042] This application also provides a non-volatile computer storage medium storing computer-executable instructions, wherein the computer-executable instructions are configured as: a smart agent configuration method based on front-end interaction as described in any of the above embodiments.

[0043] The various embodiments in this application are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, the device and medium embodiments are basically similar to the method embodiments, so the description is relatively simple; relevant parts can be referred to the description of the method embodiments.

[0044] The devices and media provided in this application are one-to-one with the methods. Therefore, the devices and media also have similar beneficial technical effects as their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media will not be repeated here.

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

[0046] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart illustrations and / or block diagrams. Figure 1 One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0047] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0048] These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable apparatus for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0049] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0050] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0051] Computer-readable media include both permanent and non-permanent, removable and non-removable media that can store information using any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0052] It should also be noted that the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.

[0053] The above description is merely an embodiment of this application and is not intended to limit the scope of this application. Various modifications and variations can be made to this application by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this application should be included within the scope of the claims of this application.

Claims

1. A method for configuring intelligent agents based on front-end interaction, characterized in that, include: The system receives user interaction behavior through a front-end interactive interface, analyzes the user interaction behavior, and generates corresponding response instructions, specifically including: Receive user interaction actions triggered by the front-end interface; The interaction behavior is analyzed to determine the operation type and operation object corresponding to the interaction behavior; the operation type includes node operation behavior, connection operation behavior, attribute editing behavior, and debugging control behavior; Based on the operation type and the operation object, generate a corresponding response instruction; Execute the response command to create multiple agent nodes and configure their corresponding role information, specifically including: Node operation events are triggered through the visual canvas of the front-end interactive interface to execute node operation instructions; When the operation object is a newly added node, the node operation instruction is determined to be a new node instruction; Drag the target node onto the visualization canvas and obtain the node coordinates in the visualization canvas through the drag-and-drop interface; Call the default attribute interface to generate the corresponding agent node based on the node coordinates and default attributes; Based on the connection relationships between the agent nodes, the task dependencies between the agent nodes are determined. Through preset task execution rules, the execution order of the agent nodes is assigned based on the task dependencies, and an agent node relationship graph is constructed. Receive and parse the task to be executed, extract the required agent role information, and determine the agent node to be executed, specifically including: The debugging control event is triggered through the front-end interactive interface to execute modulation control commands; Receive and parse the tasks to be executed, extract the key role requirements and domain keywords in the tasks to be executed, and generate structured requirement tags; Based on the structured requirement tags, the pre-configured role fields of the agent nodes in the agent node relationship graph are traversed to obtain node role keywords; Calculate the matching degree between the structured requirement tags and the node role keywords, and determine the intelligent agent nodes to be executed whose matching degree is higher than a preset threshold; The method further includes: When a node role keyword matches multiple candidate agent nodes, the execution path length of each candidate agent node is calculated based on the task dependency relationship in the agent node relationship graph. The candidate agent node with the shortest execution path length is selected as the agent node to be executed and added to the sequence of agents to be executed. The execution order corresponding to the intelligent agent nodes to be executed is determined according to the intelligent agent node relationship graph. Based on the execution order, the agent models corresponding to the agent nodes to be executed are called sequentially to execute the tasks to be executed, the execution results are obtained, and the state parameters of the agent nodes to be executed are updated.

2. The intelligent agent configuration method based on front-end interaction according to claim 1, characterized in that, After executing the response instruction, creating multiple agent nodes, and configuring corresponding role information, the method further includes: The configuration attribute editing event is triggered through the visual canvas of the front-end interactive interface, and the configuration attribute editing command is executed on the target intelligent agent node; Obtain the attribute configuration parameters through the attribute panel and map the attribute configuration parameters to the corresponding configuration variables.

3. The intelligent agent configuration method based on front-end interaction according to claim 1, characterized in that, After assigning execution order to the agent nodes based on the task dependencies and constructing the agent node relationship graph, the method further includes: The associated attribute editing event is triggered by the prompt word template of the front-end interactive interface, and the associated attribute editing instruction is executed on the target intelligent agent node; Obtain the prompt text of the prompt text template, parse the prompt text, and extract the prompt text variables; Based on the agent node relationship graph, the source node of the prompt word variable is determined, and the target agent node is associated with the source node.

4. The intelligent agent configuration method based on front-end interaction according to claim 1, characterized in that, The step of determining the task dependency relationship between the agent nodes based on the connection relationship between the agent nodes specifically includes: The connection operation event is triggered through the front-end interactive interface to execute the dependency creation instruction; The connection operation behavior is analyzed to extract the connection nodes and connection direction; The dependency relationships between the connected nodes are determined based on the node triggering conditions corresponding to the connected nodes and the connection direction.

5. A smart agent configuration device based on front-end interaction, characterized in that, include: At least one processor; as well as, A memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor to enable the at least one processor to perform a front-end interaction-based agent configuration method as described in any one of claims 1 to 4.

6. A non-volatile computer storage medium storing computer-executable instructions, characterized in that, The computer-executable instructions are configured to execute a front-end interaction-based intelligent agent configuration method as described in any one of claims 1 to 4.

Images