Zero-code visualized and automatic routing method for service orchestration of large models

Abstract

The present application relates to the technical field of routing context connection, in particular, the present application relates to the zero code visualizing and automatic routing method of large model service arrangement, the present application extracts core entity and intention dependency by analyzing user session text, constructs entity intention graph and compresses state snapshot, and assigns global session ID, binds snapshot to distributed routing decision tree node and stores, establishes cross-node state continuity, when receiving new request, fusion snapshot and new session semantics, calculate routing weight offset correction decision table, through the rule and strategy of drag interface configuration, generate routing decision logic flow, this method solves the problem of session state loss and intention drift, improves service matching degree, reduces development threshold, and is suitable for agile construction of large model collaborative application.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of routing context connection, in particular to a zero-code visualization and automatic routing method for large model service orchestration. BACKGROUND

[0002] Routing context connection is an important technology. In the context of the rapid popularization of large models, multi-model collaborative response to complex requirements is achieved through service orchestration, which is of great significance to reducing development barriers, improving service deployment efficiency, and enhancing the applicability of large models. This technology breaks through the dependence on professional skills in traditional code development, providing an intuitive and efficient solution for enterprises to quickly build large model applications. Traditional model integration methods that rely on manual coding have been unable to meet the agile development needs of diverse scenarios.

[0003] However, the existing large model service orchestration technology has the core problems of poor session state continuity and routing decision bias. The traditional solution does not structurally store and dynamically track the entity intent of user sessions. When the session interacts across nodes, state loss can easily cause context disruption, making it difficult to accurately understand the user's coherent requirements. At the same time, there is a lack of dynamic routing weight adjustment mechanism based on real-time session semantics. Fixed routing strategies are difficult to adapt to changes in user intent, leading to a decline in the matching degree of service response and actual demand. These problems make the large model service less adaptable in complex conversation scenarios, affecting user experience and restricting the large-scale application of large model services. It is difficult to meet the needs of enterprises for efficient and accurate model orchestration. In order to solve this technical problem, we provide a zero-code visualization and automatic routing method for large model service orchestration. SUMMARY

[0004] The purpose of the present application is to provide a zero-code visualization and automatic routing method for large model service orchestration to solve the problems raised in the background.

[0005] 1. Since the traditional solution does not structurally store session entity intent, state loss across node interactions can easily cause context disruption. Therefore, this case constructs an entity intent graph and generates a state snapshot, binds the session ID to a distributed storage pool, and can establish cross-node state continuity to accurately understand coherent requirements.

[0006] 2. Since the traditional solution lacks a real-time semantic routing adjustment mechanism, fixed strategies are difficult to adapt to intent drift, leading to response bias. Therefore, this case fuses state snapshots and new request semantics to calculate routing weight offset to correct the decision table, which can eliminate intent drift and improve service matching.

[0007] To achieve the above object, one of the objects of the present application is to provide a zero-code visualizing and automatic routing method for large model service arrangement, comprising the following steps:

[0008] S1, analyzing the text content of the current session of the user, extracting core entities and intention dependency relationships between entities, and constructing an entity intention graph according to the core entities and the intention dependency relationships between entities, binary compressing the entity intention graph, generating a state snapshot, and solving state loss;

[0009] S2, assigning a globally unique session ID to the current session, binding the state snapshot to the corresponding node of the distributed routing decision tree through the session ID, storing the bound state snapshot to the distributed session storage pool, and establishing cross-node state continuity;

[0010] S3, when receiving a new user session request carrying the same session ID, loading the corresponding state snapshot from the distributed session storage pool, performing fusion analysis on the loaded state snapshot and the semantic content of the new user session request, obtaining the fused context state, calculating the routing weight offset based on the fused context state, correcting the routing decision table according to the routing weight offset, and eliminating intention drift bias;

[0011] S4, configuring entity extraction rules and state snapshot generation strategies through a drag-and-drop interface, generating a routing decision logic flow that fuses the context state, and realizing zero-code development.

[0012] Compared with the prior art, the present application has the following advantages:

[0013] 1. By extracting core entities and intention dependency relationships to construct a graph, combining binary compression to generate a state snapshot containing a topology structure, both the key information of the session can be accurately preserved and the storage volume can be greatly reduced. Then, by binding a globally unique session ID to a distributed routing decision tree node, cooperating with a write-once-copy mechanism to realize multi-node redundant storage, the state loss during cross-node interaction is ensured, the context break problem in traditional solutions is completely solved, the system can always understand the user's coherent demand in complex session process, and the interaction fluency is improved.

[0014] 2. When receiving a new session request, the historical state snapshot is loaded and fused with the semantic of the new request to generate a complete context state, based on which the routing weight offset is calculated to dynamically correct the decision table, so that the routing strategy can adapt to the user's intention drift in real time, avoid the response deviation caused by fixed routing, and significantly improve the matching degree of service response and actual demand. BRIEF DESCRIPTION OF DRAWINGS

[0015] Figure 1 The overall workflow diagram of the present application. DETAILED DESCRIPTION

[0016] The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments are only part of the embodiments of the present application, rather than all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative labor fall within the protection scope of the present application.

[0017] Please refer to Figure 1 As shown in the drawings, the present embodiment provides a zero-code visualized and automatic routing method for large model service arrangement, which includes the following steps:

[0018] S1, analyzing the text content of the current session of the user, extracting core entities and intention dependency relationships between entities, and constructing an entity intention graph according to the core entities and the intention dependency relationships between entities, binary compressing the entity intention graph, generating a state snapshot, and solving state loss;

[0019] Analyzing the text content of the current session of the user, extracting core entities and intention dependency relationships between entities, specifically including:

[0020] In the process of large model service orchestration, parsing the user's current session text to extract core entities and intent dependency is the basis for building subsequent routing decisions. This step provides the basis for accurately understanding user needs by structuring the session content. The pre-trained large model's named entity recognition module extracts domain key entities. Specifically, the user session text is segmented by sentence, and then input into the named entity recognition module loaded with domain-specific dictionaries (such as "goods" and "order" in the e-commerce domain, and "account" and "transaction" in the financial domain). The module identifies domain-specific noun phrases (such as "smartphone" and "transfer amount") through pre-trained model fine-tuning parameters, and labels entity types (such as "goods" and "amount"). At the same time, it filters out meaningless virtual words or general words (such as "of" and "then"), ensuring that the extracted entities are all core elements strongly related to the current session topic. Based on the co-occurrence frequency and semantic similarity between entities, a dynamic dependency network is constructed. The co-occurrence frequency refers to the number of times two entities appear simultaneously within a certain context window (such as within 3 consecutive sentences), and the higher the frequency, the closer the entity association. Semantic similarity is obtained by calculating the cosine distance of entity word vectors in the pre-trained language model space. The smaller the distance, the stronger the semantic association between entities. Both co-occurrence frequency and semantic similarity serve as quantitative evidence of entity dependency. Co-occurrence frequency reflects the co-occurrence pattern of entities in the session, while semantic similarity verifies the rationality of the association from a semantic perspective. In the construction process, the extracted entities are used as nodes, and the initial weights of the connections between nodes are determined based on the weighted values of co-occurrence frequency and semantic similarity. This forms a preliminary dependency network. Subsequently, the weights are dynamically adjusted in real-time session flow (e.g., if a certain entity pair co-occurs again in a new session, the weight increases by 5%). This allows the network to reflect the changes in entity association in real-time. To further optimize the network structure, strong correlation entity pairs are selected using the context window. Specifically, the current session sentence is taken as the center, and a context window containing the previous 2 sentences and the next 2 sentences is set. The co-occurrence frequency and average semantic similarity of entity pairs within the window are calculated. Entity pairs with a co-occurrence frequency of ≥2 times and a semantic similarity of ≥0.7 (full score 1) are determined as strong correlation entity pairs (e.g., "goods" and "price" frequently co-occur and have a strong semantic association in shopping sessions). Isolated noise entities refer to entities that have a co-occurrence frequency of 0 or a semantic similarity of <0.3 with other entities within the context window (e.g., "weather" mentioned incidentally in an e-commerce consultation scenario has no association with other entities).In the screening, the strong correlation entity pairs and their connection weights are retained, and the isolated noise entities are removed. Finally, a weighted marked entity-intention association set is output, wherein the weight is calculated by the frequency of the entity appearing in the session (the more the number of appearances, the higher the weight) and the position (the entity weight is increased by 20% in the sentence head or core position). For example, the weight of "commodity A" appearing 5 times in the session and 3 times in the sentence head is higher than that of "coupon" appearing only 2 times, which provides high-quality input data for subsequent construction of entity intention graph, makes the whole session analysis process not only fit the field characteristics, but also dynamically adapt to the changes of the session content, and lays a solid foundation for realizing accurate service routing.

[0021] According to the core entity and the intention dependency relationship between the entities, an entity intention graph is constructed, comprising:

[0022] After the extraction of core entities and inter-entity intent dependency relationships, the next step is to convert these associations into a structured entity intent graph. This process is both a visualization of the previous analysis results and a basis for generating state snapshots. Specifically, first, the set of entity-intent associations with weighted labels is mapped to a directed graph structure: each entity is an independent node in the graph, with node attributes including entity type and frequency of occurrence. The intent dependency relationships between entities are converted into weighted directed edges, with the direction determined by the dependency relationship (e.g., "product" pointing to "price" indicates that the user's intent depends on the "price" information). The initial weight of the edge is temporarily replaced by the weight value in the entity-intent association set. To make the graph more suitable for actual routing needs, the weights of the directed edges need to be initialized based on historical routing decision paths. The system retrieves historical conversation data consistent with the current conversation domain within the past 30 days, extracts all entity pairs' routing decision paths, and counts the number of times each entity pair appears together in successful routing cases. If an entity pair (e.g., "order" and "logistics") is frequently used for routing judgment and has a success rate of over 80% in historical decisions, it is assigned a higher initial weight (e.g., 0.8) to the corresponding directed edge. Conversely, if the entity pair has less association or a success rate of less than 30% in historical routing, the initial weight is reduced (e.g., 0.3). To avoid the timeliness bias of historical data, the historical paths in the past 7 days are given a weight coefficient of 1.2, ensuring that the initialization result considers both overall rules and recent trends, and that the weights of the directed edges truly reflect the influence of entity dependency on routing decisions. Based on this, the weights of the directed edges are dynamically adjusted in real-time conversation flow, and weakly connected subgraphs are pruned and merged. When new conversation content is input, the system monitors the interaction frequency of entity pairs in the current conversation in real-time: if an entity pair is mentioned repeatedly in consecutive 3 rounds of dialogue (e.g., the user repeatedly asks about "the inventory and delivery of product A"), the weight of the corresponding directed edge is increased by 10%; if the entity pair does not appear again within 5 rounds of dialogue, the weight is reduced by 5%. In the adjusted graph, if there is a weakly connected subgraph, i.e., the average weight of all directed edges in the subgraph is less than 0.2, and the connection edge weight between the subgraph and the main graph is less than 0.1, it is determined as a redundant structure. For example, "product review" and "after-sales service" are mentioned only once in a shopping conversation and do not affect routing decisions, forming a weakly connected subgraph with the main graph. At this time, the subgraph is pruned. If two weakly connected subgraphs have highly related entity types (e.g., "coupon" subgraph and "discount" subgraph), they are merged into one subgraph and the edge weights are recalculated to reduce graph redundancy. This graph not only retains the core structure of user intent but also adapts to real-time conversations through dynamic weight adjustment, providing accurate structured data for subsequent compression of state snapshots, enabling the state snapshots to truly reflect the intent evolution rules of the conversation, and laying the foundation for the establishment of cross-node state continuity.

[0023] The entity intention graph is binary compressed to generate a state snapshot, including:

[0024] After the construction of the entity intention graph is completed, in order to facilitate storage and cross-node transmission, it needs to be binary compressed to generate a state snapshot. This process realizes efficient processing of graph data through a hierarchical compression strategy, while ensuring that key information is not lost. First, Huffman coding is performed on the label data of the graph nodes:

[0025] First, the frequency of all node labels is counted. High-frequency labels (such as "goods" and "order" frequently appearing in the session) are assigned shorter binary codes, and low-frequency labels are assigned longer codes. For example, "goods" appears 50 times and corresponds to the code "01", and "coupon" appears 5 times and corresponds to the code "1011". Convert all node labels to binary stream according to this coding rule to form a compressed label data block. This step can significantly reduce the number of bytes required for label storage while preserving the unique identification information of the nodes. The matrix of directed edge weights is subjected to differential pulse code modulation. Specifically, the weight matrix is first converted into a one-dimensional sequence according to the row order (for example, the weight value of the first row and the third column in the matrix is immediately followed by the second column in the first row), and then the difference between adjacent weight values in the sequence is calculated (for example, the difference between the current value 0.8 and the previous value 0.6 is 0.2). The difference value replaces the original weight value to form a difference sequence. Then, pulse coding is performed on the difference sequence to map the numerical range to the corresponding pulse signal length (for example, a difference value of 0.2 corresponds to 2 pulse units, encoded as "110"). In this way, continuous weight values are converted into discrete pulse codes, further compressing the data volume. It is worth noting that during the compression process, key topological structure identifiers such as the position index of edges (weight ≥ 0.5 directed edges) marking the core dependency relationship between entities and the connected component boundary information of the graph are preserved. These identifiers ensure that the connection relationship and intention dependency path of the entity nodes can be accurately restored during decompression, avoiding distortion of the topological structure. Finally, the compressed label data block, weight matrix encoding block, and topological structure identifier are integrated into a binary block, with a compression version number (used to distinguish different compression algorithm versions) and a CRC32 checksum (used to verify data integrity) attached to form a complete state snapshot. This provides a compact and reliable data carrier for subsequent binding of the state snapshot to the distributed routing decision tree nodes and establishment of cross-node state continuity, making the storage and transmission of state information more suitable for the resource needs of distributed systems.

[0026] S2, assign a globally unique session ID to the current session, bind the state snapshot to the corresponding node of the distributed routing decision tree through the session ID, store the bound state snapshot to the distributed session storage pool, and establish cross-node state continuity;

[0027] A globally unique session ID is assigned to the current session, including:

[0028] After generating the state snapshot of the entity intent graph, in order to realize the tracking of the session state across nodes, a globally unique session ID needs to be allocated for the current session, which will serve as the core identifier for the subsequent state binding and storage. Specifically, when generating the composite identifier, first, the user identity information is hashed by the SHA-256 algorithm to obtain a 256-bit user identity hash value, then the geographic coordinates of the service node of the current processing session are obtained and converted into 32-bit binary encoding, at the same time, the millisecond number of the current timestamp is intercepted and converted into a 10-bit binary number, these three parts of data are spliced in the order of "user identity hash value + service node geographic coordinate encoding + timestamp millisecond number encoding" to form a long string, then MD5 operation is performed on the string to generate a 128-bit fixed-length composite identifier, i.e. the session ID, after generating the session ID, it is injected into the root node metadata of the routing decision tree: the system locates the root node of the distributed routing decision tree, writes the session ID in the metadata field of the root node, and associates the creation time and expiration time parameters of the root node, so that the root node becomes the anchor point of the session state life cycle, when the session starts, the root node is associated with the state snapshot through the session ID; when the session continues, the state update of all child nodes is based on the session ID of the root node, when the session terminates (such as timeout inactivity), the session ID in the root node metadata will trigger the expiration cleaning mechanism, ensuring that the whole life cycle of the session state is controllable, so that the binding and storage of the subsequent state snapshot can be accurately associated to a specific session, laying the foundation for establishing the continuity of the state across nodes.

[0029] Binding the state snapshot to the corresponding node of the distributed routing decision tree through the session ID, including:

[0030] After the global unique session ID is allocated for the current session, the next step is to bind the state snapshot to the corresponding node of the distributed routing decision tree through the session ID, so as to realize the accurate association of the state and the routing decision. Specifically, when locating the partition node of the decision tree according to the session ID hash value, first, the CRC32 hash operation is performed on the session ID to obtain a hash value, and then the hash value is taken modulo the number of partitions of the distributed routing decision tree, and the result obtained is the index of the target partition node. For example, if the number of partitions is 16 and the hash value is 5 after modulo operation, the 5th partition node is located. When creating the snapshot index slot in the memory of the partition node, the system allocates a fixed-size cache area in the memory of the node, establishes an index table in the order of the hash value of the session ID, each index slot corresponds to an entry of the session ID, and when storing the physical address pointer of the state snapshot, the physical storage address of the state snapshot in the distributed storage pool is converted into a 32-bit pointer variable and written into the corresponding index slot, so that the partition node can directly access the state snapshot data through the pointer. On this basis, a real-time synchronization mechanism of the snapshot version number and the state of the decision tree node is established. The system allocates an incremental version number (such as the initial version V1.0, which is incremented by 0.1 each time it is updated) for each state snapshot, and deploys a version monitoring process in the partition node. The process compares the snapshot version number and the version number currently recorded in the decision tree node every 100 milliseconds. If the snapshot version number is found to be higher, it means that the state has been updated, and the state synchronization of the decision tree node is triggered immediately. First, the read and write operations of the node are locked, the entity intent graph in the latest state snapshot is loaded, the weight values of each routing path in the node are recalculated, and then the node is unlocked and the state update event is broadcasted, so that the child nodes of the partition node synchronize and adjust the routing logic, ensuring that the state of the decision tree node is always consistent with the latest snapshot version, avoiding routing decision deviation caused by state lag, and providing a reliable node-level association basis for storing the state snapshot to the distributed session storage pool and establishing cross-node state continuity.

[0031] The bound state snapshot is stored in the distributed session storage pool to establish cross-node state continuity, including:

[0032] After the state snapshot is bound to the distributed routing decision tree node, in order to ensure the stable continuation of the cross-node state, the bound state snapshot needs to be stored to the distributed session storage pool, and the state continuity is realized through multi-node redundancy and real-time synchronization mechanism. Specifically, when the snapshot is persisted to at least three geographically dispersed storage nodes by using the copy-on-write mechanism, the system first locks the memory copy of the current state snapshot, creates a writable copy, and then distributes the copy to storage nodes in different geographical locations through asynchronous transmission, such as one node in East China, one in North China, and one in South China. After each node receives the copy, it verifies the data integrity by comparing the snapshot check code, and writes it to the local disk after confirming that it is correct. Only when at least three nodes have completed writing and returned a successful response, the persistence operation is determined to be completed. This mechanism not only avoids interference with the original snapshot during the writing process, but also reduces the risk of data loss caused by single point failure through multi-node storage. At the same time, a metadata chain containing session ID, version number and expiration time is created for each snapshot. The metadata chain is stored in a linked list structure, and each node records the update information of the snapshot. The session ID is used to associate the corresponding session, the version number is consistent with the version of the state snapshot, and the expiration time is dynamically set according to the session activity, such as 24 hours after the last interaction. The head of the metadata chain points to the latest version, and the tail retains historical version records, which facilitates the tracing of the state evolution process. On this basis, state change events are pushed to related service nodes through the subscription and publication mode. The system deploys an event bus in the distributed session storage pool, and all service nodes participating in session processing subscribe to the state change topic of the bus. When the state snapshot is updated, the storage pool automatically publishes an event containing the session ID, new version number and change time to the event bus. After the subscribing node receives the event, it triggers local cache update, pulls the latest state snapshot from the storage pool and replaces the old version, ensuring that the state information used by each node remains consistent, providing a solid storage and synchronization foundation for establishing cross-node state continuity, so that each node can quickly obtain a unified state snapshot when receiving a new session request, supporting coherent routing decisions.

[0033] S3、When receiving a new user session request carrying the same session ID, loading the corresponding state snapshot from the distributed session storage pool, performing fusion analysis on the loaded state snapshot and the semantic content of the new user session request, obtaining the fused context state, and calculating the routing weight offset based on the fused context state, correcting the routing decision table according to the routing weight offset, and eliminating the intention drift bias;

[0034] The fusion analysis of the loaded state snapshot and the semantic content of the new user session request includes:

[0035] When a new user session request carrying the same session ID is received, the state snapshot loaded from the distributed session storage pool needs to be analyzed and fused with the semantic content of the new request. This process realizes seamless connection of historical and current session information through four-order fusion logic, provides complete context for accurate routing decision, aligns the semantic namespace of snapshot entities and new request entities, and adjusts the confidence level of attributes. The semantic namespace refers to the domain-specific semantic category set to avoid entity name ambiguity. For example, in the e-commerce field, "apple" refers to a mobile phone in the "electronic device" namespace and a fruit in the "fresh food" namespace. Specifically, the entity synonym table in the domain knowledge graph is called to map the old name "goods" in the snapshot to the new name "commodity" in the new request to a unified name, both of which are unified as "commodity". At the same time, a namespace tag "commodity [e-commerce]" is added to each entity to ensure semantic consistency across sessions. Entity attribute conflicts are detected and confidence voting is initiated. Entity attribute conflicts refer to inconsistent attribute descriptions of the same entity in the snapshot and the new request. For example, the price of "commodity A" is 200 yuan in the snapshot and 250 yuan in the new request. The system extracts the historical frequency of the conflicting attribute in the snapshot and the context weight in the new request, and generates the confidence level of each attribute value (old attribute value confidence level 0.3, new attribute value confidence level 0.7) combined with the domain common sense database (whether the commodity price has a fluctuation range). Then, the attribute value with the highest confidence level is selected as the fusion result through the voting mechanism. If the confidence difference is less than 0.2, both attributes are retained and marked as "to be confirmed". The continuity feature of the historical entity chain is inherited. The continuity feature refers to the stable association relationship of an entity in multiple rounds of conversation ( "commodity A-order 123" is always bound in historical sessions). The system traverses the temporal relationship of the entity chain in the snapshot ("commodity A→add to shopping cart→order"), copies the entity association relationship that appears more than three times to the fusion context, and labels the association strength ("strong association" "weak association") to ensure that the entity logic chain formed in the historical session is not interrupted. The intent label of the new request is corrected based on the intent migration trajectory. First, the evolution path of the historical intent is extracted from the snapshot (such as from "consulting price"→"understanding inventory"→"inquiring about delivery"). Then, the similarity between the new request intent label ("check logistics") and the nearest intent in the trajectory is calculated using a sequence comparison algorithm. If the similarity is greater than or equal to 0.8, the label is corrected to be more consistent with the trajectory ( "check logistics" is corrected to "inquire about delivery progress"). This makes the intent label more consistent with the evolution rule of user demand, preserves the traceability of information, forms a coherent and accurate conversation context, and provides a reliable basis for subsequent calculation of routing weight offset.

[0036] Based on the fused context state, the routing weight offset is calculated, and the routing decision table is corrected according to the routing weight offset, including:

[0037] After obtaining the fused context state, the routing weight offset is calculated based on the fused context state and the routing decision table is corrected to dynamically adapt to the changes of user intent and service node state. This process realizes the accurate quantification of the weight offset through the joint calculation of three dynamic factors: the historical routing success rate factor is determined according to the ratio of the number of successful routings to the total number of routings within the past 24 hours for the entity intent combination, the real-time service node load factor is converted by monitoring the CPU usage and memory occupancy of the node, and the intent deviation coefficient is calculated according to the deviation degree of the new intent from the historical intent trajectory. The three factors are weighted and summed according to the weight of 4:3:3 to obtain the final routing weight offset (such as 0.8×0.4+0.3×0.3+0.2×0.3=0.47). When correcting the routing decision table, a hot replacement partition mechanism is used. First, the routing decision table is divided into multiple logical partitions according to the service nodes, and each partition corresponds to the routing weight configuration of a group of nodes. Then, the calculated weight offset is grouped according to the service nodes, and the nodes in the same group share the same offset adjustment value (such as uniformly increasing the offset value of 0.47 for the e-commerce service node group). The size of the group is dynamically adjusted according to the network delay. If the average delay between nodes is less than 50ms, 10 nodes are divided into a group to inject the offset value in batches. If the delay is higher than 100ms, the group size is reduced to 3 nodes to avoid configuration synchronization delay caused by network congestion. During the injection process, the system first freezes the routing decision function of the target partition, applies the offset correction, and verifies the validity of the decision table through health check. After confirming that there is no error, the partition is unfrozen and the new configuration is enabled. The whole process does not interrupt the normal operation of other partitions, ensuring the continuity of the routing service. In this way, the routing decision table can respond to the changes of the fused context state in real time, making the routing strategy not only consistent with historical successful experience, but also adapting to the current service node load and user intent deviation, significantly improving the accuracy and efficiency of service matching.

[0038] S4, configure entity extraction rules and state snapshot generation strategies through a drag-and-drop interface, generate routing decision logic flow of fused context state, realize zero-code development.

[0039] Configure entity extraction rules and state snapshot generation strategies through a drag-and-drop interface, generate routing decision logic flow of fused context state, including:

[0040] A visual graph editor is provided, and the user drags an entity type icon to the canvas to automatically generate extraction rules. The association rules and state snapshot compression parameters form a configuration template. When the configuration is changed, the intermediate representation layer code is automatically generated. After sandbox verification, it is mapped to the node logic of the routing decision tree, and a three-dimensional topology graph of the decision path is rendered in real time for the user to adjust and verify.

[0041] To realize zero-code development, the system provides a drag-and-drop interface for users to configure entity extraction rules and state snapshot generation strategies, and then generates a routing decision logic flow that integrates context states. The specific process is as follows:

[0042] First, the system provides a visual schema editor, with entity type icons categorized by domain displayed on the left side of the interface (such as "goods" and "order" in the e-commerce domain, and "account" and "transaction" in the financial domain), and users can directly drag the desired icons to the central canvas. The canvas will automatically generate corresponding entity extraction rules based on the icon type. After dragging the "goods" icon, the editor will load the default rules "goods name contains brand words + category words" and "price is a number + currency unit" by default. Users can supplement custom conditions by double-clicking on the rule item ("goods inventory > 0"). The logical relationship of the rules ("and" or "or") can be adjusted by dragging the connection line, realizing the visual configuration of the extraction rules. Then, the configured entity extraction rules and state snapshot compression parameters are associated to form a configuration template. In the parameter panel on the right side of the editor, users can set the snapshot compression layering strategy, compression version number rule, and checksum algorithm. After clicking the "Associate Template" button, the system will package the rules and parameters into an XML format configuration template, which contains rule IDs, parameter values, and association relationship markers, facilitating subsequent reuse and modification. When users adjust the configuration, the system will automatically trigger the compilation process to convert the configuration template into an intermediate representation layer code, which contains the judgment logic of entity extraction, the step instructions of snapshot generation, and the trigger conditions of context fusion. This code is then sent to a sandbox environment for verification. The sandbox simulates real conversation scenarios and runs the intermediate code after inputting test text to check the accuracy of entity extraction, the compression rate of snapshots, and the integrity of decompression. If there are rule conflicts or parameter abnormalities, it will return the specific error location and prompt for modification until the verification is passed. The verified intermediate representation layer code is mapped to the node logic of the distributed routing decision tree: entity extraction rules correspond to leaf nodes of the decision tree (responsible for judging whether the input text contains target entities), state snapshot parameters correspond to intermediate nodes (control the generation timing and format of snapshots), and context fusion logic corresponds to the association strategy of the root node. At the same time, the editor will render a three-dimensional topology graph of the decision path in real-time, with different colored nodes representing the priority of rule activation (red for high priority), and arrows indicating the weight flow direction of the routing path (the wider the line, the higher the weight). Users can drag the nodes to adjust the path weight or modify the snapshot compression parameters through a slider. The topology graph will be updated in real-time and provide feedback on the adjusted routing success rate prediction value, allowing users to intuitively verify the parameters. Through this drag-and-drop configuration and visual verification mechanism, users can complete the entire process of logic design from entity extraction, snapshot generation to routing decision without writing code. The generated routing decision logic stream naturally integrates the context state, adapting to the user's personalized rules and meeting the technical needs of cross-node state continuity and intent drift correction, significantly reducing the development threshold of large model service orchestration.

[0043] The application extracts core entities and intention dependency relationship by analyzing user conversation text, constructs entity intention graph and compresses state snapshot, assigns global conversation ID, binds snapshot to distributed routing decision tree node and stores, establishes cross-node state continuity, when receiving new request, fuses snapshot and new conversation semantics, calculates routing weight offset correction decision table, generates routing decision logic flow through drag interface configuration rule and strategy, the method solves conversation state loss and intention drift problem, improves service matching degree, reduces development threshold, and is suitable for agile construction of large model collaborative application.

[0044] The basic principles, main features and advantages of the present application are shown and described above. Those skilled in the art should understand that the present application is not limited to the above-mentioned embodiments, and the above-mentioned embodiments and descriptions in the specification are only preferred examples of the present application and are not intended to limit the present application. Without departing from the spirit and scope of the present application, various changes and improvements can be made to the present application, and these changes and improvements all fall within the scope of the claimed present application. The scope of protection of the present application is defined by the appended claims and their equivalents.

Claims

1. A zero-code visualizing and automatic routing method for large model service orchestration, characterized in that, Comprise the following steps: S1, analyze the text content of the current session of the user, extract the core entity and the intention dependency relationship between entities, and construct an entity intention graph according to the core entity and the intention dependency relationship between entities, and binary compression is performed on the entity intention graph to generate a state snapshot; The analysis of the text content of the current session of the user, the extraction of the core entity and the intention dependency relationship between entities, specifically includes: Extract the key entities in the domain through the named entity recognition module of the pre-trained large model, construct a dynamic dependency network based on the co-occurrence frequency and semantic similarity between entities, and filter strong correlation entity pairs using a session context window to filter isolated noise entities, and finally output an entity-intention association set with weighted labels, wherein the weight is determined by the frequency and position of the entity in the session; The entity intention graph is constructed according to the core entity and the intention dependency relationship between entities, including: Map the entity-intention association set to a directed graph structure, where entities are nodes and intention dependency relationships are weighted directed edges; Initialize the weight of the directed edge based on the historical routing decision path, and dynamically adjust the weight value of the directed edge based on the real-time session flow, prune and merge the weak connection subgraph in the graph, and generate a high-cohesion and low-coupling entity intention graph; The binary compression is performed on the entity intention graph to generate a state snapshot, including: A hierarchical compression strategy is adopted, first the graph nodes are compressed by Huffman coding to compress the label data, then the matrix of the directed edge weight is executed by differential pulse code modulation, and the key topological structure identifier is retained during the compression process, so that the intention dependency relationship path can be restored without loss during decompression, and finally a binary block containing the compressed version number and check code is generated; S2, assign a globally unique session ID to the current session, bind the state snapshot to the corresponding node of the distributed routing decision tree through the session ID, store the bound state snapshot to the distributed session storage pool, and establish the cross-node state continuity; S3, when receiving a new user session request carrying the same session ID, load the corresponding state snapshot from the distributed session storage pool, fuse and analyze the semantic content of the loaded state snapshot and the new user session request, obtain the fused context state, and calculate the routing weight offset based on the fused context state, and correct the routing decision table according to the routing weight offset; S4, configure entity extraction rules and state snapshot generation strategies through a drag-and-drop interface, and generate a routing decision logic stream that fuses the context state.

2. The method of claim 1, wherein the method is a zero-code visualized and automatic routing method for service orchestration of large models. The globally unique session ID is assigned to the current session, including: A composite identifier is generated by combining the user identity hash value, the service node geographic coordinates, and the timestamp milliseconds, the ID global uniqueness is ensured through a preset distributed consistency protocol, the session ID is injected into the root node metadata of the routing decision tree, and the session state life cycle anchor point is formed.

3. The method of claim 1, wherein the method is a zero-code visualized and automatic routing method for large model service orchestration. The state snapshot is bound to the corresponding node of the distributed routing decision tree through the session ID, including: According to the session ID hash value, a partition node of the decision tree is located, a snapshot index slot is created in the partition node, a physical address pointer of the state snapshot is stored, a snapshot version number is established, and a real-time synchronization mechanism of the decision tree node state is established to ensure that the state update automatically triggers the decision tree reconstruction.

4. The method of claim 1, wherein the method is a zero-code visualized and automatic routing method for large model service orchestration. The bound state snapshot is stored in a distributed session storage pool to establish cross-node state continuity, including: A write-once copy mechanism is used to persist the snapshot to at least three geographically dispersed storage nodes, a metadata chain containing the session ID, version number, and expiration time is created for each snapshot, a state change event is pushed to the related service node through a subscription publishing mode to maintain cross-node state consistency.

5. The method of claim 1, wherein the method is a zero-code visualized and automatic routing method for large model service orchestration. The loaded state snapshot is fused and analyzed with the semantic content of the new user session request, including: Fourth-order fusion logic is executed to align the semantic namespace of the snapshot entity and the new request entity, detect entity attribute conflicts and start confidence voting, inherit the continuity features in the historical entity chain, correct the intent label of the new request based on the intent migration track, and generate a fused context state with version traceability markers.

6. The method of claim 1, wherein the method is a zero-code visualized and automatic routing method for large model service orchestration. The routing weight offset is calculated based on the fused context state, and the routing decision table is corrected according to the routing weight offset, including: The weight offset is calculated by three dynamic factors: historical routing success rate factor, real-time service node load factor, and intent deviation coefficient. When correcting the decision table, a hot replacement partition mechanism is used to inject the offset in batches according to service node groups, and the group size is dynamically adjusted according to network delay.

7. The method of claim 1, wherein the method is a zero-code visualized and automatic routing method for large model service orchestration. The entity extraction rules and state snapshot generation strategies are configured through a drag-and-drop interface to generate a routing decision logic flow of the fused context state, including: A visual graph editor is provided, and the user drags an entity type icon to the canvas to automatically generate extraction rules. The rules are associated with state snapshot compression parameters to form a configuration template. When the configuration is changed, intermediate representation layer code is automatically compiled and generated, and after sandbox verification, it is mapped to the node logic of the routing decision tree. A three-dimensional topology graph of the decision path is rendered in real time for user parameter adjustment and verification.

Images