Automatic construction method of end-to-end agent based on graph structure semantic fusion

Abstract

The invention relates to the technical field of artificial intelligence, in particular to an automatic construction method of an end-to-end agent based on graph structure semantic fusion. The method comprises the following steps: receiving business demand data input by a user; business target and demand constraint condition analysis is carried out on the business demand data, and a core workflow framework of the intelligent agent is generated; performing end-to-end execution path analysis on the core workflow framework of the intelligent agent to obtain an end-to-end workflow; constructing a dynamic evolution semantic map; and constructing an end-to-end call chain execution strategy based on the end-to-end workflow, and performing agent instance packaging and agent instance reinforcement learning enhancement processing according to the dynamic evolution semantic map, thereby automatically constructing an end-to-end agent. According to the invention, by fusing the graph structure knowledge and the generation capability of the large language model, an efficient, accurate and extensible agent automatic construction scheme is provided for various complex business scenes.

Description

Technical Field

[0001] The present invention relates to the field of artificial intelligence technology, and in particular to an automated construction method for an end-to-end agent based on graph structure semantic fusion. Background Art

[0002] Traditional agent construction mainly relies on preset rules and procedural logic, and this method shows obvious limitations when dealing with complex and changing business scenarios. On the one hand, it is difficult for preset rules to cover all situations, resulting in the lack of flexibility of the agent when facing new situations; on the other hand, as the business rules increase, the maintenance and update costs of the system increase exponentially. Although significant progress has been made in agent technology based on machine learning in recent years, there are still problems such as insufficient knowledge representation, limited context understanding, and weak cross-domain reasoning ability. The emergence of large language models has brought new possibilities to agent technology. These models are trained through a large amount of text data and have powerful natural language understanding and generation capabilities. However, agents constructed solely relying on large language models still face problems such as poor knowledge timeliness, insufficient depth in professional fields, and limited reasoning accuracy. These problems are more prominent especially in complex business scenarios that require precise professional knowledge and rigorous logical reasoning. Large language models tend to generate fluent but inaccurate answers and lack in-depth mastery and systematic understanding of professional knowledge. Graph-structured knowledge representation, as an important way of knowledge organization, can clearly show the relationships between concepts and the hierarchical structure of knowledge. However, existing graph knowledge applications are mostly static structures and are difficult to adapt to dynamic business environments. At the same time, there is a "disconnection" between traditional graph knowledge applications and large language models, and they cannot effectively combine structured professional knowledge with natural language processing capabilities. Summary of the Invention

[0003] Based on this, the present invention provides an automated construction method for an end-to-end agent based on graph structure semantic fusion to solve at least one of the above technical problems.

[0004] To achieve the above object, an automated construction method for an end-to-end agent based on graph structure semantic fusion includes the following steps: Step S1: Receive the business requirement data input by the user; analyze the business objective and requirement constraint conditions of the business requirement data to obtain structured requirement parameters; perform technical blueprint processing according to the structured requirement parameters to obtain a preliminary end-to-end technical blueprint; Step S2: Perform dynamic workflow processing on the preliminary end-to-end technical blueprint to generate the core workflow framework of the agent; perform multi-modal context understanding according to the structured requirement parameters to obtain multi-modal context information; perform end-to-end execution path analysis on the core workflow framework of the agent based on the multi-modal context information to obtain an end-to-end workflow; Step S3: Obtain multimodal data according to the structured requirement parameters, and construct a dynamically evolving semantic graph; perform dynamic activation of query nodes on the dynamically evolving semantic graph to generate highly activated candidate node data; perform dynamic selection of knowledge fragments on the dynamically evolving semantic graph based on the highly activated candidate node data to obtain preferred knowledge fragments. Step S4: Construct an end-to-end call chain execution strategy based on the end-to-end workflow; perform intelligent agent instance encapsulation through the end-to-end call chain execution strategy and the dynamically evolving semantic graph, and perform enhanced reinforcement learning processing on the intelligent agent instance, so as to automatically construct an end-to-end intelligent agent.

[0005] The present invention realizes the high adaptability of the intelligent agent to complex and changeable business scenarios, and significantly reduces the system maintenance and update costs. Through the analysis of structured requirement parameters and the processing of technical blueprints, the intelligent agent can accurately understand the essence of business requirements and form a scientific and reasonable technical implementation path. The multimodal context understanding mechanism greatly enhances the context awareness ability of the intelligent agent, enabling it to understand and process information from different channels, and overcoming the limitation of limited context understanding in traditional methods. As the core innovation point, the dynamically evolving semantic graph breaks through the limitation that most traditional graph knowledge applications are static structures, and realizes the real-time update and optimization of the knowledge system. Through the dynamic activation of query nodes and the dynamic selection of knowledge fragments, the intelligent agent can accurately extract the professional knowledge most relevant to the current task, solving the problem of insufficient depth of large language models in professional fields. The organic integration of this graph structure and the language model successfully eliminates the "fragmentation" phenomenon between the two, and realizes the seamless connection between structured professional knowledge and natural language processing capabilities. The end-to-end call chain execution strategy ensures the integrity and coherence of task execution, avoiding the common task fragmentation problem in traditional methods. The enhanced reinforcement learning processing mechanism of the intelligent agent instance enables the system to have the ability of self-optimization, continuously improving the performance and accuracy with business practice. The automation feature of the entire construction process greatly reduces the development threshold and labor costs, enabling non-professional technical personnel to quickly construct high-performance intelligent agents that meet specific business requirements. Through the semantic fusion of the graph structure, the accurate expression and flexible application of knowledge are realized, solving core technical problems such as insufficient knowledge representation of traditional intelligent agents and limited inference accuracy of large language models, and providing an efficient, accurate and scalable intelligent agent automation construction solution for various complex business scenarios. Therefore, an automated construction method of an end-to-end intelligent agent based on graph structure semantic fusion according to the present invention realizes accurate knowledge retrieval, context-aware multi-round conversations, and cross-domain dynamic reasoning by integrating graph structure knowledge and the generation ability of large language models, and provides efficient and accurate intelligent services for various complex business scenarios. Description of the Drawings

[0006] Figure 1Schematic diagram of the step process of the automated construction method of the end-to-end agent based on graph structure semantic fusion according to the present invention; The implementation, functional characteristics and advantages of the object of the present invention will be further described with reference to the embodiments and the accompanying drawings. Detailed implementation manners

[0007] The technical method of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are part of the embodiments of the present invention, rather than all of the embodiments. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the scope of protection of the present invention.

[0008] In addition, the accompanying drawings are only schematic diagrams of the present invention and are not necessarily drawn to scale. The same reference numerals in the drawings represent the same or similar parts, and thus repeated descriptions thereof will be omitted. Some of the block diagrams shown in the drawings are functional entities and do not necessarily correspond to physically or logically independent entities. The functional entities can be implemented in software form, or implemented in one or more hardware modules or integrated circuits, or implemented in different networks and / or processor methods and / or microcontroller methods.

[0009] It should be understood that although the terms "first", "second", etc. may be used here to describe various units, these units should not be limited by these terms. These terms are only used to distinguish one unit from another. For example, without departing from the scope of the exemplary embodiments, the first unit can be called the second unit, and similarly the second unit can be called the first unit. The term "and / or" used here includes any and all combinations of one or more of the listed related items.

[0010] To achieve the above object, please refer to Figure 1 , the present invention provides an automated construction method of an end-to-end agent based on graph structure semantic fusion, including the following steps: Step S1: Receive the business requirement data input by the user; analyze the business objective and requirement constraint conditions of the business requirement data to obtain structured requirement parameters; perform technical blueprint processing according to the structured requirement parameters to obtain a preliminary end-to-end technical blueprint; Step S2: Perform dynamic workflow processing on the preliminary end-to-end technical blueprint to generate the core workflow framework of the agent; perform multi-modal context understanding according to the structured requirement parameters to obtain multi-modal context information; perform end-to-end execution path analysis on the core workflow framework of the agent based on the multi-modal context information to obtain an end-to-end workflow; Step S3: Obtain multimodal data according to the structured requirement parameters, and construct a dynamically evolving semantic graph; perform dynamic activation of query nodes on the dynamically evolving semantic graph to generate highly activated candidate node data; perform dynamic selection of knowledge fragments on the dynamically evolving semantic graph based on the highly activated candidate node data to obtain preferred knowledge fragments; Step S4: Construct an end-to-end call chain execution policy based on the end-to-end workflow; perform agent instance encapsulation through the end-to-end call chain execution policy and the dynamically evolving semantic graph, and perform reinforcement learning enhancement processing on the agent instance, so as to automatically construct an end-to-end agent.

[0011] In an embodiment of the present invention, the method for automatically constructing an end-to-end agent based on graph structure semantic fusion includes the following steps: Step S1: Receive the business requirement data input by the user; analyze the business objective and requirement constraint conditions of the business requirement data to obtain structured requirement parameters; perform technical blueprint processing according to the structured requirement parameters to obtain a preliminary end-to-end technical blueprint; In an embodiment of the present invention, the user business requirement data is collected through a multi-channel input interface, including text descriptions, structured forms, and interactive question-and-answer content. The collected business requirement data is processed by a tokenization preprocessor, which uses the byte pair encoding algorithm to split the text into a sub-word sequence, and the vocabulary size is 50,000. The preprocessed text is processed by a self-attention network with a 24-layer transformer architecture, the hidden layer dimension is 4096, and the number of attention heads is 16, capturing long-range dependencies and deep semantics. The text representation data is processed by autoregression, applying the multi-head attention mechanism and the feed-forward neural network to extract key entities and relationships, and at the same time performing intention understanding to generate business intention label data. Based on the intention label data, perform business objective description processing, extract the core entity from the entity list as the target subject and object, and form a business objective entity pair. Subsequently, perform conditional reasoning on the text representation data, extract business constraint conditions, and map the business objective entity pair and the constraint conditions into structured requirement parameters. Based on these parameters, perform task decomposition processing through the generation model specification generation layer, match the industry standard task template, generate a task flow sequence and an API call chain, define evaluation metrics, and finally construct a preliminary end-to-end technical blueprint including an architecture view, component definitions, interface specifications, data flow diagrams, deployment plans, and evaluation mechanisms.

[0012] Step S2: Perform dynamic workflow processing on the preliminary end-to-end technical blueprint to generate the core workflow framework of the agent; perform multimodal context understanding according to the structured requirement parameters to obtain multimodal context information; perform end-to-end execution path analysis on the core workflow framework of the agent based on the multimodal context information to obtain an end-to-end workflow; In the embodiments of the present invention, the preliminary end-to-end technology blueprint is applied to the workflow conversion engine, which uses graph structure analysis technology to extract key task nodes and dependencies. The workflow processing process is implemented through a graph convolutional network, which includes three graph convolutional layers. The activation function is the rectified linear unit. The input and output parameter definitions and pre-dependency conditions are extracted for each node, and a directed acyclic graph is constructed to represent the node interface dependencies. At the same time, according to the structured requirement parameters, various format information such as text, images, and structured data are integrated, and cross-modal fusion is performed through the cross-attention mechanism to generate a context representation. For text data, a 12-layer Transformer encoder is used for processing, and the hidden layer dimension is 1024; image data is used to extract features through a visual encoder, which includes 8 residual blocks; the features of each modality are fused through 4 layers of cross-attention layers to form a unified representation. Based on the multi-modal context information and node dependency data, an autoregressive inference engine is applied to perform execution inference on each task node. The engine is based on a 48-layer causal attention architecture, and the hidden layer dimension is 4096, to analyze the execution conditions and solutions. The inference results are converted into specific operation instructions through an action planner, and a virtual environment simulator simulates the execution of these instructions to generate observation data. The "think-act-observe" loop is iteratively executed until all nodes are covered, forming an extremely long thought chain. The key nodes and execution paths are extracted through a workflow synthesizer to generate the final end-to-end workflow.

[0013] Step S3: Obtain multi-modal data according to the structured requirement parameters, and construct a dynamically evolving semantic graph; perform query node dynamic activation on the dynamically evolving semantic graph to generate highly activated candidate node data; perform knowledge fragment dynamic selection on the dynamically evolving semantic graph based on the highly activated candidate node data to obtain preferred knowledge fragments; In the embodiments of the present invention, a distributed data acquisition framework is deployed based on structured requirement parameters. The framework accesses multimodal data sources through dedicated connectors and performs information acquisition. For text data, the Latent Dirichlet Allocation algorithm is applied for topic modeling to extract core entities. For image data, object detection and scene understanding are performed through a deep convolutional network to extract visual features. A two-tower cross-modal fusion architecture is adopted for information integration to identify entity relationships and event associations between different modalities and construct a cross-modal fusion structure. For each knowledge unit, a globally unique identifier is assigned and meta-information is annotated, including knowledge source, credibility, and timeliness. The knowledge units are organized into a hierarchical structure of a concept layer, a relationship layer, and an instance layer according to abstraction degree and domain relevance, forming a dynamically evolving semantic graph. When a query request is received, the query semantics are parsed and converted into a vector representation, the semantic similarity is analyzed in the graph, and at the same time, the historical access frequency and activation time of nodes are considered to evaluate the activation state of the graph. The activation value is propagated and diffused alternately in the horizontal and vertical directions for 8 rounds. The horizontal propagation is carried out along the same-level relationships, and the vertical propagation is carried out along the hierarchical relationships until the activation value converges. The activation threshold is dynamically calculated based on the query complexity, high-activation nodes are screened, and the graph clustering engine is applied to cluster knowledge nodes. The retrieved enhanced generation technology is used to integrate the clustered knowledge, conflicting knowledge points are identified, and the conflicts are resolved through evaluation of authority, timeliness, and relevance. Finally, an optimized knowledge fragment is generated.

[0014] Step S4: Construct an end-to-end call chain execution strategy based on the end-to-end workflow; perform intelligent agent instance encapsulation through the end-to-end call chain execution strategy and the dynamically evolving semantic graph, and perform intelligent agent instance reinforcement learning enhancement processing, so as to automatically construct an end-to-end intelligent agent.

[0015] In the embodiments of the present invention, a task process directed acyclic graph is constructed based on an end-to-end workflow, and nodes are extracted, edge relationships are constructed, and the graph structure is optimized through three-stage processing. On this basis, a dual-policy network architecture is deployed, including a high-order policy network and an execution policy network. The two share a graph attention network encoder but have independent decision heads. The high-order policy network determines the necessity of retrieval, the execution timing, and the retrieval depth through a three-stage decision-making process; the execution policy network configures specific retrieval parameters and content generation policies. The policy integration engine integrates the decision results of the two levels to generate a complete call chain execution policy. The atomic operations in the call chain are used as the agent action space, and the graph state and interaction context are used as the observation space to construct a training environment. The agent executes task processing based on the call chain policy, collects decision sequences and feedback data. The call chain policy is optimized through a dual-channel learning mechanism. On the one hand, knowledge is transferred from the teacher network based on model distillation, and on the other hand, the proximal policy optimization algorithm is used to perform reinforcement learning. Expert demonstration data is introduced for supplementary training, and the expert operations are imitated through the behavior cloning method. Finally, the optimized parameters are solidified into the agent instance through quantization compression, model graph optimization, knowledge embedding, interface standardization, and containerization encapsulation. When the instance interacts with the user, it performs context awareness and intention understanding, executes multi-step queries to construct an evidence chain, provides personalized responses, and continuously learns from user feedback to complete the whole process of automatically constructing an end-to-end agent.

[0016] Preferably, the analysis of business objectives and requirement constraint conditions for business requirement data in step S1 includes: Perform tokenization preprocessing on the business requirement data to obtain tokenized requirement text; Perform multi-layer self-attention hierarchical association processing on the tokenized requirement text based on the decoder-only architecture to capture long-distance dependencies and deep semantic representations in the text, and obtain requirement text context representation data; Perform autoregressive processing on the requirement text context representation data, and extract key entity and relationship information through the multi-head attention mechanism and the feed-forward neural network in the decoder-only architecture to obtain a list of domain entity information; Perform intention understanding on the requirement text context representation data, identify the main business intention of the user, and generate business intention label data; Perform business objective description processing according to the business intention label data, and at the same time extract the core entities directly related to the business objective from the list of domain entity information as the target subject or object to obtain a preliminary business objective entity pair; Perform context condition reasoning on the requirement text context representation data, and perform constraint condition processing to generate business constraint conditions; Perform structured parameter mapping processing according to the preliminary business objective entity pair and the requirement constraint conditions to obtain structured requirement parameters.

[0017] In the embodiments of the present invention, when performing tokenization preprocessing on business requirement data, first, the BPE (Byte-Pair Encoding) tokenization algorithm is used to process the input business requirement text. The BPE algorithm builds a subword unit dictionary with a vocabulary size of 50,000 by iteratively merging the most frequent character pairs. During the tokenization process, the business requirement text is segmented into a subword sequence, and each subword is assigned a unique numerical identifier. For professional terms and domain-specific vocabulary, a pre-built domain dictionary is used for recognition, and this dictionary contains 5,000 common terms in the field of graph-structured agents. For Chinese text, character-level segmentation is first performed, and then the BPE algorithm is applied; for numbers and special symbols, they are separately marked as independent tokens. The tokenized text retains the original word order and adds a start token [BOS] and an end token [EOS] to form a complete tokenized requirement text sequence. When processing the tokenized requirement text based on a decoder-only architecture, a 24-layer Transformer decoder structure is adopted, with each layer containing 16 attention heads and a hidden layer dimension of 4096. First, the tokenized text is converted into a 768-dimensional vector representation through an embedding layer. Then, positional information is added to each token through a positional encoder, and the positional encoding is generated using sine and cosine functions, with the maximum positional encoding supporting 2048 positions. Next, the text is sequentially processed through 24 self-attention layers. In the self-attention calculation mechanism of each layer, the query, key, and value matrices are obtained by three independent linear transformations of the input vector. The attention calculation adopts a scaled dot-product attention mechanism, and the attention temperature parameter is set to 1.0. To capture long-range dependencies, a sparse attention pattern is adopted, and the input sequence is divided into blocks with a fixed length of 128. Global attention calculation is performed within the block, and local sliding window attention calculation is performed between blocks, with the window size set to 256. After each layer of self-attention, a LayerNorm normalization layer and a residual connection are connected, and finally, it is processed through a position-wise feed-forward network to obtain the context representation vector of each token, with the output dimension remaining 4096, constituting the context representation data of the requirement text. When performing autoregressive processing on the context representation data of the requirement text, an entity recognition head network is introduced, and this network consists of two fully connected layers. The dimension of the first layer is 4096×2048, and the dimension of the second layer is 2048×13 (corresponding to 13 predefined entity type labels). The context representation data is input sequentially from left to right in units of tokens. For each input token, a prediction is made based on all the tokens that have been input. By setting a lower triangular matrix in the attention mask matrix, it is ensured that each position can only access the information of the tokens before it. For the representation vector of each token, the multi-head attention mechanism extracts features from 8 different projection subspaces respectively, with the dimension of each attention head being 512, and then they are concatenated and fused to obtain an enhanced representation.The enhanced representation is achieved through a feed-forward neural network, which consists of two linear transformation layers with a GELU activation function in the middle, mapping vectors to the entity label space. A conditional random field (CRF) layer is applied to globally optimize the label sequence. The size of the CRF transition matrix is 13×13, encoding the transition probabilities between entity types. Finally, consecutive segments of the same label are extracted as entities according to the annotation results, and the type, start position, end position, and corresponding original text of each entity are recorded, forming a structured list of domain entity information containing entity names, types, and location information. The overall text representation is extracted through global pooling operation. Specifically, the context representation vectors of all tokens are averaged to obtain a 4096-dimensional global text representation vector. This vector is processed by an intent classifier, which consists of three fully connected networks. The first layer has a dimension of 4096×1024 and uses the ReLU activation function, the second layer has a dimension of 1024×512 and uses the Tanh activation function, and the third layer has a dimension of 512×42, corresponding to 42 predefined business intent categories. The output of the classifier is converted into a probability distribution through the Softmax function. The three intents with the highest probabilities are selected as candidates, and the semantic compatibility scores between them are calculated. The semantic compatibility is judged by a pre-trained intent relationship matrix, whose size is 42×42, representing the co-occurrence relationship strength between different intent pairs. The final main business intent is determined based on the weighted sum of the main intent probability value and the compatibility score. After the main intent is selected, a business intent label data structure containing the main intent category identifier, intent confidence, and a list of intent keyword triggers is generated. A pre-built intent-goal template library is loaded, which contains 300 mapping relationships between business intents and goal descriptions. Each template defines the syntactic structure of the goal description under a specific intent and the entity slots to be filled. According to the identified main intent label, the corresponding template is queried and matched. Then, from the list of domain entity information, core entities are selected through entity relevance calculation. The relevance calculation adopts a dual scoring mechanism based on location and semantics: the location score considers the distance between the entity and the trigger intent keyword, and the closer the distance, the higher the score; the semantic score is calculated through a pre-trained entity-intent association tensor, whose dimension is 13×42×5000, representing the importance distribution of each domain vocabulary under different entity types and different intents. The subject entity and the object entity are selected according to the relevance ranking, forming a preliminary business goal entity pair, which contains fields such as subject entity identifier, object entity identifier, relationship type, and list of entity attribute values. The selected entities are filled into the template slots to generate a normalized business goal description, which is output together with the entity pair information. A conditional extraction network is deployed, which is based on an autoregressive model structure and consists of 8 transformer decoders with a hidden layer dimension of 2048.First, a conditional semantic mask is applied to the context representation data. The mask is trained to identify the language patterns that represent conditional relationships, including 174 conditional trigger words such as "if" and "when" and their semantic equivalent expressions. The conditional semantic mask is applied to self-attention calculation to enhance the attention weight of conditional expressions. The processed representation vector is subjected to boundary detection by the conditional segmenter, which is composed of a bidirectional LSTM network. The output layer uses CRF for sequence labeling to identify the start and end positions of the conditional statement. After extracting the conditional fragments, each conditional fragment is semantically analyzed separately to identify the condition type (precondition, postcondition, mutually exclusive condition, etc.), condition strength (necessary, sufficient, optional) and involved entities. The condition extraction results are processed by condition normalization and converted into a triple form (conditional subject, conditional predicate, conditional object). Finally, semantically similar conditions are merged to eliminate redundancy and form a structured list of business constraints. The parameter extractor is enabled, which consists of an attention fusion network and a multi-task decoding head. First, the representation vectors of the business target entity pair and the business constraint condition are spliced ​​and input into the attention fusion network. The attention fusion network uses a cross-attention mechanism to calculate the bidirectional attention weights between entity pairs and constraints respectively. The weight calculation uses dot product attention and is scaled by a temperature coefficient of 0.7. The fused representation passes through a two-layer bidirectional GRU network with a hidden state dimension of 1024 to capture long-range dependencies. The fused representation is input into 86 predefined parameter extractors, each of which is responsible for extracting a specific type of parameter, including parameter name, parameter type, parameter value range, parameter default value, parameter unit and other meta information. For numerical parameters, the values ​​and units are extracted through regular matching and validators; for enumeration parameters, legal values ​​are extracted through table lookup matching; for text parameters, the standardized representation is extracted through semantic similarity calculation, and a structured requirement parameter set containing parameter name, parameter value, parameter type, parameter constraint, and parameter dependency is generated and output in JSON format.

[0018] Preferably, in step S1, performing technical blueprint processing on the structured demand parameters based on the GPT model includes: Input the structured demand parameters into the specification generation layer of the GPT model, and perform task decomposition sequence processing according to the preset industry standard task template library and general task decomposition logic to obtain a preliminary task process sequence; Match the API call interface according to the preliminary task flow sequence to obtain the expected API call chain; Based on the structured demand parameters and the preliminary task process sequence, the task completion quality and efficiency evaluation indicators are defined to obtain the task evaluation indicator data; The technical blueprint is processed according to the preliminary task flow sequence, expected API call chain and task evaluation indicator data to obtain a preliminary end-to-end technical blueprint.

[0019] In the embodiments of the present invention, the structured requirement parameters are converted into 1024-dimensional vectors through an input adapter, and after adding the position encoding, they are input into the specification generation layer. This generation layer is based on a 96-layer Transformer architecture, with a hidden layer dimension of 12288 and including 96 attention heads. The model loads a preset industry standard task template library, covering 1500 templates, which are abstracted and annotated from 3000 business scenarios in 50 industries. Task decomposition is achieved through a 10-layer causal self-attention module, with 32 attention heads in each layer, and the depth-first search algorithm is used to recursively decompose complex tasks. The system uses cosine similarity to match the structured requirements with the task templates, and the similarity threshold is 0.85. After the matching templates are decomposed, priorities from 1 to 10 are set for the subtasks, a directed acyclic graph (DAG) of task dependencies is constructed, and a list of subtasks, priorities, and dependencies are output to form a preliminary task flow sequence. Subsequently, an interface knowledge base is loaded, including 5000 structured interface descriptions, covering interface names, function descriptions, parameter specifications, call constraints, etc., which are extracted and maintained based on the mainstream open platform documents. The interface matching engine uses a 24-layer Transformer encoder with a hidden layer dimension of 1024 to convert each subtask into a 768-dimensional query vector, calculate the dot product similarity with the interface vectors, and select the top 5 candidate interfaces with the highest similarity. A three-layer graph attention network (GAT) is introduced, with a node feature dimension of 512 in each layer, to globally optimize the interface candidates, comprehensively considering interface compatibility, data flow, and call efficiency, and generate an interface call chain, including call order, parameter passing relationship, and error handling strategy. The evaluation metric generator is based on a 12-layer encoder-decoder structure with a hidden layer dimension of 2048, extracts key constraints from the requirement parameters, sorts them using an importance ranking algorithm (considering frequency, semantic intensity, and business impact), and jointly inputs them with the task flow into a multi-layer perceptron network (with hidden layer dimensions of 1024, 512, and 256 in sequence), which are mapped into 18 detailed evaluation metrics, covering task quality (accuracy, integrity, consistency), efficiency (response time, throughput, resource occupancy rate), and stability (error rate, recovery time, fault tolerance). Each metric defines an evaluation method, threshold, weight, and period, and outputs a structured metric system. The blueprint generation module uses a 32-layer Transformer architecture (with a hidden layer dimension of 4096), integrates data from different sources through multi-modal fusion, constructs a technical component graph, where the nodes represent components and the edges represent interaction relationships. The graph is converted into a 256-dimensional vector through an embedding algorithm and matched with 150 predefined architecture patterns (the pattern library is derived from 1000 successful cases), and the optimal architecture combination is automatically selected to form a preliminary architecture skeleton. The final end-to-end blueprint includes an architecture view, component definitions, interface specifications, data flow diagrams, deployment plans, and evaluation mechanisms, realizing an intelligent mapping from structured requirements to system implementation.

[0020] Preferably, in step S2, an end-to-end execution path analysis is performed on the core workflow framework of the agent based on multi-modal context information: Extract the expected input, output, and dependencies of each task node according to the core workflow framework of the agent to generate node interface dependency data; Aggregate node information based on the node interface dependency data and multi-modal context information to obtain a node context information package; Perform task event execution reasoning on the node context information package based on the thinking step in the React mechanism to obtain a node execution reasoning sequence; Determine task operations based on the node execution reasoning sequence based on the action step in the React mechanism to obtain node action instruction data; Simulate the execution of the node action instruction data based on the observation step in the React mechanism to obtain node expected observation data; Iteratively execute the thinking, action, and observation steps until all intermediate links in the preliminary end-to-end technology blueprint are covered, and concatenate the node execution reasoning sequence, node action instruction data, and node expected observation data into an end-to-end execution path to form an ultra-long thinking chain; Use the ultra-long thinking chain to determine the nodes and paths of the workflow to obtain an end-to-end workflow.

[0021] In the embodiments of the present invention, a workflow parser is used to perform a structured analysis on the preliminary end-to-end technical blueprint. The parser includes a three-layer graph convolutional network (with convolutional kernel sizes of 32, 64, and 128) for processing the directed graph structure after the blueprint conversion. The graph nodes represent tasks, and the edges represent the data flow direction. Each node extracts four types of information through a feature extractor: input parameters, output definitions, preconditions, and trigger rules. The feature extractor is a bidirectional LSTM structure with a hidden layer dimension of 512 and a sequence length of 128. The node dependency relationship determines the execution order through topological sorting, and the critical path is identified through depth-first traversal. The interface dependency score is calculated based on data type compatibility, semantic consistency, and conversion complexity, and the result is output in the form of a DAG, including node identifiers, interface specifications, dependency types, and strengths. After parsing, a cross-attention mechanism is introduced to fuse multimodal context information, including structured data (a 6-layer transformer encoder, 768 dimensions), text descriptions (a 12-layer encoder, 1024 dimensions), image examples (a visual encoder with 8 residual blocks, 256 channels), and historical records (a 3-layer bidirectional GRU, 512 dimensions). The fusion process is completed through a 4-layer cross-attention network, and the fusion weights are automatically determined by the meta-learning method. The fusion result is concatenated with the interface dependency data in a tensor, and after being processed by a two-layer feed-forward neural network, a 2048-dimensional node context information packet is generated, which is further compressed to 1024 dimensions through non-linear dimensionality reduction. The node information and the inference prompt template (task objectives, known conditions, resource lists, constraint descriptions, expected outputs) are input into the inference engine. The inference process adopts a recursive thinking chain mechanism with a depth of no more than 7 layers, and the text generated in each layer does not exceed 100 words. It is divided into five stages: problem decomposition, condition analysis, resource matching, solution construction, and risk identification. The confidence level is calculated for each step of the inference, and the paths with a confidence level lower than 0.75 are pruned. The output includes the inference sequence, key decision points, decision bases, and expected results. The inference sequence is further input into the intent parsing module to extract the action intent, operation object, execution conditions, and expected effects. The parsing is implemented through a 5-layer graph attention network (with a hidden layer of 1024 dimensions in each layer) to generate a structured intent representation. The structured intent is matched with the operation library, which contains 2000 basic operation templates, defining the operation names, parameters, pre / post-conditions, and resource requirements. The matching uses cosine similarity calculation with a semantic error correction mechanism. For composite operations, a hierarchical reinforcement learning algorithm is used to decompose them up to 5 layers at most, and the feasibility of the operation sequence is evaluated. The metrics cover the completion degree, resource consumption, execution time, and risk level. The optimization process uses beam search (width 16) to output the operation sequence, parameter configuration, execution conditions, and error handling strategies. Then, the action execution engine receives the above instruction data and executes the operations in sequence. Before execution, it verifies whether the preconditions are met through graph pattern matching, and then calls the processing function to update the state of the graph database environment in a transaction mechanism to ensure atomicity. The external interaction is completed by the interface simulator, and the simulated response is based on 5000 predefined response templates.During the execution process, record the changes in the environmental state, trigger events, resource consumption, and execution duration. Based on the above data, the observation generator constructs state differences, event logs, performance metrics, and anomaly records; complex observations are generated by a 16-layer transformer decoder (hidden layer 2048) to produce detailed descriptions. The output node observation data includes state changes, intermediate results, execution logs, and performance statistics. The entire operation adopts a "think-act-observe" loop mechanism, and the loop result is used as the next input to form a closed-loop control. An execution path graph is constructed for each node, and the nodes are arranged in a DAG structure according to topological sorting. Support for automatic node decomposition: if the complexity evaluation value is greater than 85, the node is disassembled into several child nodes. Set the maximum number of iterations to 500, and when the state difference is less than 0.01 for three consecutive rounds, it is considered convergent. After all nodes are processed, the inference sequence, action instructions, and observation data are concatenated to form an extremely long thought chain (the length can exceed 100,000 words). To improve processing efficiency, the thought chain is divided into segments of 4096 words, with an overlap of 2048 words between segments. Each segment extracts key task nodes (using a 7-layer BiLSTM, hidden layer 768) and their data / control flow relationships (implemented through a 6-layer graph attention network, with 8 heads per layer) through a named entity recognition module. A cross-segment integration algorithm is used to solve boundary conflicts between segments and assemble all nodes and dependencies into a complete workflow graph. The workflow is further processed by a path optimization engine, and the optimization goal is to minimize the execution path length and maximize the parallelism. The optimization model is based on a constraint satisfaction solving framework, and the constraints come from resource limitations, temporal dependencies, and business rules. Conditional branch modeling uses a decision tree with a depth of no more than 10 layers, and the loop structure identifies the entry, body, and exit conditions and encapsulates them as modular components. The final end-to-end workflow output includes node definitions, execution paths, data flow graphs, control flow graphs, and resource allocation plans, realizing full-chain automated execution support from high-level blueprints to refined operation processes.

[0022] Preferably, in step S3, obtaining multi-modal data according to the structured requirement parameters and constructing a dynamically evolving semantic graph includes: Access multi-modal, multi-paradigm data sources, and collect multi-modal information according to the structured requirement parameters to obtain multi-modal data; Perform topic modeling and keyword extraction on the text data in the multi-modal data to obtain text core entity data; Perform salient object detection and scene understanding on the image data in the multi-modal data to obtain image core feature data; Perform cross-modal alignment and information integration on the text core entity data and the image core feature data, and identify the entity relationships and event associations between different modal information to obtain cross-modal fusion structure information; Allocate knowledge unit identifiers to cross-modal fusion structure information and perform meta-information annotation to obtain annotated knowledge unit data, where the meta-information annotation includes knowledge source, credibility, and timeliness; Evaluate the knowledge abstraction level and domain relevance of the annotated knowledge unit data, and organize them into a hierarchical structure of concept layer, relationship layer, and instance layer to obtain multi-dimensional knowledge management graph structure data; Perform domain knowledge base filling processing based on the multi-dimensional knowledge management graph structure data to construct a dynamically evolving semantic graph.

[0023] In the embodiments of the present invention, the system deploys a distributed data acquisition framework that supports the access of five types of data sources, namely structured data, text, images, audio, and sensors. Each type of data source is collected by a dedicated connector and preprocessed through standardization to construct a multi-modal dataset. The structured parameters are transformed into 128-dimensional query vectors through a parameter mapper and then input into an inverted index and vector dual-engine retrieval system. Under the limitation of 3000 domain identifiers, high-quality data is obtained. The relevance score covers match degree, timeliness, and authority, and the screening threshold is set to 0.75. The text data is cleaned through steps such as Chinese word segmentation, stop word filtering, and lemmatization, and the LDA model is used for topic modeling to automatically determine 5 to 30 topics, outputting a topic distribution matrix and a keyword set. After the image data is subjected to size normalization and enhancement processing, it is input into a two-stage saliency detection network to extract object bounding boxes, class labels, and pixel-level masks. At the same time, an attention-enhanced fully convolutional network is used for scene understanding, outputting a semantic segmentation map and a scene probability distribution to form image core feature data. The system adopts a dual-tower cross-modal fusion architecture, encoding text and image features into 512-dimensional unified vectors through a 12-layer text transformer and a 24-layer vision transformer respectively. Modal alignment is established through contrastive learning, and the similarity calculation uses temperature-scaled cosine similarity. The Hungarian algorithm is used to achieve the optimal matching of entities. For entity pairs with a match degree higher than 0.8, feature splicing and fusion are performed, and projection is completed through a two-layer fully connected network. Further, 50 types of relationship types between cross-modal entities are identified through an 8-layer graph attention network to form fused structural information. The knowledge identification manager assigns 64-bit hierarchical coding identifiers to each knowledge unit to ensure uniqueness in the distributed system. Subsequently, meta-information annotation is carried out, including data source (tracked by the traceability analyzer), credibility (based on evidence strength), and timeliness (classified and marked with a validity period by the time sensitivity analyzer). After the knowledge unit, along with its identifier and meta-information, is encapsulated, a standardized annotated knowledge dataset is formed. In the knowledge representation learning stage, the system embeds the knowledge unit into a 300-dimensional vector space and evaluates its abstraction level (from 1 to 5 levels) based on the cosine distance from 1000 abstract concept sets. Combining with the domain ontology library (covering 50 core domains and 200 concepts / domains), the association degree between the knowledge unit and the target domain is calculated through a weighted graph traversal algorithm. Accordingly, the knowledge is organized into a three-layer structure: the concept layer (abstraction level 4-5), the relationship layer (abstraction level 2-3), and the instance layer (abstraction level 1), and a multi-dimensional knowledge management graph is constructed through an inter-layer pointer mechanism. The knowledge graph construction engine consists of a graph builder, a conflict resolver, and a knowledge reasoner, and adopts an incremental construction strategy. First, the nodes of the concept layer are imported to establish a semantic skeleton. Then, the relationship layer is imported to create semantic connections. Finally, the instance layer is imported to link specific samples. Conflict detection is based on three types of constraints: identifier uniqueness, logical consistency, and relationship completeness, and is processed using 23 rules.The knowledge reasoner implements three types of inference logics, namely transitive, dual, and combinatorial, using inductive logic programming, and periodically updates the inference results in batches to improve the completeness of the knowledge graph. The final knowledge graph is stored based on the property graph model, with nodes, edges, attributes, and a time snapshot mechanism, supporting dynamic evolution, including three types of evolution operations: update, expansion, and abandonment, and is accompanied by consistency checks to ensure the stability and usability of the semantic graph.

[0024] Preferably, in step S3, query node dynamic activation of the dynamically evolving semantic graph includes: Receiving the user's current query behavior, and performing behavior semantic parsing to obtain the current user query semantics; Performing semantic representation processing on the current user query semantics to obtain a query semantic vector; Extracting the node historical access frequency and the node's most recent activation time from the dynamically evolving semantic graph; Using the query semantic vector as input, performing semantic similarity analysis in the dynamically evolving semantic graph to obtain node semantic similarity data; Based on the node semantic similarity data, the node historical access frequency, and the node's most recent activation time, performing a graph activation state evaluation to obtain graph activation state data; Performing horizontal-vertical alternating propagation processing on the dynamically evolving semantic graph through the graph activation state data to generate a diffused node activation value graph; Evaluating the query complexity according to the current user query semantics, dynamically calculating the activation threshold for this query to obtain a dynamic activation screening threshold; Based on the dynamic activation screening threshold, screening out all nodes with activation values exceeding the dynamic activation threshold from the diffused node activation value graph to generate high-activation candidate node data.

[0025] In the embodiments of the present invention, a multi-channel input receiver supports three input methods: text, voice, and image. For text, it is directly acquired. For voice, 40-dimensional Mel-frequency cepstral coefficients are recognized and extracted through a convolutional-recurrent neural network. For images, the query intention is recognized by a visual question answering converter (including a 16-layer visual encoder and a 12-layer text decoder). The parsing module processes the query using a three-stage pipeline: dependency syntactic analysis (constructing a syntactic tree with 10 layers of bidirectional GRUs), intention recognition (dividing the domain, intention, and slots using conditional random fields), and anaphora resolution (using a dynamic memory network with a context window of 8). The parsing result outputs a structured query semantics. The query semantics are encoded by a 24-layer transformer semantic encoder with a hidden layer dimension of 1024 and 16 attention heads. The text is first tokenized, part-of-speech tagged, and entity linked, with an embedding dimension of 512. A 768-dimensional semantic vector is generated through attention pooling and normalized. The graph access statistic records the node access history and activation time. The access count uses an exponential decay model, and the timestamp uses a circular buffer (recording up to 50 times at most). The statistical data outputs the node identifier, historical access frequency, and the most recent activation time. The semantic graph matching uses a two-path similarity engine, including a semantic matching network (where the node and the query are respectively encoded into 768-dimensional vectors through independent 24-layer transformers to calculate the cosine similarity) and a structure matching network (a 5-layer graph attention network with a feature dimension of 256, considering node position and neighborhood structure). The similarities of the two are fused at a ratio of 7:3 to output a matching score. The graph activation state evaluation is completed through a three-stage multi-factor model. In the first stage, the semantic similarity, access frequency, and activation time are normalized. In the second stage, it is input into a multi-layer perceptron (three layers of 64-32-16, with ReLU activation) to output an activation score. In the third stage, the sigmoid function is applied to convert the score into a binary activation flag. Based on the activated nodes, the activation diffusion engine is started, and a message passing neural network is used for 8 rounds of horizontal-vertical alternating propagation. The horizontal propagation is based on the relationship type and propagation factor (0.85), and the vertical propagation is based on the hierarchical relationship and hierarchical factor (0.8). After each round, the softmax function with a temperature parameter of 0.5 is used to normalize the node activation values. To adapt to the query complexity, a complexity evaluation engine is deployed, which includes three parallel modules: semantic complexity (based on entity density and relationship complexity, scored from 0 to 10), domain span (calculated through the cosine similarity between the query vector and 50 domain vectors, with a score range of 1 to 50), and context dependence (scored through the density of pronouns and the slot missing rate, ranging from 0 to 5). The three items are weighted and summed according to the weights of 5:3:2 to dynamically adjust the activation screening threshold: threshold = base value 0.65×(1 - complexity adjustment factor 0.5×normalized score). The adaptive filter filters out the highly activated nodes from the nodes output by the diffusion graph.The first step is to statistically analyze the activation value distribution (maximum, minimum, mean, median, quartiles, standard deviation); the second step is to compare the percentile position of the dynamic threshold, and linearly interpolate and adjust the threshold if necessary to ensure reasonable results (the number of nodes is not less than 50 and does not exceed 10%); the third step is to filter out the nodes that meet the activation value ≥ threshold, and sort them according to the activation value and weighted importance score, and output the node identifier, activation value, importance score and core attributes.

[0026] Especially importantly, the horizontal-vertical alternating propagation processing of the dynamically evolving semantic graph through the graph activation state data is specifically as follows: Use the graph activation state data as the initial node activation value for iterative processing, and perform horizontal activation diffusion calculation on the nodes in the dynamically evolving semantic graph to obtain the node activation value after horizontal diffusion processing; Based on the node activation value after horizontal diffusion processing and the defined vertical hierarchical relationship and propagation rules in the dynamically evolving semantic graph, perform vertical activation diffusion calculation on the nodes in the dynamically evolving semantic graph to obtain the node activation value after a single round of alternating propagation; Perform iterative horizontal-vertical alternating propagation processing according to the node activation value after a single round of alternating propagation until the node activation value meets the preset convergence condition or reaches the preset maximum number of iterations to obtain the final stable activation value of each node; Based on the final stable activation value of each node, assign the activation state to each node in the dynamically evolving semantic graph to generate the node activation value map after diffusion.

[0027] In the embodiments of the present invention, when using the atlas activation state data as the initial node activation value for iterative processing, first construct an activation value vector. The vector dimension is equal to the total number of atlas nodes. For the nodes marked as activated in the corresponding atlas activation state data, assign an initial activation value of 1.0, and assign 0 to the unactivated nodes. Then start the horizontal activation diffusion calculator, which is based on the graph convolutional network architecture to achieve activation propagation between nodes. The horizontal diffusion only occurs between nodes at the same level. Extract the horizontal relationship matrix from the dynamically evolving semantic atlas. The size of the matrix is N×N (N is the total number of nodes), and the matrix elements represent the connection strength between nodes, with a value range of [0, 1]. The diffusion calculation formula is: new activation value = current activation value + ∑(neighbor node activation value × connection strength × distance attenuation coefficient), where the distance attenuation coefficient D = 0.85^L, and L is the propagation step. Set the activation truncation threshold to 0.01, and activation propagation below this value will be ignored to improve calculation efficiency. The calculation process is implemented using sparse matrix multiplication. The large-scale atlas is divided into multiple subgraphs for parallel processing through graph partitioning technology. Each subgraph contains no more than 10,000 nodes. After the horizontal diffusion is completed, output the node activation value vector after horizontal diffusion processing, which contains the updated activation values of all nodes. When performing vertical activation diffusion calculation based on the node activation values after horizontal diffusion processing, deploy a hierarchical propagation engine, which is specifically used to handle the activation transfer between the three-layer structure (concept layer, relationship layer, and instance layer) in the dynamically evolving semantic atlas. First, extract the vertical hierarchical relationship matrix from the atlas. This matrix consists of three sub-matrices: the mapping matrix C2R from the concept layer to the relationship layer, the mapping matrix R2I from the relationship layer to the instance layer, and their transpose matrices. The vertical diffusion follows the directional propagation rule: different propagation weights are used for upward propagation (from specific to abstract) and downward propagation (from abstract to specific). The upward propagation weight ωup is set to 0.6, and the downward propagation weight ωdown is set to 0.8. The propagation calculation formula is: target layer activation value = target layer current activation value + source layer activation value × propagation weight × hierarchical correction factor, where the hierarchical correction factor is adaptively adjusted according to the hierarchical difference, 1.0 for adjacent layers and 0.5 for cross-layers. Calculate each hierarchical node according to the topological sort to ensure correct handling of dependencies. After all hierarchical propagations are completed, apply the sigmoid normalization function to compress the node activation values into the [0, 1] interval, and output the node activation value vector after a single round of alternating propagation. When performing iterative horizontal-vertical alternating propagation processing based on the node activation values after a single round of alternating propagation, deploy an iterative controller, which manages the execution process of the entire propagation process. Set the maximum number of iterations to 20 rounds, and each round includes one horizontal diffusion and one vertical diffusion. The iterative controller calculates the activation value change rate after each round of iteration. The change rate calculation formula is: change rate = ∑|current round activation value - previous round activation value| / ∑ current round activation value, where ∑ represents the sum over all nodes. Set the convergence threshold to 0.01, and when the change rate is lower than this threshold, it is determined to converge and stop the iteration.To prevent the divergence of activation values, global normalization is applied after each iteration by dividing all node activation values by the maximum activation value to ensure that the activation values are in the range of [0, 1]. At the same time, an activation history matrix is maintained to store the activation values of each node in each iteration for analyzing the convergence trend and detecting oscillation phenomena. For the detected oscillating nodes, a damping factor of 0.7 is applied to slow down the change rate of their activation values. The iteration process is executed in batch mode, with 10,000 nodes processed in each batch, and the efficiency is improved through multi-threaded parallel computing. After the iteration is completed, the final stable activation value vector of each node that meets the convergence condition is output. When assigning activation states to the nodes in the dynamic evolution semantic graph based on the final stable activation values of each node, an activation mapping engine is deployed, which converts the continuous activation values into the graph representation form. First, post-processing is performed on the stable activation values, including denoising and enhancement steps: the activation values are smoothed by a Gaussian filter with a standard deviation of 0.5; the activation value differences are enhanced through a contrast enhancement function, and the enhancement formula is: enhanced activation value = (original activation value - mean) × gain coefficient + mean, with the gain coefficient set to 1.5. Then, the processed activation values are combined with the node metadata to construct a diffused node activation value graph. This graph is represented using an attribute graph model, and each node contains five types of key attributes: basic identification attributes (node ID, type, name), semantic attributes (definition, description, keywords), relationship attributes (in-degree, out-degree, relationship type statistics), activation attributes (original activation value, regularized activation value, activation ranking), and metadata attributes (creation time, modification time, source). The activation attributes of the nodes in the graph database are updated through atomic operations to ensure data consistency. After the update is completed, an activation value index is established to support fast queries based on the activation value range. The finally generated diffused node activation value graph is serialized in JSON format and at the same time maintains the graph structure representation in memory to support subsequent efficient query and analysis operations.

[0028] Preferably, the dynamic selection of knowledge fragments for the dynamic evolution semantic graph based on the high-activation candidate node data in step S3 includes: Performing a knowledge node clustering operation on the dynamic evolution semantic graph based on the high-activation candidate node data to obtain semantic clustering knowledge clusters; Using the RAG technology to integrate the knowledge fragments of the semantic clustering knowledge clusters to obtain preliminary integrated knowledge fragments; Identifying the conflicting knowledge points and their sources based on the preliminary integrated knowledge fragments to obtain a potential knowledge conflict list; When the potential knowledge conflict list is not empty, comprehensively evaluating and weighting the authority, information timeliness, and relevance to the current query of the knowledge sources associated with the conflicting knowledge points to obtain conflict knowledge source weight evaluation data; Resolving the conflicting knowledge points in the preliminary integrated knowledge fragments based on the conflict knowledge source weight evaluation data to obtain preferred knowledge fragments.

[0029] In the embodiments of the present invention, when performing knowledge clustering operations on a dynamically evolving semantic graph based on highly activated candidate node data, a graph clustering engine is deployed, and a multi-perspective clustering strategy is adopted. First, four types of feature vectors are extracted from the highly activated nodes: semantic vectors (768-dimensional embedding representations), structural vectors (including 10 graph topology metrics such as degree centrality and betweenness centrality), activation vectors (node activation values and their first and second derivatives), and attribute vectors (vectors obtained by one-hot encoding discrete attributes such as node type, level, and timeliness). After constructing the feature vectors, spectral clustering algorithm is used for clustering: first, a similarity matrix is calculated based on cosine similarity, then the first K eigenvectors of the graph Laplacian matrix are extracted for low-dimensional representation, and finally clustering is performed by the K-means algorithm. The number of clusters K is automatically determined by the silhouette coefficient. To improve processing efficiency, the Nyström approximation method with a 20% sampling rate is adopted, and the central nodes of each cluster are identified through density peak detection, and the clustering compactness is calculated. The output is a semantic clustering knowledge cluster containing cluster ID, member nodes, central nodes, and compactness. When integrating knowledge fragments of the semantic clustering knowledge cluster, a two-stage retrieval generator is deployed, including a dense retrieval module and a knowledge integration module. The dense retrieval module constructs a 1536-dimensional query vector (concatenated by the user query vector and the cluster central node vector), and uses maximum inner product search to retrieve relevant knowledge units in the knowledge graph index. The index structure is a hierarchical vector index, including 100 first-level clusters and 10,000 second-level buckets below them, and the recall upper limit is set to 200 units. The recall results are re-ranked by a 24-layer cross-attention encoder, and the top 50 knowledge units are selected as integration materials. The knowledge integration module is based on a 32-layer transformer, uses beam search decoding (beam width 5), combines fixed templates (task definition, integration requirements, conflict handling, etc.) to generate preliminary knowledge fragments, and finally performs format standardization and citation annotation to output coherent knowledge narratives and relationship explanations. When identifying conflicting knowledge points in the preliminary integration fragments, a knowledge consistency analyzer is deployed to execute a three-layer conflict detection process. First, the knowledge fragments are decomposed into atomic triples, and the extraction method combines graph convolutional dependency syntax analysis and named entity recognition. Subsequently, the contradiction detection rule library is matched, covering 150 domain conflict patterns and 30 logical rules, supporting direct conflicts (such as "A is B", "A is not B"), numerical conflicts (judged by numerical interval overlap), and implicit conflicts (indirect contradictions are discovered through inference chains). The severity score of each conflict is comprehensively calculated according to the type, source credibility, and content importance. Through the traceability mechanism, combined with citation marks and knowledge graph metadata, the conflict source is identified, and a conflict list containing conflict type, conflict expression, severity, related entities, and source is formed. When there are conflicting knowledge points, a multi-dimensional weighted evaluation is performed on their associated knowledge sources, and a three-dimensional evaluation engine is deployed to quantify the quality of knowledge sources from three perspectives: authority, timeliness, and relevance.The authoritative score considers the data type hierarchy, the score of the publishing agency, the citation frequency, and the certification status, with the weight distribution being 3:3:2:2; the timeliness score is based on the publication time (calculated by exponential decay), the update frequency, and the version number, with a weight of 5:3:2; the relevance is evaluated by querying the semantic similarity and topic matching degree with the content, with a weight of 7:3. Finally, the three scores are linearly weighted and aggregated to output the evaluation data with the knowledge source identifier and the three-dimensional score. Based on the conflict knowledge source weight data, a conflict resolver is deployed to resolve the conflict knowledge points. The weight comparison strategy is preferentially adopted. If the weight of a certain source is significantly higher (the difference exceeds 0.3), it is directly adopted; when the weights are close, the majority voting strategy is used to make a weighted decision according to the number of supporting sources; if it cannot be determined, the knowledge fusion strategy is applied, such as predicate reconciliation or conditional restriction methods to generate a compatible expression; for deep conflicts that cannot be resolved, the uncertainty marking strategy is adopted to clearly mark the controversial content. The entire conflict resolution process is implemented in a decision tree structure, and the nodes are determined based on the conflict type, weight difference, and knowledge importance. The finally output preferred knowledge fragment includes: the conflict-resolved consistent knowledge content, the uncertainty marking, and the knowledge source information, constituting a structured knowledge representation.

[0030] Preferably, the end-to-end call chain execution policy based on the end-to-end workflow in step S4 includes: Construct a task flow directed acyclic graph according to the end-to-end workflow; Deploy a dual policy network architecture based on the task flow directed acyclic graph; among them, the deployment of the dual policy network architecture includes a high-order policy network and an execution policy network; Judge the necessity of retrieving the task flow directed acyclic graph through the high-order policy network, select the execution time, and set the retrieval depth to obtain an instance of the high-order decision network; Set the specific retrieval parameters that should be adopted for retrieving nodes and the specific content generation strategy that should be adopted for each generated node of the task flow directed acyclic graph through the execution policy network to obtain an instance of the execution policy network; Construct an end-to-end call chain execution policy according to the instance of the high-order decision network and the instance of the execution policy network.

[0031] In the embodiments of the present invention, when constructing a task flow directed acyclic graph according to an end-to-end workflow, a workflow graph structure converter is deployed, and the converter adopts a three-stage processing flow. In the first stage, node extraction is performed to identify four types of key nodes from the end-to-end workflow: retrieval nodes (responsible for knowledge acquisition), processing nodes (responsible for information transformation), generation nodes (responsible for content creation), and decision nodes (responsible for conditional branching). Each node is assigned a globally unique identifier, encoded with 32 bits. The first 8 bits represent the node type, and the last 24 bits are the sequence number. In the second stage, edge relationship construction is carried out to determine the directed connections between nodes based on the dependencies in the workflow. The dependencies are divided into two types: strong dependencies (the preceding nodes must be completed) and weak dependencies (the preceding nodes are preferably completed), which are marked by edge attributes. The edge weights are set according to the dependency strength, ranging from 1 to 10, with the default value of 10 for strong dependencies and 5 for weak dependencies. In the third stage, graph optimization is performed. Redundant edges are detected and removed through the transitive closure algorithm, the critical path analysis is applied to identify execution bottlenecks, and the earliest start time and the latest completion time of each node are calculated. The finally generated directed acyclic graph is stored in an adjacency list structure, including a node attribute table and an edge relationship table, supporting efficient traversal and parallel execution planning. When deploying a dual-policy network architecture based on the task flow directed acyclic graph, first, a policy network infrastructure is constructed. This architecture includes two core components: a high-order policy network and an execution policy network. Both share a task graph encoder but have independent decision heads. The task graph encoder adopts a graph attention network structure, including 5 layers of graph convolutional layers, with 16 attention heads in each layer and a feature dimension of 256. The encoder represents the task graph as a combination of a node feature matrix and an adjacency matrix. The node features include node type, resource requirements, estimated execution time, and historical performance metrics. The graph encoding process is divided into two steps: local feature extraction captures the structural information around the nodes through a neighborhood aggregation function; global feature extraction generates an overall graph representation through a readout function. The high-order policy network is constructed based on a transformer decoder, including 12 attention blocks with a hidden layer dimension of 1024, for macro decision-making; the execution policy network is constructed based on a multi-head attention mechanism, including 8 attention heads, each of which focuses on different execution parameter dimensions, for micro operations. The two networks achieve knowledge sharing through a policy distillation mechanism, and the decision output of the high-order network is used as the conditional input of the execution network. The policy network is trained by a reinforcement learning method, adopting the proximal policy optimization algorithm, and the reward function is designed based on three dimensions: task completion quality, resource efficiency, and execution time. When the high-order policy network makes a retrieval operation judgment on the task flow directed acyclic graph, a three-stage decision-making process is adopted. In the first stage, necessity judgment is carried out. The high-order policy network receives the graph encoding features, the current execution state vector, and the historical retrieval records as inputs and outputs a retrieval necessity score. The necessity score is calculated based on three metrics: information uncertainty (quantified by the knowledge graph coverage rate), task complexity (evaluated by the number of dependencies between nodes), and the degree of fuzziness of the user query (calculated by the entity slot filling rate).When the necessity score exceeds the preset threshold of 0.75, the retrieval is determined to be necessary. In the second stage, the execution timing is selected. The network calculates the optimal execution time point, considering three factors: the completion status of dependent nodes, resource utilization, and expected retrieval latency. The timing score is modeled using a continuous-time Markov decision process, and the state transition probability is learned based on historical execution data. In the third stage, the retrieval depth is set. The network determines the retrieval depth level (levels 1 - 5) according to the task importance, time constraints, and expected information gain. Each level corresponds to a different retrieval resource allocation strategy. The depth calculation uses a method based on Monte Carlo tree search to simulate the retrieval results at different depth levels and their impact on subsequent nodes. The final output is a high-order decision network instance that includes the necessity judgment result, execution timing parameters, and retrieval depth settings. When setting the retrieval parameters and content generation strategies for the task flow directed acyclic graph through the execution policy network, two sets of parallel decision-making mechanisms are implemented. For retrieval nodes, the execution policy network individually configures five types of retrieval parameters for each node: the retrieval keyword generation strategy (based on context entity extraction or query expansion), retrieval scope limitation (knowledge base scope, time window, source type filtering), sorting method (relevance priority, timeliness priority, or authority priority), recall quantity (range 10 - 100, step size of 10), and depth fusion method (shallow splicing or deep semantic fusion). The parameter determination process uses a context-aware multi-armed bandit algorithm to dynamically adjust the exploration-exploitation balance based on historical retrieval effects. For generation nodes, the execution policy network sets three types of generation strategies: prompt template selection (selected from a preset library of 37 domain-specific prompt templates), decoding strategy (beam search, nucleus sampling, or greedy decoding), and generation parameter configuration (temperature coefficient, output length limit, and diversity control factor). The strategy selection is based on node characteristics, the output quality of upstream nodes, and task objective requirements, and is achieved through a deep Q-network that includes three fully connected layers with hidden layer dimensions of 512, 256, and 128. An independent strategy configuration is assigned to each generation node to form a fine-grained control scheme at the node level, and an execution policy network instance containing the complete parameter set is output. When constructing an end-to-end call chain execution policy based on the high-order decision network instance and the execution policy network instance, a policy integration engine is deployed. This engine generates the final execution policy through a four-stage processing flow. In the first stage, policy alignment verification is performed to detect the consistency between the high-order decision and the execution policy. A contradiction detection algorithm is used to identify conflict points, such as the situation where the high-order network determines the retrieval to be unnecessary while the execution network still configures retrieval parameters. Conflict resolution gives priority to adopting the high-order decision while recording the reasons for adjustment. In the second stage, an execution plan is generated by converting the task flow diagram into a specific call sequence, including API call specifications, parameter passing schemes, and error handling strategies. The conversion process uses topological sorting to determine the execution order, and for parallelizable nodes, the critical resource dependencies are calculated to determine the degree of parallelism.In the third stage, resource allocation optimization is carried out. Compute resources are allocated according to node importance and resource requirements, and a linear programming algorithm is used to maximize throughput. The constraint conditions include total memory limit, number of CPU cores, and network bandwidth. In the fourth stage, execution monitoring points are implanted. 16 types of monitoring checkpoints are set at key nodes, including intermediate result verification, timeout detection, and quality assessment. Each checkpoint is configured with triggering conditions and response strategies, such as retry logic, degradation schemes, and failure recovery mechanisms. The end-to-end call chain execution strategy output contains a complete execution graph, a resource configuration table, a monitoring rule set, and an exception handling process.

[0032] Preferably, the encapsulation of the agent instance through the end-to-end call chain execution strategy and the dynamically evolving semantic graph in step S4 includes: Taking the atomic operations in the end-to-end call chain execution strategy as the optional action space of the agent, and taking the current state of the dynamically evolving semantic graph and the user interaction context as the state observation space of the agent to obtain the agent interaction training environment; Based on the agent interaction training environment, taking the preferred knowledge fragments as the retrieval enhancement source of the RAG technology, performing scenario task processing based on the end-to-end call chain execution strategy, and collecting the decision sequence, resource consumption, and preliminary output results of the agent during task execution to obtain scenario task execution feedback data; Adopting a dual-channel learning mechanism to iteratively optimize the end-to-end call chain execution strategy. At the same time, according to the scenario task execution feedback data, using the proximal policy optimization algorithm for reinforcement learning, and applying a clipping update strategy to adjust the network parameters to maximize the cumulative reward to obtain a scenario-optimized call chain strategy; Based on the scenario-optimized call chain strategy, conducting expert demonstration supplementary training and agent reinforcement learning to obtain optimized agent policy network parameters; Solidifying the optimized agent policy network parameters into the agent, and performing agent instance encapsulation according to the dynamically evolving semantic graph, thereby automatically constructing an end-to-end agent instance.

[0033] In the embodiments of the present invention, when constructing an intelligent agent interaction training environment, first, an atomic operation set is extracted from the end-to-end call chain execution policy, and each atomic operation is standardized into a five-tuple representation (operation type, operation object, input parameter, output format, resource constraint) through an action parser. 56 basic operation types are defined, covering four major functions of knowledge retrieval, information processing, content generation, and decision control. Next, a state observer is deployed, which collects state information from two sources: the dynamically evolving semantic graph provides the knowledge state, including the current set of activated nodes, node activation values, and relationships between nodes; the user interaction context provides the interaction state, including historical conversation records, user query intentions, and response evaluations. The state information is processed by a feature extractor and converted into a 1024-dimensional state vector. The training environment is modeled using a Markov decision process, which includes four components: a state space S, an action space A, a transition function T, and a reward function R. The transition function is implemented by a simulator, which simulates the action execution results based on a rule engine. The reward function includes five scoring dimensions: task completion (0-10 points), response quality (0-8 points), efficiency metric (0-5 points), resource consumption (-5-0 points), and user satisfaction (0-7 points). A three-stage execution process is adopted. In the first stage, knowledge enhancement preprocessing is performed. The preferred knowledge fragments are indexed, and a dual retrieval mechanism of a dense vector index (using a hierarchical quantization index structure, including 12,800 first-level clustering centers) and an inverted index (based on the BM25 algorithm) is established. The retrieval process adopts a hybrid retrieval strategy. First, candidate sets are recalled through vector nearest neighbor search, and then fine sorting is performed through keyword matching. In the second stage, the call chain task is executed. The execution graph is traversed in topological order. Before each node is executed, the dependency conditions are checked, and after execution, four types of metrics are recorded: functional metrics (correctness, integrity), performance metrics (execution time, resource usage), context metrics (state changes, intermediate results), and exception metrics (error type, failure reason). Checkpoints are set for critical nodes, and the quality of the intermediate results is evaluated through an output validator. In the third stage, data collection and collation are performed, and the complete decision sequence is recorded, including the state, selected action, execution result, and reward signal at each decision point. A dual-channel policy optimizer is deployed, including a model distillation channel and a reinforcement learning channel. In the model distillation channel, a teacher network is first constructed. This network is based on a 64-layer Transformer architecture with a hidden layer dimension of 4096 and is obtained through large-scale pre-training. The teacher network scores the collected task trajectories and identifies the optimal operation sequence. A student network with the same architecture but a 75% reduction in the number of parameters is constructed, and knowledge transfer is achieved by minimizing the cross-entropy loss between the output of the student network and the output of the teacher network. The reinforcement learning channel realizes policy optimization based on the feedback data of scenario task execution and is trained using the proximal policy optimization algorithm. In the specific implementation, a policy network π and a value network V are maintained, and both share a 16-layer Transformer encoder backbone network. The proximal policy optimization algorithm sets the clipping parameter ε to 0.2 to limit the change range of the ratio of the new and old policies.The training process adopts gradient updates based on the advantage function, which is calculated by Generalized Advantage Estimation. The discount factor γ is set to 0.99, and the λ parameter is set to 0.95. An adaptive learning rate adjustment mechanism is adopted, with the initial learning rate set to 3e-5, which is dynamically adjusted according to the policy update amplitude. To prevent overfitting, entropy regularization is applied, and the entropy coefficient is set to 0.01. After training for 5 million environment steps, the optimized scenario optimization call chain policy is output. A human-machine collaborative training platform is deployed, which includes an expert demonstration collection module and a demonstration learning module. The expert demonstration collection module first constructs a set of 200 high-difficulty scenario tasks. The scenario complexity is quantified by three metrics: the number of task steps (15 - 30 steps), the length of the dependency chain (5 - 12 layers), and the number of decision branches (8 - 20). 15 domain experts are invited to perform tasks in these scenarios, and the experts' operations are recorded through behavior capture, which collects three types of data: operation sequences (including operation types, parameter selections, execution times), decision explanations (text descriptions of the experts' thinking processes), and attention distributions (information regions that the experts focus on). The demonstration learning module uses the behavior cloning method to process the expert demonstration data and constructs an imitation learning objective function. The objective function includes three loss terms: action matching loss (the negative log-likelihood of the expert action and the predicted action), state prediction loss (the mean squared error between the predicted next state and the actual state), and policy consistency loss (the KL divergence between the learned policy and the base policy). The training process adopts the gradient accumulation technique, and the model parameters are updated every 32 demonstration batches. To address the distribution difference between the demonstration data and the automatically generated data, a domain adaptation method is applied, and an adversarial loss term is introduced. After 5000 batches of iterative training, the optimized agent policy network parameters with enhanced decision-making capabilities are output. An agent packer is deployed, which adopts a five-stage process. In the first stage, parameter quantization compression is performed. The weight quantization technique is applied to the optimized network parameters, quantifying 32-bit floating-point parameters into 8-bit integer representations. The quantization method uses channel-level non-uniform quantization, and the quantization scale factor is independently determined for each channel. In the second stage, model graph optimization is carried out. The computational graph is optimized through three techniques: operator fusion, constant folding, and redundancy elimination, reducing the inference overhead by 30%. In the third stage, knowledge embedding is performed. The core knowledge structure is extracted from the dynamically evolving semantic graph, which includes 2000 highest-weight nodes and their relationships, and is converted into a structured retrieval knowledge base built into the agent. The knowledge base adopts a three-level cache architecture: hot knowledge is loaded into memory (500MB), frequently used knowledge is stored in the local index (5GB), and the complete knowledge is accessed through an interface. In the fourth stage, interface standardization is carried out, defining a unified agent interface protocol, which includes four major categories of 25 methods: initialization interface, status update interface, action execution interface, and resource management interface. In the fifth stage, containerization packaging is performed, packaging the optimized parameters, runtime environment, knowledge base, and interface into an independent container, with the container image size controlled within 3GB, supporting horizontal expansion deployment.The finally output agent instance includes a complete decision-making logic, knowledge base, execution engine, and monitoring component, realizing end-to-end automated construction.

[0034] Preferably, the agent instance reinforcement learning enhancement process in step S4 includes: When receiving a new user interaction request, use the end-to-end agent instance for multi-round dialogue context awareness to generate context awareness data; Understand the interaction intention based on the context awareness data, perform reasoning and cross-domain knowledge intention analysis to obtain the reasoning-based interaction intention; Based on the reasoning-based interaction intention, use the end-to-end agent instance to execute multi-step queries and evidence chain construction to generate a multi-step graph reasoning evidence chain; Perform semantic-level personalized knowledge retrieval based on the multi-step graph reasoning evidence chain to obtain the core data of personalized response knowledge; Based on the core data of personalized response knowledge and the multi-step graph reasoning evidence chain, use a preset large language model for natural language generation processing to obtain intelligent response text data; During the continuous interaction between the end-to-end agent instance and the user and the generation of intelligent response text data, collect user feedback data in real time, including explicit ratings, text correction suggestions, and implicit behavior signals, to obtain the original user feedback data stream; Clean, label, and quantify the original user feedback data stream, and convert it into a reward signal in the reinforcement learning environment to obtain a quantified reward signal; Perform reinforcement learning enhancement processing on the end-to-end agent instance through the quantified reward signal, thereby automatically constructing an end-to-end agent.

[0035] In the embodiments of the present invention, when a new user interaction request is received, a context processor is started. This processor first extracts historical interaction records from the session cache, including the content of the last 20 rounds of conversations. The historical records are processed by a temporal encoder, which uses an 8-layer bidirectional gated recurrent unit network with a hidden layer dimension of 512 to convert the conversation history into a sequence of context vectors. A hierarchical attention mechanism is applied to the vector sequence, which includes two levels of attention networks: word-level attention to identify keywords and sentence-level attention to capture key turns. The attention calculation uses the scaled dot product method, and the attention temperature parameter is set to 0.1. The current user input is processed by a 32-layer transformer encoder, which contains 16 attention heads and has a hidden layer dimension of 1024 to generate the current query representation. The relevance between the query and the historical content is calculated through a cross-attention mechanism, and the size of the relevance matrix is the current query length × the historical content length. The historical content with high relevance is weighted by importance, and the weights are calculated through normalized relevance scores. Further, the evolution trajectory of the conversation topic is extracted using a dynamic topic tracking algorithm, which is based on the latent Dirichlet allocation model with the number of topics set to 30. When understanding the interaction intention based on context-aware data, a three-stage intention analysis engine is deployed. In the first stage, basic intention recognition is performed by inputting the context-aware data into an intention classifier, which uses a fully connected network structure with three hidden layers having 1024, 512, and 256 nodes respectively, and the activation function is the rectified linear unit. The classifier outputs the probability distribution of 120 predefined intention types. Through threshold screening, the top 3 candidate intentions with probabilities exceeding 0.3 are retained. In the second stage, reasoning-based intention extraction is carried out by analyzing the implicit assumptions, causal relationships, and logical inferences in the user query through a reasoning enhancement network. This network uses a natural language reasoning architecture with 8 layers of cross-attention blocks, each layer having 8 attention heads. Five types of reasoning patterns are identified: deductive reasoning, inductive reasoning, abductive reasoning, analogical reasoning, and counterfactual reasoning, and a confidence score is assigned to each type of reasoning. In the third stage, cross-domain knowledge intention analysis is performed by mapping the intention to a predefined knowledge graph ontology, which contains 50 core domains, and each domain defines 200 concepts. Cross-domain associations are identified through a domain bridge, which is implemented based on a graph neural network and includes 5 layers of graph convolutional layers with a feature dimension of 256. An initial query statement is constructed according to the reasoning-based interaction intention, and the query statement includes three parts: core entities, relationship constraints, and attribute conditions. Entity linking is performed for each core entity, and the linking algorithm uses a dual-encoder architecture to map the entity name to the standard entity identifier in the knowledge graph. In the second step, multi-step query planning is performed by splitting the complex query into 5 - 12 sub-queries through a query decomposer, and the decomposition strategy is based on semantic dependency tree analysis. The sub-queries are constructed into a directed acyclic execution graph according to the dependency relationship, and the execution order is determined through topological sorting. In the third step, the sub-queries are executed and intermediate evidence is collected, and each sub-query retrieves matching nodes and relationships in the dynamically evolving semantic graph through a graph query engine.The query engine uses a bidirectional graph traversal algorithm with a maximum traversal depth of 6, and returns a set of paths that meet the conditions. In the fourth step, the collected evidence is evaluated for credibility. The evaluation algorithm considers three dimensions: the reliability of the evidence source, the freshness of the evidence, and the consistency of the evidence. The comprehensive score ranges from 0 to 10. According to the semantic association and logical dependency between the evidence, a multi-layer evidence graph is constructed. Each layer of evidence is connected by reasoning relationships to form a complete multi-step graph reasoning evidence chain. A personalized retrieval engine is deployed, which includes a user portrait module and a semantic matching module. The user portrait module first extracts user interest features from historical interaction data, including short-term interest vectors (based on the most recent 50 queries) and long-term interest vectors (based on the entire history). The interest vector is calculated through a multi-head self-attention network, which contains 6 layers of attention blocks, 12 attention heads per block, and a hidden dimension of 768. The user interest vector is similar to the key nodes in the evidence chain to determine the personalized retrieval focus. The semantic matching module adopts a dual-tower retrieval architecture, where the query tower processes the evidence chain information and the document tower indexes the knowledge base content. The dual towers share a 12-layer transformer encoder architecture and are trained using a contrastive learning method. The retrieval process is divided into two stages: the first stage is to recall 1,000 candidates from the index library through the approximate nearest neighbor algorithm, and the local sensitive hashing technology is used to accelerate the retrieval; the second stage is to reorder the candidates through a cross encoder, which contains 8 layers of cross attention layers and calculates the exact relevance score between the query and the document. Further combined with the reasoning logic in the evidence chain, the core knowledge points are identified and the relevant context is extracted, including the knowledge point definition, attribute description and relationship description, to form a structured personalized answer knowledge core data. A hierarchical generation engine is deployed, which includes two core components: the content planner and the expression generator. The content planner first performs a structured analysis on the input data and converts the knowledge core data and the evidence chain into a semantic framework, which contains a three-layer structure of argument-evidence-conclusion. The planner uses 36 preset argument templates and selects the most appropriate template based on the reasoning complexity and argument strength. The content organization is guided by the rhetorical structure theory to construct a chapter structure tree containing 15 rhetorical relationships. The expression generator is implemented based on a preset large language model, which contains a 96-layer transformer decoder, 17.5 billion parameters, and a vocabulary size of 250,000. The generation process adopts a two-stage strategy: the first stage generates a detailed outline, including paragraph themes, key arguments, and turning points; the second stage generates text content paragraph by paragraph based on the outline. The decoding adopts the kernel sampling method, with the temperature parameter set to 0.7, the number of samples to 20, and the screening factor to 0.8. Post-processing optimization is applied to the generated text, including fact consistency checking (comparing the generated content with the knowledge data), language fluency enhancement (fixing incoherent expressions), and language style adjustment (adjusting formality and professionalism according to user preferences). The final output of the intelligent answer text data contains the main content, reference marks, and confidence annotations. A multi-channel feedback collector is deployed to capture three types of feedback signals in real time.Explicit score collection is achieved through a 5-point satisfaction evaluation component embedded in the interactive interface. The score data is transmitted to the feedback processing center via a real-time transmission protocol, with the latency controlled within 100 milliseconds. Text correction suggestions are captured by a text difference analysis engine that uses the minimum edit distance algorithm to compare the generated text with the text modified by the user, and extracts the modification operations (addition, deletion, replacement, rearrangement) and their location information. Implicit behavior signals are collected by a behavior tracking module that records 12 key user behavior metrics: dwell time, scrolling pattern, click behavior, copy operation, citation behavior, question-asking behavior, interruption count, repeated inquiry, session persistence, query rewrite pattern, depth of follow-up questions, and sharing behavior. Behavior data collection is based on an event-triggered mechanism and is executed through lightweight client scripts. The data is transmitted in batches in JSON format, triggered every 10 seconds or when 20 events have accumulated. Timestamps, session identifiers, and context markers are added to all feedback data to construct a structured raw user feedback data stream. A feedback processing pipeline is deployed, which consists of three sequential processing stages. In the data cleaning stage, outliers are first detected and filtered. Outlier detection is based on statistical methods to identify numerical metrics that exceed three standard deviations and behavior sequences that violate predefined rules. Median filtering with a window size of 5 is applied to time series data to eliminate short-term fluctuations. Missing values are handled using a combination of forward filling and multiple imputation. The imputation model is based on a conditional random field and takes into account context relevance. In the data annotation stage, a semi-supervised learning method is used. The text feedback is processed by a pre-trained sentiment analysis model based on a 12-layer bidirectional transformer with an accuracy of 85%. A behavior pattern recognition algorithm is applied to the implicit behavior signals, which maps the original behavior sequences to 9 predefined user attitude categories: satisfied, confused, disappointed, surprised, skeptical, focused, distracted, impatient, and neutral. In the data quantization stage, multi-dimensional feedback is converted into a unified reward signal using a weighted fusion method. The weight of the explicit score is 0.5, the weight of the text correction signal is 0.3, and the weight of the implicit behavior signal is 0.2. The reward calculation formula is: , where s is the normalized score value, e is the edit distance, l is the text length, and b is the behavior positivity index. Further, a time decay factor is applied to reduce the impact of historical feedback. The decay formula is: , where γ is the attenuation coefficient, set to 0.95, and t is the time step. The final output is a quantized reward signal with a value range in the interval [-10, 10]. When using the quantized reward signal to enhance the end-to-end agent instance through reinforcement learning, a distributed reinforcement learning framework is deployed. This framework adopts the actor-critic architecture. The actor network is based on the agent's policy network and contains 32 layers of transformer structures with a hidden layer dimension of 2048; the critic network uses the same architecture but independent parameters and is responsible for value estimation. The proximal policy optimization algorithm is used in the reinforcement learning process. This algorithm sets the clipping parameter to 0.2 to limit the change range of the ratio of the new and old policies. The agent's interaction environment is distributedly deployed on 128 computing nodes, and each node parallelly simulates 8 user sessions to accumulate experience data. The training iteration consists of four stages: First, collect interaction trajectories based on the current policy. Each trajectory contains a state sequence, an action sequence, and a reward sequence; Second, calculate the generalized advantage estimate value, with the discount factor set to 0.99 and the λ parameter set to 0.95; Then, batch update the policy network and the value network based on the collected data. The Adam optimizer is used with a learning rate of 3e-5 and a batch size of 1024; Finally, calculate key performance indicators, including cumulative reward, policy entropy, and value loss, to monitor the training progress. To prevent catastrophic forgetting, an experience replay mechanism is implemented to retain 20% of the historical high-reward trajectories. A curriculum learning strategy is adopted to gradually increase the task difficulty. In the initial stage, simple interaction scenarios are used and gradually transitioned to complex reasoning tasks. After the reinforcement learning converges, the optimized parameters are solidified into the agent instance to complete the entire process of automatically constructing an end-to-end agent.

[0036] Of particular importance is the use of the end-to-end agent instance to perform multi-step queries and evidence chain construction based on the inferential interaction intention, specifically: Decompose and plan the initial query target using the end-to-end agent instance based on the inferential interaction intention to obtain the first graph query instruction; Use the end-to-end agent instance to perform the first knowledge node and relationship retrieval on the dynamically evolving semantic graph based on the first graph query instruction to obtain a preliminary query result set and initial evidence node data; Judge the next query direction and generate a query instruction using the end-to-end agent instance based on the preliminary query result set, the initial evidence node data, and the inferential interaction intention to obtain subsequent graph query instructions; Use the end-to-end agent instance to perform iterative knowledge deepening retrieval on the dynamically evolving semantic graph according to the subsequent graph query instructions, and evaluate the relevance and importance of the new knowledge nodes and relationships obtained from each retrieval to obtain candidate evidence increment data; Perform logical connection and extension verification based on the candidate evidence increment data, and integrate the verified evidence nodes and relationships into the current evidence chain to obtain a gradually expanding graph inference path; Iteratively execute subsequent graph query instruction generation, iterative knowledge deepening retrieval, candidate evidence incremental data acquisition, logical connection and extension verification steps until the inferential interaction intention is fully resolved or the preset inference depth is reached, and orderly and structurally integrate all relevant evidence nodes and inference relationships in the gradually expanding graph inference path to generate a multi-step graph inference evidence chain.

[0037] In the embodiments of the present invention, for the initial query target of the inferential interaction intention, a query planner is deployed, and a hierarchical target decomposition algorithm is adopted. Through the semantic parser, the dependency syntactic analysis of complex intentions is carried out, the core inferential target is extracted and decomposed into atomic query units, following the "entity-relationship-attribute" pattern, with an accuracy rate of 91%. The decomposed query units are sorted three-dimensionally according to causal priority, entity importance, and information entropy (weight ratio 4:3:3), and a directed acyclic query graph is constructed. The execution order is optimized by the greedy algorithm, and graph pruning is applied to remove redundancy. The first query unit is converted into a standard graph query language expression, including query type, retrieval conditions, and return format. In the first query, a graph retrieval engine is deployed, which adopts a three-layer architecture: the query parser constructs an abstract syntax tree, the index access layer calls a hybrid index structure (B+ tree attribute index, inverted full-text index, adjacency list structure index), and the graph traversal engine executes bidirectional breadth-first search (maximum depth is 3). Multi-condition filtering is applied to the result nodes (activation value > 0.6, relationship strength > 0.4, update period < 180 days), and a small subgraph containing core entities, first-order relationships, and directly associated nodes is extracted. The nodes are attached with five types of metadata (identifier, semantic type, confidence, data source, update time), and the preliminary query results and evidence nodes are output. Subsequent queries are driven by the inference navigator, and the next direction is determined in three stages: in the first stage, information gap analysis is carried out, and the knowledge graph path algorithm is used to measure the semantic distance. A path length exceeding 3 is regarded as a gap, and the identified gap types include entity / relationship / attribute missing, temporal fault, and logical contradiction; in the second stage, the expected information gain of potential directions is evaluated (= direction relevance × success probability × information value), and the optimal direction is selected by Monte Carlo tree search (depth 4, simulation times 1000); in the third stage, structured query instructions are generated, including query subject, conditions, and return format, and parameter optimization is carried out to control the depth and breadth. When performing iterative graph retrieval, an adaptive depth retriever is deployed, and knowledge deepening is achieved in four steps: 1) determining the retrieval starting point, and entity linking is carried out through the dual encoder algorithm (accuracy rate 96%); 2) adopting an alternating graph traversal strategy (breadth-first in the first layer, depth-first in the subsequent layers), and dynamically adjusting the expansion and deepening factors; 3) evaluating the retrieval results of each round, scoring according to semantic relevance, evidence value, novelty, and credibility (weight ratio 4:3:2:1), and only retaining nodes with a score > 0.7; 4) organizing them into structured data packets as candidate evidence incremental data.To ensure the rationality of newly added evidence, an evidence verifier is deployed, and the verification and integration are completed in five steps: 1) Logical consistency check: Use a formal knowledge base and a Droopgen inference engine to verify logical compatibility, supporting 12 basic inference patterns; 2) Evidence correlation analysis: Construct an evidence graph, measure the edge strength through citation overlap, and mark those with a value lower than 0.3 as low correlation; 3) Source reliability assessment: Only retain those with a score > 0.65; 4) Calculate the information entropy gain to ensure that the increment brings positive information gain; 5) Conflict resolution: Compare the evidence strength (three factors: source reliability, content certainty, timeliness) to decide whether to retain or replace. The evidence that passes the verification is incorporated into the existing evidence chain to expand the reasoning path of the graph. The evidence chain integrator controls the iterative execution of the reasoning process. Three termination conditions are set: the reasoning completeness reaches 90%, the maximum number of iterative rounds is 12, and if the evidence gain is lower than 0.05 for two consecutive rounds, it is judged to converge. After each round, evidence rearrangement is performed, using the centrality comprehensive score (degree centrality, betweenness centrality, eigenvector centrality), and a causal structure graph is constructed based on the Bayesian network, where the nodes represent facts and the edges represent causal relationships and their strengths. The evidence chain is organized into a three-layer structure: the top layer is the conclusion, the middle layer is the support, and the middle and lower layers are the original evidence, and the confidence of the entire reasoning path is calculated through the geometric mean of the node confidences. The output multi-step graph reasoning evidence chain includes four parts: a structured evidence graph, a linear reasoning path, evidence source annotations, and a comprehensive confidence assessment, realizing automated, multi-round, and logically complete knowledge retrieval and reasoning support for reasoning tasks.

[0038] The present invention first receives multimodal information input by the user, including various data forms such as text and images, and then uses feature extraction technology to convert information of different modalities into a unified semantic vector representation, forming an initial set of semantic nodes. Based on the unified vector representation, a dynamic semantic graph is constructed. This graph organizes knowledge through three levels: the concept level, the relationship level, and the instance level. Each node has an independent semantic embedding representation, and the weights of the connections between nodes are determined according to the semantic association strength. After the semantic graph is constructed, the hierarchical semantic activation network is started. When the user makes a query, the query is first encoded as a semantic vector, and based on this vector, initial activation is triggered on the graph. The activation value is jointly determined by the semantic similarity between the node and the query, the historical access frequency of the node, and the last activation time. Next, through a unique horizontal-vertical alternating propagation algorithm, the activation value spreads throughout the graph. First, it spreads horizontally among nodes at the same level, and then vertically among different levels. After the spread is completed, according to the complexity of the current query and the user's interaction history, the activation threshold is dynamically calculated, and the set of nodes with activation values exceeding this threshold is selected as candidate knowledge fragments. For these candidate fragments, a semantic clustering and merging algorithm is further applied to integrate semantically related nodes into coherent knowledge fragments. When knowledge conflicts occur, they are resolved through a multi-source evidence weight mechanism, comprehensively considering the authority, timeliness, and relevance of the knowledge sources. After the knowledge fragments are ready, a multi-level call chain optimization framework is constructed. The task processing flow of the intelligent agent is represented as a directed acyclic graph, where nodes represent atomic operations such as retrieval, reasoning, and generation, and edges represent the dependency relationships between operations. A dual-strategy network architecture is deployed, including a high-order strategy network responsible for high-level decision-making and an execution strategy network responsible for specific execution. The former determines the necessity, timing, and depth of retrieval, and the latter determines specific retrieval parameters and generation strategies. After the dual-network architecture is established, the training phase begins. For scenarios with clear feedback, the proximal policy optimization algorithm is used for reinforcement learning; for scenarios lacking clear feedback but with expert demonstrations, the behavior cloning technique is used to learn the optimal strategy, forming a complete dual-channel learning mechanism. After training is completed, it enters the actual execution phase. By monitoring the output quality of each operation node, the links with poor execution effects are identified, and dynamic adjustments are made through methods such as node replacement, path reconstruction, or node insertion / deletion to achieve adaptive optimization of the call chain. By using the proximal policy optimization pruning function to improve performance while restricting the update amplitude when updating the policy network, an end-to-end intelligent agent with semantic understanding ability can finally be automatically constructed. This intelligent agent can integrate graph-structured knowledge with the generation ability of large language models to achieve accurate knowledge retrieval, context-aware multi-turn conversations, and cross-domain dynamic reasoning, providing efficient and accurate intelligent services for various complex business scenarios.

[0039] Therefore, in any aspect, the embodiments should be regarded as exemplary and non-limiting. The scope of the present invention is defined by the appended claims rather than the above description. Thus, all changes falling within the meaning and scope of the equivalent elements of the application documents are intended to be encompassed within the present invention.

[0040] The above are only specific embodiments of the present invention, enabling those skilled in the art to understand or implement the present invention. Various modifications to these embodiments will be obvious to those skilled in the art. The general principles defined herein can be implemented in other embodiments without departing from the spirit or scope of the present invention. Therefore, the present invention will not be limited to these embodiments shown herein, but rather to the broadest scope consistent with the principles and novel features invented herein.

Claims

1. An automated construction method for an end-to-end agent based on graph structure semantic fusion, characterized in that, The following steps are involved: Step S1: receiving business demand data input by a user; analyzing the business objectives and demand constraints of the business demand data to obtain structured demand parameters; Process the technical blueprint according to the structured demand parameters to obtain a preliminary end-to-end technical blueprint; Step S2: Perform dynamic workflow processing on the preliminary end-to-end technical blueprint to generate the core workflow framework of the intelligent agent; perform multimodal context understanding according to the structured demand parameters to obtain multimodal context information; perform end-to-end execution path analysis on the core workflow framework of the intelligent agent based on the multimodal context information to obtain the end-to-end workflow; Step S3: acquiring multimodal data according to structured demand parameters and constructing a dynamic evolution semantic graph; dynamically activating query nodes on the dynamic evolution semantic graph to generate highly activated candidate node data; Based on the highly activated candidate node data, the knowledge fragments are dynamically selected from the dynamically evolving semantic graph to obtain the optimal knowledge fragments; Step S4: Building an end-to-end call chain execution strategy based on the end-to-end workflow; The agent instance is encapsulated through end-to-end call chain execution strategy and dynamically evolving semantic graph, and reinforcement learning enhancement processing is performed on the agent instance to automatically build an end-to-end agent.

2. The automated construction method of the end-to-end agent based on graph structure semantic fusion according to claim 1, wherein The business goal and demand constraint analysis of the business demand data in step S1 includes: Perform tokenization preprocessing on business demand data to obtain tokenized demand text; Based on the decoder-only architecture, multi-layer self-attention hierarchical association processing is performed on the tokenized demand text to capture the long-distance dependencies and deep semantic representations in the text, and obtain the demand text context representation data; Autoregressive processing is performed on the contextual representation data of the requirement text, and key entity and relationship information is extracted through the multi-head attention mechanism and feedforward neural network in the decoder-only architecture to obtain a list of domain entity information; Understand the intent of the demand text context representation data, identify the user's main business intent, and generate business intent label data; The business goal description is processed according to the business intent label data, and the core entities directly related to the business goal are extracted from the domain entity information list as the target subject or object to obtain a preliminary business goal entity pair; Perform contextual condition reasoning on the contextual representation data of the requirement text, perform constraint processing, and generate business constraint conditions; According to the preliminary business target entity pairs and demand constraints, structured parameter mapping processing is performed to obtain structured demand parameters.

3. The automated construction method of the end-to-end agent based on graph structure semantic fusion according to claim 1, characterized in that, In step S1, the technical blueprint processing of the structured demand parameters based on the GPT model includes: Input the structured demand parameters into the specification generation layer of the GPT model, and perform task decomposition sequence processing according to the preset industry standard task template library and general task decomposition logic to obtain a preliminary task process sequence; Match the API call interface according to the preliminary task flow sequence to obtain the expected API call chain; Based on the structured demand parameters and the preliminary task process sequence, the task completion quality and efficiency evaluation indicators are defined to obtain the task evaluation indicator data; Perform technical blueprint processing based on the preliminary task flow sequence, the expected API call chain, and the task evaluation metric data to obtain a preliminary end-to-end technical blueprint.

4. The automated construction method of the end-to-end agent based on graph structure semantic fusion according to claim 1, characterized in that In step S2, perform end-to-end execution path analysis on the core workflow framework of the agent based on multimodal context information: Extract the expected inputs, outputs, and dependencies of each task node according to the core workflow framework of the agent to generate node interface dependency data; Perform node information aggregation based on the node interface dependency data and multimodal context information to obtain a node context information package; Perform task event execution reasoning on the node context information package based on the thinking steps in the React mechanism to obtain a node execution reasoning sequence; Determine task operations on the node execution reasoning sequence based on the action steps in the React mechanism to obtain node action instruction data; Perform simulated execution on the node action instruction data based on the observation steps in the React mechanism to obtain node expected observation data; Iteratively execute the thinking, action, and observation steps until all intermediate links in the preliminary end-to-end technical blueprint are covered, and concatenate the node execution reasoning sequence, node action instruction data, and node expected observation data in an end-to-end execution path to form an ultra-long thought chain; Use the ultra-long thought chain to determine the nodes and paths of the workflow to obtain an end-to-end workflow.

5. The automated construction method of the end-to-end agent based on graph structure semantic fusion according to claim 1, wherein In step S3, obtain multimodal data according to the structured requirement parameters and construct a dynamically evolving semantic graph, including: Connect to multimodal, multi-paradigm data sources, and perform multimodal information collection according to the structured requirement parameters to obtain multimodal data; Perform topic modeling and keyword extraction on the text data in the multimodal data to obtain text core entity data; Perform salient object detection and scene understanding on the image data in the multimodal data to obtain image core feature data; Perform cross-modal alignment and information integration on the text core entity data and the image core feature data, and identify the entity relationships and event associations between different modal information to obtain cross-modal fusion structure information; Assign knowledge unit identifiers to the cross-modal fusion structure information and perform meta-information annotation to obtain annotated knowledge unit data, where the meta-information annotation includes knowledge source, credibility, and timeliness; Evaluate the knowledge abstraction degree and domain relevance of the annotated knowledge unit data, and organize it into a hierarchical structure of a concept layer, a relationship layer, and an instance layer to obtain multi-dimensional knowledge management graph structure data; Perform domain knowledge base filling processing according to the multi-dimensional knowledge management graph structure data to construct a dynamically evolving semantic graph.

6. The automated construction method of the end-to-end intelligent agent based on graph structure semantic fusion according to claim 1, wherein In step S3, perform query node dynamic activation on the dynamically evolving semantic graph, including: Receive the user's current query behavior and perform behavior semantic parsing to obtain the current user query semantics; Perform semantic representation processing on the current user query semantics to obtain a query semantic vector; Extract the node historical access frequency and the node recent activation time according to the dynamically evolving semantic graph; Use the query semantic vector as input to perform semantic similarity analysis in the dynamically evolving semantic graph to obtain node semantic similarity data; Based on the node semantic similarity data, node historical access frequency, and node recent activation time, evaluate the activation status of the graph to obtain the graph activation status data; Perform horizontal-vertical alternating propagation processing on the dynamically evolving semantic graph through the graph activation status data to generate a post-diffusion node activation value map; Evaluate the query complexity according to the current user query semantics, dynamically calculate the activation threshold for this query, and obtain the dynamic activation screening threshold; Based on the dynamic activation screening threshold, screen out all nodes in the post-diffusion node activation value map whose activation values exceed the dynamic activation threshold to generate high-activation candidate node data.

7. The automated construction method of the end-to-end agent based on graph structure semantic fusion according to claim 1, characterized in that, In step S3, the dynamic selection of knowledge fragments for the dynamically evolving semantic graph based on the high-activation candidate node data includes: Perform knowledge node clustering operations on the dynamically evolving semantic graph based on the high-activation candidate node data to obtain semantic clustering knowledge clusters; Use the RAG technology to integrate the knowledge fragments of the semantic clustering knowledge clusters to obtain the preliminarily integrated knowledge fragments; Identify the conflicting knowledge points and their sources based on the preliminarily integrated knowledge fragments to obtain a potential knowledge conflict list; When the potential knowledge conflict list is not empty, comprehensively evaluate and weight the authority, information timeliness, and relevance to the current query of the knowledge sources associated with the conflicting knowledge points to obtain the conflict knowledge source weight evaluation data; Resolve the conflicting knowledge points in the preliminarily integrated knowledge fragments based on the conflict knowledge source weight evaluation data to obtain the preferred knowledge fragments.

8. The automated construction method of the end-to-end agent based on graph structure semantic fusion according to claim 1, characterized in that, In step S4, the construction of the end-to-end call chain execution strategy based on the end-to-end workflow includes: Construct a task flow directed acyclic graph according to the end-to-end workflow; Deploy a dual-strategy network architecture based on the task flow directed acyclic graph; among them, the deployment of the dual-strategy network architecture includes a high-order strategy network and an execution strategy network; Judge the necessity, select the execution time, and set the retrieval depth of the retrieval operation on the task flow directed acyclic graph through the high-order strategy network to obtain a high-order decision network instance; Set the specific retrieval parameters that should be adopted by the retrieval nodes on the task flow directed acyclic graph and the specific content generation strategy that should be adopted at each generated node through the execution strategy network to obtain an execution strategy network instance; Construct an end-to-end call chain execution strategy according to the high-order decision network instance and the execution strategy network instance.

9. The automated construction method of the end-to-end agent based on graph structure semantic fusion according to claim 1, wherein In step S4, the encapsulation of the agent instance through the end-to-end call chain execution strategy and the dynamically evolving semantic graph includes: Take the atomic operations in the end-to-end call chain execution strategy as the optional action space of the agent, and take the current state of the dynamically evolving semantic graph and the user interaction context as the state observation space of the agent to obtain the agent interaction training environment; Based on the agent interaction training environment, use the preferred knowledge fragments as the retrieval enhancement source of the RAG technology, execute the scenario task processing based on the end-to-end call chain execution strategy, and collect the decision sequence, resource consumption, and preliminary output results of the agent during the task execution to obtain the scenario task execution feedback data; Adopt a dual-channel learning mechanism to iteratively optimize the end-to-end call chain execution strategy. At the same time, use the proximal policy optimization algorithm for reinforcement learning based on the execution feedback data of the scenario task, and apply a pruning update strategy to adjust the network parameters to maximize the cumulative reward, obtaining the scenario-optimized call chain strategy; Based on the scenario-optimized call chain strategy, conduct expert demonstration supplementary training and perform agent reinforcement learning to obtain the optimized agent policy network parameters; Solidify the optimized agent policy network parameters into the agent, and perform agent instance encapsulation according to the dynamically evolving semantic graph, thereby automatically constructing an end-to-end agent instance.

10. The automated construction method of the end-to-end agent based on graph structure semantic fusion according to claim 1, characterized in that The agent instance reinforcement learning enhancement process in step S4 includes: When receiving a new user interaction request, use the end-to-end agent instance for multi-round dialogue context awareness to generate context awareness data; Understand the interaction intention based on the context awareness data, and perform reasoning and cross-domain knowledge intention analysis to obtain the reasoning-based interaction intention; Based on the reasoning-based interaction intention, use the end-to-end agent instance to execute multi-step queries and evidence chain construction to generate a multi-step graph reasoning evidence chain; Perform semantic-level personalized knowledge retrieval according to the multi-step graph reasoning evidence chain to obtain the core data of personalized response knowledge; Based on the core data of personalized response knowledge and the multi-step graph reasoning evidence chain, use a preset large language model for natural language generation processing to obtain intelligent response text data; During the continuous interaction between the end-to-end agent instance and the user and the generation of intelligent response text data, collect user feedback data in real time, including explicit ratings, text correction suggestions, and implicit behavior signals, to obtain the original user feedback data stream; Clean, annotate, and quantify the original user feedback data stream, and convert it into a reward signal in the reinforcement learning environment to obtain a quantified reward signal; Perform reinforcement learning enhancement processing on the end-to-end agent instance through the quantified reward signal, thereby automatically constructing an end-to-end agent.

Images