A large language model MCP-enabled RPA business automation method

Abstract

The application relates to the technical field of process automation, in particular to an RPA business automation method enabled by a large language model MCP. The method comprises the following steps: acquiring user input data, and performing intent understanding on the user input data through a multi-round intent recognition model to obtain semantic instruction data; performing standard semantic protocol conversion according to the semantic instruction data to obtain standard semantic protocol data; performing flowchart node matching according to the standard semantic protocol data to obtain flowchart node data; and generating a business process according to the flowchart node data to obtain business process data. Through the fusion of the multi-round intent recognition capability of the large language model and the standard semantic protocol conversion, the application realizes accurate mapping from natural language to a business process, and improves the intelligent level and user friendliness of the RPA system. Through process node matching and process logic checking, the execution effectiveness of the automatically generated process is ensured, and the manual cost and configuration errors are reduced.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of process automation, and in particular to an RPA business automation method enabled by a large language model MCP. BACKGROUND

[0002] With the deepening of enterprise digital transformation, RPA (robotic process automation) as an important means to improve business processing efficiency has been widely used in finance, personnel, customer service and other business scenarios. However, traditional RPA process construction relies on manual modeling, process analysis and script writing, which has problems such as long process online cycle, poor adaptation ability, weak interaction understanding ability, etc. Especially when facing complex, ambiguous or multi-round human-computer interaction instructions, the traditional method is difficult to effectively analyze user intent and generate standard process templates. In recent years, with the rapid development of large language models (such as GPT, GLM, MCP, etc.), they have shown excellent performance in natural language understanding, context maintenance, multi-round dialogue modeling, etc. Introducing large language models into RPA systems can give them intelligent dialogue analysis-intent modeling-process automatic generation functions, allowing non-professional users to generate standardized business processes through natural language instructions, greatly reducing the threshold of process automation. However, when there are many process nodes corresponding to the input instructions, it is easy to have unclear business process requirements. SUMMARY

[0003] To solve the above technical problems, the present application provides an RPA business automation method enabled by a large language model MCP to solve at least one of the above technical problems.

[0004] The present application provides an RPA business automation method enabled by a large language model MCP, which comprises:

[0005] S1, obtaining user input data and performing intent understanding through a multi-round intent recognition model according to the user input data to obtain semantic instruction data;

[0006] S2, performing standard semantic protocol conversion according to the semantic instruction data to obtain standard semantic protocol data;

[0007] S3, performing process graph node matching according to the standard semantic protocol data to obtain process graph node data;

[0008] S4, generating a business process according to the process graph node data to obtain business process data.

[0009] In the application, by introducing the multi-round intention recognition model in step S1, the complex semantics and context relationship in the user input can be deeply understood, and the accuracy and continuity of intention recognition are improved; in step S2, the natural language instruction is mapped to a unified intermediate expression format through standard semantic protocol conversion, and the compatibility of different business systems is enhanced; in step S3, the accurate mapping of the semantic protocol to the process node is realized, and the flexible matching and reuse of the process template are supported; in step S4, the system automatically generates an executable flowchart according to the structured node information, effectively simplifying the RPA process design and deployment process, and significantly improving the process automation configuration efficiency and intelligent level.

[0010] Optionally, the construction step of the multi-round intention recognition model comprises:

[0011] S11, historical user input data and historical user intention data are acquired;

[0012] S12, dialogue state extraction and entity data extraction are performed according to the historical user input data, and dialogue state data and entity data are obtained respectively;

[0013] S13, main intention recognition and sub-intention recognition are performed according to the dialogue state data, the entity data and the historical user intention data, and main intention data and sub-intention data are obtained;

[0014] S14, multi-round semantic coordination is performed according to the main intention data and the sub-intention data, and cross-round intention fusion data is obtained;

[0015] S15, a semantic instruction conversion layer is added according to the cross-round intention fusion data, and a multi-round intention recognition model is obtained.

[0016] In the application, by acquiring historical user input data and historical user intention data, user behavior trajectory can be introduced as the context basis for semantic recognition, and the context understanding ability of the model is improved; the dialogue state extraction and entity data extraction module can accurately capture key elements such as time, object and operation type in user expression, and provide structured support for intention analysis; the main intention and sub-intention recognition mechanism realizes hierarchical analysis of complex tasks, and enhances the perception ability of the model to multi-task parallel or nested semantics; the multi-round semantic coordination processing can perform semantic fusion and ambiguity correction on cross-round input, and improve the overall interaction continuity; the addition of the semantic instruction conversion layer ensures that the output has a unified format, which is convenient for the docking of the process execution system.

[0017] Optionally, the main intention recognition comprises:

[0018] According to the dialogue state data, the entity data and the historical user intention data, a semantic fusion vector is generated, and semantic fusion vector data is obtained;

[0019] Contextual gating processing is performed on the semantic fusion vector data to obtain semantic context data.

[0020] A main intention prediction graph is constructed for the semantic context data to obtain main attention prediction graph data.

[0021] The main intention prediction graph data is matched with the semantic fusion vector data to obtain main intention matching data.

[0022] The main intention matching data is subjected to main intention confidence adjustment to obtain main intention data.

[0023] In the present application, semantic fusion vectors are generated by fusing dialogue state data, entity information and historical intention trajectories, which can realize deep modeling of current user input and context, effectively improving the accuracy and robustness of intention recognition. Contextual gating processing can weight and filter historical context information through a dynamic adjustment unit, avoiding irrelevant information interference in current judgment. The construction of the main intention prediction graph enables the system to have structured reasoning ability and construct high-order associations in the intention label space. Combined with the fusion vector and the prediction graph, matching is performed to support fuzzy intention analysis and path consistency judgment. The main intention confidence adjustment improves the reliability and explainability of the output.

[0024] Optionally, the contextual gating processing comprises:

[0025] Contextual gating unit processing and attention gating unit processing are performed on the semantic fusion vector data to obtain contextual gating unit data and attention gating unit data, respectively.

[0026] Round gating adjustment and theme classification adjustment are performed on the semantic fusion vector data according to the contextual gating unit data and the attention gating unit data to obtain round gating data and theme classification data, respectively.

[0027] Similarity fitting is performed according to the round gating data and the theme classification data to obtain gating fitting data.

[0028] Trajectory average processing is performed on the round gating data and the theme classification data according to the gating fitting data to obtain semantic context data.

[0029] By introducing the context gating unit and the attention gating unit, the weight of historical information in the current semantic judgment can be dynamically adjusted from the time level and the semantic attention angle respectively, so as to effectively cope with the semantic drift and topic jump problems in multi-round dialogue; the round gating adjustment can identify the intention residue or intention fracture in cross-round dialogue, and improve the consistency of the dialogue chain; the topic classification adjustment is helpful to identify the core topic currently concerned by the user, and realizes fine analysis of the multi-intention parallel scene; the similarity fitting mechanism structures the gating output into a fusion index, so that the model has quantitative judgment ability on the context continuity; the trajectory average processing realizes fusion balance between different semantic channels, generates stable and reliable semantic context data, which is helpful to improve the accuracy of downstream intention prediction and the ability to resist ambiguous input, and enhances the practicability and stability of the system in different dialogue tasks.

[0030] Optionally, wherein the sub-intention data includes first sub-intention data and second sub-intention data, the sub-intention identification includes:

[0031] Context encoding is performed according to the semantic fusion vector data, to obtain context encoding data;

[0032] Global semantic query vector generation is performed on the context encoding data, to obtain global semantic query vector data;

[0033] Pointer start-end position calculation is performed on the global semantic query vector data, to obtain pointer start-end position data;

[0034] Probability mapping is performed according to the pointer start-end position data, to obtain start-end position probability data;

[0035] Sub-intention picture segment generation is performed according to the start-end position probability data, to obtain the first sub-intention data;

[0036] Hierarchical node matching is performed according to the semantic fusion vector data and a preset intention library, to obtain hierarchical node data;

[0037] Routing attention calculation is performed on the hierarchical node data, to obtain the second sub-intention data.

[0038] In the application, by introducing context encoding, the system can perform local and global semantic enhancement on the semantic fusion vector, effectively preserving the temporal dependence and context information; the generation of the global semantic query vector enables the model to accurately capture the key fragments related to the sub-task from the overall semantics, improving the robustness of fragment positioning; the pointer start and end position calculation combined with probability mapping realizes high-precision labeling of the sub-intention range, which can flexibly cope with multi-intention nested scenarios; sub-intention picture generation structures the recognition results for output, facilitating process calling and visual display; combined with the preset intention library for hierarchical node matching and routing attention calculation, not only the structural relevance of sub-intention recognition is enhanced, but also the potential intention structure across semantic levels can be effectively identified.

[0039] Optionally, the routing attention calculation comprises:

[0040] Perform semantic compression graph representation on the hierarchical node data to obtain semantic compression graph data;

[0041] Perform jump-aware graph convolution on the semantic compression graph data to obtain graph convolution data;

[0042] Perform cross-layer conditional triggering on the graph convolution data to obtain graph cross-layer data;

[0043] Perform self-attention calculation on the graph cross-layer data to obtain second sub-intention data.

[0044] In the application, by performing semantic compression graph representation on the hierarchical node data, the redundancy and computational complexity of the intention graph can be effectively reduced while the key semantic structure is preserved; by using jump-aware graph convolution, the non-continuous dependence relationship between cross-semantic levels can be modeled, thereby improving the understanding ability of the model for long-distance semantic coupling; based on graph convolution, by cross-layer conditional triggering, high-order node paths can be dynamically activated according to specific conditions, realizing flexible selection and response of multi-layer intention structure; by using the self-attention mechanism to focus on aggregating the graph cross-layer data, the semantic accuracy and representation ability of the sub-intention output are improved.

[0045] Optionally, the multi-round semantic collaboration comprises:

[0046] Annotate the main intention data with sub-intention function roles according to the first sub-intention data and the second sub-intention data to obtain sub-intention annotation data;

[0047] Construct an intention fusion graph according to the sub-intention annotation data to obtain intention fusion graph data;

[0048] Simulate semantic dependence according to the intention fusion graph data to obtain semantic dependence simulation data;

[0049] Perform semantic conflict graph minimum cut on the intention fusion graph data according to the semantic dependence simulation data to obtain cross-round intention fusion data.

[0050] In the present application, by using the first sub-intention data and the second sub-intention data to annotate the main intention with functional roles, the logical attribution and functional positioning of the sub-intention in the overall semantic structure are clarified, and an interpretable semantic identifier is provided for fusion; on this basis, an intention fusion graph is constructed, and the system can uniformly map intention nodes of different semantic levels to a structured graph, facilitating subsequent path planning and relationship modeling; through semantic dependency simulation, the potential logical dependency relationship between intention nodes can be simulated, thereby effectively discovering hidden context semantic constraints; by performing a semantic conflict graph minimum cut operation on the fusion graph, logical conflicts and redundant paths between intentions can be accurately identified and eliminated, realizing stable fusion and unified output across rounds of semantics.

[0051] Optionally, S2 comprises:

[0052] S21, performing semantic instruction slot parsing according to the semantic instruction data to obtain semantic instruction slot data;

[0053] S22, performing protocol semantic template matching according to the semantic instruction slot data to obtain template matching data;

[0054] S23, performing protocol format verification enhancement according to the template matching data to obtain standard semantic protocol data.

[0055] In the present application, by performing slot parsing on semantic instruction data, key parameter elements in user intention can be accurately extracted, such as operation object, action type, condition restriction, etc., providing basic semantic units for structured mapping; then, through protocol semantic template matching, semantic alignment between natural language intention and preset protocol specification is realized, improving the accuracy of semantic conversion and template reuse rate; through protocol format verification enhancement, consistency check and automatic completion are performed in combination with grammar specifications and business rules, ensuring the structural integrity and execution feasibility of the conversion result. The overall process is processed in three steps of slot extraction, semantic alignment and structure verification, which significantly improves the mapping accuracy of semantics to protocol and strengthens the stability and standardization of landing of large language model generated content to process automation system.

[0056] Optionally, S3 comprises:

[0057] performing process node library retrieval according to the standard semantic protocol data to obtain process node retrieval data;

[0058] performing dependency adjustment according to the process node retrieval data to obtain process graph node data.

[0059] In the application, by performing flow node library retrieval on standard semantic protocol data, structured mapping between the semantic layer and the execution layer can be realized, the flow node template meeting the current semantic task requirement can be accurately positioned, and the accuracy and automation degree of task matching can be effectively improved; based on the flow node retrieval data, the dependence relationship is adjusted, the precedence constraint, conditional branching and parallel dependence relationship between nodes can be automatically identified, and the flowchart node structure with logical consistency is constructed, so that logical conflicts or node out-of-order problems in flow execution are avoided.

[0060] Optionally, S4 comprises:

[0061] S41, constructing a flow structure diagram according to the flowchart node data to obtain flow structure diagram data;

[0062] S42, performing node-level dependence processing according to the flow structure diagram data to obtain graph node dependence data;

[0063] S43, performing flowchart logic verification on the graph node dependence data to obtain graph node verification data;

[0064] S44, compiling a business process according to the graph node verification data to obtain business process data.

[0065] In the application, by constructing a flow structure diagram on the flowchart node data, the system can uniformly organize each semantic node in a graphical form, and clearly define the overall topology structure of the flow; by performing node-level dependence processing, the logical relationship such as the front and rear setting, concurrency or conditional jump between task nodes can be automatically established, and the accuracy of the flow execution order is ensured; by flowchart logic verification, the system can detect potential dead loops, logical chain breaks or illegal paths, and improve the safety and stability of the flow; by the flow compilation process, the semantic-driven flowchart is translated into a low-code or machine instruction form that can be executed by an RPA system, and an efficient closed loop from semantic understanding to business execution is realized.

[0066] The application aims to, in step S1, adopt a multi-round intention recognition model, accurately recognize the main intention and nested sub-intention in combination with the current input and historical context of the user, and improve the depth and continuity of semantic analysis; in step S2, the semantic instruction is standardized into a data structure conforming to the MCP protocol, ensuring the mapability and executability between natural language and flow logic, and enhancing the instruction universality; in step S3, based on the standard semantic protocol, the flowchart node matching is performed, not only supporting template-level accurate calling, but also dynamically adjusting the dependence relationship, realizing the automatic configuration of the flowchart node under the semantic driving; in step S4, by constructing a flow structure diagram, verifying dependence and compiling a flow, an RPA flow with strict structure and executability is automatically generated, and the correctness of the flow logic and the adaptability of cross-system deployment are ensured. BRIEF DESCRIPTION OF DRAWINGS

[0067] Other features, objects, and advantages of the application will become more apparent from the following detailed description when read in connection with the following drawings:

[0068] Figure 1 A step flow chart of a large language model MCP enabled RPA business automation method is shown in an embodiment;

[0069] Figure 2 A step flow chart of a multi-turn intent recognition model construction method is shown in an embodiment;

[0070] Figure 3 A step flow chart of a standard semantic protocol conversion method is shown in an embodiment;

[0071] Figure 4 A step flow chart of a business process generation method is shown in an embodiment;

[0072] The implementation, functional features and advantages of the present application will be further described with reference to the embodiments in conjunction with the drawings. DETAILED DESCRIPTION

[0073] The technical method of the present application will be described clearly and completely below in conjunction with the drawings. Obviously, the described embodiments are part of the embodiments of the present application, rather than all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those skilled in the art without creative labor fall within the scope of protection of the present application.

[0074] In addition, the drawings are only schematic illustrations of the present application, and are not necessarily drawn to scale. The functional entities can be implemented in software form, or in one or more hardware modules or integrated circuits, or in different network and / or processor methods and / or microcontroller methods.

[0075] It should be understood that although the terms “first”, “second” and the like can be used herein to describe various elements, these elements should not be limited by these terms. These terms are only used to distinguish one element from another. For example, without departing from the scope of the example embodiments, a first element can be called a second element, and similarly a second element can be called a first element. The term “and / or” as used herein includes any and all combinations of one or more of the associated listed items.

[0076] Referring to Figures 1 to 4 The present application provides a large language model MCP enabled RPA business automation method, which comprises:

[0077] S1, obtain user input data, and perform intent understanding on the user input data through a multi-round intent recognition model to obtain semantic instruction data;

[0078] Specifically, the user input data can include natural language text, speech-to-text data, and mixed text and image data. The input data is represented in a structured format, including but not limited to user identification, timestamp, current input content, and corresponding dialogue context information. The input format can be represented as: {user number, input time, user content, historical dialogue context}. The system performs semantic fusion processing. The system uses a context-aware semantic encoding module to embed and model the input content of the current round, which can include a structure based on a pre-trained language model (such as BERT) combined with a sliding dialogue window mechanism. The system further obtains the historical dialogue round information of the current user, and represents the historical main intent trajectory as a sequence wherein represents the main intent identification of the kth round; and represents the entity trajectory as a sequence wherein represents the key entity extracted in the kth round. The above information is encoded as a sequence of hidden variable semantic vectors. The system performs joint recognition of the main intent and the sub-intent. The main intent recognition is completed through a path matching graph, which is a type of knowledge graph constructed based on prior business process semantic relationships, used to represent the evolution path relationship between different main intents, for example: "export data" can be mapped to the sequence of nodes "generate report", followed by "download file" and the like. The sub-intent recognition is completed through a pointer network mechanism, which can identify the semantic related segment interval in the current input sentence and output one or more nested sub-intents in the current round. For example, when the user initiates a "report export" request, the sub-intents can include "set filtering conditions" and "select export format". The system converts the above recognition results into structured semantic instruction data. The semantic instruction data includes: main intent label, corresponding sub-intent set, semantic slot filling result, and confidence index, etc. The structure is that the main intent is "submit for approval", and the semantic slots are "object: project X" and "role: department supervisor".

[0079] S2, performing standard semantic protocol conversion according to the semantic instruction data to obtain standard semantic protocol data;

[0080] Specifically, the system performs semantic mapping rule library loading. The system pre-constructs a set of mapping relationship tables between user intent and business action based on MCP protocol semantic standards (such as MCPv2.1 version). The mapping relationship is used to convert semantic instructions in natural language form into action identifiers recognizable by the system. For example, when the main intent is to submit for approval, the system can map it to the protocol action identifier task.submit.approval; when the intent is to download a report, it is mapped to task.export.download. The mapping table is used as a standard semantic protocol conversion rule library, which is called by the system to parse user instructions. The system performs protocol structure body construction. The system takes semantic instruction data as input, which includes main intent, sub-intent, and semantic slot filling content (such as target object, operation role, etc.). Through structure mapping, the system uniformly converts semantic instructions into protocol standard triple format, specifically including action field (action), target field (target), and executor field (actor). For example, if the semantic instruction is "submit the approval of project X by the department supervisor", it can be converted into the standard protocol form: "action" is "submit the approval" (i.e. task.submit.approval), "target" is "project X", and "executor" is "department supervisor". The system performs parameter normalization and data type binding. The system submits the "target" field (such as "project X") in the semantic instruction to the pre-set business resource knowledge graph for query, extracts the corresponding standardized identification information, for example, "project X" is parsed into the standard project number "PRJ-003921". This standardization process ensures that all target fields can match the resource tag set defined in the business system. In addition, all generated protocol fields need to meet the pre-set semantic type constraints: the action field (action) must belong to the action set (MCP-ACTION-SET), the target field (target) must exist in the resource tag set (RESOURCE-TAG-SET), and the executor field (actor) needs to match the legal entries in the role register table (ROLE-REGISTER-SET). The above set can be pre-defined and continuously maintained by the system administrator.

[0081] S3, according to the standard semantic protocol data, the flowchart node matching is performed, and the flowchart node data is obtained;

[0082] Specifically, the system performs retrieval of the flow node. The system receives the standard semantic protocol data generated by the previous flow step, and performs retrieval in the preset flow template library according to the action field therein. The flow template library stores various reusable flow node templates, each of which contains node type identification, parameter template, precondition and the like. The system supports fuzzy matching of the semantic protocol action field and the node template name and description field using a keyword matching algorithm (such as term frequency-inverse document frequency, TF-IDF) or a context semantic embedding matching algorithm (such as BERT-based sentence vector encoding), and sets a similarity threshold (for example, greater than or equal to 0.85) to filter a candidate node set. For multiple candidate nodes, the system sorts and scores according to dimensions such as semantic matching score, context adaptation degree and historical usage frequency, and selects the node template with the highest score as the matching node of the current step. The system performs dependency relationship correction and context fusion. In order to ensure that the logical order of the current matching node in the business process graph is reasonable, the system reconstructs the dependency order in combination with the semantic context in which the current intent is located and the historical process trajectory. For example, if the action identified in the current standard protocol is “generate report”, and there is an identified sub-process “filter customers” in the historical process, the system automatically infers that “filter customers” is the logical pre-step of “generate report”, and then constructs a directed dependency edge from “filter customers” to “generate report” in the process graph. The dependency correction process is implemented by constructing a temporary process graph subgraph G=(V,E), wherein V represents the set of identified flow nodes, and E represents the set of directed dependency edges between nodes. The system generates the process graph node structure. The system outputs the matched flow node data in a structured manner, including the unique identifier (such as “N1”, “N2”) of each node, the node type (such as data filtering, report generation, etc.) and the semantic parameters (such as customer name, report format, etc.), and outputs the dependency edge structure, which indicates the execution order relationship between nodes in the process graph. For example, “node N1” is a data filtering task with the parameter “customer=A company”; “node N2” is a report generation task with the parameter “format=PDF”; there is a dependency edge from N1 to N2 between them, indicating that the “generate report” task depends on the output result of the “filter customers” task.

[0083] S4, generating a business process according to the flow graph node data to obtain business process data.

[0084] Specifically, the system performs the construction of the flow structure diagram. The system receives flowchart node data and organizes it into a directed acyclic graph based on the dependencies between nodes. During the construction process, the system topologically sorts the connection order of each node to ensure that the execution order of tasks conforms to the causal dependency relationship. At the same time, the system checks the integrity of the critical path to ensure that, for example, in an approval type task, there must be a task initiator node and a receiver node. If a critical node is missing, the system will automatically generate a warning or guide the user to complete the missing part to ensure the closure of the process loop. The system performs node-level dependency injection and process logic enhancement. To improve the robustness of the process and the completeness of the business rules, the system can automatically insert several auxiliary nodes. For example, when detecting the presence of a "export report" type node, the system will automatically insert a "data integrity check" node as a pre-step to ensure data validity. This injection process is based on pre-set mapping rules of task types to enhancement logic. In addition, the system also supports a variable binding mechanism for process parameters, that is, dynamically mapping the parameter fields of process nodes to variables in the user context environment, such as binding "user ID" to "node N1's submitter identity field" and "date range" to "node N2's query time window." This binding mechanism is based on the matching relationship between the context variable pool and the parameter placeholder, and ensures that all necessary parameters are injected during the flowchart construction phase. The system performs process logic verification and structure output. The system calls the built-in rule engine (such as Drools, etc.) to perform consistency verification on the entire process structure diagram, including but not limited to the following constraint conditions: there must be no logical closed loop in the process (i.e., there must be no loop path in the graph); all sub-processes must have a clear end node; parallel tasks must have a convergence point; certain task types cannot be used as starting nodes, etc. After verification, the system exports the final process structure to a standard structured format for parsing and scheduling execution by downstream RPA platforms. Supported output formats include JSON, YAML, or BPMN specification format, and the output structure includes but is not limited to the following fields: process number (such as workflow_id), workflow engine type used (such as Camunda), version information, node set, and dependency edge set, etc.

[0085] Optionally, the constructing step of the multi-round intent recognition model comprises:

[0086] S11, obtaining historical user input data and historical user intent data;

[0087] Specifically, the system first extracts historical user input information and its corresponding historical user intent data from the session log. The historical user input data includes the original text information issued by the user in continuous multiple rounds of dialogue, and each input contains its turn number (turn id) in the multiple rounds of interaction and the original content of the round input. For example, the first round of input is "I want to download the customer report", and the second round of input is "select the report of company A". Such information constitutes the text corpus basis of the user intent evolution process. Correspondingly, the historical user intent data is the structured expression after semantic understanding of each round of input, including turn number, main intent category and semantic slot filling results under the intent. For example, the main intent identified by the first round of input is "export report", and the semantic slot is "object = customer report"; the intent of the second round of input is "conditional filtering", and the slot is "customer = A company".

[0088] S12, dialogue state extraction and entity data extraction are performed according to the historical user input data, to obtain dialogue state data and entity data respectively;

[0089] Specifically, in terms of dialogue state extraction, the system adopts a dialogue state tracking model based on bidirectional gated recurrent unit (Bi-GRU) and fusion of attention mechanism. The model encodes each round of user input, and combines the dialogue state and semantic trajectory of the previous round to construct the state vector representation of the current round. The generation process of the current state vector is to take the embedding vector of the current input as the encoding input, combine it with the state vector of the previous round through the gated recurrent mechanism, and introduce the attention mechanism to weight and fuse the historical semantic trajectory, so as to generate the complete current dialogue state representation. Formally, the current state vector is equal to the result of the gated recurrent unit processing the current input vector and the state of the previous round, plus the attention weighted output of the historical trajectory. In terms of entity data extraction, the system introduces a conditional random field (CRF) model as a named entity recognition module, which is used to identify key entity items in user input, including but not limited to customer name, product name, time range, etc. Entity recognition is not limited to shallow matching, but also includes context-related ambiguity resolution and normalization processing. For example, for the input "I want to check the report of company A", the system can identify the "customer entity" as "A company" and infer that it has an ownership relationship with "report" in the context, so as to label the associated type of the entity as "report ownership object".

[0090] S13, main intent recognition and sub-intent recognition are performed according to the dialogue state data, entity data and historical user intent data, to obtain main intent data and sub-intent data;

[0091] Specifically, the system jointly models the current round input vector with the historical intent trajectory, extracts the current encoding vector, performs average pooling operation on the identified intent vectors in the historical rounds, and combines the entity semantic graph constructed based on the graph structure (i.e., the identified entities are organized in the form of nodes, and the edges represent the semantic dependence between the entities), extracts the entity relationship vector through the graph aggregation function, and generates the multi-round semantic fusion vector of the current round by fusing the three. The above fusion vector and the candidate main intent node in the intent knowledge graph are calculated for similarity, which includes vector cosine similarity, which is used to measure the semantic closeness of the current semantic and the candidate main intent; the path similarity index is used to quantify the similarity of the historical main intent trajectory and the candidate main intent in the path structure of the intent graph; the weighted combination of the two is used as a scoring index, and the main intent node with the highest score is selected as the current main intent recognition result.

[0092] The sub-intent recognition adopts a double mechanism parallel processing, specifically including adopting an end-to-end pointer network architecture to perform fragment-level positioning on the current input text of the user, and the model output is the index position of the starting and ending token, so as to intercept the semantic fragment expressing the specific sub-operation intent, and structure it into a sub-intent item, forming a nested structure containing the operation target and the operation type. And match the current semantic fusion vector with all the sub-node vectors in the pre-defined hierarchical intent tree, and the system realizes the focusing on different levels of functional sub-items through the multi-layer routing attention mechanism. The attention mechanism judges the matching weight of the fusion vector at each node of the intent tree layer by layer, so as to identify all the sub-intent paths involved in the current context.

[0093] S14, multi-round semantic cooperation according to the main intent data and the sub-intent data, to obtain cross-round intent fusion data;

[0094] Specifically, the system performs semantic role labeling on each sub-intent data, i.e., explicitly determines the semantic function position of the sub-intent in the main intent execution structure. For example, when the main intent is "export report", if the sub-intent is "select customer", it can be labeled as the "report filtering constraint" role; if the sub-intent is "select export format", it corresponds to the "output parameter configuration" role. The system uses conditional convolution attention processing, uses different role labels as modulation parameters, guides the sub-intent to aggregate in the embedding space towards its semantic path-dependent direction, thereby improving the collaborative modeling capability, and generates role-path-dependent representation. After completing the semantic role modeling, the system constructs a cross-turn dialogue intent graph, which is formally represented as a graph structure G =(V, E), where the graph nodes V represent each round of main intent or sub-intent, and the graph edges E represent the semantic connection relationship between them. The semantic edge types include "semantic parallelism", "logical inclusion", and "parameter constraint", etc. Using a loss function based on semantic representation difference, the weakly related edges in the graph structure are pruned (such as edges with edge weights below a set threshold of 0.2 are deleted); and the co-occurrence of mutually exclusive intents (such as "delete file" and "backup file") is detected and labeled, and the conflict weight penalty is realized through edge type reconstruction or conflict Figure 1 consistency correction. The graph structure after completing the semantic role annotation and consistency correction will be input into the graph neural network module. The system performs graph convolution operation on the graph G, aggregates and propagates the node information in the local neighborhood, and outputs the context-enhanced semantic representation of each node. The convolutional representations of all main intents and their associated sub-intents are weighted and fused to generate the final intent fusion vector, which will be used as the input basis for the subsequent standard semantic instruction generation module.

[0095] S15, add a semantic instruction conversion layer according to the cross-turn intent fusion data to obtain a multi-turn intent recognition model.

[0096] Specifically, the fused semantic vector obtained in the previous step (i.e., the unified representation formed after the main intent and sub-intent are fused through the semantic graph) is input into an instruction generator based on a Transformer decoder structure. The generator outputs structured semantic instruction information step by step in a decoding manner, and the output content is a structured expression with clear semantic intent, slot information, and parameter value. For example, if the fused vector represents the user's semantic request of "exporting the sales report of A company in the past 30 days", the generator can output the following structured instruction format: action: the operation name representing the semantic intent, such as "export report"; filters: the context filtering conditions required for the execution behavior, for example, "customer" is "A company" and "time" is "the past 30 days". The system checks whether there is a missing mandatory slot in the structure. For example, for the "send email" intent, if the recipient address or attachment file information is missing, it is marked as an incomplete slot; the system performs semantic enhancement and explicit conversion on the potential intent in the instruction. For example, "please send to the boss", the system will infer the corresponding behavior combination as "generate report" and "send by email" through the context semantics, and complete the required instruction fields. After the above generation module is trained, the system will freeze the module parameters to ensure the consistency and stability of the predicted behavior in actual deployment. The generated multi-turn intent recognition model serves as a pre-parser module in the RPA business automation system, which directly performs semantic analysis on user input at runtime and outputs standardized semantic instructions.

[0097] Optionally, the main intent recognition includes:

[0098] According to the semantic fusion vector generation based on the dialogue state data, entity data, and historical user intent data, the semantic fusion vector data is obtained.

[0099] Specifically, the current user input sentence (denoted as the t-th input) is input into a context-aware encoder (such as BERT or GRU encoder) to obtain the semantic representation vector of the current round; the historical context representation is extracted using a gated recurrent unit (GRU) for sequence modeling of the previous n rounds of dialogue content; the structured entities (such as "customer A", "report", "export", etc.) identified from the current and historical dialogues are mapped to a set of dense vectors of uniform dimensions by consulting an entity embedding matrix or an entity vector dictionary; a historical intent path graph is constructed with the historical intent sequence as nodes and edges constructed according to the time sequence and semantic dependency; the intent graph is embedded using a graph neural network (such as GCN or GAT) to output the historical intent context representation; a gated attention fusion mechanism is used to weight and fuse the above multiple vector spaces wherein is a gating fusion factor (dynamically controls the weight distribution between the current semantic and other semantic sources). is a Sigmoid activation function (compressing the gating output to the range [0, 1]), is a gating weight matrix (a learnable parameter for calculating the gating coefficient), is a concatenated joint representation vector (representing the joint representation of the current semantics and other source information), is the current round semantic representation vector, is the fused historical context information vector, is the gating bias vector, is the fused semantic representation vector. Cross-domain attention mechanisms are established for the four types of input vectors, and gating coefficients are introduced to dynamically adjust the influence weight of different source information, thereby outputting the fused representation vector.

[0100] According to the semantic fusion vector data, context gating processing is performed to obtain semantic context data;

[0101] Specifically, the current semantics and context information in the semantic fusion vector are dynamically adjusted by multiple learnable gating mechanisms; the contribution ratio of the current round semantics and context in the fusion vector is adjusted using a learnable gating structure: wherein is a gating weight coefficient, is a Sigmoid activation function, is a context gating weight matrix, is a fused semantic vector, is a context gating bias vector, is a context-adjusted semantic output vector, is the semantic representation vector of the current round of user input sentence, i.e., the result of the input of this round (the t-th round) after encoding by a context-aware encoder (such as BERT, GRU), representing the independent features of the current semantics. The alignment degree of the current semantic vector and the entity set is determined by multi-head attention, and a semantic alignment vector is calculated: wherein is the output of the i-th attention head, representing the semantic vector result after alignment of the current semantics and the entity set, is a Softmax function, is a query matrix, is a key matrix, is a vector dimension, ​is a value matrix. The system introduces a topic classifier in the process to classify the semantic topic to which the current session round belongs (such as "query type", "download type", "setting type"), which is used to identify the semantic main line; meanwhile, a round position code is introduced to encode the information of the current semantic session round, which improves the memory ability of the model to the context outline of the dialogue, so as to obtain the context semantic representation vector, i.e. semantic context data, based on the foregoing steps.

[0102] The semantic context data is subjected to main intention prediction graph construction to obtain main attention prediction graph data.

[0103] Specifically, the system optimizes the graph embedding representation of the constructed graph based on a graph convolutional neural network (GCN). The following graph convolution formula is used to enhance the embedding of all candidate main intention nodes: , wherein is the high-order semantic representation result coded by GCN, is an activation function used to introduce a nonlinear transformation, is the degree matrix of the adjacency matrix A, is the adjacency matrix of the graph, is the initial main intention embedding matrix, with a dimension of (n is the number of candidate main intentions, and d is the embedding dimension), is a training learnable graph convolution weight matrix. If some main intention nodes have explicit records in the historical user interaction, a label prompt vector can be added to the corresponding node. The prompt vector can be derived from the historical intention label representation or a frequency sensitive vector.

[0104] The main intention prediction graph data is matched according to the semantic fusion vector data to obtain main intention matching data.

[0105] Specifically, the system performs similarity calculation on the generated semantic fusion vector (denoted as , which fuses the current round input semantics, historical context state, entity information and historical intention structure) and the embedding representation of each candidate main intention node in the main intention prediction graph, and uses cosine similarity as the scoring basis: , wherein represents the similarity score of the fusion semantic vector and the i-th main intention node, and the larger the value is, the higher the matching degree is. The system modifies the initial score in combination with the historical intention path structure. A preset path deviation penalty factor is used to modify the original score to obtain a new score : , wherein is a path penalty coefficient, which is 0.05, is the candidate main intention node The greater the deviation from the historical intent path indicates the higher the path jump or context incoherence. The system sorts all the modified matching scores in descending order and selects the top K candidate items (where K is a preset candidate number, such as K = 3) as the primary intent matching results. The descending order is sorted, and the top K candidate items with the highest scores (where K is a preset candidate number, such as K = 3) are selected as the primary intent matching results.

[0106] The primary intent confidence score is adjusted based on the primary intent matching data to obtain primary intent data.

[0107] Specifically, the system synthesizes multiple semantic indicators to construct a primary intent confidence function. Let the initial matching score of the i th candidate primary intent node be The corresponding prediction probability distribution is The context fitting score is The confidence score is The expression is as follows: Wherein is the context fitting data, is the initial matching weight data, and the value is 0.5, is the initial matching data, is the probability entropy penalty weight data, and the value is 0.05, is the probability entropy penalty term, is the context fitting weight data, and the value is 0.45, is the semantic fit degree data between the current candidate intent and the historical dialogue context. The system calculates the information entropy value of the prediction probability distribution of the candidate primary intent. If the entropy value is close to the maximum entropy, it means that the score difference of each candidate intent is small, indicating that the model confidence is low. Therefore, the system introduces an entropy penalty term to negatively correct , reducing the risk of model output deviating from explicit decision. The system uses the context semantic vector in the multi-round dialogue to construct a cross-round semantic similarity function. This function is used to calculate the similarity between the current candidate primary intent and the previously confirmed intent, and this value is used as to participate in confidence calculation. The system sets a confidence threshold , such as 0.6. When the highest confidence is less than the threshold, the system considers that the current intent recognition result is uncertain, outputs the “unable to identify intent” state, and automatically triggers the clarification module to request further confirmation or supplementary information from the user. If there is a candidate item with a confidence higher than the threshold, the system outputs the primary intent node with the highest score, and returns its matching slot information, confidence score, and whether the clarification module is triggered.

[0108] Optionally, the context gating processing includes:

[0109] Context gating unit processing and attention gating unit processing are performed on the semantic fusion vector data to obtain context gating unit data and attention gating unit data, respectively;

[0110] Specifically, the context gating unit processes system-defined context gating functions to control the degree of integration between the current semantics and the historical context. Its expression is as follows: ,in For context-gated coefficient vectors, It is the Sigmoid activation function. This is the current semantic weight matrix. For the current fused semantic vector, The context state weight matrix, For historical context state vectors, This is the bias term. Using the gated vector... The current semantics and context state are weighted and fused to obtain the fusion result: ,in For context-gated fusion vectors, For context-gated coefficient vectors, For the current fused semantic vector, This is an element-wise multiplication at the corresponding positions.

[0111] Attention gating unit processing involves the system employing a multi-head attention mechanism to model the matching relationship between semantic fusion vectors and entity information; query vector generation involves... The mapping is to the query vector Q; the key and value vectors are generated by mapping the entity vector set to the key vector K and value vector V respectively; the attention score is calculated by using a scaled dot product attention mechanism to obtain the attention weight vector. ; , For entities Attention weights The query vector is a linear mapping derived from the current semantic fusion vector. A matrix that is a set of key vectors. The transpose operator, The embedding dimension is specified. The system performs a weighted summation based on the attention weights of each entity to generate a fused entity attention representation: ,in For entity attention fusion vectors, For entity indexing, For the total number of entities, For entities Attention weights For entities The embedding vector of the current semantic input, representing the aggregation of all related entity semantics, highlights the key entity semantic features that the current semantic input focuses on.

[0112] The semantic fusion vector data is round-gated and topic-classified according to the context gating unit data and the attention gating unit data, respectively, to obtain round-gated data and topic-classified data;

[0113] Specifically, the round-gating adjustment constructs a corresponding round embedding vector for the dialogue round to which the current semantic input belongs. The embedding can be generated in the following two ways: (1) a trainable position encoding network is used to generate a fixed-dimensional embedding representation based on the current round index; (2) a preset dialogue round vector table is used to map different round numbers to vectors. The system controls the fusion of the context gating unit data and the round embedding, and defines the round-aware gating function as follows: wherein is the round gating coefficient vector, is the Sigmoid activation function, is the context vector weight matrix, is the semantic fusion representation after context gating, is the round embedding weight matrix, is the current round embedding. According to the gating weight , the fused round-aware representation is calculated as: wherein is the fused round-aware representation, is the round gating coefficient vector, is the element-level bitwise multiplication operation, is the semantic fusion representation after context gating, is the current round embedding vector.

[0114] The topic classification adjustment uses a multi-class topic classifier to classify the attention gating unit data, which is used to identify the business semantic topic to which the semantic representation belongs. The preset topic categories can include but are not limited to "report processing", "approval process", "data acquisition", "information notification", etc. The classification function is in the form of: wherein is the probability distribution of all topic categories, is the multi-class normalization function, is the topic classification mapping weight matrix, is the entity attention fusion vector. The system defines a set of topic embeddings, each corresponding to a trainable semantic embedding vector for each topic. The topic representation of the current semantic input is extracted in a weighted summation manner: wherein is the topic representation vector of the current semantic input, the first predicted probability of the topic, the embedding vector of the first topic.

[0115] According to the round gating data and the topic classification data, similarity fitting is performed to obtain gating fitting data;

[0116] Specifically, the system first splices and fuses the round gating representation vector and the topic classification vector to form a joint semantic representation vector. The system uses a double-tower matching mechanism to respectively encode the joint semantic representation vector and the candidate main intent representation vector pre-stored in the intent knowledge base, and calculates the semantic similarity between the two. The matching formula is as follows ： wherein the cosine similarity score of the first candidate intent node and the current input, is a cosine similarity function, is a joint semantic representation vector, is the embedding vector of the first intent in the intent knowledge base. The system sets the topic uncertainty regularization term as a smoothing penalty term to adjust the candidate similarity score: wherein is the adjusted similarity score, is the cosine similarity score of the first candidate intent node and the current input, is an adjustment factor, the value range is [0.1, 1.0], is the variance of the topic prediction probability distribution. All candidate intent vectors are weighted and fused according to their adjusted similarity scores to generate a gating fitting semantic vector: wherein is a gating fitting semantic representation vector, is a candidate intent index, is a normalization operation, is the adjusted first candidate intent score, is a candidate intent embedding vector.

[0117] According to the gating fitting data, the round gating data and the topic classification data are processed by trajectory averaging to obtain semantic context data.

[0118] Specifically, the system determines a time window size T (for example, T=5), and truncates the data of the last T rounds of dialogue turns from the current time t to form a paired sequence of round gating vectors and topic classification vectors. Let wherein: represents the first Wheel-level gating vector; Indicates the first The theme classification vector of the wheel. The system uses the gating fitting vector of the current wheel. Attention weights are applied to the aforementioned historical trajectory sequences. The attention weights for each round of data are calculated. , defined as the dot product of the current gated fitting vector and the gated vector of each round, normalized by softmax: ,in Let be the attention weight for the t-th round of data, representing the contribution of that round to the semantic context. After concatenating the gating vectors and topic vectors from previous rounds, a weighted average is calculated according to the aforementioned attention weights to obtain the comprehensive semantic context representation: , This is a vector concatenation operation used to jointly express the vectors of rounds and topics into a single semantic trajectory unit.

[0119] Optionally, the sub-intent data includes first sub-intent data and second sub-intent data, and the sub-intent identification includes:

[0120] Context encoding is performed on the semantic fusion vector data to obtain context-encoded data;

[0121] Specifically, the system receives two types of input information: the semantic fusion vector of the current round, denoted as... This represents the fused semantic expression of the current user input within a multimodal semantic structure; historical context data sequence. ,in Indicates the first The user input text in the wheel; Indicates the first The system response text of the wheel; Indicates the first The entity information identified by the wheel, The values ​​are 1…T. The above historical round data are concatenated into an input sequence and fed into the context modeler for encoding. A context encoder based on the Transformer architecture is constructed to model the semantic dependencies and response relationships between multi-turn dialogues; the input sequence is organized as follows: ,in This serves as the classification identifier. The above sequence is input into the Transformer encoder to obtain a multi-round context semantic representation matrix: ,in This is the encoded hidden state matrix; Represents the semantic dimension. From the output matrix Extract the semantic vector from the first position (i.e., the [CLS] identifier position) and use it as the global context encoding vector for the current semantic round: ,in A compressed representation of the global dialogue context.

[0122] Global semantic query vectors are generated from context-encoded data to obtain global semantic query vector data;

[0123] Specifically, the two semantic vectors mentioned above are concatenated (i.e., vector-level concatenation); the result is then input into the gating control unit to calculate the fusion weights. ,in As a gated fusion factor, The activation function is Sigmoid, ensuring that the fusion factor g takes values ​​between 0 and 1. This is the weight matrix for the gating mechanism. For contextual semantic vectors, For the current round of semantic vectors, For bias terms, This is a concatenation operation between two vectors. Based on a gated fusion factor. The system generates a global semantic query vector q: ,in This is the generated global semantic query vector. As a gated fusion factor, For contextual semantic vectors, This is the semantic vector for the current round. The system uses a gating factor as the weight to linearly weight the context semantics and the current semantics, achieving dynamic semantic alignment.

[0124] Calculate the pointer start and end positions on the global semantic query vector data to obtain the pointer start and end position data;

[0125] Specifically, the system receives the following two types of input: a global semantic query vector, denoted as q, which indicates the matching direction of the target semantic segment; and the word embedding sequence of the current user-input sentence, represented as... ,in For the first The system uses an embedding representation of n tokens to calculate a matching score for each position as either the start or end point, employing an attention mechanism. For each token vector... Calculate the linear matching score between each vector and the query vector q: ,in For the first Each token serves as the matching score for the starting position. For the transpose of the query vector, The learnable projection matrix for the starting position. For the first Word vectors, a learnable projection matrix for the end position, a first Token as the end position. The scores on all positions form two vectors: a start vector and an end vector .

[0126] According to the pointer start-end position data, probability mapping is performed to obtain start-end position probability data;

[0127] Specifically, the logits data are normalized into probability distributions respectively, wherein is the probability of being predicted as the start point of the segment, is the probability of being predicted as the end point of the segment. The system constructs a two-dimensional joint probability matrix, and each element represents the combined probability of taking position as the start point and position as the end point, which is defined as follows: that is, only the legal segment interval (i.e., the start position is not later than the end position) is retained, otherwise the corresponding probability is set to zero to eliminate invalid candidate segments. The system selects the index pair corresponding to the maximum probability value from the matrix as the predicted optimal semantic segment start and end positions, and outputs the corresponding maximum combined confidence: wherein is the optimal start and end position pair, is the maximum probability index selection operation, is the joint probability matrix, is the optimal semantic segment confidence, is the maximum value of the joint probability.

[0128] According to the start-end position probability data, a sub-intention segment is generated to obtain first sub-intention data;

[0129] Specifically, the system intercepts the continuous segment located in the interval from the input encoding vector sequence according to the maximum confidence interval determined in the previous processing step, and records it as the sub-intention picture segment vector sequence , is the start word vector of the semantic segment, is the intermediate word vector in the segment, that is, the vector of one token after the start word, is an end word vector of a semantic segment, which represents a semantic segment in the current user input recognized by the model that is most likely to carry the sub-intent semantics. To compress the information of the semantic segment and form a structured semantic representation, the system encodes the above-mentioned segment vector sequence using a set of sequence modeling and compression modules. The sequence of sub-intent segment vectors is input into a bidirectional gated recurrent unit network (BiGRU) to obtain a context-fused time series vector sequence; a mean pooling operation is performed on the sequence to obtain a global representation vector of the sub-intent segment. The processing result is: wherein is a structured embedding vector of the first sub-intent data, is a mean pooling operation, is a bidirectional gated recurrent unit network, is a sequence of sub-intent segment vectors.

[0130] According to the semantic fusion vector data and the preset intent library, hierarchical node matching is performed to obtain hierarchical node data;

[0131] Specifically, the system performs semantic similarity calculation on the fusion vector and the representation vector of each node in the intent library, and uses cosine similarity to measure the matching degree of the semantic fusion vector and each intent node. The initial matching score of the node is: wherein is a semantic similarity score, is a cosine similarity function, is a semantic fusion vector, is an intent node embedding vector. The system weights and corrects the matching score by setting a hierarchical penalty term to reduce the situation that the matching score of a deep node may be low due to high semantic abstraction. The corrected matching score is: wherein is the corrected matching data, is the initial matching data, is a penalty coefficient (such as 0.1-0.5), is the hierarchical depth of the node in the intent library, is an intent node embedding vector. The system sorts all intent nodes according to the adjusted matching score and selects the top K nodes with the highest scores to form a candidate matching path node set.

[0132] Routing attention calculation is performed on the hierarchical node data to obtain second sub-intent data.

[0133] Specifically, the input is hierarchical node data, which is represented as a set of several child nodes matched by the current semantic fusion vector in the intent library. Each node contains its semantic embedding vector representation. The system constructs the connection edges between the nodes according to the semantic subordination relationship in the intent library, forming a local graph structure. Each node in the graph corresponds to a candidate sub-intent; the edge represents the hierarchical semantic relationship, such as "contains", "depends on" or "parallel". For the above local sub-graph, the system uses the graph attention mechanism (GAT) to propagate and weight the information of the candidate sub-nodes; for any node in the candidate sub-node set, the system calculates the semantic matching degree between its adjacent nodes and the global semantic query vector (such as the aforementioned q) to determine the attention weight. The matching degree is realized by the dot product or affine transformation between vectors, and is normalized by the softmax function, so as to obtain the attention coefficient of each neighbor. For each node, the system performs weighted summation on the embedding vector based on the attention weight of all neighbor nodes to generate the node representation updated by the graph attention, represented as the graph attention output vector. The embedding vectors of all candidate sub-nodes after the above graph attention propagation are subjected to mean pooling operation (mean pooling), that is, the average value of all updated node representations is calculated, thereby generating the second sub-intent representation under the current round of semantic intent.

[0134] Optionally, the routing attention calculation comprises:

[0135] The hierarchical node data is subjected to semantic compression graph representation to obtain semantic compression graph data;

[0136] Specifically, the system obtains two input data, including a candidate hierarchical intent node set, that is, a node set identified after comparing the semantic fusion vector with the preset intent library, denoted as a candidate node set; and structure edge data, that is, the semantic hierarchical relationship edges between nodes, including "parent-child", "sibling", "contains" and other semantic associations. For each node in the candidate node set, the system maps it to a vector representation. According to the structural connection relationship between nodes and the semantic similarity, the original graph is divided into several semantically consistent sub-regions using a graph clustering algorithm, including the Louvain algorithm based on community discovery; the SpectralClustering method based on spectral decomposition. For each clustering sub-graph, the semantic vectors of all nodes in the sub-graph are averaged to obtain a "super node" representation representing the sub-graph. The super node is regarded as an abstract representation of the original sub-intent. The system takes the super node as the node set of the new graph, and simultaneously establishes the corresponding edge set according to the connection relationship between the sub-graphs in the original graph, forming the compressed semantic graph.

[0137] The semantic compression graph data is subjected to jump perception graph convolution to obtain graph convolution data;

[0138] Specifically, for each node in the graph, its feature update not only depends on the information of its direct adjacent nodes, but also sets a regulation mechanism for long-distance semantic jump edges; the system aggregates the features of all adjacent nodes of the current node. The feature vector of each neighbor node is multiplied by an attention weight factor, which represents the importance of the neighbor to the current node. The attention weight can be obtained by calculating the dot product attention mechanism or graph attention network (GAT). In addition to local adjacency information, the system also introduces a global semantic query vector to assist in enhancing each node. The enhancement signal is weighted by a fusion coefficient, which is calculated by the similarity between the representation vector of the current node and the global query vector, which is realized by a normalized dot product similarity function, for example, mapped by a softmax function, so that the perception of all nodes to the global vector is normalized. After adding the weighted sum of the adjacent information and the weighted vector of the global information, a linear transformation and a nonlinear activation function (such as ReLU) are performed to obtain the new semantic representation of the node. This operation is iterated for multiple rounds.

[0139] The graph cross-layer data is obtained by triggering the graph convolution data across layers.

[0140] Specifically, the system receives the following input data: a set of node features after graph convolution, denoted as graph convolution data, which represents the updated representation of each node in the graph; a set of hierarchical identification information, which is used to mark the depth or belonging level of each node in the semantic hierarchy; and a main intent representation vector corresponding to the current task, which is used to determine whether the cross-layer path needs to be activated. The system determines whether to allow information propagation between different levels according to the semantic similarity and the level difference between nodes, forming a conditionally activated cross-layer path graph. For any two nodes, the system calculates the semantic similarity between the feature representation of the node and the main intent vector, and if the similarity is greater than a set similarity threshold (e.g., 0.6) and the difference in level depth between the two is greater than a set jump level threshold (e.g., 2 layers), it is determined that the node meets the cross-layer propagation condition. The first condition is that the node has high semantic consistency with the main intent vector; the second condition is that the level span between the node and its potential cross-layer connection object is significant, meeting the demand for semantic jump. After the above condition judgment is performed on all node pairs, only the connections between the nodes that meet the conditions are retained, and a cross-layer graph structure after conditional triggering is constructed, denoted as cross-layer graph.

[0141] The second sub-intent data is obtained by performing self-attention calculation on the graph cross-layer data.

[0142] Specifically, the system constructs a query matrix, a key matrix and a value matrix based on the cross-layer node representation data. The query matrix is obtained by performing a first mapping weight matrix transformation on the input node representation; the key matrix and the value matrix are extracted from the same set of node representations through the corresponding weight matrices, maintaining structural consistency. The system uses dot-product attention mechanism to calculate the correlation weight between nodes. That is, the inner product result between the query and the key is scaled, and the attention weight distribution between nodes is obtained through a normalization function (such as softmax). Subsequently, the attention distribution is applied to the value representation to generate a new representation for each node. The system adopts a multi-head attention mechanism to perform multiple sets of attention calculations in parallel, and then splices the output results of each set. The system adds the initial cross-layer node embedding to the output as a residual term, and performs normalization through a layer normalization module, thereby obtaining a set of node representations. The final node representations are averaged to obtain a vector representing the current sub-intent, referred to as second sub-intent data.

[0143] Optionally, the multi-round semantic collaboration includes:

[0144] According to the first sub-intent data and the second sub-intent data, the main intent data is annotated with sub-intent functional roles to obtain sub-intent annotation data.

[0145] Specifically, the main intent representation vector is denoted as , which represents the core intent expressed by the user in the current dialogue. The first sub-intent representation vector is denoted as , which is a key fragment extracted by a pointer network and represents the target content pointed to by the user's operation. The second sub-intent representation vector is denoted as , which is usually obtained by structured semantic path graph reasoning and represents the user's semantic path or semantic domain. The system predefines a set of multi-label role space, covering intent semantic function labels such as action target (Action Target): refers to the specific object that the user wants to operate; semantic qualifier (Qualifier): represents the user's additional limitations on actions or conditions; temporal condition (Temporal Condition): indicates the time or timing dependency of intent execution; fallback logic (Fallback): represents the backup intent when the main intent fails to trigger; and other application scenario-based extended labels. The role set is denoted as: R = {Action Target, Qualifier, Temporal Condition, Fallback, etc.}; for each sub-intent vector ( or ), combined with the main intent vector , construct a multi-label classification input pair; use a pre-trained or end-to-end trained multi-label classifier to determine the functional role of the sub-intent in the main intent; the classifier calculates the confidence score of each semantic role label corresponding to the sub-intent according to the input pair (the splicing of the sub-intent vector and the main intent vector), and outputs the multi-label distribution through the activation function (such as Sigmoid); threshold processing or sorting screening is performed on the output result, and one or more functional labels are assigned to each sub-intent.

[0146] According to the sub-intent annotation data, an intent fusion graph is constructed, and intent fusion graph data is obtained;

[0147] Specifically, an intent fusion graph is constructed , denoted as , wherein the node set V includes the following three types of nodes: the current main intent node ; two sub-intent nodes and ; historical intent nodes (t=1 to T); the edge set E: represents different types of semantic and contextual association relationships, mainly including functional connection edges, which are used to connect the main intent and its sub-intents, and the type of the edge is determined by the functional label of the sub-intent (such as operation target, time condition); context tracking edges, which are used to connect the historical round intent and the current main intent , reflecting the continuous intent trajectory in the dialogue; theme merging edges, which are used to connect the intent nodes that mention the same semantic object (such as the same business module or data field) in different rounds. For each pair of nodes and with an association relationship, the edge weight is calculated. The system calculates the semantic similarity between nodes, for example, using the cosine similarity to measure and represent the semantic closeness between vectors; if both nodes have functional labels and , the functional similarity score of the semantic role is calculated, and is weighted by the adjustment coefficient ; the edge weight is defined as .

[0148] According to the intent fusion graph data, semantic dependency simulation is performed, and semantic dependency simulation data is obtained;

[0149] Specifically, for each node i in the fusion graph, the semantic dependency result is simulated by weighting the information of its adjacent nodes j. For node i, the feature vectors of its adjacent nodes j∈N(i) are aggregated , and the attention weight is calculated as the dependency strength; the attention weight The calculation is obtained by the following steps: constructing edge representation features f_ij, including the role difference between nodes (such as the degree of inconsistency of function labels), the difference in dialogue turns (such as the time sequence relationship), the historical path connectivity (such as whether similar paths have appeared in the past), and the like; the feature vector h_i of the node i and j is spliced with the edge feature f_ij as the input, and input into a multi-layer perceptron (MLP) model to output the weight e_ij; the e_ij is normalized by softmax to obtain the attention weight ; the simulation representation of the node i is the weighted fusion result of the features of all neighbor nodes: where W is a trainable linear transformation matrix.

[0150] According to the semantic dependency simulation data, the semantic conflict graph minimum cut is performed on the intent fusion graph data to obtain cross-round intent fusion data.

[0151] Specifically, on the basis of the original fusion graph structure, a conflict weight is assigned to each edge , which is used to measure the degree of semantic conflict existing in the current connection, and the calculation method is as follows: wherein is the conflict weight, is the dependency confidence score of the edge , and the higher the value, the more reliable, is the inconsistency measure between the functional roles of the nodes and , which can take a value of 0 (completely consistent) or a positive number (the larger the conflict), the fusion graph is converted into a flow network, the main intent node is set as the source point, and all terminal intent nodes (such as user question terminal points or system action nodes) are set as the sink points, and the edge weight uses the aforementioned conflict weight ; the minimum cut algorithm (such as Stoer-Wagner minimum cut algorithm or Edmonds-Karp maximum flow minimum cut algorithm) is used to perform the minimum cut operation on the conflict graph, with the goal of minimizing the total weight of semantic conflict, to delete edges or subgraph structures with high logical inconsistency from the graph; the graph structure with reasonable structure, reliable semantic path, and consistent role relationship is retained to form a cross-round fusion intent structure graph.

[0152] Optionally, S2 includes:

[0153] S21, performing semantic instruction slot parsing according to the semantic instruction data to obtain semantic instruction slot data;

[0154] ​Specifically, a pre-defined set of semantic slot labels is used to cover common instruction components, including but not limited to the following categories: Action: representing the action the user wants the system to perform (e.g., "create", "open", "delete"); Object Type: representing the category of the target object (e.g., "Excel file", "document", "calendar"); Object Name: representing the named entity specified by the user (e.g., "project plan", "meeting minutes"); Modifier: representing additional conditions, degree, or time modifications; Condition: representing the conditions that trigger or execute the instruction. Sequence labeling algorithms based on pre-trained language models (e.g., BERT-BiLSTM-CRF or T5 encoder-decoder models) are applied to the semantic instruction data to perform BIO (Begin-Inside-Outside) slot labeling for each lexical unit. For example, the annotation result for the instruction "Please help me create an Excel file named 'Project Plan'" is as follows: "Create" → B-Action; "One" → O (non-slot); "Named 'Project Plan'" → B-ObjectName; "Excel file" → B-ObjectType. The slot information in the above annotation sequence is extracted and reorganized to form a structured semantic slot representation, organized using key-value pairs. Taking the above example, the slot structure is as follows: Action: Create; Object Type: Excel file; Object Name: Project Plan.

[0155] S22. Perform protocol semantic template matching based on semantic instruction slot data to obtain template matching data;

[0156] Specifically, the system iterates through all protocol templates in the template library, comparing the key slots required by the template with the actual slot content in the input data. For each pair of slot keys, if the input data approximately matches the template, the matching score is incremented by one. The matching score can be expressed as: ,in Match data for slots. For semantic instruction slot data, For the first A protocol template, For slot key name, For slot key set, This is an indicator function; it takes the value 1 if the slot content matches or nearly matches, and 0 otherwise. To input slot value, The template slot requires a value. The system performs data enhancement when judging "approximate match", including morphological restoration of slot content; introducing synonym mapping or hyponym expansion; using semantic embedding representation (such as Word2Vec, BERT vector) to calculate cosine similarity. Select the template with the highest matching score and meet all necessary constraints as the optimal protocol template for the current semantic slot. Replace the placeholder in the template with the slot value in the input data to generate a structured and semantically consistent protocol expression result.

[0157] S23, according to the template matching data, the protocol format verification enhancement is carried out, and the standard semantic protocol data is obtained.

[0158] Specifically, the system presets a protocol format verification rule set, including but not limited to type legality judgment, the field "object_type" should belong to the predefined set {"excel", "word", "ppt"}; name format specification judgment, the field "object_name" should not contain illegal characters (such as special symbols, control characters); parameter integrity constraint judgment, all fields marked as required cannot be empty or default; semantic combination legality judgment, if the field "action" is "create", it cannot contain status fields indicating "deleted" or "archived". The processing flow includes checking the structural integrity of parameter pairs (such as bracket closure, key value format); according to the association between action type and object attribute, it is judged whether the protocol combination has execution rationality; if there is a missing optional field, the system can complete it through context information, default value or historical protocol filling mode; for redundant fields or illegal fields, the system removes the invalid part through the rule set, or provides repair candidate suggestions for manual confirmation.

[0159] Optionally, S3 includes:

[0160] According to the standard semantic protocol data, the flow node library retrieval is carried out, and the flow node retrieval data is obtained;

[0161] In particular, the standard semantic protocol data, which is a structured semantic representation standardized by the protocol template matching module, contains the following key-value pairs: action: representing the action expected to be performed by the user, such as "create"; object_type: representing the category of the operation object, such as an "excel" file; object_name: representing the specific identification of the operation object, such as "project plan". The flow node library (denoted as Lnode_lib) is an ontological structure library containing a plurality of predefined flow nodes. Each node definition includes the following fields: node_id: uniquely identifying the flow node; node_type: representing the function performed by the node, such as "file_create"; parameters: representing the key parameter names required for the node to execute; conditions: used to limit the acceptable value range of the node parameters, for example, the "type" field can only be "excel" or "csv". The system calculates the matching score between the current semantic protocol data and the node. The score is composed of the following: type matching degree, if the "action" field in the protocol matches the "node_type" of the node, then the value is 1, otherwise 0; parameter coverage, representing the coverage ratio between the valid fields in the protocol and the node definition parameters, calculated as: number of matching fields / total number of required parameters; constraint satisfaction degree, if the values of each field in the protocol satisfy the node preset conditions (such as object type within the allowed list), then the value is 1, otherwise 0. The above three indicators are combined with weights to obtain the matching index: wherein is the matching index, is the type matching weight data, with a value of 0.5, is the type matching degree indicator, is the parameter coverage weight data, with a value of 0.3, is the parameter coverage indicator, is the condition satisfaction weight data, with a value of 0.2, is the parameter constraint satisfaction degree. The above matching scores are calculated for all nodes in the flow node library, and are sorted from high to low, and the top k nodes (e.g. k=3) with the highest scores are selected as the candidate node set.

[0162] According to the flow node retrieval data, the dependency is adjusted to obtain the flowchart node data.

[0163] Specifically, based on the current context graph structure, the reasonable insertion position of the candidate node is analyzed, and it is judged that the starting node has no predecessor dependency relationship in the context; the intermediate node has an upstream dependent node, and the dependent condition (such as data dependency or state judgment) needs to be further analyzed; the terminal node is at the end of the flow, and has no successor operation. The condition field in the candidate node is parsed (such as "if the file does not exist" and "when the user's approval is passed"), and the corresponding condition edge is established in the context graph. The condition edge type is marked as "type": "conditional", and can be combined with a Boolean expression or a context variable to judge the dependent trigger path. If the current flow is a parallel structure (such as multi-task approval or multi-module initialization), the node is inserted into the concurrent structure according to the upstream and downstream task states, and a control gateway node (such as AND_GATEWAY or OR_GATEWAY) is automatically added, and the edge type is marked as "type": "concurrent". The overall flowchart structure is scanned to prevent the introduction of loop or deadlock paths; according to the actual semantic intention, the direction and dependency type of the edge (including sequential dependency "sequential", conditional dependency "conditional", and concurrent dependency "concurrent") are adjusted; if there are redundant paths or conflict relationships between nodes, merging, pruning or reconstruction is performed to maintain the simplicity and reachability of the flowchart structure.

[0164] Optionally, S4 comprises:

[0165] S41, constructing a flow structure graph according to the flowchart node data to obtain flow structure graph data;

[0166] In particular, the input data is a structured flow node dataset, which contains several flow nodes, each including a node identifier (node_id), a corresponding operation type (operation), a parameter dictionary (params), etc. If the graph structure is already available, graph normalization processing is performed. A pre-defined or automatically inferred flow edge list is obtained, representing the execution order or dependency relationship between nodes. For each flow node, the system normalizes it into a unified data structure, which includes a node identifier (e.g., NODE_023), a node operation type (e.g., create_file), and operation parameters (e.g., {type: "excel", name: "project plan"}), representing the specific operation execution content. The system assigns a unique runtime identifier (e.g., UUID or GUID) to each node. The system internally constructs a node mapping table to map logical node numbers to runtime instance numbers one-to-one, supporting flow traceability and backtracking. The connection relationship between nodes is standardized, and each edge is expressed as a structure with a unified field format. The typical format includes a starting node (from), a target node (to), and an edge type (type) to represent the semantic of the connection relationship, such as "sequential" (sequential execution), "conditional" (conditional jump), "parallel" (parallel branch), etc. If the type of an edge is not explicitly specified, the system defaults it to "sequential", i.e., sequential execution relationship. The output is a preliminary constructed flow structure graph data, which includes a flow graph node set: all normalized nodes participating in flow construction; and a flow graph edge set: standard format connection edges representing the control or data flow relationship between nodes.

[0167] S42, node-level dependency processing is performed according to the flow structure graph data to obtain graph node dependency data;

[0168] In particular, an adjacency matrix A[i][j] is constructed to represent whether node i in the flow graph depends on node j. If the execution of node i must be performed after the execution of node j, then is defined, indicating that there is an explicit predecessor dependency relationship; if there is no direct dependency between nodes, If a node contains conditional trigger information (e.g. an "if" condition in the parameter or semantic field, such as "if file_not_exist"), the system establishes a conditional dependency edge between the node and its precondition node, with the edge type set to "conditional". When the system detects that multiple nodes can be executed in parallel without dependency conflicts, an aggregation control node (such as an "AND_GATEWAY" or "FORK_JOIN" node) can be inserted to explicitly represent that these nodes belong to the same concurrent flow block, which can serve as the starting or merging node of multiple concurrent sub-paths. The system performs operations such as deleting semantically redundant or repetitive path connections, for example, multiple redundant edges between the start and end points; if multiple nodes have the same target node (i.e. the same successor) and are semantically consistent, they can be combined into a single aggregation node to simplify the structure; when performing invalid edge pruning or merging strategies, the graph connectivity and logical dependencies are maintained.

[0169] S43, performing flowchart logic verification on the graph node dependency data to obtain graph node verification data;

[0170] Specifically, a graph traversal algorithm (such as depth-first search DFS or topological sorting) is used to detect closed loops in the graph structure; if a loop composed of nodes is detected in the graph (i.e. it is possible to return to itself along the dependency path from a certain node), it is considered illegal; the system records all closed loop paths and outputs error information for the developer to correct the dependency relationship. The starting node (source node of the flowchart) should have no incoming edges to ensure that the flow can be started from the starting point; the terminating node (terminal node of the flowchart) should have no outgoing edges, representing that the flow can naturally terminate; all intermediate nodes should be on at least one path from the starting point to the ending point, otherwise they are considered to be dangling nodes, reporting a path disconnection error. For flow paths with conditional dependency edges, a merging control node (such as an OR-Join or Merge node) should be explicitly set after all branch paths to avoid conditional path dangling; the condition expression should be consistent in type with the parameters or context variables defined in the flow node, otherwise a condition semantic mismatch is prompted. Check if there are dependency-exclusion structures in the graph, such as two nodes that depend on each other to complete before triggering; identify potential deadlock paths and prompt for logical restructuring suggestions. The output is graph node verification data, including the verification status flag (legal / illegal) of each node or path; a detailed list of all structural errors or logical conflicts (such as loop paths, dangling node IDs, missing branch merging, etc.).

[0171] S44, compiling the business process according to the graph node verification data to obtain business process data.

[0172] Specifically, each node in the figure is mapped to a process task type according to its "operation type"; supported node types include task nodes, conditional branch nodes, concurrency control nodes, start nodes, end nodes, etc.; control flow relationships (such as sequence, condition, concurrency) determine the connection mode between nodes according to the edge type. The operation parameters (such as file type, target name, execution condition, etc.) contained in each node are structured and packaged, and are uniformly converted into key-value pair format; if the target platform is BPMN, an XML file conforming to the BPMN specification is generated; if the target is a Python script type automation execution platform, the process is compiled into a function call script for sequential or concurrent control; if the target is a specific platform type process execution engine (such as UiPath, Camunda, Ali PAI), a DSL (Domain Specific Language) or JSON format process definition file of the corresponding platform is generated. Assign a unique process ID (such as UUID format) to each business process definition file; and set the version number (such as v1.0, v2, etc.) to support process evolution management; store the process definition file and its metadata in the process repository database for subsequent scheduling, updating, and backtracking operations. The output is business process data, including process definition files that can be called by process execution engines; corresponding execution parameters, dependency structures, and meta-information; visual topology structure (such as SVG graph or process graph structure) for user backtracking and review.

[0173] Therefore, embodiments should be considered in all respects as illustrative and not restrictive, the scope of the application being defined by the appended claims rather than the above description, and all changes which come within the meaning and range of equivalency of the claims are therefore intended to be embraced therein.

[0174] The above description is merely that of a specific implementation of the present application, which enables those skilled in the art to understand or implement the present application. Various modifications to these embodiments will be apparent to those skilled in the art, and the general principles defined herein can be implemented in other embodiments without departing from the spirit or scope of the present application. Therefore, the present application shall not be limited to these embodiments shown herein, but is intended to conform to the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for RPA business automation empowered by a large language model MCP, characterized in that, The method comprises: S1, obtaining user input data, and performing intent understanding on the user input data through a multi-round intent recognition model to obtain semantic instruction data; S2, performing standard semantic protocol conversion according to the semantic instruction data to obtain standard semantic protocol data; S3, performing flowchart node matching according to the standard semantic protocol data to obtain flowchart node data; S4, generating a business process according to the flowchart node data to obtain business process data; The construction steps of the multi-round intent recognition model comprise: obtaining historical user input data and historical user intent data; performing dialogue state extraction and entity data extraction according to the historical user input data to obtain dialogue state data and entity data respectively; performing main intent recognition and sub-intent recognition according to the dialogue state data, the entity data and the historical user intent data to obtain main intent data and sub-intent data; performing multi-round semantic collaboration according to the main intent data and the sub-intent data to obtain cross-round intent fusion data; adding a semantic instruction conversion layer according to the cross-round intent fusion data to obtain the multi-round intent recognition model; The main intent recognition comprises: generating a semantic fusion vector according to the dialogue state data, the entity data and the historical user intent data to obtain semantic fusion vector data; performing context gating processing according to the semantic fusion vector data to obtain semantic context data; constructing a main intent prediction graph on the semantic context data to obtain main intent prediction graph data; matching the main intent prediction graph data according to the semantic fusion vector data to obtain main intent matching data; adjusting the main intent matching data to obtain main intent data; The context gating processing comprises: performing context gating unit processing and attention gating unit processing according to the semantic fusion vector data to obtain context gating unit data and attention gating unit data respectively; performing round gating adjustment and theme classification adjustment on the semantic fusion vector data according to the context gating unit data and the attention gating unit data to obtain round gating data and theme classification data respectively; performing similarity fitting according to the round gating data and the theme classification data to obtain gating fitting data; performing trajectory average processing on the round gating data and the theme classification data according to the gating fitting data to obtain semantic context data.

2. The method of claim 1, wherein, The sub-intent data comprises first sub-intent data and second sub-intent data, and the sub-intent recognition comprises: performing context encoding according to the semantic fusion vector data to obtain context encoding data; generating a global semantic query vector according to the context encoding data to obtain global semantic query vector data; performing pointer start-end position calculation on the global semantic query vector data to obtain pointer start-end position data; performing probability mapping according to the pointer start-end position data to obtain start-end position probability data; generating a sub-intent picture segment according to the start-end position probability data to obtain the first sub-intent data; performing hierarchical node matching according to the semantic fusion vector data and a preset intent library to obtain hierarchical node data; performing routing attention calculation on the hierarchical node data to obtain the second sub-intent data.

3. The method of claim 2, wherein, The routing attention calculation comprises: The hierarchical node data is subjected to semantic compression atlas representation to obtain semantic compression atlas data; According to the semantic compression atlas data, the jump perception graph convolution is performed to obtain graph convolution data; The graph convolution data is subjected to cross-layer condition triggering to obtain graph cross-layer data; According to the graph cross-layer data, the self-attention calculation is performed to obtain second sub-intention data.

4. The method of claim 2, wherein, The multi-round semantic cooperation includes: According to the first sub-intention data and the second sub-intention data, the main intention data is subjected to sub-intention function role annotation to obtain sub-intention annotation data; According to the sub-intention annotation data, the intention fusion graph is constructed to obtain intention fusion graph data; According to the intention fusion graph data, the semantic dependence simulation is performed to obtain semantic dependence simulation data; According to the semantic dependence simulation data, the semantic conflict graph minimum cut of the intention fusion graph data is performed to obtain cross-round intention fusion data.

5. The method of claim 1, wherein S2 It includes: According to the semantic instruction data, the semantic instruction slot parsing is performed to obtain semantic instruction slot data; According to the semantic instruction slot data, the protocol semantic template matching is performed to obtain template matching data; According to the template matching data, the protocol format verification enhancement is performed to obtain standard semantic protocol data.

6. The method of claim 1, wherein S3 It includes: According to the standard semantic protocol data, the process node library retrieval is performed to obtain process node retrieval data; According to the process node retrieval data, the dependence adjustment is performed to obtain process graph node data.

7. The method of claim 1, wherein, S4 includes: According to the process graph node data, the process structure graph is constructed to obtain process structure graph data; According to the process structure graph data, the node-level dependence processing is performed to obtain graph node dependence data; The graph node dependence data is subjected to process graph logic verification to obtain graph node verification data; According to the graph node verification data, the business process compilation is performed to obtain business process data.

Images