Large model zero-illusion software orchestration scheduling method and device based on hierarchical constraints

Abstract

The application discloses a large model zero illusion software arrangement and scheduling method and device based on hierarchical constraints. The method comprises the following steps: receiving an input request, extracting the intention of the input request based on a large model, and outputting a structured intention containing a function domain label and a business parameter; matching a candidate function in a static function library based on the function domain label, checking the interface running state of the candidate function in a dynamic interface library, and screening to obtain a compliant function set; mapping the compliant function set to a node of a pre-constructed business knowledge graph, and determining a unique business branch based on a routing rule associated with a topology edge to generate a global function chain; performing parameter mapping and encapsulation on the global function chain and the structured intention to generate a structured execution chain and issue an execution. The application relies on a hierarchical constraint architecture, combines dynamic and static dual library linkage, suppresses large model illusion, replaces dynamic link deduction with graph retrieval to eliminate path deviation, and realizes zero illusion arrangement and scheduling in a large model arrangement scene.

Description

Technical Field

[0001] This application relates to the interdisciplinary field of artificial intelligence and software engineering, and in particular to a method and apparatus for zero-illusion software orchestration and scheduling of large models based on hierarchical constraints. Background Technology

[0002] Traditional software automation orchestration and scheduling solutions often rely on hard-coded, fixed business processes. Execution chains and business logic are pre-written into the program code, requiring secondary development and iterations for process changes. This results in poor business expansion flexibility and high costs for scenario adaptation. With the development of large language model technology, the industry is gradually shifting towards dynamic software orchestration solutions driven by natural language intent. These solutions leverage large language models to understand user intent and automatically generate execution chains, effectively overcoming the inflexibility limitations of traditional hard-coded solutions.

[0003] However, existing software orchestration solutions based on large models generally suffer from a double illusion: first, a functional illusion, because users' natural language intent is open-ended while the software's callable interfaces are a finite and closed set, existing solutions do not set rigid functional boundaries and rely entirely on the large model to autonomously match business interfaces that are easily fabricated and do not exist; second, a path illusion, because existing solutions allow the large model to freely orchestrate execution paths without pre-fixed standard business topologies, resulting in inconsistent execution links generated multiple times for the same input request, and the stability of business operation cannot be guaranteed.

[0004] Furthermore, the generative paradigm in the industry, which relies solely on real-time algorithmic deduction of the orchestration process supplemented by post-event verification, has inherent technical shortcomings: each request requires real-time algorithmic deduction and repeated verification, resulting in significant waste of computing power and high scheduling latency; moreover, the inherent probabilistic output bias of generative orchestration is difficult to eliminate at the architectural root, and the orchestration results are not reproducible, making it difficult to meet the high determinism, high reproducibility, and high reliability scheduling requirements of industrial scenarios. Therefore, a new orchestration and scheduling architecture is urgently needed to solve the problems of functional illusion and path illusion in large-model orchestration scenarios. Summary of the Invention

[0005] This application provides a zero-illusion software orchestration and scheduling method and apparatus for large models based on hierarchical constraints. Relying on the hierarchical constraint architecture, it solves the problems of dual illusion of function and path, redundancy of computing power in dynamic link extrapolation, and unreproducible probabilistic deviations in orchestration results in existing large model software orchestration technologies.

[0006] To address the aforementioned technical problems, this application adopts the following technical solution: a large-scale model zero-illusion software orchestration and scheduling method based on hierarchical constraints is provided, the method comprising: Receive input requests, extract intent from the input requests based on the large model, and output a structured intent containing functional domain labels and business parameters; Based on the functional domain labels, candidate functions are matched in the static function library, and the interface running status of the candidate functions is verified in the dynamic interface library to obtain a set of compliant functions. The set of compliance functions is mapped to nodes of a pre-built business knowledge graph, and a unique business branch is determined based on the routing rules associated with the business parameters and topology edges to generate a global function chain. The global function chain and the structured intent are encapsulated by parameter mapping to generate a structured execution chain and then executed.

[0007] In one optional embodiment of this application, the step of mapping the compliance function set to nodes of a pre-built business knowledge graph and determining a unique business branch based on the routing rules associated with the business parameters and topology edges includes: Based on the function identifiers corresponding to each compliance function in the compliance function set, the corresponding nodes are retrieved in the business knowledge graph, and the attribute information and topological connection relationships of the nodes are obtained. The topological edge is located based on the topological connection relationship, and the service parameters are compared and calculated with the routing rules associated with the topological edge; Based on the comparison calculation results and the preset branch mutual exclusion identifier of the topology edge, the unique business branch is hit.

[0008] In an optional embodiment of this application, after comparing and calculating the service parameters with the routing rules associated with the topology edge, the method further includes: If the service parameters do not meet the routing rules associated with any of the topology edges, the current service branch generation process is terminated and an error message is output.

[0009] In an optional embodiment of this application, before generating the global function chain, the method further includes: Based on the unique business branch and the topological connection relationship, the nodes are connected in series to generate an initial business link; Based on the functional identifier, link weight, and mutual exclusion blacklist in the attribute information, duplicate nodes, conflicting nodes, and mutual exclusion nodes in the initial business link are removed. Based on the serial-parallel rules in the attribute information, the initial business links after being removed are globally time-series rearranged to generate the global functional chain.

[0010] In one optional embodiment of this application, the step of extracting intent from the input request based on a large model and outputting a structured intent containing functional domain labels and business parameters includes: After preprocessing the input request, at least one core intent of the input request is extracted based on the large model and preset field templates; Based on a pre-defined three-level directory system, functional domain tags are bound to each of the core intents; the three-level directory system includes business domains, action subclasses, and operation objects; The business parameters are extracted from the core intent to output the structured intent.

[0011] In an optional embodiment of this application, the step of matching candidate functions in a static function library based on the functional domain labels and verifying the interface running status of the candidate functions in a dynamic interface library to filter and obtain a set of compliant functions includes: Based on the functional domain tags, the static functional library using the three-level directory system is searched level by level, discarding the structured intents that do not match the corresponding functions, and using the matched corresponding functions as the candidate functions; Based on the function identifiers corresponding to the candidate functions, the online status and circuit breaker flags of the corresponding interfaces are queried in the dynamic interface library that synchronizes the software running status in real time. Candidate functions with offline or circuit breaker-broken interfaces are eliminated to obtain the set of compliant functions.

[0012] In an optional embodiment of this application, the step of parameter mapping and encapsulating the global function chain with the structured intent to generate a structured execution chain includes: Based on preset multi-level template flow rules, the business parameters of the structured intent are mapped and verified with the global function chain to generate the structured execution chain. The mapping process is constrained by template fixation, and only parameter filling and field inheritance are performed after compliance verification is passed.

[0013] In an optional embodiment of this application, after generating the structured execution chain, the method further includes: The scheduling instructions and interface calls in the structured execution chain are executed sequentially, and a preset fallback mechanism is triggered in the event of an execution exception; the preset fallback mechanism includes at least timeout retry, service circuit breaking, and temporary storage of abnormal tasks; The running logs and status data are aggregated and fed back to the dynamic interface library to update the software running status, and then fed back to the business knowledge graph to iteratively optimize the nodes and the topology edges.

[0014] To solve the above-mentioned technical problems, another technical solution adopted in this application is: to provide a software orchestration and scheduling device for large models with zero illusion based on hierarchical constraints, the device comprising: The extraction module is used to receive input requests, extract intent from the input requests based on the large model, and output a structured intent containing functional domain labels and business parameters. The filtering module is used to match candidate functions in the static function library based on the functional domain labels, and to verify the interface running status of the candidate functions in the dynamic interface library to filter and obtain a set of compliant functions. The generation module is used to map the set of compliance functions to nodes of a pre-built business knowledge graph, and determine a unique business branch based on the routing rules associated with the business parameters and topology edges to generate a global function chain. The encapsulation module is used to encapsulate the global function chain and the structured intent by parameter mapping, generate a structured execution chain, and issue it for execution.

[0015] To solve the above-mentioned technical problems, another technical solution adopted in this application is: to provide a computer device, including a memory, a processor and a computer program stored in the memory, wherein the processor executes the computer program to implement the steps of the above-mentioned large model zero illusion software orchestration and scheduling method based on hierarchical constraints.

[0016] To solve the above-mentioned technical problems, another technical solution adopted in this application is to provide a storage medium on which a computer program is stored, which, when executed by a processor, implements the steps of the above-mentioned large model zero-illusion software orchestration and scheduling method based on hierarchical constraints.

[0017] The beneficial effects of this application are as follows: Unlike existing technologies, this application discloses a large-scale model zero-illusion software orchestration and scheduling method and apparatus based on hierarchical constraints. This method constructs a hierarchical constraint architecture for large-scale model intent extraction and subsequent programmatic rigid control, accurately converging open natural language intents into structured intents. It also utilizes the linkage verification of static function libraries and dynamic interface libraries to construct dual rigid boundaries for functionality and operational status, preventing functional illusions from the data layer. Simultaneously, it completely abandons the dynamic link deduction paradigm, employing a pre-built business knowledge graph for retrieval-based path selection. By comparing routing rules associated with topological edges with business parameters, it accurately locks the unique business branch, eliminating probabilistic path deviations and computational redundancy in generative orchestration. This achieves stable, reproducible, and highly deterministic orchestration results, meeting the low-latency, high-reliability zero-illusion software orchestration and scheduling requirements in industrial scenarios. Attached Figure Description

[0018] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort, wherein: Figure 1This is a flowchart illustrating an embodiment of the large-scale zero-illusion software orchestration and scheduling method based on hierarchical constraints provided in this application; Figure 2 This is a schematic diagram of an embodiment of the large model zero-illusion software orchestration and scheduling device based on hierarchical constraints provided in this application; Figure 3 This is a schematic diagram of the structure of an embodiment of the computer-readable storage medium provided in this application; Figure 4 This is a schematic diagram of the structure of an embodiment of the computer device provided in this application. Detailed Implementation

[0019] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of the embodiments. Based on the embodiments of this application, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of this application.

[0020] The terms "first," "second," and "third" used in the embodiments of this application are for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first," "second," or "third" may explicitly or implicitly include at least one of that feature. In the description of this application, "multiple" means at least two, such as two, three, etc., unless otherwise explicitly specified. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion. For example, a process, method, system, product, or device that includes a series of steps or units is not limited to the listed steps or units, but may optionally include steps or units not listed, or may optionally include other steps or units inherent to these processes, methods, products, or devices.

[0021] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of this application. The appearance of this phrase in various places throughout the specification does not necessarily refer to the same embodiment, nor is it a mutually exclusive, independent, or alternative embodiment. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0022] This application provides a method and apparatus for zero-illusion software orchestration and scheduling of large models based on hierarchical constraints. The core idea lies in constructing a hierarchical constraint architecture that combines flexible semantic parsing of large models with rigid program control. At the downstream program rigid control level, this architecture relies on a three-layered constraint system consisting of static constraints on functional domains, dynamic constraints on interface operation, and routing rule constraints on the business graph. This restricts the large model from autonomously generating fictitious functions outside the library and illegal links, thus achieving anti-illusion orchestration. Through this hierarchical constraint architecture, traditional generative link orchestration is reconstructed into pre-built knowledge graph retrieval-based path selection. While retaining the convenient interactive capabilities of natural language, it eliminates model illusions from the architectural root, reduces ineffective computational overhead, and achieves low-latency, high-determinism, high-stability, and reproducible automated software orchestration and scheduling in industrial scenarios.

[0023] Before detailing the embodiments of this application, the pre-initialization deployment process is first described. Before officially going live and receiving user requests, it is necessary to complete the data entry and field calibration of the static function library and dynamic interface library, and pre-build a complete business knowledge graph based on all business scenarios of the software. After going live, the callable functional modules, inter-module dependencies, legal business combination logic, and standardized execution links are all finite and fixed closed sets. Therefore, all topology nodes, branch routing conditions, and link constraint rules can be solidified in advance based on these inherent characteristics. A self-check is completed before going live to ensure that the mapping between the two libraries is consistent and that there are no conflicts in the graph topology. After going live, it is not necessary to repeatedly build paths or perform path deduction for each user request.

[0024] This application provides a large-scale model zero-illusion software orchestration and scheduling method based on hierarchical constraints. (See reference...) Figure 1 , Figure 1 This is a flowchart illustrating an embodiment of the large-scale zero-illusion software orchestration and scheduling method based on hierarchical constraints provided in this application. The method includes: S10: Receive input requests, extract intent from input requests based on the large model, and output a structured intent containing functional domain labels and business parameters.

[0025] The input request is an open-ended natural language orchestration instruction issued by the user. Due to the open, diverse, and boundless nature of natural language, this input request typically contains colloquial and invalid statements, redundant modifiers, and a mixture of core execution intentions, auxiliary intentions, and complex business logic relationships, such as sequential execution, parallel synchronization, and branching conditional triggering. Therefore, the input request first needs to undergo text normalization preprocessing. The preprocessing includes sentence filtering, semantic simplification, and removal of invalid modifiers. Colloquial and invalid statements are filtered out, retaining only imperative and purposeful declarative sentences. Redundant modifiers are removed, and only the core semantic skeleton of subject, verb, and object is retained, thus achieving text format uniformity.

[0026] In an optional embodiment, step S10 above further includes: S11: After preprocessing the input request, extract at least one core intent of the input request based on the large model and preset field templates.

[0027] After preprocessing the input request, based on the large model and preset field templates, standardized fields such as intent action, processing object, execution preconditions, and post-business requirements are uniformly extracted, thereby extracting at least one core intent.

[0028] Specifically, core intent extraction relies on pre-defined fixed field templates to forcibly transform non-standardized natural language into a standardized field structure. Here, the intent action represents the specific operation the user expects to perform, the processing object represents the target entity affected by the operation, the preconditions define the constraints that trigger the action, and the post-action business requirements limit the expected business result after the action is completed.

[0029] After extracting multiple core intents, due to the diversity of natural language, users may use different expressions to refer to the same business request. To prevent redundant intents from interfering with subsequent link splicing, the system uses semantic vector comparison technology to perform synonym semantic deduplication, thereby avoiding the problem of repeated matching of graph nodes and redundant link splicing caused by repeated intents.

[0030] After deduplication, the core intent set can be further hierarchically divided, such as into core execution intents, supporting intents, and invalid or irrelevant intents. Figure 3 There are several levels. Among them, the core execution intent is the necessary action that constitutes the main business process, the auxiliary and supporting intent is the synchronous or asynchronous auxiliary action that is attached to the main process, and the invalid and irrelevant intent is noise information that has no business implementation value.

[0031] A single independent intent level is insufficient to support the generation of a complete business chain; intents often involve strict temporal and logical constraints. Therefore, five basic logical relationships can be further identified and labeled: node pre-dependency, sequential timing, parallel synchronization, branch condition triggering, and node mutual exclusion. Specifically, node pre-dependency stipulates that the current intent can only be triggered after its dependent intents are completed; sequential timing constrains the execution order of intents; parallel synchronization indicates that multiple intents can be executed simultaneously; branch condition triggering defines the logic for selective execution based on specific business parameters; and node mutual exclusion excludes incompatible intent combinations within the same chain.

[0032] S12: Based on the preset three-level directory system, bind functional domain tags to each core intent; the three-level directory system includes business domains, action subclasses, and operation objects.

[0033] To achieve accurate convergence of open semantics to limited legal software functions, this optional embodiment pre-defines a three-level directory system based on business domain, action subclass, and operation object, binding a unique functional domain tag to each extracted core intent. Here, the business domain is the top-level business division, the action subclass is the specific operation type within that business domain, and the operation object is the specific entity to which the action is performed.

[0034] This three-level directory system completes coarse matching at the prompt word level, narrows the semantic matching range in the subsequent function description library, and achieves precise docking between intent and subsequent function library. This forces open and divergent natural language intents to converge into the limited function classification framework preset by the software system. Relying on this hierarchical constraint architecture, it restricts the arbitrary expansion of function boundaries of large models from the source and avoids the functional illusion caused by unfounded fictitious functions.

[0035] S13: Extract business parameters from the core intent to output a structured intent.

[0036] After binding the functional domain label, key business parameters such as business input parameters are extracted from the core intent, and a structured intent message containing fixed fields such as functional domain label, execution subject, execution action, processing object, preconditions, key business input parameters, and logical association number is uniformly output, so as to achieve a unified intent output format across all scenarios.

[0037] Unlike existing technologies where inconsistent intent parsing formats and the open, divergent nature of natural language intents make precise integration with backend functions difficult, this application provides a hierarchical constraint-based zero-illusion software orchestration and scheduling method for large models. This method extracts core intents through preset field templates and binds functional domain tags based on a three-level directory system containing business domains, action subclasses, and operation objects. Coarse matching is performed at the prompt word level, forcibly converging open, divergent natural language intents into a limited functional classification framework preset by the software system. This provides standardized, unambiguous input for downstream rigid program control, restricting the large model's autonomous semantic rewriting from the source and avoiding the resulting parameter fabrication illusions.

[0038] S20: Match candidate functions in the static function library based on function domain tags, and verify the interface running status of candidate functions in the dynamic interface library to obtain a set of compliant functions.

[0039] Specifically, this step involves defining functional boundaries using a static library and verifying interface availability using a dynamic library, achieving dual interception of invalid functions and malfunctioning interfaces, thus suppressing functional illusions at the data level. The static and dynamic libraries have independent physical storage structures and standardized fields, representing an improvement in the underlying data architecture rather than an abstract algorithm optimization.

[0040] In an optional embodiment, step S20 above further includes: S21: Based on the functional domain tags, search the static functional library using a three-level directory system level by level, discard structured intents that do not match the corresponding functions, and use the matched corresponding functions as candidate functions.

[0041] The static function library is an offline, fixed static storage system. Internally, it adopts the same three-level directory system as the intent extraction stage, namely, a three-level search directory containing business domains, action subclasses, and operation objects. The static function library has built-in standardized fields that include at least a unique function identifier (ID), function name, standardized function description, its three-level directory category (including business domain, action subclass, and operation object), standard input parameter template, standard output parameter template, pre-existing business constraints, serial / parallel identification, exception fallback strategy, and call access control.

[0042] Based on the functional domain tags in the structured intent, a step-by-step search is performed in the static functional library. First, the business domain is matched, then the action subclass, and finally the operation object. After this fine-grained matching, the static functional library provides a complete description of the matched function. Through this mechanism, the three-level directory tag binding in the intent extraction phase serves as a coarse match, quickly narrowing the search scope in the functional description library; the step-by-step search of the three-level directory in the static functional library serves as a fine-grained match, accurately locating the corresponding function and providing a complete description of the functional module, thus balancing matching efficiency with the accuracy of rigid constraints.

[0043] If no matching function is found in the static function library, it indicates that the user's intent exceeds the software's capabilities. In this case, the invalid structured intent is discarded, thereby intercepting excessive invalid intents and converging open semantics. If a matching function is successfully found in the static function library, it is used as a candidate function, thus defining the boundaries of all legitimate functions of the software and curbing the problem of functional illusion from the source.

[0044] S22: Based on the function identifier corresponding to the candidate function, query the online status and circuit breaker flag of the corresponding interface in the dynamic interface library that synchronizes the software running status in real time, eliminate the candidate functions that are offline or circuit breaker triggered, and filter to obtain a set of compliant functions.

[0045] The dynamic interface address library is an in-memory, dynamically updated storage system. It includes standardized fields such as function identifier, microservice identifier, communication protocol, real-time interface address, service online status, timeout threshold, retry count, circuit breaker flag, and load threshold. The dynamic interface library synchronizes with the backend microservice runtime status in real time.

[0046] Based on the function identifier corresponding to the candidate function, the online status and circuit breaker flag of the corresponding interface are queried in the dynamic interface library. If the corresponding interface is offline or has triggered a circuit breaker, it means that the function is currently unavailable. At this time, these invalid candidate functions are removed, thereby ensuring that the final set of compliant functions is truly usable.

[0047] Unlike existing technologies that lack rigid functional boundaries and rely entirely on large model knowledge bases for autonomous matching, which can easily lead to the fabrication of non-existent business interfaces and software functions and cause functional illusions, this application provides a hierarchical constraint-based large model zero-illusion software orchestration and scheduling method. This method uses a static function library to progressively retrieve and define legitimate functional boundaries, intercepting invalid intentions that exceed limits. It also uses a dynamic interface library to verify the interface's operational status in real time and eliminate faulty interfaces. By constructing rigid protection boundaries from both the functional scope and interface operational status dimensions, this method effectively curbs functional illusions, achieves precise convergence of unlimited user intentions to finite legitimate software functions, and ensures the true usability of the compliant function set.

[0048] S30: Map the set of compliance functions to nodes in the pre-built business knowledge graph, and determine a unique business branch based on the routing rules associated with business parameters and topology edges to generate a global function chain.

[0049] Specifically, this step relies on a pre-built business knowledge graph to complete path retrieval and splicing, solving two major technical problems: branch routing selection and link topology regularization, and effectively avoiding path illusion and link timing disorder.

[0050] In an optional embodiment, step S30 above further includes: S31: Based on the function identifiers corresponding to each compliance function in the compliance function set, retrieve the corresponding nodes in the business knowledge graph and obtain the node's attribute information and topological connection relationship.

[0051] The business knowledge graph adopts a two-layer independent and fixed architecture of graph nodes (referred to as nodes) and topology association edges (referred to as topology edges). By decoupling functional attributes from routing logic, the division of labor between nodes and topology edges is clear. Nodes are specifically responsible for storing the inherent static attribute information of functions and topology associations, while topology edges are specifically used to carry dynamic branch routing rules.

[0052] Based on the unique identifier of each compliance function in the compliance function set, when the corresponding graph node is retrieved in the business knowledge graph, rich attribute information of the node and the topological connection relationship between the node and other nodes are obtained simultaneously. This attribute information is not a simple list of identifiers, but the core basis for supporting subsequent link regularization and rigid constraints. Specifically, the list of pre-dependent nodes, post-related nodes, and serial / parallel attributes fixed in the node define the basic flow sequence and dependency logic between functions; the mutual exclusion blacklist and link weight built into the node provide direct judgment criteria for subsequent execution link deduplication, topological conflict resolution, and mutual exclusion node removal; in addition, fields such as input parameter structure, output parameter structure, and abnormal linkage strategy ensure the closed-loop controllability during function execution.

[0053] Meanwhile, the acquired topology connections are not merely simple node pointing information; they locate the topology edges associated with the downstream nodes of the current node. These topology edges, acting as bridges connecting different business nodes, are internally bound to dynamic branch routing rules consisting of business condition expressions, threshold determination rules, and other components. This lays the data foundation for subsequent comparison calculations based on actual business parameters and the selection of a unique execution branch.

[0054] S32: Locate the topology edge based on the topology connection relationship, and compare and calculate the service parameters with the routing rules associated with the topology edge.

[0055] Based on the topological connection relationship obtained in step S31, the topological edge downstream of the current graph node is located. It is important to note that the routing rules associated with the topological edge are the core mechanism for implementing multi-branch conditional routing. This routing rule is not a single-dimensional abstract concept, but rather a logical judgment system composed of multiple attribute fields fixed on the topological edge, specifically including business condition expressions, threshold judgment rules, branch mutual exclusion identifiers, and branch execution priorities.

[0056] Among them, the business condition expression and threshold judgment rule define the parameter thresholds and logical conditions that must be met to proceed to the branch, the branch mutual exclusion identifier constrains the exclusivity of multiple branches under the same judgment node, and the branch execution priority is used to determine the preferred path when multiple branch conditions are met at the same time.

[0057] During the comparison calculation, the business parameters are extracted from the structured intent output from the upstream, and the business parameters are substituted into the routing rules associated with the located topology edge for logical evaluation to determine whether the business parameters meet the triggering conditions for the topology edge to point to the corresponding branch.

[0058] Taking a travel expense reimbursement scenario as an example, two mutually exclusive topology edges are set downstream of the amount determination node. The routing rule associated with the first edge is that if the reimbursement amount is greater than 5,000 yuan, it connects to the director's approval branch; the routing rule associated with the second edge is that if the reimbursement amount is less than or equal to 5,000 yuan, it connects to the regular approval branch. At this time, the extracted reimbursement amount business parameter is compared and calculated with the routing rules associated with these two edges to determine which edge's routing condition the business parameter specifically meets, thus providing an accurate basis for subsequently locking in a unique business branch.

[0059] In an optional embodiment, after comparing and calculating the service parameters with the routing rules associated with the topology edges in step S32 above, the method further includes: If the business parameters do not meet the routing rules associated with any topology edge, the current business branch generation process is terminated and an exception message is output.

[0060] Specifically, if the routing rules associated with all topological edges cannot be satisfied after comparison and calculation with the current business parameters, it means that there is no legal execution branch matching the current business parameters. At this time, the link generation process is terminated directly and an exception information prompt is thrown to avoid the path illusion caused by generating illegal business paths out of thin air from the routing level.

[0061] S33: Based on the comparison calculation results and the preset branch mutual exclusion identifier of the topology edge, a unique business branch is hit.

[0062] After comparing and calculating the business parameters and routing rules, a final decision is made among multiple possible branches based on the calculation results to select the unique business branch.

[0063] Branch mutual exclusion is a mandatory topology constraint that stipulates the exclusivity of multiple topology edges emanating from the same parent node in a single business request; that is, only one edge can be successfully hit and activated. After obtaining the comparison calculation results, candidate topology edges whose business parameters satisfy the routing rules are first filtered out, and then the branch mutual exclusion identifiers on these candidate topology edges are read. If the candidate topology edges belong to the same mutual exclusion group, other conflicting branches are automatically eliminated based on the mutual exclusion constraint and branch execution priority, accurately locking in the unique compliant business branch.

[0064] Taking a travel expense reimbursement scenario as an example, if the reimbursement amount business parameter in the structured intent is 8,000 yuan, after comparison and calculation, this parameter satisfies the routing rule of the first edge (reimbursement amount greater than 5,000 yuan), but does not satisfy the routing rule of the second edge (reimbursement amount less than or equal to 5,000 yuan). Simultaneously, since these two branches have a mandatory mutual exclusion flag, based on the comparison calculation result and this mutual exclusion flag, the director's approval branch is automatically selected as the sole business branch.

[0065] Unlike existing technologies that rely solely on node pre- and post-dependencies for link splicing, which fails to address conditional branch selection and leads to prominent path illusion problems, this application provides a large-scale model zero-illusion software orchestration and scheduling method based on hierarchical constraints. By associating routing rules on topology edges and performing comparison calculations, combined with pre-defined branch mutual exclusion identifiers on topology edges, it can accurately hit a unique business branch based on actual business parameters. This effectively suppresses ambiguity and path illusion during path selection at the architectural level, ensuring that even in complex conditional branch networks, links with multiple outputs of the same input command remain stable and consistent, achieving stable and reproducible rigid scheduling in industrial scenarios.

[0066] In an optional embodiment, after the unique business branch is hit and before the global function chain is generated, step S30 above further includes: S34: Based on the unique business branch and topology connection relationship, connect each node to generate the initial business link.

[0067] After identifying a unique business branch, based on the specific direction of that unique business branch and the topological connection relationship between each graph node, the nodes mapped by the compliance function are initially physically spliced ​​together to generate an initial business link.

[0068] However, because users' natural language commands often contain both core execution intentions and auxiliary supporting intentions, multiple sub-chains can easily intersect when mapping multiple compliance functions to graph nodes and performing branch splicing. While this simple physical splicing locks in the main business path, it often harbors topological flaws such as node redundancy, topological intersections, and temporal disorder. Therefore, the initial business link is merely a rough link containing all business nodes, and subsequent standardized regularization operations must be performed based on the inherent constraints of the global graph to meet the stringent requirements of industrial-grade scheduling.

[0069] S35: Based on the function identifier, link weight, and mutual exclusion blacklist in the attribute information, remove duplicate nodes, conflicting nodes, and mutual exclusion nodes in the initial business link.

[0070] This step is the core filtering mechanism of the standardized link straightening operation, which aims to eliminate the structural defects caused by splicing multiple sub-chains from a logical level.

[0071] First, link deduplication is performed by comparing the unique identifiers of nodes in each sub-chain of the initial business link with the bound function identifiers. This accurately locates and eliminates redundant duplicate nodes during semantic matching and multi-branch convergence, thereby ensuring that a single function is strictly constrained to be executed only once in the entire link, preventing repeated calls to the same interface from causing business data anomalies.

[0072] Second, topology conflict resolution: when the main business link, conditional branch link, and parallel auxiliary link intersect, a comprehensive detection is performed to check for hidden conflicts such as timing overlap, dependency inversion, or resource preemption between the links. At this time, intelligent decisions are made based on the preset link weights in the node attribute information, retaining the high-weight legitimate main links and decisively eliminating the low-weight invalid sub-links that cause conflicts, ensuring the smooth flow of the main business process.

[0073] Third, mutual exclusion node removal involves traversing every node in the current complete link, performing logical compliance checks against other existing nodes in the link, and automatically removing nodes that are logically mutually exclusive with existing nodes by comparing them with the built-in mutual exclusion blacklist in the node attribute information. The mutual exclusion blacklist is used to store combinations of functional nodes that cannot coexist.

[0074] This mechanism enforces rigid compliance of business logic at the architectural level, effectively preventing logical accidents caused by mutually exclusive functions being orchestrated in the same link.

[0075] S36: Based on the serial-parallel rules in the attribute information, perform global time-series rearrangement of the initial business links after elimination to generate a global functional chain.

[0076] After the structural elimination of the first three steps, the nodes in the initial business chain are logically unique and compliant. However, the execution order of scattered child nodes, conditional branch links, and synchronous auxiliary nodes may still be disordered. This step reconstructs the timing of the entire chain from a global perspective based on the serial-parallel rules pre-stored in the node attribute information, clarifies the pre-dependencies and post-associations of each node, and unifies the execution timing of the entire chain.

[0077] After branch selection and four layers of rigorous regularization, a unique, non-redundant, conflict-free, and time-sequential standardized global functional chain is finally output. In this process, no large model is involved in path reasoning, no algorithm dynamically generates links, and there are no multiple loop checks. The retrieval-based orchestration is completed entirely based on the static inherent constraints of the pre-built knowledge graph, effectively eliminating probabilistic path errors caused by dynamic inference and achieving stable and reproducible zero-illusion scheduling in industrial scenarios.

[0078] Unlike existing technologies where link topology conflicts cannot be automatically resolved and multi-sub-link splicing easily leads to topological defects such as timing overlap, dependency inversion, and redundant node insertion, this application provides a large-model zero-illusion software orchestration and scheduling method based on hierarchical constraints. This method removes duplicate, conflicting, and mutually exclusive nodes from the initial business links based on functional identifiers, link weights, and mutual exclusion blacklists in attribute information. Furthermore, it performs global timing rearrangement based on serial-parallel rules, logically eliminating the structural defects caused by multi-sub-link splicing. This ensures rigid compliance of business logic and global consistency of execution timing, effectively avoiding logical accidents caused by mutually exclusive functions being orchestrated in the same link.

[0079] S40: Encapsulate the global function chain and structured intents through parameter mapping, generate a structured execution chain, and issue it for execution.

[0080] The global function chain is an abstract business topology link that does not contain specific interface addresses and business parameters, while the execution chain is a concrete instruction that can be directly scheduled by the engine; the two correspond one-to-one. This step follows multi-level template flow rules, batch-filling standardized function chains with runtime parameters to generate a directly schedulable structured execution chain.

[0081] In an optional embodiment, step S40 above further includes: S41: Based on preset multi-level template flow rules, the business parameters of the structured intent are mapped and validated against the global function chain to generate a structured execution chain. The mapping process is constrained by template rigidity; after compliance validation, only parameter filling and field inheritance are performed.

[0082] A multi-level template-based lossless mapping specification is enforced on the global function chain. In this optional embodiment, the multi-level templates are, in sequence, an intent structure template, a function description template, a graph node template, and an execution chain node template. Business parameters in the structured intent, such as custom business parameters like the person submitting the expense report, document number, expense amount, and approver, are mapped and validated against each node in the global function chain.

[0083] During the mapping process, the backfilled business parameters are first validated according to the predefined parameter constraint rules (such as parameter type, required field identifier, value range, etc.) of each level of template. If the validation fails, the abnormal parameter is intercepted and reported, and the corresponding execution chain node is refused to be generated to prevent invalid or erroneous parameters from flowing into the execution process. After the validation passes, the latest real-time interface address is obtained by associating the dynamic interface library with the function identifier, the user's original business parameters are backfilled, and the timeout retry and exception fallback strategies of each node are bound to complete the instruction encryption and encapsulation.

[0084] The final generated structured execution chain contains a unified set of fields for each node, including node number, bound function identifier, real-time interface address, business initialization input parameters, expected output parameters, prerequisite dependency number, timeout threshold, exception fallback strategy, and real-time execution status. This results in a standardized structured execution chain that can be directly scheduled, has a fixed timing sequence, and complete parameters.

[0085] Unlike existing technologies where generative links suffer from probabilistic biases, large-scale model autonomous semantic rewriting and random logical deduction can easily lead to uncontrollable orchestration results. This application provides a large-scale model zero-illusion software orchestration and scheduling method based on hierarchical constraints. The entire process relies on template rules for compliance verification, allowing only verified parameters to be filled into the template for parameter filling and field inheritance. The mapping process is constrained by the fixed template constraints, prohibiting large-scale model autonomous semantic rewriting, prohibiting random logical deduction of algorithms, and prohibiting repeated path generation. This ensures lossless information flow, standardization, stable reproducibility, and low-overhead operation throughout the entire process.

[0086] In an optional embodiment, after generating the structured execution chain, step S40 further includes: S42: Execute the scheduling instructions and interface calls in the structured execution chain sequentially, and trigger the preset fallback mechanism in case of execution exception. The preset fallback mechanism includes at least timeout retry, service circuit breaking, and temporary storage of abnormal tasks.

[0087] In this optional embodiment, the execution engine adopts a four-layer closed-loop scheduling architecture, namely, a command parsing layer, a timing scheduling layer, an interface call layer, and a runtime monitoring layer. The standardized execution process of a single node is instruction parsing, task timing scheduling, multi-protocol interface calls, and full-process runtime monitoring.

[0088] The execution engine sequentially executes the scheduling instructions and interface calls in the structured execution chain. During execution, if abnormal scenarios such as interface response timeouts or service unavailability occur, the execution engine's natively supported preset fallback mechanisms will be triggered. These preset fallback mechanisms include at least timeout retry, service circuit breaking, and abnormal task temporary storage capabilities. Specifically, the timeout retry mechanism allows calls to be re-initiated within a preset time threshold; the service circuit breaking mechanism cuts off the call chain when the interface remains abnormal, preventing cascading failures; and the abnormal task temporary storage mechanism persistently saves the state of currently unprogressable tasks, allowing them to resume execution after the fault is recovered, thereby ensuring high business availability.

[0089] S43: Summarize the operation logs and status data, feed them back to the dynamic interface library to update the software operation status, and feed them back to the business knowledge graph to iteratively optimize nodes and topology edges.

[0090] After a single orchestration task is completed, the runtime logs, interface latency, and exception data are aggregated and fed back to the dynamic interface library and business knowledge graph. The data fed back to the dynamic interface library is used to update the software's runtime status and to calibrate the online status and circuit breaker flags of interfaces in real time. The data fed back to the business knowledge graph is used to iteratively optimize the link weights of nodes and the routing rules of topology edges, such as adjusting the branch execution priority or threshold determination rules of mutual exclusion edges based on historical execution data.

[0091] Unlike existing technologies that lack standardized fallback strategies for abnormal scenarios and suffer from uncontrollable orchestration results, the large-scale zero-illusion software orchestration and scheduling method based on hierarchical constraints provided in this application effectively prevents cascading failures and ensures high service availability by pre-setting fallback mechanisms that include at least timeout retries, service circuit breaking, and temporary storage of abnormal tasks. Simultaneously, by fully feeding back runtime logs and status data to a dynamic interface library and business knowledge graph, real-time calibration of software runtime status and iterative optimization of node link weights and topology edge routing rules are achieved, forming a self-optimizing closed loop that improves the accuracy of subsequent orchestration and scheduling and the stability of long-term operation.

[0092] To more clearly illustrate the technical solution of this application, the following example of an office travel expense reimbursement case will be used to fully demonstrate the specific execution process of the above steps, without any independent logical deduction.

[0093] During the pre-initialization phase, the full range of office workflow functional modules and corresponding microservice interfaces are entered, a reimbursement business knowledge graph is pre-built, and the conditions for determining the amount branch, the parallel logic for sending copies, and the mutual exclusion rules for nodes are preset to complete the initialization self-check.

[0094] The user inputs a natural language command as an input request. The specific content is: "Reimburse this week's travel expenses, with a copy sent to the department head. If the reimbursement amount exceeds 5,000 yuan, it requires a second approval from the director. After approval, the finance department will file the documents."

[0095] In step S10, the input request is parsed using a structured intent analysis based on the large model. The core intent is extracted, and the copying is labeled as parallel logic, while the amount determination is labeled as conditional branching logic. The output is a standardized structured intent containing the reimbursement amount and approval level. Specifically, the structured intent template parsing yields standardized fields: the executing entity is the company employee; the core execution action is travel expense reimbursement; the processing object is this week's travel documents; the branching condition is approval by the executive director for amounts exceeding 5000 yuan; the auxiliary action is simultaneous copying to the department head; and the post-approval result is financial archiving after approval. Simultaneously, the office approval business domain label is bound, and key parameters for determining the reimbursement amount are entered.

[0096] In step S20, dual-database function matching is performed. Static function libraries are retrieved based on function domain tags to accurately match five categories of legitimate functions: expense reporting, document submission, departmental copying, hierarchical approval, and financial archiving. Preset input / output parameters, serial / parallel rules, and fallback strategies for each function are inherited, and invalid or redundant semantic information is removed. After matching all legitimate expense approval functions, all interfaces are verified to be online and available based on the dynamic interface library. Offline or circuit-breaker interfaces are removed to ensure no invalid functions or offline interfaces, and a set of compliant functions is output.

[0097] In step S30, a graph path retrieval is performed. Compliance functions are mapped one by one to fixed nodes in the graph, inheriting node pre- and post-dependencies, mutual exclusion rules, and branch decision weights. Based on the topology edge condition expression, corresponding approval branches are matched, and the built-in amount determination conditions of the topology edge are automatically matched. If the amount is greater than 5000 yuan, the director's secondary approval branch is selected, and a parallel copy node is attached. Subsequently, four-layer link normalization is automatically completed, namely link deduplication, conflict resolution, mutual exclusion node removal, and timing normalization, repairing link redundancy, timing conflicts, and residual mutual exclusion nodes. Finally, a complete and compliant global reimbursement approval function chain is output, namely a fixed reimbursement business chain formed by the interconnection of expense entry nodes, document submission nodes, parallel copy nodes, amount determination nodes, director's secondary approval nodes, and financial archiving nodes.

[0098] In step S40, a structured execution chain is encapsulated. Based on preset multi-level template flow rules, the business parameters of the structured intent are mapped to the global function chain. The mapping process is constrained by template solidification constraints, and only parameter filling and field inheritance are performed. In the intent structured template, key judgment parameters for reimbursement amount are entered; in the function description template, various preset input and output parameters of functions are inherited; in the graph node template, the dependencies of the complete topology link are solidified; in the execution chain node template, the real-time interface address is obtained by associating with the dynamic interface library, and custom business parameters such as reimbursement personnel, document number, reimbursement amount, and approver are filled in. Timeout retry and exception fallback strategies are bound to each node, and finally, a standardized structured execution chain that can be directly scheduled, has a fixed timing, and complete parameters is generated.

[0099] Finally, the execution engine completes the entire process of automatic approval according to the structured execution chain, and triggers fallback strategies such as task temporary storage and approval reminders in abnormal scenarios; the runtime log backflow optimizes the graph branch judgment threshold, completes the autonomous iterative optimization of parameters, and forms a self-optimizing closed loop.

[0100] Furthermore, the large-model zero-illusion software orchestration and scheduling method based on hierarchical constraints provided in the above embodiments of this application has a significant quantitative improvement effect compared with the link scheme that simply relies on algorithms for real-time inference. A comparative test was conducted using 200 differentiated office natural language commands and the link scheme that relies on algorithms for real-time inference. The method's function matching accuracy approached full marks, and its consistency in repeated link execution was excellent, effectively avoiding problems such as fictitious interfaces and link timing errors. In comparison, the method reduced computing power consumption by 37.2%, shortened the average orchestration response latency by 29.6%, and achieved an abnormal process fault tolerance rate of 96.8%, fully verifying the low latency and high reliability advantages of this method in industrial high-frequency real-time scheduling scenarios.

[0101] This application provides a large-scale model zero-illusion software orchestration and scheduling device based on hierarchical constraints, see reference. Figure 2 , Figure 2 This is a schematic diagram of an embodiment of the large model zero-illusion software orchestration and scheduling device based on hierarchical constraints provided in this application. The large model zero-illusion software orchestration and scheduling device based on hierarchical constraints includes: Extraction module 10 is used to receive input requests, extract intent from the input requests based on the large model, and output a structured intent containing functional domain labels and business parameters; The filtering module 20 is used to match candidate functions in the static function library based on the functional domain labels, and to verify the interface running status of the candidate functions in the dynamic interface library to filter and obtain a set of compliant functions. The generation module 30 is used to map the set of compliance functions to nodes of a pre-built business knowledge graph, and determine a unique business branch based on the routing rules associated with the business parameters and topology edges to generate a global function chain. The encapsulation module 40 is used to encapsulate the global function chain and the structured intent by parameter mapping, generate a structured execution chain, and send it down for execution.

[0102] In an optional embodiment, the generation module 30 is specifically used for: Based on the function identifiers corresponding to each compliance function in the compliance function set, the corresponding nodes are retrieved in the business knowledge graph, and the attribute information and topological connection relationships of the nodes are obtained. The topological edge is located based on the topological connection relationship, and the service parameters are compared and calculated with the routing rules associated with the topological edge; Based on the comparison calculation results and the preset branch mutual exclusion identifier of the topology edge, the unique business branch is hit.

[0103] In an optional embodiment, the generation module 30 is further configured to: If the service parameters do not meet the routing rules associated with any of the topology edges, the current service branch generation process is terminated and an error message is output.

[0104] In an optional embodiment, the generation module 30 is further configured to: Based on the unique business branch and the topological connection relationship, the nodes are connected in series to generate an initial business link; Based on the functional identifier, link weight, and mutual exclusion blacklist in the attribute information, duplicate nodes, conflicting nodes, and mutual exclusion nodes in the initial business link are removed. Based on the serial-parallel rules in the attribute information, the initial business links after being removed are globally time-series rearranged to generate the global functional chain.

[0105] In an optional embodiment, the extraction module 10 is specifically used for: After preprocessing the input request, at least one core intent of the input request is extracted based on the large model and preset field templates; Based on a pre-defined three-level directory system, functional domain tags are bound to each of the core intents; the three-level directory system includes business domains, action subclasses, and operation objects; The business parameters are extracted from the core intent to output the structured intent.

[0106] In an optional embodiment, the filtering module 20 is specifically used for: Based on the functional domain tags, the static functional library using the three-level directory system is searched level by level, discarding the structured intents that do not match the corresponding functions, and using the matched corresponding functions as the candidate functions; Based on the function identifiers corresponding to the candidate functions, the online status and circuit breaker flags of the corresponding interfaces are queried in the dynamic interface library that synchronizes the software running status in real time. Candidate functions with offline or circuit breaker-broken interfaces are eliminated to obtain the set of compliant functions.

[0107] In an optional embodiment, the encapsulation module 40 is specifically used for: Based on preset multi-level template flow rules, the business parameters of the structured intent are mapped and verified with the global function chain to generate the structured execution chain. The mapping process is constrained by template fixation, and only parameter filling and field inheritance are performed after compliance verification is passed.

[0108] In an optional embodiment, the system further includes an execution engine module, which is specifically used for: The scheduling instructions and interface calls in the structured execution chain are executed sequentially, and a preset fallback mechanism is triggered in the event of an execution exception; the preset fallback mechanism includes at least timeout retry, service circuit breaking, and temporary storage of abnormal tasks; The running logs and status data are aggregated and fed back to the dynamic interface library to update the software running status, and then fed back to the business knowledge graph to iteratively optimize the nodes and the topology edges.

[0109] Since the embodiments of the device part correspond to the embodiments of the above method, the description of the large model zero illusion software orchestration and scheduling device based on hierarchical constraints provided in this application is referred to the above method embodiments. This application will not repeat it here, as it has the same beneficial effects as the above large model zero illusion software orchestration and scheduling method based on hierarchical constraints.

[0110] See Figure 3 , Figure 3 This is a schematic diagram of an embodiment of the computer-readable storage medium provided in this application.

[0111] The storage medium 300 stores program data 310, which, when executed by the processor, implements, as follows: Figure 1 The steps of the large model zero-illusion software orchestration and scheduling method based on hierarchical constraints are described.

[0112] The program data 310 is stored in a storage medium 300 and includes several instructions for causing a network device (which may be a router, personal computer, server or other network device) or processor to execute all or part of the steps of the methods described in the various embodiments of this application.

[0113] Optionally, the storage medium 300 can be any medium capable of storing program data, such as a USB flash drive, portable hard drive, read-only memory (ROM), random access memory (RAM), disk, or optical disc.

[0114] See Figure 4 , Figure 4 This is a schematic diagram of the structure of an embodiment of the computer device provided in this application.

[0115] The device 400 includes a processor 420 and a memory 410 interconnected. The memory 410 stores a computer program, and when the processor 420 executes the computer program, it implements, for example, Figure 1 The steps of the large model zero-illusion software orchestration and scheduling method based on hierarchical constraints are described.

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

[0117] This application can be used in a wide range of general-purpose or special-purpose computing system environments or configurations. For example: personal computers, handheld or portable devices, tablet devices, multiprocessor systems, microprocessor-based systems, network PCs, minicomputers, distributed computing environments including any of the above systems or devices, etc.

[0118] In the several embodiments provided in this application, it should be understood that the disclosed methods and devices can be implemented in other ways. For example, the device embodiments described above are merely illustrative; multiple units or components may be combined or integrated into another system, or some features may be omitted or not performed.

[0119] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment, depending on actual needs.

[0120] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0121] The above description is merely an embodiment of this application and does not limit the patent scope of this application. Any equivalent structural or procedural transformations made using the content of this application's specification and drawings, or direct or indirect applications in other related technical fields, are similarly included within the patent protection scope of this application.

Claims

1. A zero-illusion software orchestration and scheduling method for large models based on hierarchical constraints, characterized in that, include: Receive input requests, extract intent from the input requests based on the large model, and output a structured intent containing functional domain labels and business parameters; Based on the functional domain labels, candidate functions are matched in the static function library, and the interface running status of the candidate functions is verified in the dynamic interface library to obtain a set of compliant functions. The set of compliance functions is mapped to nodes of a pre-built business knowledge graph, and a unique business branch is determined based on the routing rules associated with the business parameters and topology edges to generate a global function chain. The global function chain and the structured intent are encapsulated by parameter mapping to generate a structured execution chain and then executed.

2. The large-scale model zero-illusion software orchestration and scheduling method based on hierarchical constraints according to claim 1, characterized in that, The step of mapping the compliance function set to nodes in a pre-built business knowledge graph and determining a unique business branch based on the routing rules associated with the business parameters and topology edges includes: Based on the function identifiers corresponding to each compliance function in the compliance function set, the corresponding nodes are retrieved in the business knowledge graph, and the attribute information and topological connection relationships of the nodes are obtained. The topological edge is located based on the topological connection relationship, and the service parameters are compared and calculated with the routing rules associated with the topological edge; Based on the comparison calculation results and the preset branch mutual exclusion identifier of the topology edge, the unique business branch is hit.

3. The large-scale model zero-illusion software orchestration and scheduling method based on hierarchical constraints according to claim 2, characterized in that, After comparing and calculating the service parameters with the routing rules associated with the topology edges, the method further includes: If the service parameters do not meet the routing rules associated with any of the topology edges, the current service branch generation process is terminated and an error message is output.

4. The large-scale model zero-illusion software orchestration and scheduling method based on hierarchical constraints according to claim 2, characterized in that, Before generating the global function chain, the following is also included: Based on the unique business branch and the topological connection relationship, the nodes are connected in series to generate an initial business link; Based on the functional identifier, link weight, and mutual exclusion blacklist in the attribute information, duplicate nodes, conflicting nodes, and mutual exclusion nodes in the initial business link are removed. Based on the serial-parallel rules in the attribute information, the initial business links after being removed are globally time-series rearranged to generate the global functional chain.

5. The large-scale zero-illusion software orchestration and scheduling method based on hierarchical constraints according to claim 1, characterized in that, The intent extraction based on the large model of the input request outputs a structured intent containing functional domain labels and business parameters, including: After preprocessing the input request, at least one core intent of the input request is extracted based on the large model and preset field templates; Based on a pre-defined three-level directory system, functional domain tags are bound to each of the core intents; the three-level directory system includes business domains, action subclasses, and operation objects; The business parameters are extracted from the core intent to output the structured intent.

6. The large-scale model zero-illusion software orchestration and scheduling method based on hierarchical constraints according to claim 5, characterized in that, The process involves matching candidate functions in a static function library based on the functional domain tags, verifying the interface operation status of the candidate functions in a dynamic interface library, and filtering to obtain a set of compliant functions, including: Based on the functional domain tags, the static functional library using the three-level directory system is searched level by level, discarding the structured intents that do not match the corresponding functions, and using the matched corresponding functions as the candidate functions; Based on the function identifiers corresponding to the candidate functions, the online status and circuit breaker flags of the corresponding interfaces are queried in the dynamic interface library that synchronizes the software running status in real time. Candidate functions with offline or circuit breaker-broken interfaces are eliminated to obtain the set of compliant functions.

7. The large-scale model zero-illusion software orchestration and scheduling method based on hierarchical constraints according to claim 1, characterized in that, The step of encapsulating the global function chain with the structured intent through parameter mapping to generate a structured execution chain includes: Based on preset multi-level template flow rules, the business parameters of the structured intent are mapped and verified with the global function chain to generate the structured execution chain. The mapping process is constrained by template fixation, and only parameter filling and field inheritance are performed after compliance verification is passed.

8. The large-scale model zero-illusion software orchestration and scheduling method based on hierarchical constraints according to claim 1, characterized in that, After generating the structured execution chain, the process also includes: The scheduling instructions and interface calls in the structured execution chain are executed sequentially, and a preset fallback mechanism is triggered in the event of an execution exception; the preset fallback mechanism includes at least timeout retry, service circuit breaking, and temporary storage of abnormal tasks; The running logs and status data are aggregated and fed back to the dynamic interface library to update the software running status, and then fed back to the business knowledge graph to iteratively optimize the nodes and the topology edges.

9. A software orchestration and scheduling device for large models with zero illusion based on hierarchical constraints, characterized in that, include: The extraction module is used to receive input requests, extract intent from the input requests based on the large model, and output a structured intent containing functional domain labels and business parameters. The filtering module is used to match candidate functions in the static function library based on the functional domain labels, and to verify the interface running status of the candidate functions in the dynamic interface library to filter and obtain a set of compliant functions. The generation module is used to map the set of compliance functions to nodes of a pre-built business knowledge graph, and determine a unique business branch based on the routing rules associated with the business parameters and topology edges to generate a global function chain. The encapsulation module is used to encapsulate the global function chain and the structured intent by parameter mapping, generate a structured execution chain, and issue it for execution.

10. A computer device, comprising a memory, a processor, and a computer program stored in the memory, characterized in that, The processor executes the computer program to implement the steps of the large model zero-illusion software orchestration and scheduling method based on hierarchical constraints as described in any one of claims 1-8.

11. A storage medium having a computer program stored thereon, characterized in that, When executed by a processor, the computer program implements the steps of the large model zero-illusion software orchestration and scheduling method based on hierarchical constraints as described in any one of claims 1-8.

Images