Auxiliary construction method for automatically generating AI agent process based on business requirement document

Abstract

The application relates to the technical field of artificial intelligence, and discloses an auxiliary construction method for automatically generating an AI agent process based on a business requirement document, which comprises the following steps: deconstructing a business requirement document to extract an action execution subject, operation logic and boundary trigger constraints, and generating an initial directed acyclic graph; mapping a function text into a feature vector and calculating a similarity, calling an external interface and binding model parameters to a graph node; calculating a context overhead on the basis of a downstream path of the node, combining a maximum context threshold to calculate a budget, and inserting an abstract extraction node to reconstruct a topology when the budget is lower than a trigger threshold; comparing input and output data architecture specifications of adjacent nodes, reversely writing constraint instructions into a predecessor node to complete data format alignment when the specifications do not match; scanning and removing a cyclic dependence loop, and outputting a workflow configuration file. The application solves the problems of context overrun of a large model node, inconsistency of upstream and downstream data formats and network topology deadlock circulation.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, specifically to an auxiliary construction method for automatically generating AI intelligent agents based on business requirement documents. Background Technology

[0002] With the development of large language model technology, building AI agents and orchestrating business workflows based on large language models has become an important means of automating complex tasks. In the conventional process of building intelligent agents, developers need to read unstructured business requirement documents, manually sort out the execution subject, operation logic and triggering conditions of the task, and then manually configure nodes and establish directed edges in the graphical interface or code configuration file to form an execution topology graph.

[0003] However, relying on manual deconstruction of business requirement documents and construction of network topology is inefficient and difficult to cope with frequently changing business requirements. In the process of converting from unstructured text to automated workflow paths, as the number of workflow nodes increases, long-link data transmission will cause the accumulated text volume to exceed the maximum context length threshold of large language model nodes, triggering context over-limit errors and causing business process interruptions.

[0004] Meanwhile, due to the non-deterministic nature of text generation results from large language models, the output data structure of front-end model nodes often cannot directly meet the strict input data architecture specifications of downstream external tool nodes. Data format mismatch between upstream and downstream components often leads to interface serialization errors and call failures. In addition, during the mapping and transformation stage of complex business logic, due to the lack of dynamic detection of network structure, deadlock loops may form between nodes due to deviations in timing dependency judgments. This results in structural and logical contradictions in the final output workflow configuration file, which cannot be loaded and run normally by the underlying execution engine. Summary of the Invention

[0005] To address the shortcomings of existing technologies, this invention provides an auxiliary construction method for automatically generating AI intelligent agent processes based on business requirement documents. This method solves the problems of low efficiency in manually constructing AI intelligent agent processes in existing technologies, as well as issues such as large language model node context exceeding limits error, inconsistent data formats of upstream and downstream components leading to interface call failures, and network topology deadlock loops in automated workflow paths.

[0006] To achieve the above objectives, the present invention provides the following technical solution:

[0007] A method for automatically generating AI agent workflows based on business requirements documents, comprising the following steps:

[0008] Deconstruct unstructured business requirement document data to extract the execution subject, operation logic and boundary trigger constraints, divide the basic task node set and combine it with the temporal dependency relationship to establish a directed edge set, bind the boundary trigger constraints to the corresponding directed edges in the directed edge set to form weighted directed edges, combine the basic task node set and the directed edge set containing weighted directed edges to generate an initial directed acyclic graph;

[0009] The functional text composed of the action execution subject and operation logic in the initial directed acyclic graph is mapped into a high-dimensional feature vector. The cosine similarity operation with the pre-set resource feature space is performed. Based on the cosine similarity operation result, the resource index and resource type matching each graph node are determined. The corresponding external tool application programming interface parameters, logic control components or large language model initialization parameters are retrieved and bound to the corresponding graph node.

[0010] The total basic context cost of the downstream path of the computation graph node is calculated, and the maximum generation budget is calculated in combination with the preset maximum context length threshold. If the cost is lower than the preset summary trigger threshold, a summary extraction node is inserted to generate a reconstructed topology graph.

[0011] Compare the input and output data architecture specifications of the predecessor large language model nodes and successor tool nodes connected in the reconstructed topology graph. If they do not match, compile the model-specific constraint instructions and write them back to the predecessor large language model node to complete the forced alignment of upstream and downstream data formats.

[0012] Scan the network structure data to eliminate circular dependencies, extract the runtime parameter configuration and edge routing rules, and output the agent workflow configuration file.

[0013] The above technical solution generates a graph structure directly by deconstructing the business requirement document, realizing the automatic conversion from natural language to program topology; it introduces a context budget mechanism to prevent large model over-limit problems in advance, and resolves the contradiction between the nondeterminism of the output of the large language model and the mandatory format requirements of the tool interface by writing constraint instructions in reverse. Combined with loop elimination logic, it ensures the structural legality and operability of the output agent workflow file.

[0014] Furthermore, the steps of deconstructing the data extraction action subject, operation logic, and boundary triggering constraints of unstructured business requirement documents, dividing the basic task node set into a directed edge set based on temporal dependencies, binding the boundary triggering constraints to the corresponding directed edges in the directed edge set to form weighted directed edges, and combining the basic task node set with the directed edge set containing weighted directed edges to generate an initial directed acyclic graph include:

[0015] The semantic deconstruction network model is used to preprocess unstructured business requirement document data and output entity category labels and dependency relationship matrices.

[0016] Based on the dependency matrix, predicate verbs are extracted as the operational logic, and related nominal components are extracted as the action execution subjects;

[0017] The boundary trigger constraints are separated by matching the pre-defined conditional conjunction dictionary;

[0018] The corresponding data segments containing a single action execution subject and a single operation logic are encapsulated into basic execution units to form a set of basic task nodes;

[0019] Perform temporal dependency determination on the basic task node set to generate a directed edge set. Bind the boundary triggering constraint to the corresponding directed edge in the directed edge set to form a weighted directed edge. Combine the basic task node set with the directed edge set containing the weighted directed edge to generate an initial directed acyclic graph.

[0020] The above extraction and generation steps rely on semantic network models to perform lexical dependency analysis on natural language, locate the execution entities and conditional constraints in business instructions, and provide structured data support for building basic business logic execution units.

[0021] Furthermore, the steps of preprocessing unstructured business requirement document data using a semantic deconstruction network model to output entity category labels and dependency relationship matrices include:

[0022] Transform unstructured business requirement document data into tensor sequences containing word vectors and positional encodings;

[0023] The semantic deconstruction network model extracts the context-dependent features within the tensor sequence and outputs a high-dimensional hidden layer vector with semantic representation.

[0024] Decode the high-dimensional hidden layer vectors to output entity category labels and dependency matrix.

[0025] The above preprocessing operations transform the text into tensors carrying location information, and use the hidden layer feature extraction function of the network model to capture the temporal and contextual relationships in the text, thereby improving the accuracy of dependency relationship output.

[0026] Furthermore, the steps of mapping the functional text composed of the action execution subject and operation logic in the initial directed acyclic graph to a high-dimensional feature vector, performing a cosine similarity operation with the pre-set resource feature space, determining the resource index and resource type matching each graph node based on the cosine similarity operation result, retrieving the corresponding external tool application programming interface parameters, logic control components, or large language model initialization parameters, and binding them to the corresponding graph nodes include:

[0027] Extract the functional text, which is a combination of the action execution subject and operation logic, stored in the node memory space of the initial directed acyclic graph;

[0028] The functional text is segmented into discrete word sequence and an absolute position encoding tensor is attached by a feature encoding network model.

[0029] Extract the global contextual semantic relationships within the discrete word sequence, output the hidden state feature sequence, and reduce the dimensionality to fuse it into a high-dimensional feature vector;

[0030] Perform cosine similarity calculation between the high-dimensional feature vector and each resource vector in the pre-set resource feature space;

[0031] When the cosine similarity matching value is greater than or equal to the similarity value judgment threshold, the corresponding resource index is determined and recorded. Based on the resource index, the matching resource type is determined to retrieve the corresponding external tool application programming interface parameters, logic control components or large language model initialization parameters and bind them to the memory space of the corresponding graph node.

[0032] The above binding process transforms discrete text semantic intent into mathematical expression in a multi-dimensional continuous vector space. By calculating the cosine angle of the space, the matching degree is quantified, enabling automatic mapping and mounting of business logic nodes with underlying system computing resources and external tools.

[0033] Furthermore, the steps of calculating the total basic context cost of the downstream paths of the computation graph nodes, combined with a preset maximum context length threshold, to calculate the maximum generation budget, and inserting a summary extraction node to generate a reconstructed topology graph when the budget is lower than a preset summary triggering threshold, include:

[0034] Perform a reverse breadth-first search operation along the execution path of the completed parameter-bound topology graph structure, and recursively calculate the sum of the basic context overhead of the downstream path by accumulating the inherent overhead of the nodes and the maximum overhead of the downstream branches;

[0035] Perform a subtraction operation between the maximum context length threshold and the sum of the underlying context costs of downstream paths, and calculate the maximum generation budget;

[0036] When the maximum generation budget is strictly below the summary trigger threshold, the original directed edges from the current large language model node to the successor node are cut off, and a summary extraction node with a text summarization network model based on a sequence-to-sequence architecture is instantiated at the breakpoint to generate a reconstructed topology graph.

[0037] The above topology reconstruction process uses reverse search to count symbol consumption along the execution path, actively cuts off the topology and inserts intermediate nodes before determining that resources are exceeded, and compresses the redundant context generated by long-link data transmission while maintaining business results.

[0038] Furthermore, the method for creating and training a text summarization network model includes the following steps:

[0039] Text cleaning and fixed-length truncation are performed on the pre-configured multi-dimensional long text originals and manually simplified summaries in the business scenario database to create positive sample data pairs. Negative sample data pairs are formed by combining erroneous summaries to construct a summary training dataset.

[0040] The encoder extracts features from long text inputs in the summary training dataset, and the decoder outputs a predicted summary sequence.

[0041] The loss value is obtained by calculating the distribution difference between the predicted summary sequence and the manually simplified summary using the cross-entropy loss function. The error gradient is calculated using the backpropagation algorithm, and the network connection weights are updated using an iterative algorithm until the loss function converges.

[0042] The above-mentioned production and training method constructs a set of positive and negative samples containing long and short text mappings, and adjusts the model weights through loss calculation and gradient backpropagation to establish a sequence dimensionality reduction model that meets the input width of downstream nodes.

[0043] Furthermore, the steps for forcibly aligning upstream and downstream data formats by comparing the input and output data architecture specifications of the predecessor large language model nodes and successor tool nodes connected in the reconstructed topology graph, and compiling model-specific constraint instructions to write back to the predecessor large language model node when there is a mismatch, include:

[0044] A depth-first traversal operation is performed along the directed edges of the reconstructed topology graph, and the field coverage between upstream and downstream nodes is calculated by performing intersection operations on the extracted sets.

[0045] When the field coverage is below the architecture matching threshold and a structural conflict occurs, extract the complete input data architecture specification file of the subsequent tool node;

[0046] Extract the structural features of the input data architecture specification file, assemble structured declaration text fragments, and concatenate them with formatting prompt words and affixes to compile and generate model-specific constraint instructions;

[0047] The model-specific constraint instructions are appended to the end of the system prompt word memory block of the predecessor large language model node, and the write protection instruction is invoked to lock the memory block state.

[0048] The above alignment operation quantifies the intersection range of interface parameters between nodes. When structural conflicts are found, the tool standard structure is extracted and compiled into instructions to constrain the output format of the model from the source, thereby reducing the serialization failure rate when transferring between components.

[0049] Furthermore, the steps of scanning network structure data to eliminate circular dependencies and extracting runtime parameter configurations and edge routing rules to output the agent workflow configuration file include:

[0050] Based on timestamp status parameters, detect circular dependency loops in the network path, and destroy back edge objects pointing to previously visited nodes when a closed loop structure is determined to exist.

[0051] After the structure validity check is passed, the memory regions of each graph node are accessed according to the execution sequence sorted by topology to extract the running parameter configuration and edge routing rules;

[0052] The extracted structured data is converted into a key-value pair structure in standard markup language format, and standard markup language text paragraphs are written to an external storage device to output the agent workflow configuration file.

[0053] The above output process verifies the legality of node flow through time and topology sequence checks, eliminates deadlock loops caused by logical contradictions, and ensures that the final output configuration file conforms to the static loading standard of the underlying execution engine.

[0054] Furthermore, based on timestamp state parameters, the steps for detecting circular dependencies in the network path and destroying back edge objects pointing to previously visited nodes when a closed loop structure is determined to exist include:

[0055] Complete the basic initialization configuration of the depth-first search access stack and node timestamp record table in memory;

[0056] Extract the timestamp state parameters of the current node and the adjacent connected nodes pointed to by the directed edges;

[0057] The minimum timestamp record is updated by the minimum value determination module, and the back edge object pointing to the previously visited node is destroyed when a closed loop is detected.

[0058] The aforementioned destruction operation maintains the node access stack and timestamp table, identifies closed loops in connected components by comparing the minimum timestamps of adjacent nodes, and blocks back edges at the memory level to complete loop repair.

[0059] Furthermore, the training steps for the feature encoding network model include:

[0060] Extract the business function description text and the matching external resource index and package them into positive sample data pairs. Randomly combine the business function description text and irrelevant resource indexes and package them into negative sample data pairs to create a comparative learning training dataset.

[0061] Positive and negative sample data pairs are input into the feature encoding network model to obtain the corresponding feature vector representations;

[0062] The network weight parameters are iteratively updated until convergence by using a contrastive loss function to minimize the distance between positive sample data and feature vectors and maximize the distance between negative sample data and feature vectors.

[0063] The training process described above utilizes a contrastive loss mechanism to narrow the vector distance between related text and corresponding interfaces, increase the geometric distance between unrelated resources, and solve the matching failure problem caused by differences in industry terminology during the cross-modal mapping stage.

[0064] In summary, the present invention has at least one of the following beneficial technical effects:

[0065] 1. This invention performs a reverse breadth-first search operation along the execution path of the topology graph structure, calculates the total basic context overhead of the downstream path and estimates the maximum generation budget, and then actively cuts off directed edges and inserts a summary extraction node when the maximum generation budget is lower than the summary trigger threshold. In this way, the resource consumption situation is predicted in advance in the automatic flow path, and the redundant data transmission in the long link is compressed by using the inserted summary extraction node, avoiding workflow interruption and error problems caused by the expiration of the context of the large language model node, and ensuring the stability of the overall business process execution.

[0066] 2. This invention compares the data architecture specifications of connected predecessor large language model nodes and successor tool nodes. When the field coverage is lower than the architecture matching threshold, it extracts the structural features of the successor tool node, compiles and generates model-specific constraint instructions, and then appends these model-specific constraint instructions to the memory block of the predecessor large language model node. This allows for the direct application of format constraints to the predecessor node when structural conflicts occur, aligning the data structures between upstream and downstream components from the source and reducing the failure rate of interface calls caused by inconsistent parameter formats during cross-component flow.

[0067] 3. This invention detects circular dependency loops in the network path based on node timestamp status parameters, and directly destroys the back edge objects pointing to previously visited nodes when a closed loop structure is determined to exist. Then, it extracts the running parameters to configure and output the intelligent agent workflow configuration file. This completes the verification of the legality of node flow during the automated network graph construction stage, eliminates deadlock loop nesting caused by business logic contradictions from the underlying data structure level, and ensures that the final generated workflow configuration file meets the static loading and running standards of the underlying execution engine. Attached Figure Description

[0068] Figure 1 This is a schematic diagram of the system timing interaction of the present invention;

[0069] Figure 2 This is a schematic diagram of the method flow of the present invention;

[0070] Figure 3 This is a schematic diagram of the basic task node adjacency matrix of the present invention;

[0071] Figure 4 This is a schematic diagram of the high-dimensional feature vector space distribution of the present invention;

[0072] Figure 5 This is a schematic diagram of feature vector cosine similarity matching according to the present invention;

[0073] Figure 6 This is a schematic diagram of the network topology reconstruction and summary extraction process of the present invention;

[0074] Figure 7 This is a schematic diagram of the reverse compensation and data format alignment process of the present invention;

[0075] Figure 8 This is a schematic diagram of the node timestamp status update process of the present invention;

[0076] Figure 9 This is a schematic diagram illustrating the parameter state changes of different graph nodes in this invention. Detailed Implementation

[0077] See attached document Figure 1 This invention provides an auxiliary construction system for automatically generating AI intelligent agents based on business requirement documents. The system includes a text parsing module, a resource configuration module, a topology reconstruction module, a reverse compensation module, and a serialization output module.

[0078] The text parsing module extracts the received unstructured business requirement document data. The text parsing module calls the dependency parsing algorithm and the named entity recognition algorithm to separate the action execution subject, operation logic and boundary triggering constraints from the document data. The text parsing module decomposes the overall requirement data into a finite set of basic task nodes and establishes a set of directed edges according to the execution sequence. The text parsing module uses the set of task nodes and the set of directed edges to construct the initial directed acyclic graph of the corresponding business logic.

[0079] The resource configuration module connects with the text parsing module to receive the initial directed acyclic graph. The resource configuration module calls a vector encoding algorithm to convert the node function text in the initial directed acyclic graph into feature vectors. The resource configuration module calculates the cosine similarity between the node feature vector and the preset resource feature space. Based on the similarity calculation results, it extracts the external tool application programming interface parameters, logic control components and large language model initialization parameters from the external storage device. The resource configuration module binds the extracted parameter information to the memory address of the corresponding graph node.

[0080] The topology reconstruction module connects with the resource configuration module to receive the topology graph structure with completed parameter binding. The topology reconstruction module performs a reverse breadth-first search along the directed edge path of the graph structure to calculate the basic context cost value of the downstream path of each node. The topology reconstruction module calculates the node generation budget in combination with the maximum context length threshold and overwrites the generation budget into the corresponding constraint item in the large language model parameter configuration. When the generation budget is lower than the summary trigger threshold, the topology reconstruction module disconnects the original directed edge and inserts a summary extraction node in the path to generate a reconstructed topology graph.

[0081] The reverse compensation module is connected to the topology reconstruction module to receive the reconstructed topology graph. The reverse compensation module traverses the network connection path and compares the data input and output architecture settings of the nodes at both ends of the directed edge. When it is determined that the output architecture of the predecessor large language model node does not match the input architecture of the successor tool node, the reverse compensation module compiles the data architecture specification of the successor node into model-specific constraint instructions and writes the model-specific constraint instructions as a prerequisite into the configuration file of the predecessor large language model node.

[0082] The serialization output module is connected to the reverse compensation module to receive the network structure with the data format aligned. The serialization output module calls the strongly connected component algorithm to scan the entire graph structure to identify and remove cyclic dependencies in the network. After the entire graph is verified, the serialization output module traverses the memory regions of all nodes in the graph, extracts the running parameter configuration and edge routing rules attached to the nodes, maps the extracted data to a standard markup language, and outputs the agent workflow configuration file.

[0083] See attached document Figure 2 This invention provides an auxiliary construction method for automatically generating AI intelligent agent processes based on business requirement documents. The method includes the following steps:

[0084] S1, the text parsing module receives unstructured business requirement document data. The text parsing module applies dependency parsing algorithm and named entity recognition algorithm to deconstruct the unstructured business requirement document data to extract the action execution subject, operation logic and boundary triggering constraints. The text parsing module divides the deconstructed requirement data into a set of basic task nodes and establishes a set of directed edges by combining the temporal dependencies between tasks. The text parsing module combines the set of basic task nodes and the set of directed edges to generate an initial directed acyclic graph.

[0085] S2, the resource configuration module obtains the initial directed acyclic graph. The resource configuration module maps the functional text of each node in the initial directed acyclic graph to a high-dimensional feature vector through a vector encoding algorithm. The resource configuration module performs a cosine similarity operation between the high-dimensional feature vector and the preset resource feature space. Based on the numerical matching results, the resource configuration module retrieves the external tool application programming interface parameters, logic control components and large language model initialization parameters from the external storage device. The resource configuration module instantiates the retrieved parameter items and binds them to the memory space of the corresponding graph node.

[0086] S3, the topology reconstruction module reads the topology graph structure with completed parameter binding. The topology reconstruction module performs a reverse breadth-first search along the execution path of the topology graph structure, recursively calculating the sum of the basic context costs of the downstream paths of each node. The topology reconstruction module calculates the maximum generation budget of the node based on the maximum context length threshold and the sum of the basic context costs of the downstream paths. The topology reconstruction module overwrites the maximum generation budget as a mandatory constraint into the restriction terms of the large language model parameter configuration. When the maximum generation budget is lower than the summarization trigger threshold, the topology reconstruction module actively cuts the directed edges of the original path and inserts a summary extraction node at the breakpoint to generate the reconstructed topology graph.

[0087] S4, the reverse compensation module extracts the network connectivity data of the reconstructed topology graph. The reverse compensation module traverses the network edge paths and compares the data input architecture specifications and data output architecture specifications of the nodes at both ends of the directed edge one by one. When a structural conflict is found between the output architecture of the predecessor large language model node and the input architecture of the successor tool node, the reverse compensation module extracts the data architecture specifications of the successor node and compiles them to generate model-specific constraint instructions. The reverse compensation module then injects the model-specific constraint instructions as suffix parameters into the configuration file of the predecessor large language model node to complete the forced alignment of the upstream and downstream data formats.

[0088] S5, the serialization output module receives the format-aligned network structure data, runs the strongly connected component algorithm to scan the entire graph structure, detects and blocks cyclic dependencies in the network path, and after the graph structure legality verification is passed, the serialization output module extracts the running parameter configuration and edge routing rules of the entire graph nodes. The serialization output module compiles the extracted structured data into a standard markup language and outputs it as an agent workflow configuration file.

[0089] See attached document Figure 3 In specific implementations, step S1 provided by the present invention may include the following steps:

[0090] S101, the text parsing module receives unstructured business requirement document data, calls a semantic deconstruction network model containing named entity recognition algorithm and dependency parsing algorithm to perform preprocessing operations on the unstructured business requirement document data, the text parsing module converts the unstructured business requirement document data into tensor sequences containing word vectors and positional encoding through the input layer, inputs the generated tensor sequence into a semantic deconstruction network model composed of multi-layer bidirectional Transformer encoders, extracts the contextual dependency features inside the tensor sequence through a multi-head self-attention mechanism and outputs a high-dimensional hidden layer vector with semantic representation, the text parsing module uses fully connected layers and conditional random field layers to decode the high-dimensional hidden layer vector, and outputs the entity category label of each word in the tensor sequence and the dependency relationship matrix between words;

[0091] The method for creating and training a semantic deconstruction network model includes the following steps: obtaining an industry business corpus labeled with business entity tags and dependency syntax trees as samples; performing text cleaning, word segmentation, and word embedding mapping on the sample data to create a semantic deconstruction dataset for model training; establishing a network computation graph structure consisting of a multi-layer bidirectional Transformer encoder, a fully connected layer, and a conditional random field layer; and initializing the weight parameters of each layer inside the semantic deconstruction network model using a random distribution function to complete the model creation and construction.

[0092] During the training phase, the tensor sequence of the semantic deconstruction dataset is input into the semantic deconstruction network model for forward propagation to obtain the predicted label. The difference loss value between the predicted label and the true label is calculated using the cross-entropy loss function. The gradient of the loss function with respect to each weight parameter is calculated using the backpropagation algorithm. The encoder network weights are iteratively updated using the optimization algorithm until the loss value converges, and the trained semantic deconstruction network model is obtained.

[0093] During the inference phase, the text parsing module extracts the predicate verbs from the unstructured business requirement document data based on the output dependency matrix as the operation logic, and extracts the noun components associated with the predicate verbs as the action execution subjects. The text parsing module separates the boundary trigger constraints in the unstructured business requirement document data by matching a preset condition conjunction dictionary containing 10 to 50 basic condition conjunctions with the clause parsing logic.

[0094] S102, the text parsing module divides the deconstructed unstructured business requirement document data into a set of basic task nodes. Each data fragment containing a single action execution subject and a single operation logic is encapsulated into an indivisible basic execution unit. Then, a global node identifier is assigned to each basic execution unit. All basic execution units that have completed the assignment of global node identifiers are aggregated to form a set of basic task nodes. Subsequently, the text parsing module establishes a mapping table in memory with the global node identifier as the primary key. The text fragments of the action execution subject and operation logic are stored as key-value pairs in the mapping table. The node attribute data is solidified in the mapping table in the form of key-value pairs to the corresponding memory storage block.

[0095] S103, the text parsing module performs temporal dependency determination on each element in the basic task node set, and establishes a set of directed edges based on the temporal dependency relationship between tasks. When the text parsing module determines that there is a prerequisite constraint between two basic task nodes, it generates a directed edge from the basic task node as the prerequisite to the basic task node as the subsequent action. All generated unidirectional connection segments are integrated to establish a set of directed edges. When establishing directed edges, the text parsing module simultaneously generates an adjacency matrix to represent the connection relationship between graph nodes, writes Boolean connectivity values ​​at the corresponding element positions of the adjacency matrix, and directly maps the directional flow relationship between basic task nodes in memory.

[0096] S104, the text parsing module extracts the Boolean logic expressions from the boundary trigger constraints, and binds the extracted Boolean logic expressions as weight parameters to the corresponding directed edges to form weighted directed edges. The text parsing module combines the basic task node set with the set of directed edges with boundary trigger constraints to generate an initial directed acyclic graph. The data structure is encapsulated into a unidirectional flow and loop-free network topology graph structure. The text parsing module calls the depth-first search algorithm to traverse the generated network topology graph structure. When a back edge is detected, the circular dependency handling rule is triggered to actively cut off the circular dependency back edge paths generated at the data flow level of the initial directed acyclic graph.

[0097] See attached document Figure 4 and attached Figure 5 In specific implementations, step S2 provided by the present invention may include the following steps:

[0098] S201, the resource configuration module receives the initial directed acyclic graph output by the text parsing module, traverses the set of basic task nodes in the initial directed acyclic graph, and extracts the functional text composed of the action execution subject and operation logic stored in the node memory space. Then, it calls the vector encoding algorithm to perform a high-dimensional feature vector mapping operation on the functional text. The vector encoding algorithm is used to transform discrete natural language character segments into continuous and fixed-dimensional mathematical feature vectors to represent the inherent contextual semantic features of the text. At the same time, the vector encoding algorithm relies on a pre-set feature encoding network model, which includes a lexical embedding layer and a multi-layer self-attention encoding layer. Then, the resource configuration module segments the functional text into discrete word sequences and attaches an absolute position encoding tensor through the lexical embedding layer.

[0099] In S202, the resource configuration module inputs the discrete word sequence with an additional absolute position encoding tensor into the multi-layer self-attention encoding layer. At the same time, the multi-layer self-attention encoding layer extracts the global contextual semantic relationships within the discrete word sequence through self-attention matrix operations, and outputs a hidden layer state feature sequence containing global semantic intent information at the end of the multi-layer self-attention encoding layer. The resource configuration module uses the linear projection pooling layer at the end of the feature encoding network model to perform dimensionality reduction and fusion operations on the hidden layer state feature sequence, and then extracts a high-dimensional feature vector with a fixed dimension. The final output high-dimensional feature vector represents the digital semantic intent features of the business logic of the underlying graph nodes.

[0100] S203. To enable the feature encoding network model to have cross-modal alignment capabilities, a comparative learning training is performed on the feature encoding network model before deployment. Specifically, this includes: extracting a corpus of real business scenarios, which contains a massive amount of business function description text and matching external resource indexes, and packaging the massive amount of business function description text and matching external resource indexes into positive sample data pairs, while randomly combining business function description text and irrelevant resource indexes into negative sample data pairs, thus completing the creation of the comparative learning training dataset; and inputting the positive and negative sample data pairs into the model to obtain the corresponding feature vector representations.

[0101] Among them, the external resource index is mapped in the underlying database to complete structured text content such as resource name, resource function description, application programming interface description, input and output field requirements, calling conditions and resource type labels, so as to ensure that the input feature encoding network model has sufficient resource feature semantics;

[0102] During the training phase, the contrastive loss function is used to minimize the distance between positive sample data and feature vectors and maximize the distance between negative sample data and feature vectors. At the same time, the stochastic gradient descent algorithm is used as an optimizer to iteratively update the network weight parameters inside the feature encoding network model according to the loss gradient until the contrastive loss function converges, thereby establishing a unified feature mapping benchmark between natural language text and computing resources.

[0103] S204, the resource configuration module reads the preset resource feature space in the external storage device. The preset resource feature space stores a resource vector library that has been mapped by isomorphic encoding. The resource configuration module maintains a resource registration mapping table in the external storage device. The resource registration mapping table contains at least the mapping relationship between fields such as resource index, resource type, resource function description, resource vector storage address, physical storage address of application programming interface or model initialization parameters, and input / output architecture specification file address.

[0104] The resource allocation module performs cosine similarity calculations between the high-dimensional feature vector and each resource vector in the pre-set resource feature space. The module determines the semantic matching degree between the functional text and the pre-set resources by quantifying the geometric angle between the two vectors in the multi-dimensional feature space. The specific cosine similarity calculation formula is as follows:

[0105] ;

[0106] In the formula, The cosine similarity score is used to match the high-dimensional feature vector generated by the node function text mapping with the value of a single resource vector. This is a high-dimensional feature vector generated by the node function text mapping; A single resource vector stored in a pre-defined resource feature space; The total number of vector dimensions in the feature space; The traversal index number for the feature space dimension, with values ​​ranging from 1 to... Integers; High-dimensional feature vectors In the scalar components in each dimension; Resource vector In the scalar components in each dimension.

[0107] S205, the resource configuration module compares the calculated cosine similarity matching value with the preset similarity value judgment threshold. The similarity value judgment threshold is set between 0.8 and 0.95. When the cosine similarity matching value is greater than or equal to the similarity value judgment threshold, the resource configuration module records the corresponding resource index. The resource configuration module determines the matching resource type based on the recorded resource index and retrieves the corresponding external tool application programming interface parameters, logic control components or large language model initialization parameters from the external storage device.

[0108] Specifically, when the resource type is an external tool, the external tool application programming interface parameters, including the request Uniform Resource Locator, request method type, authentication token, and input / output parameter format specifications, are retrieved; when the resource type is logic control, the logic control component, including conditional branch execution component, loop iteration component, or concurrent execution component, is retrieved; when the resource type is a large language model, the large language model initialization parameters, including the model version identifier, temperature coefficient, maximum context limit, Top-P sampling threshold, and preset system prompt word instruction set, are retrieved.

[0109] In addition, when multiple cosine similarity matching values ​​exceed the similarity value judgment threshold, the resource configuration module extracts the resource index with the largest value as the final retrieval basis. Then, when all the calculated cosine similarity matching values ​​are strictly less than the similarity value judgment threshold, the resource configuration module triggers the exception handling logic and retrieves an empty resource placeholder and allocates it to the current node's memory space to prevent the graph traversal process from being suspended.

[0110] S206, the resource configuration module loads the external tool application programming interface parameters, logic control components, and large language model initialization parameters into the runtime cache. At the same time, the resource configuration module calls the deserialization program to convert the bytecode data in the runtime cache into runtime parameter objects that can be directly called. The resource configuration module extracts the global node identifier of the current processing node and retrieves the matching memory address in the mapping table. Then, the resource configuration module binds the runtime parameter object to the memory space of the corresponding graph node through pointer overwriting operation. After completing the traversal and binding operation of all graph nodes, the resource configuration module outputs the topology graph structure with complete parameter binding.

[0111] See attached document Figure 6 In specific implementations, step S3 provided by the present invention may include the following steps:

[0112] S301, the topology reconstruction module reads the topology graph structure with completed parameter binding output by the resource configuration module, locates all terminal nodes with an out-degree of 0 in the topology graph structure and adds the terminal nodes to the search queue as the starting set, and performs a reverse breadth-first search operation up the layer predecessor node level by level along the reverse path of the directed edges. During the search process, the context occupancy parameter of the current node is extracted to evaluate the global memory overhead limit of the data flow path. At the same time, the topology reconstruction module triggers the recursive calculation rule when traversing to each predecessor node, and then extracts the overhead data of the child nodes and recursively calculates the sum of the basic context overhead of the downstream path of the current predecessor node.

[0113] S302, the sum of the basic context overhead of the downstream path represents the fixed number of symbols that a large language model node needs to bear under the worst execution path. The topology reconstruction module calculates the sum of the basic context overhead of the downstream path by accumulating the inherent overhead of the node and the maximum overhead of the downstream branch. In addition, the topology reconstruction module extracts the length of the system prompt word sequence in the initialization parameters of the large language model of the node itself as the inherent overhead base consumption. The specific formula for calculating the sum of the basic context overhead of the downstream path is as follows:

[0114] ;

[0115] In the formula, For the currently being processed number The total basic context cost of the downstream path of each graph node; For the current number The fixed system prompt word length consumption value in the initialization parameters of the large language model for each graph node; For the current number The total number of direct successor nodes pointed to by each graph node; The traversal index of the direct successor node, with a value ranging from 1 to... Integers; For the first The total basic context overhead of the downstream path for each direct successor node to complete the accounting output; This is the traversal index of the currently processed graph node.

[0116] S303, the topology reconstruction module reads the set maximum context length threshold from the external system configuration table, and the value range of the maximum context length threshold is limited to between 4096 and 128000. The topology reconstruction module performs a subtraction operation between the maximum context length threshold and the sum of the basic context overhead of the downstream path, and calculates the maximum generation budget of the target large language model node. Then, the topology reconstruction module extracts the memory address of the corresponding restriction item of the large language model parameter configuration in the memory space of the large language model node. At the same time, the topology reconstruction module converts the maximum generation budget into an integer value through a memory address overwrite operation and forcibly writes it into the restriction item memory address.

[0117] S304, the topology reconstruction module compares the calculated maximum generation budget with the set summary trigger threshold. The summary trigger threshold is limited to a range of 256 to 512. When the maximum generation budget is greater than or equal to the summary trigger threshold, the topology reconstruction module retains the original directed edges from the current large language model node to the successor node. In addition, when the maximum generation budget is strictly lower than the summary trigger threshold, the topology reconstruction module triggers the network topology edge rewriting rule.

[0118] In response to the current situation where a large language model node has multiple successor nodes or multiple downstream branches, the topology reconstruction module executes a branch-level judgment process, extracts the context cost values ​​of each successor branch and sorts them, selects the single target edge with the calculated maximum cost as the edge breaking processing object, or when multiple successor branches meet the triggering conditions, they share a single instantiated summary extraction node for unified dimensionality reduction interception processing.

[0119] The topology reconstruction module cuts off the original directed edges from the current large language model node to the successor node in memory, and instantiates a summary extraction node in memory.

[0120] S305, the summary extraction node internally carries a text summarization network model based on a sequence-to-sequence architecture. The topology reconstruction module re-establishes new predecessor edges from the current large language model node to the summary extraction node and new successor edges from the summary extraction node to the successor node. At the same time, the text summarization network model contains an encoder and decoder composed of a multi-layer Transformer structure based on a self-attention mechanism. The topology reconstruction module inputs text exceeding the length limit into the encoder and transforms it into a hidden state tensor containing global semantics. Then, the decoder generates a compressed summary text sequence based on the autoregression of the hidden state tensor. In addition, after traversing all connected paths in the entire graph, the topology reconstruction module outputs a reconstructed topology graph containing the newly added nodes.

[0121] S306, The method for creating and training a text summarizing network model includes the following steps: collecting massive amounts of multi-dimensional long original texts and manually simplified summaries pre-configured in the business scenario database; performing text cleaning and fixed-length truncation on these long original texts and manually simplified summaries to create positive sample data pairs; and generating negative sample data pairs through random combination of erroneous summaries; combining these to form a summarizing training dataset; building a model skeleton based on a sequence-to-sequence architecture; constructing a Transformer encoder and decoder module containing a multi-layer self-attention mechanism; and randomly initializing the connection matrices of each layer to complete the model creation.

[0122] In the feature alignment training stage, the long text in the summary training dataset is input into the encoder for forward feature extraction calculation, the decoder outputs the predicted summary sequence, and the cross-entropy loss function is used to calculate the character distribution difference between the generated sequence and the real summary to obtain the loss value.

[0123] Simultaneously, negative sample data is input to the encoder and decoder. A binary classification auxiliary loss function is used to calculate the deviation between the predicted summary of negative samples and the true distribution to extract the penalty weight loss. The base loss value and the penalty weight loss are combined to generate a comprehensive loss function value. The backpropagation algorithm is used to calculate the comprehensive error gradient. An iterative algorithm is applied to update the network connection weights of the encoder and decoder until the comprehensive loss function value converges. The trained text summarization network model is obtained. The text summarization network model performs sequence length compression on redundant business text and matches the input width limit index of downstream nodes. The topology reconstruction module performs parameter dimensionality reduction adaptation for data flow between nodes by loading the trained text summarization network model.

[0124] See attached document Figure 7 In specific implementations, step S4 provided by the present invention may include the following steps:

[0125] S401, the reverse compensation module finally completes the forced alignment of upstream and downstream data formats and outputs network connectivity data to the serialization output module. At the same time, the reverse compensation module reads the reconstructed topology graph output by the topology reconstruction module. The edge connection relationship inside the reconstructed topology graph objectively represents the upstream and downstream parameter dependency relationship of the business logic execution flow. In addition, the reverse compensation module instantiates a traversal pointer in memory and performs a depth-first traversal operation along the directed edges of the reconstructed topology graph. Furthermore, the initial node parameter reading and memory state mapping are synchronously verified based on the existing graph traversal baseline logic.

[0126] S402, continuous data interaction between nodes relies on the data coverage relationship between the upstream output and the downstream required input parameters. The reverse compensation module extracts the corresponding field set for regular intersection operation, and the related coverage calculation is directly implemented through the basic set intersection operation logic. The specific field coverage calculation formula is as follows:

[0127] ;

[0128] In the formula, The calculated upstream and downstream node field coverage; The number of fields in the output field set declared for the predecessor large language model node; The total number of fields in the set of required input fields required for subsequent tool nodes.

[0129] S403, the reverse compensation module extracts the standard architecture configuration compensation logic. The reverse compensation module compares the calculated field coverage rate with the preset architecture matching threshold of 1. At the same time, when the judgment result fails to meet the standard and a structural conflict state occurs, the judgment rules for the structural conflict state include not only verifying the field coverage rate, but also judging the characteristic attributes of the corresponding fields in the upstream and downstream. When any structural conflict type is detected, such as inconsistent field names, inconsistent data types, inconsistent nesting depth, inconsistent array element types, missing required fields, and inconsistent enumeration values ​​or format constraints, it is determined that a structural conflict state has been triggered. The reverse compensation module directly loads the complete input data architecture specification file of the subsequent tool node into the subsequent compilation process.

[0130] S404, the reverse compensation module calls the preset syntax conversion component to extract the structural features inside the input data architecture specification file, and maps and encapsulates the associated key-value pair constraints in memory into an abstract syntax tree structure. The reverse compensation module traverses the leaf nodes to extract attribute information and assembles them according to the standard specification. Then, the reverse compensation module concatenates the generated structured declaration text fragments with preset formatting prompt words with format restriction instructions and a character length between 10 and 50 characters to generate model-specific constraint instructions.

[0131] S405, the reverse compensation module locates the runtime parameter configuration file of the predecessor large language model node. The reverse compensation module extracts the memory address block corresponding to the system prompt word from the runtime parameter configuration file. The reverse compensation module appends the generated model-specific constraint instructions as suffix parameters to the end of the system prompt word memory block. The reverse compensation module calls the write protection instruction through the system's underlying interface to lock the state of the system prompt word memory block. At the same time, the reverse compensation module blocks external concurrent processes from modifying or accessing the locked memory block while it is locked.

[0132] See attached document Figure 8 In specific implementations, step S5 provided by the present invention may include the following steps:

[0133] S501, the serialization output module receives the network structure data with the completed format alignment from the reverse compensation module. To prevent the introduction of new abnormal deadlock risks during the intermediate topology reconstruction and edge relationship rewriting process and to perform the final security check, the serialization output module completes the basic initialization configuration of the depth-first search access stack and node timestamp record table in memory. The related strongly connected component algorithm scanning logic and timestamp state parameter extraction operations are executed synchronously according to the standard depth-first search protocol.

[0134] S502, the serialization output module detects cyclic dependencies in the network path based on the timestamp status parameters. Simultaneously, the minimum timestamp record update is directly completed by the system's underlying minimum value determination and calculation module. The specific formula for updating the minimum timestamp record is as follows:

[0135] ;

[0136] In the formula, For the current node The smallest traceable timestamp record value; To be related to the current node Adjacent subsequent nodes The smallest timestamp value recorded; The identifier of the current node that is currently performing a strongly connected component scan traversal; For the current node The identifier of the adjacent connected node pointed to by the directed edge.

[0137] When the serialization output module determines that a closed-loop structure exists, it directly destroys the back edge objects pointing to the earlier visited nodes inside the strongly connected components in memory. When there are multiple candidate back edges in the network path, the serialization output module first deletes the back edge pointing to the earliest visited node to avoid deleting necessary business paths. After completing the back edge destruction operation, it re-executes the full graph reachability and topology validity checks.

[0138] S503, after confirming that the full graph structure has passed the validity check and there are no closed-loop dependencies, the serialization output module enters the data extraction stage. At the same time, the serialization output module accesses the memory areas of the full graph nodes in the execution sequence according to the topological sorting. The serialization output module extracts the running parameter configurations mounted inside each graph node and the edge routing rules between the connected nodes. The extracted running parameter configurations and edge routing rules cover the external tool application programming interface parameters, the large language model initialization parameters, and the Boolean logic expression weight parameters of the execution order between nodes.

[0139] S504, the serialization output module establishes a data mapping dictionary in memory. At the same time, the serialization output module directly converts the extracted structured data into a key-value pair structure in standard markup language format. The serialization output module extracts the global node identifiers of the graph nodes and converts them into the primary key indexes of the independently executed task blocks. The serialization output module converts the external tool application programming interface parameters into nested attribute fields according to the dictionary format and attaches the corresponding parameter values ​​below the attribute fields. The serialization output module maps the node identifiers recorded in the edge routing rules and the Boolean logic expression weight parameters into a condition dependency array based on the primary key index.

[0140] S505, the serialization output module concatenates standard markup language text segments with hierarchical nesting. In addition, the serialization output module calls the file system interface to allocate physical disk sectors in the external storage device and writes the concatenated standard markup language text segments in a unified character encoding format. After the write operation is completed, the serialization output module closes the file handle and outputs the final agent workflow configuration file. The agent workflow configuration file contains complete node running logic that has been decoupled from dependencies and aligned with data, and is loaded and run by the target execution engine as a static resource text file.

[0141] Specifically, the output agent workflow configuration file has a standard key-value pair nested hierarchical structure. The configuration text fragment of the agent workflow configuration file fully records the node global identifier, node type label, external model or tool parameter call address, input-output mapping relationship dictionary, directed connected list composed of successor node identifiers, edge route Boolean logic expression responsible for controlling branch flow, and timeout limit and exception handling callback strategy fields. The target execution engine can realize the deserialization and instantiation of graph nodes and connected relationships in memory by reading and parsing the standard fields.

[0142] See attached document Figure 9 To aid in understanding the technical solution of this invention, the following provides an application example of an auxiliary construction method for automatically generating AI intelligent agent processes based on business requirement documents.

[0143] The application example receives unstructured business requirement document data for building an intelligent agent for automated refund processing in e-commerce after-sales service. The content of the unstructured business requirement document data includes: when a user's refund request is received, firstly, querying the order status; if the order status is "shipped", requesting the user's return logistics tracking number; if the order status is "not shipped", directly calling the financial system to execute the refund action; and finally, generating a complete processing summary and sending an SMS notification to the user.

[0144] The text parsing module extracts the action execution subject and operation logic within the unstructured business requirement document data. The text parsing module extracts the boundary trigger constraints formed by if and then. The text parsing module splits the requirement data into a set of basic task nodes consisting of intent recognition nodes, order query nodes, request order number nodes, refund call nodes, and send notification nodes. The text parsing module establishes an initial directed acyclic graph based on the time sequence and adds Boolean logic flow conditions consisting of shipped and unshipped items to the directed edges.

[0145] The resource configuration module transforms the functional text of the refund call node into a high-dimensional feature vector and performs cosine similarity retrieval in the preset resource feature space. The resource configuration module matches the financial refund interface in the external storage device based on the cosine similarity matching value that is greater than the similarity value judgment threshold. The resource configuration module retrieves and binds the external tool application programming interface parameters of the financial refund interface, including the request uniform resource locator, request method type, authentication token, and input / output parameter format specifications, to the memory space of the refund call node.

[0146] The topology reconstruction module performs a reverse breadth-first search along the directed edge reverse path from the notification sending node and calculates the total basic context cost of the downstream path. When the maximum generation budget of the calculated output is lower than the summary trigger threshold, the topology reconstruction module cuts off the original directed edge from the order query node to the refund call node. The topology reconstruction module instantiates a summary extraction node between the order query node and the refund call node to generate a reconstructed topology graph. The summary extraction node loads the text summary network model to perform dimensionality reduction processing on the tensor sequence of historical customer complaint chat records to generate a short text sequence.

[0147] The reverse compensation module extracts and reconstructs the topology graph and traverses the network edge paths to compare the data output architecture specification of the order query node with the data input architecture specification of the refund call node. When the reverse compensation module determines that the data input and output architecture specifications do not match, it extracts the data architecture specification of the refund call node and compiles it to generate model-specific constraint instructions containing key-value pairs of objects with specified output formats. The reverse compensation module writes the model-specific constraint instructions as suffix parameters into the system prompt word memory block of the large language model initialization parameters of the order query node to complete the forced alignment of upstream and downstream data formats.

[0148] The serialization output module receives the format-aligned network structure data and runs the strongly connected component algorithm to scan the entire graph structure to identify and eliminate cyclic dependencies. After the full graph structure passes the validity check, the serialization output module extracts the running parameter configuration and edge routing rules of the full graph nodes according to the topology sorting. The serialization output module converts the running parameter configuration and edge routing rules into standard markup language and outputs the refund processing agent workflow configuration file that the target execution engine needs to load and run.

[0149] As shown in the figure, the parameter state changes indicate that during the construction of the e-commerce after-sales automated refund processing agent, the total basic context overhead increases with the increase in node complexity. Specifically, the order query node has the lowest overhead and sufficient maximum generation budget because it only involves simple state judgments; the refund call node involves external interface parameters and has moderate overhead; however, when the summary extraction node is executed, the total basic context overhead reaches its peak due to the need to process a large number of historical customer complaint chat record tensor sequences, causing the maximum generation budget to drop sharply and triggering the threshold. At the same time, the cosine similarity matching values ​​corresponding to the external tool calls of each node are all stable above the similarity value judgment threshold, ensuring the accuracy of resource allocation.

[0150] Although embodiments of the invention have been shown and described, it will be understood by those skilled in the art that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the appended claims and their equivalents.

Claims

1. A method for automatically generating AI agent processes based on business requirement documents, characterized in that: The method includes the following steps: Deconstruct the unstructured business requirement document data extraction action execution subject, operation logic and boundary trigger constraints, divide the basic task node set and establish a directed edge set based on the temporal dependency relationship, bind the boundary trigger constraints to the corresponding directed edges in the directed edge set to form weighted directed edges, combine the basic task node set and the directed edge set containing the weighted directed edges to generate an initial directed acyclic graph; The functional text composed of the action execution subject and the operation logic in the initial directed acyclic graph is mapped into a high-dimensional feature vector. The cosine similarity operation with the preset resource feature space is performed. Based on the result of the cosine similarity operation, the resource index and resource type matching each graph node are determined. The corresponding external tool application programming interface parameters, logic control components or large language model initialization parameters are retrieved and bound to the corresponding graph node. The total basic context cost of the downstream path of the graph node is calculated, and the maximum generation budget is calculated in combination with the preset maximum context length threshold. If the cost is lower than the preset summary triggering threshold, a summary extraction node is inserted to generate a reconstructed topology graph. If the input and output data architecture specifications of the predecessor large language model node and the successor tool node connected in the reconstructed topology graph do not match, the compilation model-specific constraint instructions are reverse-written into the predecessor large language model node to complete the forced alignment of upstream and downstream data formats. Scan the network structure data to eliminate circular dependencies, extract the runtime parameter configuration and edge routing rules, and output the agent workflow configuration file.

2. The assisted construction method for automatically generating AI intelligent agent processes based on business requirement documents according to claim 1, characterized in that, The steps of deconstructing the unstructured business requirement document data extraction action, including the execution subject, operation logic, and boundary trigger constraints; dividing the basic task node set and establishing a directed edge set based on temporal dependencies; binding the boundary trigger constraints to the corresponding directed edges in the directed edge set to form weighted directed edges; and combining the basic task node set with the directed edge set containing the weighted directed edges to generate an initial directed acyclic graph include: The unstructured business requirement document data is preprocessed using a semantic deconstruction network model, and the entity category labels and dependency relationship matrix are output. Based on the dependency matrix, the predicate verb is extracted as the operation logic, and the associated nominal components are extracted as the action execution subject; The boundary trigger constraints are separated by matching a preset dictionary of conditional conjunctions; The corresponding data segments containing a single action execution subject and a single operation logic are encapsulated into basic execution units to form the basic task node set; The set of basic task nodes is subjected to temporal dependency determination to generate the set of directed edges. The boundary triggering constraints are bound to the corresponding directed edges in the set of directed edges to form weighted directed edges. The set of basic task nodes and the set of directed edges containing the weighted directed edges are combined to generate the initial directed acyclic graph.

3. The assisted construction method for automatically generating AI intelligent agent processes based on business requirement documents according to claim 2, characterized in that, The step of preprocessing the unstructured business requirement document data using a semantic deconstruction network model to output entity category labels and dependency relationship matrices includes: The unstructured business requirement document data is converted into a tensor sequence containing word vectors and positional encodings; The semantic deconstruction network model extracts the context-dependent features within the tensor sequence and outputs a high-dimensional hidden layer vector with semantic representation. The high-dimensional hidden layer vector is decoded to output the entity category label and the dependency matrix.

4. The assisted construction method for automatically generating AI intelligent agent processes based on business requirement documents according to claim 1, characterized in that, The steps of mapping the functional text composed of the action execution subject and the operation logic in the initial directed acyclic graph to a high-dimensional feature vector, performing a cosine similarity operation with the preset resource feature space, determining the resource index and resource type matching each graph node based on the cosine similarity operation result, retrieving the corresponding external tool application programming interface parameters, logic control components or large language model initialization parameters, and binding them to the corresponding graph nodes include: Extract the functional text, which is the combination of the action execution subject and the operation logic, stored in the node memory space of the initial directed acyclic graph; The functional text is segmented into discrete word sequences and an absolute position encoding tensor is attached using a feature encoding network model. Extract the global contextual semantic relationships within the discrete word sequence to output the hidden layer state feature sequence, and then reduce its dimensionality and fuse it into the high-dimensional feature vector; Perform cosine similarity calculation between the high-dimensional feature vector and each resource vector in the preset resource feature space; When the cosine similarity matching value is greater than or equal to the similarity value judgment threshold, the corresponding resource index is determined and recorded. Based on the resource index, the matching resource type is determined to retrieve the corresponding external tool application programming interface parameters, logic control components, or large language model initialization parameters and bind them to the memory space of the corresponding graph node.

5. The auxiliary construction method for automatically generating AI intelligent agent processes based on business requirement documents according to claim 1, characterized in that, The steps of calculating the total basic context cost of the downstream paths of the graph nodes, calculating the maximum generation budget in combination with a preset maximum context length threshold, and inserting a summary extraction node to generate a reconstructed topology graph when the cost is lower than a preset summary triggering threshold include: A reverse breadth-first search operation is performed along the execution path of the completed parameter-bound topology graph structure. The sum of the basic context overhead of the downstream path is recursively calculated by accumulating the inherent overhead of the nodes and the maximum overhead of the downstream branches. Perform a subtraction operation between the maximum context length threshold and the sum of the underlying context costs of the downstream paths, and calculate the maximum generation budget; When the maximum generation budget is strictly lower than the summary trigger threshold, the original directed edges from the current large language model node to the successor node are cut off, and the summary extraction node, which is internally mounted with a text summarization network model based on a sequence-to-sequence architecture, is instantiated at the breakpoint to generate the reconstructed topology graph.

6. The assisted construction method for automatically generating AI intelligent agent processes based on business requirement documents according to claim 5, characterized in that, The method for creating and training the text summarization network model includes the following steps: Text cleaning and fixed-length truncation are performed on the pre-configured multi-dimensional long text originals and manually simplified summaries in the business scenario database to create positive sample data pairs. Negative sample data pairs are formed by combining erroneous summaries to construct a summary training dataset. The long text input into the summary training dataset is used to extract features from the encoder, and the decoder outputs a predicted summary sequence. The loss value is obtained by calculating the distribution difference between the predicted summary sequence and the manually simplified summary using the cross-entropy loss function. The error gradient is calculated using the backpropagation algorithm, and the network connection weights are updated using an iterative algorithm until the loss function converges.

7. The assisted construction method for automatically generating AI intelligent agent processes based on business requirement documents according to claim 1, characterized in that, The steps for comparing the input and output data architecture specifications of the predecessor large language model nodes and successor tool nodes connected in the reconstructed topology graph, and forcing the upstream and downstream data format alignment by reverse-writing the compilation model-specific constraint instructions to the predecessor large language model nodes when they do not match include: A depth-first traversal operation is performed along the directed edges of the reconstructed topology graph, and the field coverage between upstream and downstream nodes is calculated by performing an intersection operation on the extracted sets. When the field coverage is lower than the architecture matching threshold and a structural conflict occurs, the complete input data architecture specification file of the subsequent tool node is extracted. Extract the structural features of the input data architecture specification file, assemble a structured declaration text fragment, and concatenate it with formatted prompt words and affixes to generate the model-specific constraint instructions; The model-specific constraint instruction is appended to the end of the system prompt word memory block of the predecessor large language model node, and the write protection instruction is invoked to lock the memory block state.

8. The assisted construction method for automatically generating AI intelligent agent processes based on business requirement documents according to claim 1, characterized in that, The steps of scanning the network structure data to remove cyclic dependencies and extracting the runtime parameter configuration and edge routing rules to output the agent workflow configuration file include: Based on the timestamp status parameters, the circular dependency loops in the network path are detected, and when a closed loop structure is determined to exist, the back edge objects pointing to previously visited nodes are destroyed. After the structural validity check is passed, the memory regions of each graph node are accessed according to the execution sequence sorted by topology, and the running parameter configuration and the edge routing rules are extracted. The extracted structured data is converted into a key-value pair structure in standard markup language format, and the standard markup language text paragraphs are written to an external storage device to output the agent workflow configuration file.

9. The assisted construction method for automatically generating AI intelligent agent processes based on business requirement documents according to claim 8, characterized in that, The step of detecting cyclic dependencies in the network path based on timestamp state parameters and destroying back edge objects pointing to previously visited nodes when a closed loop structure is determined to exist includes: Complete the basic initialization configuration of the depth-first search access stack and node timestamp record table in memory; Extract the timestamp state parameters of the current node and the adjacent connected nodes pointed to by the directed edges; The minimum value determination module updates the minimum timestamp record and destroys the back edge objects that point to previously visited nodes when a closed loop is detected.

10. The assisted construction method for automatically generating AI intelligent agent processes based on business requirement documents according to claim 4, characterized in that, The training steps of the feature encoding network model include: Extract the business function description text and the matching external resource index and package them into positive sample data pairs. Randomly combine the business function description text and irrelevant resource indexes and package them into negative sample data pairs to create a comparative learning training dataset. The positive sample data pairs and the negative sample data pairs are respectively input into the feature encoding network model to obtain the corresponding feature vector representations; The network weight parameters are iteratively updated until convergence by using a contrastive loss function to minimize the distance between the positive sample data and the feature vector and maximize the distance between the negative sample data and the feature vector.

Images