Modular construction method of low-code visual interaction system

Abstract

The invention provides a modular construction method of a low-code visual interaction system, and relates to the technical field of low-code development. The method comprises the following steps: constructing an edge cognitive topology network, packaging each node into a reconfigurable meta-module, analyzing a user operation track by using an intention perception interface to generate a meta-intention vector, and carrying out context correlation analysis through a semantic behavior chain to generate a potential behavior sequence. And establishing an asymmetric coupling relationship based on an implicit context mapper, forming a dynamic semantic resonance field, triggering distributed intention resonance and activating a matching element module, and generating a collaborative logic cluster under the constraint of edge computing node resources. And dynamically adjusting an interaction rule and a resource allocation strategy of the logic unit. According to the method, automatic construction and high-precision intention adaptation of complex business logic are realized, the elastic expansion capability and the real-time response efficiency of the system in an edge computing scene are improved, and the risk of logic fault and resource scrambling caused by node isomerism is reduced.

Description

Technical Field

[0001] The present invention relates to the technical field of low-code development, and specifically to a modular construction method for a low-code visual interaction system. Background Art

[0002] As a core tool for the digital transformation of modern enterprises, the low-code visual interaction system significantly reduces the development complexity and accelerates the iteration and deployment of business applications through a visual interface and modular logic. The prior art has initially achieved the rapid assembly and partial automation of business processes through pre-set function modules, standardized interfaces, and rule engines, especially showing flexibility advantages in medium and small-scale systems. Such systems usually rely on a centralized architecture or a fixed resource pool and can meet the user's requirements for basic logic orchestration in a controllable environment, providing effective support for cross-departmental collaboration and lightweight development.

[0003] However, with the exponential growth of business complexity, the limitations of traditional methods are gradually exposed. In an environment where heterogeneous resources are widely distributed and resources fluctuate dynamically, existing systems are difficult to achieve dynamic and accurate matching of user operation intentions and underlying logic, resulting in frequent logical breaks or response delays in the business construction process. The semantic gap between users' implicit needs and explicit operations further exacerbates this problem. Summary of the Invention

[0004] To achieve the above objectives, the present invention is realized through the following technical solutions: A modular construction method for a low-code visual interaction system, including:

[0005] Construct an edge cognitive topology network, which is composed of multiple edge computing nodes with heterogeneous distributions. Each edge computing node is encapsulated into a dynamically reconfigurable logical unit through a meta-module. The logical unit includes an intention perception interface, a semantic behavior chain, and an implicit context mapper. Among them, the intention perception interface generates an intention feature vector by parsing the operation trajectory of the user in the visual interface. The intention feature vector undergoes context relevance analysis among edge computing nodes through semantic matching in the semantic behavior chain, generates a potential behavior sequence adapted to the user's potential logical requirements, and establishes an asymmetric coupling relationship with the meta-modules of adjacent nodes through the implicit context mapper to form a dynamic semantic resonance field. When the user triggers business logic construction through the visual interface, the system initiates distributed intention resonance based on the dynamic semantic resonance field, activates the meta-modules matching the potential behavior sequence through the coupling mechanism of the implicit context mapper, and generates a collaborative logic cluster across edge computing nodes under the heterogeneous resource constraints of the edge computing nodes. The collaborative logic cluster optimizes the interaction rules between modules, collects the implicit association between the real-time state data of the edge computing nodes and the user operation trajectory, dynamically adjusts the semantic weights and resource allocation strategies of the collaborative logic cluster, and finally generates a logical unit that maintains dynamic semantic consistency with the global business logic.

[0006] The construction of the edge cognitive topology network first initializes multiple edge computing nodes with heterogeneous distributions and assigns a unique semantic identifier to each node to distinguish its functional attributes. Periodically collect the resource status data of each node through the dynamic semantic perception protocol, including indicators such as CPU utilization rate and memory occupancy rate. At the same time, combine the historical behavior logs and the characteristics of the user operation trajectory, use a sliding time window to extract the time series features of the node state, and then based on a preset semantic similarity threshold, screen out the nodes with strong relevance to generate an initial semantic description vector containing multi-dimensional semantic information. After inputting the semantic description vector into the meta-module, according to the physical connection topology and semantic similarity between nodes, use the cosine similarity algorithm to calculate the semantic association strength between nodes and construct a matrix of asymmetric coupling relationships, where tightly coupled relationships are formed between nodes with high similarity, and loose associations are maintained between nodes with low similarity. Dynamically adjust the encapsulation granularity of the logical units of the nodes based on the matrix. For nodes with high resource loads, the system automatically reduces their encapsulation granularity to release redundant resources, while for nodes with low resource loads, the encapsulation granularity is increased to improve the logical processing ability, thereby achieving dynamic adaptation of resources and loads.

[0007] Analyze the implicit requirements of the user operation trajectory in real time through an implicit context mapper, optimize the semantic association strength between nodes, so that the network topology can be dynamically adjusted according to user behavior; specifically, the system captures user operation events such as clicks and drags in the visualization interface in real time, extracts basic features such as operation frequency and path complexity, and calculates the feature weights in combination with the real-time load status of edge computing nodes; after these weighted features are quantified into intention feature vectors, semantic matching analysis is performed by a semantic behavior chain, and this process screens out candidate nodes whose similarity to the current intention feature reaches a set threshold by traversing the existing behavior chain nodes in the edge computing node resource pool; the implicit context mapper further analyzes the context dependence relationship between these candidate nodes, calculates the asymmetric coupling strength according to the physical connection topology and semantic similarity between nodes, and finally forms a potential behavior sequence adapted to the user's potential needs; the whole process is completely based on the existing resource status of edge computing nodes and behavior chain nodes for real-time calculation, without relying on pre-trained models or historical behavior libraries, ensuring that the analysis results are always dynamically synchronized with the current network environment and user operations. This lightweight analysis method not only meets the real-time requirements but also can accurately reflect the implicit logical requirements behind user operations.

[0008] The basic kernel of the meta-module is abstracted from the local resource attributes and business logic capabilities of edge computing nodes. Its essence is a set of standardized interface sets. For example, physical attributes such as the number of CPU cores, memory capacity, and built-in algorithm libraries of computing nodes are abstracted into computing power interfaces, while business logics such as image processing and data filtering supported by the nodes are mapped into functional service interfaces; based on the interface set of the basic kernel of the meta-module, the semantic behavior chain generator disassembles the original capabilities into combinable behavior chain nodes. For example, the image processing interface is disassembled into three behavior chain nodes: image decoding - feature extraction - result rendering. Each node defines constraints such as input data format, output semantic type, and processing time consumption; the implicit context mapper analyzes the behavior chain nodes of adjacent nodes, calculates the context dependence relationship between nodes through physical connection topology and semantic similarity. For example, if the behavior chain of node A contains data filtering and the behavior chain of node B contains visualization rendering, a dependency link of filtered result → rendering input can be established between the two, and finally a cross-node context dependence relationship graph is formed; during this process, the system introduces a behavior entropy constraint mechanism, and its entropy value calculation formula is: , where It is the proportion of interface call frequency. When the entropy value exceeds the preset threshold, it triggers interface level adjustment. For example, if the data transmission interface of a certain meta-module has its entropy value increased due to frequent calls, the system will raise its opening level to allow more nodes to directly access it to accelerate data flow. While the log recording interface has a low entropy value due to low-frequency use, its opening level is lowered to save resources. The semantic behavior chain generator and the semantic behavior chain are strictly distinguished in function. The former is responsible for initializing the behavior chain node structure of the meta-module. For example, it generates data collection - preprocessing - model inference chained nodes for the real-time data analysis module. The latter is used to perform real-time matching of user operation intentions. For example, when the user drags a data filtering control, the semantic behavior chain traverses all nodes in the resource pool that contain filtering semantics and selects the behavior chain combination with the highest matching degree. Through the above process, the meta-module finally forms a logically unit that can be adaptively reconstructed, and the semantic depth of its behavior chain dynamically expands according to the potential needs of users. For example, simple needs only activate the basic behavior chain nodes, while complex needs trigger the generation of a multi-node collaborative logic cluster to achieve the balance between resource efficiency and business logic accuracy.

[0009] The implementation of the logical unit converts user operations into distributed business logic through a multi-level collaboration mechanism. The intention perception interface captures the operations of users in the visualization interface in real time, extracts features such as operation frequency and path complexity, and combines with the real-time load status of edge computing nodes, such as CPU utilization and memory remaining, to dynamically calculate the feature weight values. For example, when the user continuously drags the data filtering control and the operation path shows a complex network structure, the system automatically raises the weight value of this trajectory to identify its potential logical priority. Capture the original operation events of users in the visualization interface and extract basic features such as operation frequency and path complexity. These features are combined with the real-time load status of edge computing nodes, and through dynamic weight calculation, feature weight values are generated. Based on these weighted features, the system converts them into multi-dimensional intention feature vectors.

[0010] After receiving the intention vector, the semantic behavior chain performs association analysis through dynamic semantic matching. Using the vector similarity algorithm based on Euclidean distance, it traverses the behavior nodes registered in the resource pool of edge computing nodes and selects the candidate nodes whose distance from the intention feature vector is less than the preset threshold. For example, when the intention feature vector represents the need for real-time data visualization, it preferentially selects the behavior nodes that have processed the combination of data cleaning and chart generation in the past and whose Euclidean distance meets the standard, and sorts them according to the current resource utilization rate of the nodes. Nodes with a memory occupancy rate lower than 20% are given higher priority, and finally a potential behavior sequence is generated.

[0011] The implicit context mapper further encodes the potential behavior sequence into a high-order tensor, and the dimensions of the high-order tensor are respectively mapped to behavior types, resource states, and time series. For example, the first dimension labels behavior types such as data filtering or model inference, the second dimension quantifies the resource states of CPU load and network bandwidth, and the third dimension records the time series of operation response latency. For example, nodes with low CPU load show high response efficiency in data filtering behavior. Based on this, the semantic gravitational strength between adjacent nodes is calculated, and the gravitational value between nodes with complementary resources and frequent collaboration increases, thereby constructing a semantic resonance channel. Low-gravity nodes, such as nodes with CPU utilization exceeding 85% or mismatched behavior types, automatically exit the resonance field through the resonance decay factor to ensure that only highly adaptable nodes are retained in the dynamic semantic resonance field. Finally, the system generates a logic unit that precisely matches the user's intention through the collaboration of nodes in the resonance field.

[0012] After the implicit context mapper is connected to the heterogeneous resource pool of the edge computing node, it monitors the node load status in real time. When the CPU utilization exceeds the preset high-load threshold of 80%, the system compresses the redundant dimensions of the intention feature vector. For example, the non-core log record levels in the data filtering operation are merged into a single dimension to reduce the computational overhead. If the CPU utilization is lower than the low-load threshold of 30%, the dimensions are expanded to improve the parsing accuracy. For example, the data preprocessing is split into two independent dimensions of format conversion and missing value filling to refine the semantic expression. At the same time, the system extracts effective path segments based on the historical evolution path of the semantic behavior chain, and only retains the segments with a correlation with the current intention feature exceeding the threshold of 0.7. For example, the data filtering to visualization rendering link frequently triggered in the user's historical operations, and injects it into the intention feature vector in reverse. For example, it is forced to require the format consistency between the filtering result and the rendering input, thereby eliminating noise interference.

[0013] The construction of the dynamic semantic resonance field encodes the potential behavior sequences of meta-modules into high-order tensors through an implicit context mapper; based on the semantic similarity between high-order tensors, the system uses a gravitational calculation formula to calculate the semantic gravitational values between nodes, where the gravitational value is defined as the reciprocal of the Euclidean distance between the tensor vectors of two nodes, and the smaller the distance, the greater the gravitational value; for example, if the tensor representation of node A is data filtering - low latency and that of node B is data filtering - high throughput, and their Euclidean distance is relatively low, the gravitational value is high, forming a strong association. After the initial semantic gravitational field is generated, the system activates and matches meta-modules according to the implicit requirements of the user operation trajectory, triggering distributed intention resonance. Nodes with high gravitational values are preferentially aggregated into resonance cluster cores; for example, three nodes for processing real-time data cleaning form a resonance cluster core because their gravitational values all exceed the threshold of 0.8. Nodes with low gravitational values serve as candidate cluster cores; for example, a node with a relatively high historical response latency has a gravitational value of 0.3 and is not included for the time being. The semantic resonance decay factor dynamically updates the node gravitational values according to exponential decay; for example, if the CPU utilization rate of a node within a cluster core exceeds 85%, its gravitational value exponentially decreases by a factor of 0.5 per hour. When the value is lower than the threshold of 0.6, it is demoted to a candidate node, and at the same time, the node with the highest gravitational value is selected from the candidate cluster cores to be added in.

[0014] The optimization process of the collaborative logic cluster is specifically as follows: The system real-time collects data on the resource utilization rate, memory occupancy rate, and network throughput of edge computing nodes and converts them into the adaptation entropy of heterogeneous resources. The calculation formula is: the adaptation entropy is equal to the weighted sum of the normalized values of the CPU utilization rate, memory occupancy rate, and network throughput, and the weights are dynamically allocated according to the node type; for example, a computationally intensive node is given a higher weight for the CPU utilization rate, while a communication-intensive node focuses on the network throughput. When the adaptation entropy exceeds the threshold of 0.7, the system automatically reduces the resource quota, such as reducing the CPU allocation of non-anchor nodes by 20%; if the adaptation entropy is lower than 0.3, the resource priority is increased, for example, increasing the memory cache space for low-load nodes. At the same time, the system extracts the high-frequency interaction nodes in the operation trajectory; for example, when the user continuously triggers data filtering operations, the behavior chain of this node is marked as an anchor point, and its semantic weight is locked at the highest level, prohibiting downgrade adjustment. The weights of non-anchor nodes are dynamically optimized according to the real-time load; for example, if the memory occupancy rate of a visualization rendering node increases to 75%, its weight is reduced. The optimized logic unit needs to be verified through a semantic consistency verification protocol. The system reversely maps its operation result to the dynamic semantic resonance field and calculates the semantic deviation degree, which is defined as the vector Euclidean distance between the expected result and the actual output. If the deviation degree exceeds the dynamic fault tolerance interval of 0.1 to 0.15, semantic resonance reconstruction is triggered: for example, if the deviation degree of a collaborative logic cluster reaches 0.18 due to uneven node loads, the system immediately disbands the current cluster, reselects nodes based on the updated semantic gravitational values, and generates a new logic cluster containing low-latency data sources and high-throughput computing nodes until the deviation degree converges within 0.1.

[0015] The present invention provides a modular construction method for a low-code visual interaction system, having the following beneficial effects:

[0016] Through the dynamic semantic resonance mechanism between heterogeneous edge computing nodes, the present invention realizes the real-time and accurate matching of user operation intentions and distributed logical resources, improves the logical construction efficiency and semantic consistency of the low-code system in the edge computing environment, and reduces the response delay and resource allocation conflicts caused by node heterogeneity in the traditional centralized architecture.

[0017] Through the dynamic allocation technology of decision weights based on context awareness, the present invention realizes the real-time recommendation of the logical construction direction and the optimal allocation of resources during the development process, improves the active response and decision-making assistance level of the system to the potential intentions of users, and reduces the rigidity and adaptation limitations of the traditional method that relies on manually preset rules based on experience.

[0018] Through the cross-module semantic resonance and self-evolution cooperation mechanism, the present invention realizes the intelligent compatibility and conflict resolution of heterogeneous business logic units, improves the global consistency guarantee ability during the construction of large-scale complex systems, and reduces the logical redundancy and maintenance costs caused by module fragmentation in the traditional low-code platform. BRIEF DESCRIPTION OF THE DRAWINGS

[0019] Figure 1 It is a schematic diagram of the process of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0020] The technical solutions in the embodiments of the present invention will be clearly and completely described below. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all the embodiments; based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present invention.

[0021] In the deployment, first, initialize multiple heterogeneous distributed edge computing nodes, such as Internet of Things gateways, edge servers, and cloud computing nodes deployed in different geographical locations; each node is assigned a unique semantic identifier to distinguish its functional attributes. For example, node A is marked as a data processing node, and node B is a visualization rendering node; periodically collect the resource status data of each node through the dynamic semantic perception protocol, including indicators such as CPU utilization rate and memory occupancy rate; for example, the CPU utilization rate of node A reaches 75% during the peak period, while the memory occupancy rate of node B is 40%; combine the characteristics of historical behavior logs and user operation trajectories, and use a sliding time window to extract the time series characteristics of the node status, generating an initial semantic description vector containing multi-dimensional semantic information; for example, the semantic description vector of node A contains features such as high computing power and low-latency response, and the semantic description vector of node B contains features such as high rendering efficiency and low memory occupancy; through a preset semantic similarity threshold of 0.7, filter out nodes with strong correlations and construct an asymmetric coupling relationship matrix; for example, node A and node B form a tight coupling relationship because the semantic similarity is 0.8; based on the matrix, dynamically adjust the encapsulation granularity of the node's logical unit. High-load nodes automatically reduce the encapsulation granularity to release resources. For example, when the CPU utilization rate of node A exceeds 80%, the encapsulation granularity is adjusted from fine-grained to medium-grained, while low-load nodes increase the encapsulation granularity to enhance the logical processing ability. For example, when the memory occupancy rate of node B is lower than 30%, the encapsulation granularity is increased from medium-grained to fine-grained; finally, form an edge cognitive topology network that supports distributed intention resonance, and the semantic association strength between its nodes is dynamically adapted to the implicit needs of the user operation trajectory; for example, when the user frequently operates data filtering and visualization rendering, automatically enhance the semantic association strength between node A and node B to ensure the efficient execution of the business logic.

[0022] The construction of the meta-module and the encapsulation process of the logic unit further refine the functional implementation; extract the local resource attributes and business logic capabilities of the edge computing nodes, and abstract them into the kernel of the meta-module; for example, the kernel of node A includes a data processing capability interface, supporting functions such as data cleaning and feature extraction; the kernel of node B includes a visualization rendering capability interface, supporting functions such as chart generation and dynamic interaction; through the semantic behavior chain generator, map the original capabilities of the kernel into combinable behavior chain nodes; for example, the behavior chain nodes of node A include data cleaning - feature extraction - model inference, and the behavior chain nodes of node B include chart generation - dynamic interaction - result output; each behavior chain node defines constraints such as the input data format, output semantic type, and processing time consumption; for example, the data cleaning node requires the input to be CSV format data, the output to be cleaned structured data, and the processing time consumption not to exceed 2 seconds; the implicit context mapper analyzes the behavior chain nodes of adjacent nodes and establishes a cross-node context dependency graph; for example, the feature extraction node of node A and the chart generation node of node B establish a dependency relationship of feature data → chart input; based on the dependency graph, dynamically adjust the interface opening level of the meta-module using behavior entropy constraints; for example, due to the high frequency of calls to the data transmission interface of node A, the behavior entropy value increases, and its opening level is promoted from internal call to cross-node call to accelerate data flow; while the log recording interface of node B has a low behavior entropy value due to low-frequency use, and its opening level is reduced from cross-node call to internal call to reduce resource occupancy; finally, a logic unit is generated, and the semantic depth of its behavior chain is positively correlated with the complexity of the user's potential needs; for example, when the user's needs expand from simple data filtering to complex data analysis and visualization, more behavior chain nodes are automatically activated to form a cross-node collaborative logic cluster.

[0023] The logic unit converts the user's operations into distributed business logic through a multi-level collaboration mechanism; the intent perception interface captures the user's operations in the visualization interface in real time, such as the user dragging the data filtering control and connecting it to the chart generation control; extract features such as operation frequency and path complexity, and fuse the real-time load status of the edge computing nodes to dynamically calculate the feature weight values; for example, the user drags the data filtering control 5 times continuously and the operation path presents a complex network structure, automatically increasing the weight value of this trajectory to 0.8 to identify its potential logic priority; after capturing the user's original operation events in the visualization interface, extract basic features such as operation frequency and path complexity; these features are combined with the real-time load status of the edge computing nodes, and the feature weight values are generated through dynamic weight calculation; based on these weighted features, convert them into multi-dimensional intent feature vectors, for example, dimension 1 represents data processing requirements, dimension 2 represents visualization requirements, and dimension 3 represents real-time requirements.

[0024] After receiving the intention feature vector, the semantic behavior chain performs association analysis through dynamic semantic matching. For example, when the intention feature vector represents the need for real-time data visualization, a vector similarity algorithm based on Euclidean distance is adopted to traverse the behavior nodes registered in the edge computing node resource pool. Suppose the historical behavior data of node A contains a combination of data cleaning - chart generation, and its Euclidean distance is 0.3, which is less than the preset threshold of 0.5. Then it is screened as a candidate node and sorted according to the current resource utilization rate of the node. For example, the memory occupancy rate of node A is 20%, so it is given a higher priority to generate a potential behavior sequence. The implicit context mapper further encodes the potential behavior sequence into a high-order tensor. For example, dimension 1 marks the behavior type, dimension 2 quantifies the resource state, and dimension 3 records the time series of operation response latency. For example, node A shows high response efficiency in the data filtering behavior, with a latency of 150 milliseconds, while node B shows high throughput capacity in the chart generation behavior, processing 1000 data items per second. Based on this, the semantic gravitational strength between adjacent nodes is calculated, and the gravitational value between nodes with complementary resources and frequent cooperation increases. For example, the semantic gravitational value between node A and node B is 0.8, and then a semantic resonance channel is constructed. Low-gravitational nodes, such as nodes with a semantic gravitational value below 0.3, automatically exit the resonance field through the resonance decay factor, ensuring that only high-adaptation nodes are retained in the dynamic semantic resonance field. Through the cooperation of the nodes in the resonance field, a logical unit that precisely matches the user's intention is generated. For example, a collaborative logic cluster containing data processing of node A and visualization rendering of node B is generated.

[0025] After the implicit context mapper is connected to the heterogeneous resource pool of the edge computing node, it monitors the node load status in real time. For example, when the CPU utilization rate of node A exceeds the preset high-load threshold of 80%, redundant dimensions of the intention feature vector are compressed. For example, the non-core log record levels in the data filtering operation are merged into a single dimension, reducing the computational overhead by about 30%. If the CPU utilization rate of node B is lower than the low-load threshold of 30%, the dimension is expanded to improve the parsing accuracy. For example, the data preprocessing is split into two independent dimensions of format conversion and missing value filling, refining the semantic expression by about 40%. At the same time, effective path segments are extracted based on the historical evolution path of the semantic behavior chain, and only segments with a correlation with the current intention feature exceeding the threshold of 0.7 are retained. For example, the data filtering to visualization rendering link frequently triggered in the user's historical operations is retained, while the data storage link with low correlation is excluded. These effective segments are reversely injected into the intention feature vector. For example, the format consistency between the filtering result and the rendering input is forced, thereby eliminating noise interference and improving the intention parsing accuracy.

[0026] The construction process of the dynamic semantic resonance field is realized by encoding the potential behavior sequences of meta-modules into high-order tensors. For example, the potential behavior sequence of node A is characterized as data filtering - feature extraction, and the sequence of node B is characterized as chart generation - dynamic interaction. Based on the semantic similarity between high-order tensors, the gravitational calculation formula is used to calculate the semantic gravitational value between nodes. For example, the Euclidean distance between the tensor vectors of node A and node B is 0.4, and the gravitational value is 2.5, forming a strong association. After the initial semantic gravitational field is generated, the matching meta-modules are activated according to the implicit requirements of the user operation trajectory, triggering distributed intention resonance. Nodes with high gravitational values are preferentially aggregated into resonance cluster cores. For example, three nodes for processing real-time data cleaning form a resonance cluster core because their gravitational values all exceed the threshold of 0.8, while nodes with low gravitational values serve as candidate cluster cores. The semantic resonance decay factor dynamically updates the gravitational value of nodes according to exponential decay. For example, a certain node in the cluster core triggers decay because its CPU utilization rate exceeds 85%, and its gravitational value decreases exponentially by a factor of 0.5 per hour. When the value is lower than the threshold of 0.6, the node is demoted to a candidate node, and at the same time, the node with the highest gravitational value is selected from the candidate cluster cores to be added. Finally, a dynamic semantic resonance field oriented by user operations is formed, and its topological structure is synchronized with the global business logic requirements in real time. For example, when the user adjusts the data filtering conditions, the resonance field structure is automatically updated to ensure the semantic consistency of the logic unit.

[0027] The optimization process of the collaborative logic cluster is achieved by collecting real-time data on the resource utilization rate, memory occupancy rate, and network throughput of edge computing nodes; for example, the resource utilization rate of node A is 70%, the memory occupancy rate is 45%, and the network throughput is 80 Mbps; these data are converted into the adaptation entropy of heterogeneous resources, and the calculation formula is that the adaptation entropy is equal to the weighted sum of the CPU utilization rate, memory occupancy rate, and normalized value of network throughput, and the weights are dynamically allocated according to the node type; for example, a compute-intensive node is given a higher weight for CPU utilization rate, with a weight of 0.6, while a communication-intensive node focuses on network throughput, with a weight of 0.5; when the adaptation entropy exceeds the threshold of 0.7, the resource quota is automatically reduced, for example, the CPU allocation of non-anchor nodes is reduced by 20%; if the adaptation entropy is lower than 0.3, the resource priority is increased, for example, the memory cache space is increased for low-load nodes; the high-frequency interaction nodes in the operation trajectory are extracted, for example, when the user continuously triggers the data filtering operation, the behavior chain of this node is marked as an anchor point, and its semantic weight is locked at the highest level, and demotion adjustment is prohibited; the weights of non-anchor nodes are dynamically optimized according to the real-time load, for example, the weight of a visualization rendering node is reduced from 0.8 to 0.6 due to the memory occupancy rate rising to 75%; the optimized logic unit needs to be verified through the semantic consistency verification protocol, and its operation result is reverse-mapped to the dynamic semantic resonance field to calculate the semantic deviation degree; for example, the semantic deviation degree of a collaborative logic cluster is 0.18, exceeding the dynamic fault tolerance interval of 0.1 to 0.15, and the current cluster is immediately dissolved, and nodes are re-screened based on the updated semantic gravity value to generate a new logic cluster including low-latency data sources and high-throughput computing nodes until the deviation degree converges within 0.1.

[0028] The present invention realizes the automated construction of complex business logic and high-precision intent adaptation; through the dynamic adjustment of the edge cognitive topology network, it ensures that the semantic association strength between nodes is synchronized with the implicit requirements of the user operation trajectory in real time; ultimately, the present invention improves the elastic expansion ability and real-time response efficiency in the edge computing scenario, reduces the risks of logical faults and resource contention caused by node heterogeneity, and provides an efficient and accurate technical solution for the modular construction of low-code visual interaction.

[0029] Although the embodiments of the present invention have been shown and described, for those of ordinary skill in the art, it can be understood that various changes, modifications, substitutions, and variations can be made to these embodiments without departing from the principles and spirit of the present invention, and the scope of the present invention is defined by the appended claims and their equivalents.

Claims

1. A modular construction method for a low-code visual interaction system, characterized in that, Including the following steps: Construct an edge cognitive topology network, which is composed of multiple heterogeneous distributed edge computing nodes. Each edge computing node is encapsulated into a dynamically reconfigurable logic unit through a meta-module. The logic unit includes an intention perception interface, a semantic behavior chain, and an implicit context mapper. Among them, the intention perception interface generates an intention feature vector by parsing the operation trajectory of the user in the visualization interface. The intention feature vector performs context relevance analysis between edge computing nodes through semantic matching in the semantic behavior chain, generates a potential behavior sequence adapted to the user's potential logical requirements, and establishes an asymmetric coupling relationship with the meta-modules of adjacent nodes through the implicit context mapper to form a dynamic semantic resonance field. When the user triggers business logic construction through the visualization interface, the system initiates distributed intention resonance based on the dynamic semantic resonance field, activates the meta-modules matching the potential behavior sequence through the coupling mechanism of the implicit context mapper, and generates a collaborative logic cluster across edge computing nodes under the heterogeneous resource constraints of the edge computing nodes. The collaborative logic cluster optimizes the interaction rules between modules, collects the implicit association between the real-time state data of the edge computing nodes and the user operation trajectory, dynamically adjusts the semantic weight and resource allocation strategy of the collaborative logic cluster, and finally generates a logic unit that maintains dynamic semantic consistency with the global business logic.

2. The modular construction method of the low-code visual interaction system according to claim 1, characterized in that: The construction process of the edge cognitive topology network is to initialize multiple heterogeneous distributed edge computing nodes, assign a unique semantic identifier to each node, periodically collect the resource status data, historical behavior logs, and feature of the user operation trajectory of each node through the dynamic semantic perception protocol to generate an initial semantic description vector of the node, input the semantic description vector into the meta-module, and establish a matrix of asymmetric coupling relationships according to the physical connection topology and semantic similarity between nodes. Based on the matrix, dynamically adjust the encapsulation granularity of the logic unit of the node. Among them, high-load nodes automatically reduce the encapsulation granularity to release resources, and low-load nodes increase the encapsulation granularity to enhance the logical processing ability. Form an edge cognitive topology network that supports distributed intention resonance, and the semantic association strength between its nodes is dynamically adapted to the implicit requirements of the user operation trajectory.

3. The modular construction method of the low-code visual interaction system according to claim 2, characterized in that: The construction and logic unit encapsulation process of the meta-module includes: extracting the local resource attributes and business logic capabilities of the edge computing node, and abstracting them into the kernel of the meta-module; mapping the original capabilities of the kernel into combinable behavior chain nodes through a semantic behavior chain generator, and each behavior chain node includes semantic constraint conditions of input / output interfaces; using an implicit context mapper to analyze the behavior chain nodes of adjacent nodes and establish a cross-node context dependency graph; based on the dependency graph, dynamically adjust the interface opening level of the meta-module using behavior entropy constraint: for interfaces with high-frequency calls, increase its opening level to accelerate data flow; for low-frequency interfaces, reduce the opening level to reduce resource occupancy; finally generate a logic unit that can be adaptively reconfigured, and the semantic depth of its behavior chain is positively correlated with the complexity of the user's potential requirements.

4. The modular construction method of the low-code visual interaction system according to claim 3, characterized in that: The logic unit captures the user's operations in the visual interface in real time for the intent perception interface, extracts the characteristics of the operation trajectory, and calculates the weight value of the characteristics of the operation trajectory based on the operation frequency, path complexity and real-time load status of the edge computing node; quantifies the operation trajectory based on the weight value to generate an intention feature vector; the semantic behavior chain receives the intention feature vector and analyzes its correlation with the heterogeneous resource pool of the edge computing node through dynamic semantic matching: dynamic semantic matching traverses the historical behavior data in the resource pool, screens candidate behavior nodes whose semantic similarity with the intention feature vector is higher than the threshold, and sorts them by resource utilization priority to generate a potential behavior sequence; The implicit context mapper encodes the potential behavior sequence into a high-order tensor and calculates the semantic gravitational strength between adjacent nodes. Based on the gravitational strength, a semantic resonance channel is established between nodes to form a dynamic semantic resonance field across nodes, in which low-gravity nodes automatically exit the resonance field through the semantic resonance attenuation factor.

5. The modular construction method of the low-code visual interaction system according to claim 4, characterized in that: The implicit context mapper is connected to the heterogeneous resource pool of the edge computing node; according to the real-time load status of the heterogeneous resource pool, the semantic dimension of the intent feature vector is expanded, redundant dimensions are compressed under high load conditions to reduce computing overhead, and dimensions are expanded under low load conditions to enhance the accuracy of intent parsing; based on the historical evolution path of the semantic behavior chain, semantic denoising is performed on the feature vector, and valid path fragments with a correlation with the current intent feature higher than a threshold in the historical path are extracted and reversely injected into the intent feature vector to eliminate noise interference and generate an intent feature vector.

6. The modular construction method of the low-code visual interaction system according to claim 1, characterized in that: The dynamic semantic resonance field is constructed by encoding the potential behavior sequence of the meta-module into a high-order tensor through an implicit context mapper, where each tensor dimension corresponds to a semantic behavior type; calculating the semantic gravity value between nodes based on the semantic similarity between tensors to generate an initial semantic gravity field; activating the meta-module that matches the potential behavior sequence based on the implicit needs of the user's operation trajectory to trigger distributed intention resonance: nodes with high semantic gravity values are prioritized to form resonance cluster cores, and nodes with low gravity values serve as candidate cluster cores; Cluster core members are dynamically screened through the semantic resonance attenuation factor: if the real-time load of the nodes in the cluster core exceeds the threshold, some nodes are eliminated in descending order of gravity value, and the candidate cluster core nodes are simultaneously included in the resonance field; ultimately, a dynamic semantic resonance field guided by user operations is formed, and its topology structure is synchronized with the global business logic requirements in real time.

7. The modular construction method of the low-code visual interaction system according to claim 1, characterized in that: The collaborative logic cluster collects resource utilization, memory occupancy, and network throughput data of edge computing nodes in real time and converts them into adaptive entropy of heterogeneous resources. Based on the adaptive entropy, the modules of the collaborative logic cluster are elastically scaled. If the adaptive entropy is higher than a threshold, the resource quota is reduced; if it is lower than the threshold, the resource priority is increased. High-frequency interaction nodes in the operation trajectory are extracted and their behavior chain nodes are marked as anchor points. The semantic weight of the anchor point cannot be reduced, and the weight of the non-anchor point is adjusted according to the real-time load. The optimized logic unit is verified using a semantic consistency verification protocol. Reverse-map its operation result to the dynamic semantic resonance field and calculate the semantic deviation degree; if the deviation degree exceeds the dynamic fault tolerance interval, trigger semantic resonance reconstruction and regenerate the collaborative logic cluster until the deviation degree converges.

Images