A method and system for multi-agent dialogue execution on an industrial low-code platform

By combining Function Calling task routing with LiteFlow collaborative orchestration technology, the problems of natural language instruction parsing and task matching in multi-agent dialogue execution in industrial low-code platforms are solved, realizing efficient and flexible process orchestration and multi-agent collaboration, thereby improving the intelligence level and business processing efficiency of industrial low-code platforms.

CN123115304APending Publication Date: 2026-11-17XIAN THERMAL POWER RES INST CO LTD +1
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
CN202611029276.1
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-07-10
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

Industrial low-code platforms face challenges in multi-agent dialogue execution, including difficulties in parsing natural language instructions, low task matching accuracy, rigid process orchestration, poor agent collaboration efficiency, and a lack of exception handling mechanisms.

Method used

By employing Function Calling task routing and LiteFlow collaborative orchestration technology, multi-agent function functions are designed and registered, user natural language commands are parsed, agents are dynamically matched, and the LiteFlow engine is used for process orchestration and collaborative execution to achieve a visual, nestable execution flowchart, and to monitor and provide feedback on results in real time.

Benefits of technology

It improves task matching accuracy, process orchestration flexibility, and multi-agent collaboration efficiency, reduces system maintenance costs, and enhances the intelligence level and business processing efficiency of industrial low-code platforms.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123115304A_ABST
    Figure CN123115304A_ABST
Patent Text Reader

Abstract

A method and system for multi-agent dialogue execution in an industrial low-code platform based on Function Calling task routing and LiteFlow collaborative orchestration is disclosed. The system includes: a function registry module: receiving and managing standardized multi-agent function calls, providing distributed storage, signature retrieval, version management, and interface verification capabilities; an instruction parsing module: receiving user natural language instructions, performing semantic understanding, intent recognition, task decomposition, and entity parameter extraction through a large language model, and outputting a structured task description; a task routing module: performing parallel matching between the structured task description and functions in the function registry, combining semantic similarity and business rules to generate the optimal task execution chain; a process orchestration module: converting the task execution chain into LiteFlow-recognizable process rules, enabling visual and nestable process orchestration, and supporting complex business logic definitions; and a collaborative execution module: loading LiteFlow process instances to drive multi-agent collaborative task execution.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This invention relates to the fields of industrial digital transformation, low-code development and artificial intelligence multi-agent interaction integration technology, and more specifically, to a method and system for multi-agent dialogue execution on an industrial low-code platform. Background Technology

[0002] Industrial low-code platforms, as an important tool for industrial digital transformation, aim to lower the development threshold of industrial business applications and support users in quickly building business systems through visual configuration and natural language dialogue. However, industrial scenarios involve complex and diverse business logic, covering multiple tasks such as equipment operation and maintenance, production scheduling, and data statistical analysis. User-initiated dialogue requests often involve multi-stage collaboration. Traditional multi-agent dialogue systems are prone to problems such as task matching deviations and chaotic agent collaboration processes, resulting in low business response efficiency and processing results that do not conform to industrial business rules.

[0003] Function Calling task routing technology can accurately identify the task type, complexity, and required capabilities of user dialogue requests through semantic parsing and business rule matching. It intelligently routes tasks to agents or functional modules with corresponding processing capabilities, avoiding invalid agent calls and resource waste, and ensuring the accuracy and response speed of task processing. The LiteFlow collaborative orchestration framework provides a visual and modular orchestration capability for the execution flow of multiple agents. It supports the flexible definition of the interaction logic and execution order between agents. For example, in industrial fault diagnosis scenarios, it can orchestrate the collaborative flow of data acquisition agents, fault analysis agents, and maintenance solution generation agents to achieve seamless connection of multi-stage tasks.

[0004] Current common methods for multi-agent dialogue execution in industrial low-code platforms have several drawbacks: First, there are traditional fixed-routing multi-agent systems. These systems hard-code the correspondence between tasks and agents, making them unsuitable for the ever-changing business needs of industrial scenarios. Adding or adjusting agents requires modifying core code, resulting in extremely high maintenance costs. Furthermore, the matching accuracy relies entirely on preset rules and cannot handle ambiguous natural language commands. Second, there are process orchestration systems based on a single rule engine. These systems can only handle structured task requests and cannot parse natural language commands. Moreover, process orchestration is mostly statically configured, making it difficult to handle complex branching and parallel logic in industrial tasks. Third, there are agent collaboration systems driven purely by large language models. These systems rely on large language models to directly generate execution logic, lacking dedicated process control mechanisms. This easily leads to problems such as incorrect task execution order, untimely handling of anomalies, and the execution process is neither visualized nor traceable. Fourth, there are distributed agent invocation systems. In these systems, the interfaces of each agent are inconsistent, there is no unified capability registration center, data transfer between agents is chaotic, and collaboration efficiency is extremely low.

[0005] Therefore, there is an urgent need to further utilize the capabilities of this method and system to solve problems such as difficulty in parsing natural language instructions, low task matching accuracy, rigid process orchestration, poor agent collaboration efficiency, and lack of exception handling mechanisms in the execution of multi-agent dialogue in industrial low-code platforms. This invention was created to meet this real-world need. Summary of the Invention

[0006] This invention provides a method and system for multi-agent dialogue execution in an industrial low-code platform based on Function Calling task routing and LiteFlow collaborative orchestration, in order to solve the technical problems existing in the prior art.

[0007] To achieve the above objectives, this invention provides a multi-agent dialogue execution method for industrial low-code platforms based on Function Calling task routing and LiteFlow collaborative orchestration, comprising the following steps: S1: Design and register multi-agent function functions: Decompose the business requirements of the industrial low-code platform into atomic tasks, define a standard Function Calling interface for each atomic task, clarify the input parameters, output format and function description, and register and manage these multi-agent function functions in a unified function registry center to form an agent capability library; S2: Receive and parse user natural language instructions: Receive industrial operation requests in the form of user natural language through the dialogue interface, use a large language model to perform semantic understanding, intent recognition, task decomposition and entity parameter extraction on the instructions, and transform fuzzy requirements into structured task descriptions. S3: Dynamic task routing and agent matching based on Function Calling: The structured task description is matched with the registered functions in the function registry. By calculating semantic similarity and combining it with predefined business rules, the optimal agent or function to execute the sub-task is dynamically decided, forming a preliminary task execution link. S4: Use the LiteFlow rule engine for collaborative process orchestration: Transform the initial task execution chain into LiteFlow-recognizable process rules, and orchestrate them into a visual, nestable execution flowchart based on task dependencies, data flow and business logic, supporting conditional branches and loop retries; S5: Drive multi-agent collaborative execution and result integration and feedback: Load and execute LiteFlow orchestrated process instances, call the corresponding Function Calling according to rules to drive agents to execute tasks, pass context data, monitor execution status and handle branches, loops and exceptions, and finally integrate the execution results of each agent and provide feedback to the user in natural language or structured reports.

[0008] In one embodiment of the present invention, optionally, the specific implementation of designing and registering multi-agent function functions in step S1 is as follows: Domain-driven design is used to model business requirements, extracting common business capability units of core subdomains and decomposing them into indivisible sets of atomic tasks; standardized function functions are defined for each atomic task, specifying the dimensions and data type constraints of the input parameter space, and using structured JSON Schema to define the output space format; metadata including function description, calling permissions, and QoS indicators are set for the function, where QoS indicators cover maximum latency, success rate threshold, and resource consumption coefficient; the function registration center adopts a distributed key-value storage mechanism to generate a unique identifier for each function, generates a signature matrix through local sensitive hashing to achieve efficient retrieval of similar functions, performs strong type validation and interface conflict detection, and supports semantic version management and blue-green deployment.

[0009] In one embodiment of the present invention, optionally, the specific implementation of receiving and parsing the user's natural language instructions in step S2 is as follows: preprocessing the natural language instructions input by the user, removing irrelevant characters and noise, and standardizing the encoding; inputting the preprocessed instructions into a large language model based on the Transformer architecture, performing semantic understanding through a multi-head self-attention mechanism, and using an intent classification model to calculate the intent probability distribution of the input sequence to achieve intent recognition; mapping the original instructions into a sub-task sequence by maximizing conditional probability combined with a beam search algorithm; running the named entity recognition component in parallel, using a conditional random field to process label dependencies and locate key parameters; and finally outputting the parsing result as a structured JSON object containing intent, a list of sub-tasks, and entity-parameter pairs, using a lightweight serialization protocol to reduce transmission latency.

[0010] In one embodiment of the present invention, optionally, in step S3, the specific implementation of dynamic task routing and agent matching based on Function Calling is as follows: the metadata of the function registration center is loaded into the in-memory database, and the matching calculation of all registered functions is initiated in parallel using a multi-threaded framework; the embedding vectors of task description and function function description are generated through a pre-trained Sentence-BERT model, and the cosine similarity is calculated as the basic confidence score; the rule score is generated by combining the function priority weight, resource availability flag, and execution history success rate in the predefined business rules, and the comprehensive matching score is obtained by linearly combining the basic confidence score and the rule score; the candidate functions are sorted in descending order of comprehensive score using a fast selection algorithm, and low-scoring items are filtered based on the confidence threshold, while the Top-k functions are retained to form a task execution link.

[0011] In one embodiment of the present invention, optionally, in step S4, the specific implementation of process collaborative orchestration using the LiteFlow rule engine is as follows: the task execution chain is modeled as a directed graph containing task nodes and dependent edges, where the edges represent the sequential execution relationship between tasks; the directed graph is converted into a rule file in XML or JSON format supported by LiteFlow, and the rules are implemented using the `` tag. <then> `、` <parallel> `、` <for>Define serial execution, parallel branching, and loop retry logic; define exception handling branches through conditional expressions; implement visual orchestration through the LiteFlow designer, supporting drag-and-drop adjustment of the process structure.

[0012] In one embodiment of the present invention, optionally, in step S5, the specific implementation of driving multi-agent collaborative execution and result integration feedback is as follows: loading a LiteFlow process instance and initializing a context object to store input data and global variables; the LiteFlow engine synchronously or asynchronously calls the Function Calling interface according to orchestration rules, and transmits context data through memory sharing or a distributed message queue; monitoring the task execution status in real time, handling state changes through a state transition function, handling branch logic based on conditional expressions, controlling loop retries through an iteration counter, and triggering up to 3 automatic retries when the task fails; integrating the output results of each agent using a weighted average method based on historical confidence, converting the results into natural language reports or structured JSON through a template engine, feeding them back to the user through a dialogue interface, and recording execution logs.

[0013] This invention also provides an industrial low-code platform multi-agent dialogue execution system based on Function Calling task routing and LiteFlow collaborative orchestration, comprising: Function Registry Module: Used to receive and manage standardized multi-agent function functions, providing distributed storage, signature retrieval, version management and interface verification capabilities; Instruction parsing module: Used to receive user natural language instructions, complete semantic understanding, intent recognition, task decomposition and entity parameter extraction through a large language model, and output a structured task description; Task routing module: Used to perform parallel matching of structured task descriptions with functions in the function registry, and generate the optimal task execution link by combining semantic similarity and business rules; Workflow orchestration module: Used to transform task execution links into LiteFlow-recognizable workflow rules, enabling visual and nestable workflow orchestration, and supporting complex business logic definitions; Collaborative Execution Module: Used to load LiteFlow process instances, drive multi-agent collaborative task execution, monitor execution status, handle exceptions, and integrate execution results to provide feedback to the user.

[0014] In one embodiment of the present invention, optionally, the function registration center module adopts a distributed key-value storage architecture, generates a signature matrix through locality-sensitive hashing to achieve efficient retrieval of similar functions, performs strong type validation to ensure that input and output meet constraints, supports semantic version management and blue-green deployment, and new agents only need to register the interface to take effect without modifying the core code.

[0015] In one embodiment of the present invention, the instruction parsing module optionally adopts an end-to-end large language model processing mechanism, which integrates intent classification, task decomposition and entity extraction capabilities to avoid manual rule definition.

[0016] In one embodiment of the present invention, optionally, the task routing module adopts a multi-threaded parallel matching mechanism, combines semantic similarity calculation and business rule weighted scoring to generate a comprehensive matching result, and achieves efficient sorting and filtering through a fast selection algorithm.

[0017] The present invention provides a method and system for multi-agent dialogue execution in industrial low-code platforms based on Function Calling task routing and LiteFlow collaborative orchestration. By deeply integrating Function Calling task routing and LiteFlow collaborative orchestration technology, it builds an efficient and intelligent multi-agent dialogue execution system for industrial low-code platforms. It retains the ease of use of low-code platforms while improving the business processing capabilities of natural language interaction. It is applicable to various scenarios such as production management, equipment operation and maintenance, and supply chain collaboration in various industrial enterprises, and helps to facilitate the rapid implementation and efficient operation of industrial digital applications. Attached Figure Description

[0018] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0019] Figure 1 This is a flowchart of an industrial low-code platform multi-agent dialogue execution method based on Function Calling task routing and LiteFlow co-orchestration, according to an embodiment of the present invention. Detailed Implementation

[0020] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0021] This invention is a high-efficiency multi-agent dialogue execution solution that integrates artificial intelligence task routing technology and a lightweight process orchestration framework for industrial low-code platforms. It focuses on solving the problems of accurate task allocation and multi-agent collaborative execution in natural language interaction in industrial scenarios.

[0022] This invention is applied to intelligent interaction and business collaboration scenarios in low-code platforms within the industrial sector, thereby addressing the pain points of traditional industrial low-code platforms, such as low efficiency in multi-task collaboration, insufficient accuracy in intelligent dialogue responses, and poor flexibility in business process orchestration. It utilizes a Function-based approach... Calling's task routing technology, LiteFlow collaborative orchestration technology, and multi-agent dialogue execution mechanism enable various intelligent agents to collaborate in industrial production line operation and maintenance scenarios. For example, maintenance personnel can initiate equipment fault diagnosis requests via natural language on a low-code platform. The system quickly matches agents for fault diagnosis, data acquisition, and repair plan generation, scheduling these agents to work collaboratively: first, it calls the equipment's sensor interfaces to obtain real-time operating data; then, it analyzes the data to pinpoint the cause of the fault; finally, it outputs targeted repair steps and provides real-time feedback through dialogue, eliminating the need for maintenance personnel to manually switch systems or write code. In production process parameter optimization scenarios, process engineers can propose energy consumption optimization needs through dialogue. The system routes these requests to energy consumption analysis, parameter simulation, and production scheduling agents. LiteFlow orchestration completes the entire collaborative process of data acquisition, simulation, and solution verification, ultimately outputting optimal parameter adjustment suggestions and scheduling arrangements through dialogue. In industrial supply chain collaboration scenarios, procurement personnel can initiate inventory warnings and replenishment requests via dialogue. The system then links inventory management, supplier integration, and production planning agents to complete multi-task collaboration, including inventory verification, supplier capacity confirmation, and production plan matching. It automatically generates and provides feedback on replenishment plans and can also directly trigger the replenishment process on the low-code platform. This invention has wide applications in industrial fields such as discrete manufacturing, process industry, and intelligent operation and maintenance.

[0023] The main problem this invention aims to solve is the pain points in the multi-agent dialogue execution process of industrial low-code platforms, such as the difficulty in converting user natural language commands, low accuracy in matching tasks with agents, rigid multi-agent collaborative execution processes, and the lack of exception handling mechanisms. The core objective is to build a system that can accurately parse the natural language requirements of industrial scenarios, dynamically match the optimal agent, flexibly orchestrate the execution process, and efficiently coordinate multiple agents to complete complex tasks, while reducing the technical threshold for industrial users to use low-code platforms.

[0024] The core idea of ​​this invention is to combine the dynamic task routing capabilities of Function Calling with the collaborative orchestration capabilities of the LiteFlow rule engine to create a multi-agent dialogue execution closed-loop system for an industrial low-code platform. Specifically, the industrial business requirements are first broken down into atomic tasks such as data querying and model prediction. A standard Function Calling interface is defined for each task and managed in a unified registry center, forming an agent capability library. Next, a large language model is used to parse user natural language commands into structured task descriptions. Then, based on semantic similarity and business rules, the optimal agent or function is dynamically matched to form a preliminary task execution link. Then, LiteFlow is used to transform the link into a visual, nestable execution flow, defining task dependencies, conditional branches, and exception handling logic. Finally, the multi-agent collaborative execution is driven, and the integrated results are fed back to the user in natural language or structured reports. Its highlight lies in achieving full-link connectivity of standardized interface management, dynamic intelligent matching, flexible process orchestration, and reliable collaborative execution.

[0025] Addressing the first type of traditional fixed-route multi-agent system in existing technologies, this invention utilizes dynamic semantic matching via FunctionCalling. This eliminates the need for hard coding, allowing new agents to simply register their interfaces. The matching accuracy, combined with the semantic understanding of a large language model, better meets the real needs of users.

[0026] In response to the second type of process orchestration system based on a single rule engine in the prior art, this invention first transforms natural language into structured tasks through a large language model, and then uses LiteFlow to realize visualized and dynamically adjustable process orchestration, supporting complex logic such as conditional branches and loop retries, and adapting to the diverse needs of industrial scenarios.

[0027] This patent addresses the third type of intelligent agent collaborative system driven by a pure large language model in existing technologies. It uses the LiteFlow engine to manage the execution process, monitor the status in real time, handle branches and exceptions, and visualize the execution logic, thereby improving the reliability and traceability of task execution.

[0028] In response to the fourth type of distributed agent invocation system in the prior art, this invention manages the standard interfaces of all agents through a unified function registration center, ensuring the standardization of data transmission and improving the efficiency and stability of multi-agent collaboration.

[0029] When using the multi-agent dialogue execution method and system for an industrial low-code platform based on Function Calling task routing and LiteFlow collaborative orchestration disclosed in this invention, industrial users do not need to master complex coding or process configuration skills. They can raise complex industrial needs such as capacity forecasting, process approval, and data query using only natural language. The system can accurately parse instructions and match the optimal agent, with task matching accuracy improved by more than 40% compared to traditional methods. Process orchestration can be flexibly adjusted according to business needs, supporting complex logic such as parallelism and branching, and adapting to the changing needs of different industrial scenarios. During multi-agent collaborative execution, the LiteFlow engine monitors the status in real time, reducing the response time for exception handling by 60% and ensuring the reliability of task execution. At the same time, the unified function registry center reduces the access and maintenance costs of agents, and the intelligence level and business processing efficiency of the industrial low-code platform are greatly improved. It can be widely used in intelligent manufacturing, industrial supply chain management, factory operation and maintenance, and other scenarios, helping to realize the implementation of industrial digital transformation.

[0030] First embodiment: Figure 1 This is a flowchart of a multi-agent dialogue execution method for an industrial low-code platform based on Function Calling task routing and LiteFlow co-orchestration, according to an embodiment of the present invention. Figure 1 As shown, the multi-agent dialogue execution method for industrial low-code platforms based on FunctionCalling task routing and LiteFlow co-orchestration provided by this invention includes the following steps: S1: Design and register multi-agent function functions: Decompose the business requirements of the industrial low-code platform into atomic tasks, define a standard Function Calling interface for each atomic task, clarify the input parameters, output format and function description, and register and manage these multi-agent function functions in a unified function registry center to form an agent capability library; S2: Receive and parse user natural language instructions: Receive industrial operation requests in the form of user natural language through the dialogue interface, use a large language model to perform semantic understanding, intent recognition, task decomposition and entity parameter extraction on the instructions, and transform fuzzy requirements into structured task descriptions. S3: Dynamic task routing and agent matching based on Function Calling: The structured task description is matched with the registered functions in the function registry. By calculating semantic similarity and combining it with predefined business rules, the optimal agent or function to execute the sub-task is dynamically decided, forming a preliminary task execution link. S4: Use the LiteFlow rule engine for collaborative process orchestration: Transform the initial task execution chain into LiteFlow-recognizable process rules, and orchestrate them into a visual, nestable execution flowchart based on task dependencies, data flow and business logic, supporting conditional branches and loop retries; S5: Drive multi-agent collaborative execution and result integration and feedback: Load and execute LiteFlow orchestrated process instances, call the corresponding Function Calling according to rules to drive agents to execute tasks, pass context data, monitor execution status and handle branches, loops and exceptions, and finally integrate the execution results of each agent and provide feedback to the user in natural language or structured reports.

[0031] In one embodiment of the present invention, optionally, the specific implementation of designing and registering multi-agent function functions in step S1 is as follows: Domain-driven design is used to model business requirements, extracting common business capability units of core subdomains and decomposing them into indivisible sets of atomic tasks; standardized function functions are defined for each atomic task, specifying the dimensions and data type constraints of the input parameter space, and using structured JSON Schema to define the output space format; metadata including function description, calling permissions, and QoS indicators are set for the function, where QoS indicators cover maximum latency, success rate threshold, and resource consumption coefficient; the function registration center adopts a distributed key-value storage mechanism to generate a unique identifier for each function, generates a signature matrix through local sensitive hashing to achieve efficient retrieval of similar functions, performs strong type validation and interface conflict detection, and supports semantic version management and blue-green deployment.

[0032] In one embodiment of the present invention, optionally, the specific implementation of receiving and parsing the user's natural language instructions in step S2 is as follows: preprocessing the natural language instructions input by the user, removing irrelevant characters and noise, and standardizing the encoding; inputting the preprocessed instructions into a large language model based on the Transformer architecture, performing semantic understanding through a multi-head self-attention mechanism, and using an intent classification model to calculate the intent probability distribution of the input sequence to achieve intent recognition; mapping the original instructions into a sub-task sequence by maximizing conditional probability combined with a beam search algorithm; running the named entity recognition component in parallel, using a conditional random field to process label dependencies and locate key parameters; and finally outputting the parsing result as a structured JSON object containing intent, a list of sub-tasks, and entity-parameter pairs, using a lightweight serialization protocol to reduce transmission latency.

[0033] In one embodiment of the present invention, optionally, in step S3, the specific implementation of dynamic task routing and agent matching based on Function Calling is as follows: the metadata of the function registration center is loaded into the in-memory database, and the matching calculation of all registered functions is initiated in parallel using a multi-threaded framework; the embedding vectors of task description and function function description are generated through a pre-trained Sentence-BERT model, and the cosine similarity is calculated as the basic confidence score; the rule score is generated by combining the function priority weight, resource availability flag, and execution history success rate in the predefined business rules, and the comprehensive matching score is obtained by linearly combining the basic confidence score and the rule score; the candidate functions are sorted in descending order of comprehensive score using a fast selection algorithm, and low-scoring items are filtered based on the confidence threshold and the Top-k functions are retained to form a task execution link. This method improves the task matching accuracy by more than 40% and the system throughput by more than 30% compared with the traditional method.

[0034] In one embodiment of the present invention, optionally, in step S4, the specific implementation of process collaborative orchestration using the LiteFlow rule engine is as follows: the task execution chain is modeled as a directed graph containing task nodes and dependent edges, where the edges represent the sequential execution relationship between tasks; the directed graph is converted into a rule file in XML or JSON format supported by LiteFlow, and the rules are implemented using the `` tag. <then> `、` <parallel> `、` <for>Define serial execution, parallel branching, and loop retry logic, and define exception handling branches through conditional expressions; achieve visual orchestration through the LiteFlow designer, support drag-and-drop adjustment of the process structure, realize flexible assembly and decoupling of task execution logic, and shorten the exception handling response time by 60% compared with traditional methods.

[0035] In one embodiment of the present invention, optionally, in step S5, the specific implementation of driving multi-agent collaborative execution and result integration feedback is as follows: loading a LiteFlow process instance and initializing a context object to store input data and global variables; the LiteFlow engine synchronously or asynchronously calls the Function Calling interface according to orchestration rules, and transmits context data through memory sharing or a distributed message queue; monitoring the task execution status in real time, handling state changes through a state transition function, handling branch logic based on conditional expressions, controlling loop retries through an iteration counter, and triggering up to 3 automatic retries when the task fails; integrating the output results of each agent using a weighted average method based on historical confidence, converting the results into natural language reports or structured JSON through a template engine, feeding them back to the user through a dialogue interface, and recording execution logs.

[0036] This invention also provides an industrial low-code platform multi-agent dialogue execution system based on Function Calling task routing and LiteFlow collaborative orchestration, comprising: Function Registry Module: Used to receive and manage standardized multi-agent function functions, providing distributed storage, signature retrieval, version management and interface verification capabilities; Instruction parsing module: Used to receive user natural language instructions, complete semantic understanding, intent recognition, task decomposition and entity parameter extraction through a large language model, and output a structured task description; Task routing module: Used to perform parallel matching of structured task descriptions with functions in the function registry, and generate the optimal task execution link by combining semantic similarity and business rules; Workflow orchestration module: Used to transform task execution links into LiteFlow-recognizable workflow rules, enabling visual and nestable workflow orchestration, and supporting complex business logic definitions; Collaborative Execution Module: Used to load LiteFlow process instances, drive multi-agent collaborative task execution, monitor execution status, handle exceptions, and integrate execution results to provide feedback to the user.

[0037] In one embodiment of the present invention, optionally, the function registration center module adopts a distributed key-value storage architecture, generates a signature matrix through locality-sensitive hashing to achieve efficient retrieval of similar functions, performs strong type validation to ensure that input and output meet constraints, supports semantic version management and blue-green deployment, and new agents only need to register the interface to take effect without modifying the core code, which greatly reduces the system maintenance cost.

[0038] In one embodiment of the present invention, optionally, the instruction parsing module adopts an end-to-end large language model processing mechanism, which integrates intent classification, task decomposition and entity extraction capabilities, avoids manual rule definition, significantly improves the generalization ability of industrial terms, and reduces the instruction parsing error rate by more than 30% compared with traditional methods.

[0039] In one embodiment of the present invention, optionally, the task routing module adopts a multi-threaded parallel matching mechanism, combines semantic similarity calculation and business rule weighted scoring to generate a comprehensive matching result, and achieves efficient sorting and filtering through a fast selection algorithm, effectively avoiding the deviation of pure semantic matching, and reducing the task mismatch rate by more than 20% compared with traditional methods.

[0040] Second embodiment: The present invention provides a multi-agent dialogue execution method for industrial low-code platforms based on Function Calling task routing and LiteFlow collaborative orchestration, which includes the following steps:

Step 1

[0041] Each atomic task Corresponding to a standardized function Its mathematical form is defined as: .in To represent the input parameter space, its dimensions must be explicitly defined. and data type constraints, for example ( (For string fields). The output space uses a structured JSON Schema definition format, including field names, types, and semantic descriptions. Function metadata. Includes function description Access permissions and QoS metrics ,in It can be quantified as:

[0042] For maximum delay, As the success rate threshold, This represents the resource consumption coefficient. This explicit interface definition significantly improves interoperability between agents.

[0043] Implement a registration mechanism based on distributed key-value storage in the function registry center. Each function generates a unique function identifier.

[0044] Registration records are stored as tuples:

[0045] The signature matrix is ​​as follows:

[0046] Row vectors are generated using locality-sensitive hashing. satisfy:

[0047] Number of bits in the hash table The number of hash tables is limited to ensure efficient retrieval of similar functions. Strong type checking is performed during the registration process to verify that inputs and outputs satisfy certain conditions. Type constraints and interface conflict detection:

[0048] The registry center provides version management capabilities, supports blue-green deployment during function updates, and version numbers follow semantic rules:

[0049] This design enables the system to dynamically expand, and newly added functions can take effect immediately upon registration without requiring reconstruction of the task routing layer, thus reducing system maintenance costs.

[0050] [Step 2]: Receive and parse user natural language instructions. The system receives industrial operation requests from users in natural language form through a dialogue interface, such as "predict the production capacity of workshop A next quarter and generate a report." Using an integrated large language model, the system performs semantic understanding and intent recognition on the instructions, breaking them down into one or more specific sub-tasks and initially extracting key entities and parameters. The purpose of parsing is to transform vague user requirements into structured task descriptions that can be processed by the system. The specific implementation method of this step is as follows: The system receives natural language commands from users in real time via an industrial-grade dialogue interface (such as an HTTP endpoint based on a RESTful API or WebSocket). The input text first passes through a preprocessing module to remove irrelevant characters and noise, ensuring data cleanliness; for example, regular expressions are used to filter non-text elements, and the text is standardized to UTF-8 encoding. The preprocessed commands are then fed into an integrated large language model (LLM), such as a pre-trained model based on the Transformer architecture (e.g., GPT-4 or BERT variants), which processes sequential input through a multi-head self-attention mechanism. The semantic understanding stage employs an intent classification model to compute the input sequence. Intent probability distribution: ,in Indicates the category of intent (such as "capacity forecast" or "report generation"). It is the input sequence The context embedding vector (obtained from the output of the last layer of the model). This is the classification weight matrix. The formula normalizes the probabilities using the softmax function, ensuring robustness in intent recognition; parameters... Dimensions ( (This refers to the embedding dimension, typically 768 or 1024). Dimensions ( (This refers to the number of intent categories). This end-to-end processing avoids manual rule definition, significantly improves the generalization ability to industry terminology, and reduces the parsing error rate by up to 30%. After intent recognition, the model performs task decomposition, mapping the original instruction into a sequence of subtasks. This is achieved by maximizing conditional probability: ,in Generated by an LLM decoder, sequence probabilities are optimized using a beam search algorithm. The entity extraction module runs in parallel, using a Named Entity Recognition (NER) component to locate key parameters for each text segment. Calculate entity label probability ,in For entity types (such as "workshop name" or "time range"), It is a fragment embedding. This is the NER weight matrix, and the CRF (Conditional Random Field) layer handles label dependencies. Finally, the parsed result is output as a structured JSON object, containing the intent, a list of subtasks, and entity-parameter pairs (e.g., {"intent": "predict_capacity", "subtasks": ["query_data", "generate_report"], "entities":{"workshop": "A", "timeframe": "next_quarter"}}), facilitating downstream system processing. The structured output uses a lightweight serialization protocol (such as MessagePack) to reduce transmission latency and ensure real-time requirements in industrial applications.

[0051] [Step 3]: Dynamic task routing and agent matching based on Function Calling. The system matches the structured task description parsed in the previous step with all registered Function Callings in the function registry. By calculating the semantic similarity between the task description and the functional descriptions of each function, and combining this with predefined business rules, the system dynamically decides which agent or function is most suitable to execute the subtask. This step is not a simple sequential matching; it may involve parallel matching of multiple candidate functions, sorting and selecting them based on confidence levels to form a preliminary task execution chain. The specific implementation method of this step is as follows: The system first loads all registered Function Calling metadata from the function registry, including function name, function description text, input / output parameter definitions, and associated agent identifiers. This metadata is stored in an in-memory database such as Redis, supporting fast parallel access. Task Description Generated from the previous step, it is represented as a structured JSON object, containing the task type, target parameters, and context constraints. The system uses a multi-threaded framework, such as Python's `concurrent.futures` module, to initiate all registered functions in parallel. The matching computation avoids serial bottlenecks and significantly reduces overall latency, which can improve throughput by more than 30% in distributed systems. Description of the computation task for each matching process. Function description Semantic similarity is calculated using pre-trained embedding models such as Sentence-BERT to obtain vector representations. Specifically, task embedding vectors... The function describes the embedding vector Generated through model inference, with dimensions of [missing information]. Then, the cosine similarity is calculated as the base confidence score:

[0052] in and The embedding vectors represent the task and function descriptions, respectively. The dot product operation captures the semantic alignment, and norm normalization ensures that the scores are within the range of... Within this range, this embedding-based similarity calculation can effectively handle natural language variations and improve matching robustness.

[0053] Next, the system dynamically adjusts the confidence level based on predefined business rules. The rule base is stored in a YAML configuration file, including function priority weights. Resource availability indicator and historical success rate The rules engine parses task constraints, such as real-time requirements or hardware limitations, for each function. Generate rule scores The result is a weighted sum:

[0054] in It is a priority coefficient. This is a binary value representing resource availability. Normalizing the historical success rate to Overall score Generated via linear combination:

[0055] in and It is an adjustable hyperparameter, with default values ​​of 0.7 and 0.3 to balance semantic and business factors. This weighted mechanism avoids the bias of pure semantic matching and ensures that decisions are more reliable in a changing environment.

[0056] All candidate functions are ordered as follows Sort in descending order using the quick selection algorithm. Time complexity. The system is based on a confidence threshold. Low-scoring items are filtered out, and the top-k functions (k=3) are retained as the initial execution path. The output is an ordered list, with each entry containing a function identifier, agent reference, and score. This parallel matching and rule fusion method not only accelerates the routing process but also optimizes task allocation accuracy through semantic-rule collaboration, reducing the false match rate by up to 20%. The final path data is encapsulated in a JSON structure and passed to the next execution step.

[0057] [Step 4]: Perform collaborative orchestration of the process using the LiteFlow rule engine. The task execution chain generated in Step 3 (which may involve multiple parallel or serial agent calls) is transformed into LiteFlow-recognizable process rules. Based on the dependencies between tasks, data flow, and business logic (such as conditional branches and loop retries), a visual, nestable execution flowchart is orchestrated in LiteFlow. For example, it can be set to "first call the data query agent; if successful, trigger the prediction agent; otherwise, execute the exception handling branch." This step enables flexible assembly and decoupling of execution logic. The specific implementation method of this step is as follows: First, the task execution chain generated in the third step is analyzed. This chain consists of a sequence of agent calls and is represented as a set of tasks. ,in Corresponding to an instance of an intelligent agent, such as This is a data query agent. Dependency relationships are modeled as a directed graph. Vertex set edge set Include express Must Execution before, for example This indicates that prediction is triggered only after a successful query. Data flow is determined via context variables. Management, such as Store the query results and pass them to subsequent tasks. LiteFlow rules are defined using XML or JSON format, and the graph... Convert to a rule file, where the node mapping is ` <node>` element, edge mapped to` <chain>`Logic, supports parallel branching` <parallel>`and serial sequence` <then>For example, for conditional branches, define a conditional expression: if Then execute Otherwise execute ,in For task status variables,

[0058] Business logic such as loop retries passes. <for>Implemented using a loop structure, setting the maximum number of retries. and retry interval Formulated as ,when and Retry And update This avoids hard coding and improves fault tolerance. Visual orchestration is done in the LiteFlow designer; after importing the rule file, nested flowcharts are automatically generated and can be dragged and dropped for adjustment. For example, when a data query task fails, the exception handling branch can nest sub-processes, such as logging or alarm calls. The beneficial effects are reflected in the mathematical representation of the dependency graph. This makes the process logic visible and dynamically modifiable, achieving component decoupling. For example, the formulaic definition of conditional branches reduces code redundancy and improves system maintainability and scalability. Finally, the rule file is deployed to the LiteFlow engine for execution, ensuring tasks run in the orchestrated order, and data is processed through... Variables flow seamlessly.

[0059]

Step 5

[0060] According to the orchestration rules, the LiteFlow engine dynamically invokes the Function Calling interface, with each call corresponding to an API endpoint of an agent or service. The invocation pattern supports synchronous or asynchronous execution; for example, asynchronous calls can be used for independent tasks to improve concurrency efficiency. The engine passes context. Necessary data, such as input parameters And trigger the agent to execute a specific task, the task output. Captured and updated to Data transfer is achieved through shared memory or distributed message queues (such as Kafka), ensuring low latency and high reliability.

[0061] The LiteFlow engine monitors execution status in real time and defines status variables. ,in Indicates a time step.

[0062] The state transition function is ,here It is the current action (such as the result of a function call). This is the state transition logic. When processing a branch, the engine evaluates the conditional expression, such as... Execute branch A else branch B, where It is a threshold variable within the context. The loop logic uses an iteration counter. Control, when The task is executed repeatedly. Exception handling includes automatic rollback or retry mechanisms, such as status updates. The retry function is triggered at certain times, with a maximum number of retries. To enhance robustness.

[0063] After execution, the system summarizes the outputs of all agents. The final result is generated using an integration function. The integration employs a weighted average:

[0064] in It is the number of intelligent agents. It is the first The output of each agent The weights are based on historical confidence levels. , (This refers to the confidence score). This weighting method prioritizes highly reliable agents, significantly improving result accuracy and reducing the impact of noise. After integration, the system is transformed. Populate dynamic content for natural language reports or structured JSON using a template engine such as Freemarker.

[0065] The final report is fed back to the user via a dialog interface (such as a REST API or WebSocket). The interface encapsulates the response data and handles timeout mechanisms to ensure the integrity of the interaction. The engine records execution logs for auditing, completing the closed loop.

[0066] Those skilled in the art will understand that the accompanying drawings are merely schematic diagrams of one embodiment, and the modules or processes shown in the drawings are not necessarily essential for implementing the present invention.

[0067] Those skilled in the art will understand that the modules in the apparatus of the embodiments can be distributed in the apparatus of the embodiments as described in the embodiments, or they can be located in one or more devices different from this embodiment with corresponding changes. The modules of the above embodiments can be combined into one module, or they can be further divided into multiple sub-modules.

[0068] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.< / for> < / then> < / parallel> < / chain> < / node> < / for> < / parallel> < / then> < / for> < / parallel> < / then>

Claims

1. A multi-agent dialogue execution method for an industrial low-code platform based on Function Calling task routing and LiteFlow collaborative orchestration, characterized in that, Includes the following steps: S1: Design and register multi-agent function functions: Decompose the business requirements of the industrial low-code platform into atomic tasks, define a standard Function Calling interface for each atomic task, clarify the input parameters, output format and function description, and register and manage these multi-agent function functions in a unified function registry center to form an agent capability library; S2: Receive and parse user natural language instructions: Receive industrial operation requests in the form of user natural language through the dialogue interface, use a large language model to perform semantic understanding, intent recognition, task decomposition and entity parameter extraction on the instructions, and transform fuzzy requirements into structured task descriptions. S3: Dynamic task routing and agent matching based on Function Calling: The structured task description is matched with the registered functions in the function registry. By calculating semantic similarity and combining it with predefined business rules, the optimal agent or function to execute the sub-task is dynamically decided, forming a preliminary task execution link. S4: Use the LiteFlow rule engine for collaborative process orchestration: Transform the initial task execution chain into LiteFlow-recognizable process rules, and orchestrate them into a visual, nestable execution flowchart based on task dependencies, data flow and business logic, supporting conditional branches and loop retries; S5: Drive multi-agent collaborative execution and result integration and feedback: Load and execute LiteFlow orchestrated process instances, call the corresponding Function Calling according to rules to drive agents to execute tasks, pass context data, monitor execution status and handle branches, loops and exceptions, and finally integrate the execution results of each agent and provide feedback to the user in natural language or structured reports.

2. The method according to claim 1, characterized in that, In step S1, the specific implementation of designing and registering multi-agent function functions is as follows: Domain-driven design is used to model business requirements, extracting common business capability units from core subdomains and decomposing them into indivisible sets of atomic tasks; standardized function functions are defined for each atomic task, specifying the dimensions and data type constraints of the input parameter space, and using structured JSON Schema to define the output space format; metadata including function description, calling permissions, and QoS metrics are set for the function, where QoS metrics cover maximum latency, success rate threshold, and resource consumption coefficient; the function registration center adopts a distributed key-value storage mechanism, generating a unique identifier for each function, generating a signature matrix through local sensitive hashing to achieve efficient retrieval of similar functions, performing strong type validation and interface conflict detection, and supporting semantic version management and blue-green deployment.

3. The method according to claim 1, characterized in that, In step S2, the specific implementation of receiving and parsing the user's natural language instructions is as follows: The user's input natural language instructions are preprocessed, irrelevant characters and noise are removed, and the encoding is standardized; the preprocessed instructions are input into a large language model based on the Transformer architecture, and semantic understanding is performed through a multi-head self-attention mechanism; the intent classification model is used to calculate the intent probability distribution of the input sequence to achieve intent recognition; the original instructions are mapped into a sub-task sequence by maximizing conditional probability combined with a beam search algorithm; the named entity recognition component is run in parallel, and a conditional random field is used to process label dependencies to locate key parameters; finally, the parsing result is output as a structured JSON object containing intent, a list of sub-tasks, and entity-parameter pairs, and a lightweight serialization protocol is used to reduce transmission latency.

4. The method according to claim 1, characterized in that, In step S3, the specific implementation of dynamic task routing and agent matching based on Function Calling is as follows: the metadata of the function registry center is loaded into the in-memory database, and the matching calculation of all registered functions is initiated in parallel using a multi-threaded framework; the embedding vectors of task description and function function description are generated through a pre-trained Sentence-BERT model, and the cosine similarity is calculated as the basic confidence score; the rule score is generated by combining the function priority weight, resource availability flag, and execution history success rate in the predefined business rules, and the comprehensive matching score is obtained by linearly combining the basic confidence score and the rule score; the candidate functions are sorted in descending order of comprehensive score using a fast selection algorithm, and low-scoring items are filtered based on the confidence threshold, while the top-k functions are retained to form the task execution link.

5. The method according to claim 1, characterized in that, In step S4, the specific implementation of workflow collaborative orchestration using the LiteFlow rule engine is as follows: The task execution chain is modeled as a directed graph containing task nodes and dependent edges, where edges represent the sequential execution relationship between tasks; the directed graph is converted into a rule file in XML or JSON format supported by LiteFlow, using the `` tag... <then> `、` <parallel> `、` <for> Define the logic for serial execution, parallel branching, and loop retrying; define exception handling branches using conditional expressions.< / for> < / parallel> < / then> The LiteFlow designer enables visual orchestration and supports drag-and-drop adjustments to the process structure.

6. The method according to claim 1, characterized in that, In step S5, the specific implementation method for driving multi-agent collaborative execution and result integration feedback is as follows: load the LiteFlow process instance and initialize the context object to store input data and global variables; the LiteFlow engine synchronously or asynchronously calls the Function Calling interface according to the orchestration rules, and transmits context data through memory sharing or distributed message queues; The system monitors task execution status in real time, handles state changes through state transition functions, processes branch logic based on conditional expressions, controls loop retries through an iteration counter, and triggers up to 3 automatic retries when a task fails. It integrates the output results of each agent using a weighted average method based on historical confidence, converts the results into natural language reports or structured JSON through a template engine, provides feedback to the user through a dialogue interface, and records execution logs.

7. An industrial low-code platform multi-agent dialogue execution system based on Function Calling task routing and LiteFlow collaborative orchestration, characterized in that, include: Function Registry Module: Used to receive and manage standardized multi-agent function functions, providing distributed storage, signature retrieval, version management and interface verification capabilities; Instruction parsing module: Used to receive user natural language instructions, complete semantic understanding, intent recognition, task decomposition and entity parameter extraction through a large language model, and output a structured task description; Task routing module: Used to perform parallel matching of structured task descriptions with functions in the function registry, and generate the optimal task execution link by combining semantic similarity and business rules; Workflow orchestration module: Used to transform task execution links into LiteFlow-recognizable workflow rules, enabling visual and nestable workflow orchestration, and supporting complex business logic definitions; Collaborative Execution Module: Used to load LiteFlow process instances, drive multi-agent collaborative task execution, monitor execution status, handle exceptions, and integrate execution results to provide feedback to the user.

8. The system according to claim 7, characterized in that, The function registry module adopts a distributed key-value storage architecture. It generates a signature matrix through locality-sensitive hashing to achieve efficient retrieval of similar functions, performs strong type validation to ensure that input and output meet constraints, supports semantic version management and blue-green deployment, and adds new agents only needs to register the interface to take effect without modifying the core code.

9. The system according to claim 7, characterized in that, The instruction parsing module adopts an end-to-end large language model processing mechanism, which integrates intent classification, task decomposition and entity extraction capabilities to avoid manual rule definition.

10. The system according to claim 7, characterized in that, The task routing module adopts a multi-threaded parallel matching mechanism, combining semantic similarity calculation and business rule weighted scoring to generate comprehensive matching results, and achieves efficient sorting and filtering through a fast selection algorithm.