A zero-code agent construction platform

Abstract

The present invention belongs to the field of computer technology, and particularly relates to a zero-code agent construction platform. It includes: a module database, a semantic parsing and intention decomposition unit, a task flow tree generation unit, and an agent construction unit; the semantic parsing and intention decomposition unit is used to perform image language parsing on the natural language instructions input by the user, decompose the natural language instructions into multiple intention units with a sequential order, and construct an intention vector; the task flow tree generation unit is used to generate corresponding multiple task flow trees according to the intention vector; the agent construction unit is used to analyze all the task flow trees, find the optimal task flow tree, call all the target function modules in the task flow tree, and complete the construction of the agent. The present invention significantly improves the accuracy of semantic parsing, the flexibility of task logic generation, and the automation degree of agent construction.

Description

Technical Field

[0001] The present invention belongs to the field of computer technology, and particularly relates to a zero-code agent construction platform. Background Art

[0002] With the rapid development of artificial intelligence (AI) technology, intelligent task execution and human-computer interaction technologies are increasingly widely applied in various industries. However, the construction of the vast majority of current intelligent systems still requires professional programming skills, which poses a relatively high threshold for users without a technical background. To lower this technical threshold, zero-code development platforms have gradually received attention and promotion. The zero-code platform aims to help users complete the development and deployment of complex tasks without writing code through an intuitive user interface, modular task construction, and visual logic design. However, there are still deficiencies in some key aspects of zero-code agent construction in the prior art, and it cannot fully meet the intelligent needs of users for diverse and dynamic tasks.

[0003] Most zero-code development platforms only support structured text input or passing task requirements through interface operations, and cannot effectively process unstructured or complex inputs. For example, for a handwritten image containing natural language instructions, the prior art often lacks effective parsing capabilities, and can only recognize characters through OCR, and then relies on static rules to map task logic. This method not only has limited parsing accuracy but also cannot adapt to multi-modal input scenarios (such as containing both images and text). Current mainstream platforms mostly rely on simple keyword matching or predefined rules to achieve semantic parsing, rather than dynamic analysis based on deep learning or high-dimensional geometric features. For example, when a user inputs a multi-level complex task instruction (such as "generate a bar chart after analyzing sales data and send the result by email to the management"), traditional platforms often have difficulty accurately decomposing it into independent intent units. This results in users needing to perform additional decomposition of the task, losing the simplicity of zero-code development. In the prior art, task logic is usually implemented through fixed process definitions or templated module calls, and it is difficult to dynamically adjust or optimize. For example, the optimal path selection of the task process is manually completed on most platforms, lacking an intelligent solution based on computational optimization. When users face high-concurrency tasks or resource-constrained scenarios, existing platforms are difficult to provide sufficient task flexibility. Although some platforms provide the ability to store and reuse functional modules, there are still shortcomings in the prior art in aspects such as dynamic update of modules, redundant call management, and adjustment of logical relationships between modules. For example, the addition or deletion of modules usually requires system downtime maintenance or relies on complex manual operations, and it is difficult to meet the real-time adjustment of task requirements. In addition, there is no effective redundant management mechanism for multi-version calls of the same functional module, which is likely to lead to system instability. Summary of the Invention

[0004] The main objective of the present invention is to provide a zero-code agent construction platform, which significantly improves the accuracy of semantic parsing, the flexibility of task logic generation, and the automation level of agent construction. Its beneficial effects include supporting efficient parsing of multi-modal inputs, dynamically optimizing the task flow tree, enhancing module management and expansion capabilities, improving the fault tolerance and automation level of agent construction, greatly reducing the user development threshold, and being widely applicable to complex and diverse intelligent task scenarios.

[0005] To solve the above technical problems, the present invention provides a zero-code agent construction platform, which includes: a module database, a semantic parsing and intent decomposition unit, a task flow tree generation unit, and an agent construction unit; multiple function modules that perform a single function are stored in the module database at fixed positions, and each function module is connected to the adjacent stored function module; there are at least N function modules with the same function, where N is a set value; the semantic parsing and intent decomposition unit is used to perform image language parsing on the natural language instructions input by the user, decompose the natural language instructions into multiple intent units with a sequential order, take each intent unit as an element in a vector, and construct an intent vector according to the sequential order of the intent units; the task flow tree generation unit is used to generate corresponding multiple task flow trees according to the intent vector; the agent construction unit is used to analyze all the task flow trees, find the optimal task flow tree, and call all the target function modules in the optimal task flow tree according to the order of the target function modules in the optimal task flow tree to complete the construction of the agent.

[0006] Furthermore, the update process of the module database specifically includes: if any function module in the module database is to be deleted, directly put the function module into permanent sleep; if a function module is to be added to the module database, directly add and store the function module at any idle position in the module database and connect it to the adjacent other function modules.

[0007] Further, the process of generating any task flow tree by the task flow tree generation unit specifically includes: finding all the functional modules corresponding to each intention unit in the intention vector in the module database as the target functional modules of each intention unit; each functional module includes a keyword set for matching the intention unit; in the keyword set, each keyword is represented by a feature code, and each intention unit is also a code; for each intention unit, forming a set of all the corresponding target functional modules as the target functional module set of the intention unit; arbitrarily selecting a target functional module from each target functional module set and connecting the target functional modules in other target functional module sets in the order of the intention units to generate a corresponding target task tree; during the connection process, if the functional module adjacent to the target functional module is not a target functional module, then the functional module is put into sleep and grayed out.

[0008] Further, the process of the agent construction unit analyzing all the task flow trees to find the optimal task flow tree includes: taking the task flow tree with the fewest functional modules put into sleep and grayed out as the optimal task flow tree.

[0009] Further, the method for the semantic parsing and intention decomposition unit to perform image language parsing on the natural language instruction input by the user and decompose the natural language instruction into multiple intention units with a sequential order specifically includes: obtaining an image containing the natural language instruction, analyzing the fractal geometry feature vector of the image, and constructing a multifractal spectrum; based on the multifractal spectrum, constructing a dynamic topological structure vector of the strokes; constructing a high-dimensional feature space vector according to the multifractal spectrum and the dynamic topological structure vector; mapping the high-dimensional feature space vector into a discriminant manifold space to obtain a discriminant manifold vector; performing a conversion based on the prior probability on each element in the discriminant manifold vector to obtain the corresponding intention unit.

[0010] Further, through the following formula, obtain an image containing the natural language instruction, analyze the fractal geometry feature vector of the image, and construct a multifractal spectrum:

[0011] ;

[0012] where is the integration region, representing the region of the image; is the fractal order parameter, which is a set value; is the time scale parameter, which is a set value; is the space curvature parameter, which is a set value; is the th observation window size of the scale; is the gray value of the input image at the position; is the coordinate of the X-axis; is the coordinate of the Y-axis; is an integer subscript index; is the scale number; is the multifractal spectrum.

[0013] Furthermore, based on the multifractal spectrum, the dynamic topological structure vector of the stroke is constructed through the following formula :

[0014] ;

[0015] where, is the value that maximizes ; is the highest curvature order; is an integer subscript index; is gradient of; is the imaginary symbol; is the th order curvature characteristic scale, which is a set value with a value range of 0.5 to 0.9; is the regional integral differential element; is the characteristic angle, with a value range of 10 to 30 degrees.

[0016] Furthermore, the high-dimensional feature space vector is constructed according to the multifractal spectrum and the dynamic topological structure vector through the following formula:

[0017] ;

[0018] where, is the high-dimensional feature space vector; is the coordinate of the first coordinate axis in the high-dimensional feature space; is the coordinate of the second coordinate axis in the high-dimensional feature space; is the resolution parameter of the high-dimensional feature space; is th order Bessel function.

[0019] Furthermore, the high-dimensional feature space vector is mapped into the discriminant manifold space through the following formula to obtain the discriminant manifold vector:

[0020] ;

[0021] where, is the harmonic function in the discriminant manifold space; is the F-norm operation; is the absolute value operator; is the th component of the manifold coordinate system; is the characteristic scale of the th component of the manifold coordinate system, which is a set value.

[0022] Furthermore, through the following formula, each element in the discriminant manifold vector is transformed based on the prior probability to obtain the corresponding intention unit:

[0023] ;

[0024] where is the th intention unit; is the prior probability of the Gaussian distribution with both mean and variance being ; is the gradient; is the th element in the discriminant manifold vector.

[0025] A zero-code agent construction platform of the present invention has the following beneficial effects:

[0026] The present invention breaks through the dependence of traditional zero-code platforms on structured inputs and realizes the direct parsing of natural language images for the first time. Through the image parsing method based on fractal geometry, the present invention can extract geometric and semantic features from handwritten instructions, blurred images, or even complex unstructured texts, providing strong technical support for diverse input scenarios. By using the multifractal spectrum and dynamic topological structure vector, the present invention can accurately capture the local geometric characteristics and global distribution laws in the image, realizing the efficient parsing of complex natural language instruction images. This ability greatly expands the applicable range of zero-code platforms, making them have significant advantages in multimodal input scenarios and meeting the needs of users in diverse business scenarios.

[0027] The present invention constructs a high-dimensional feature space vector and maps it into the discriminant manifold space, greatly improving the accuracy and robustness of natural language instruction parsing. Different from traditional keyword matching and static rule methods, the present invention uses dynamic topological structure and high-dimensional feature analysis technologies to deeply parse complex and multi-level natural language instructions. For example, for complex task instructions containing multi-step logic, the present invention can accurately decompose them into intention units with a sequential order and optimize the parsing results through the prior probability model. This semantic parsing method based on high-dimensional features and geometric optimization not only improves the accuracy of the parsing results but also significantly enhances the system's adaptability to fuzzy expressions, handwritten inputs, and irregular instructions.

[0028] Traditional zero-code platforms usually rely on static rules to generate task logic and are difficult to dynamically adjust the process path. Through the task process tree generation unit, the present invention realizes the dynamic optimization of task logic. By analyzing the intention vector and the module database, the present invention can generate multiple candidate task process trees and select the optimal task process tree based on the principle of the least number of dormant graying modules. This dynamic optimization method can significantly improve the execution efficiency of the process tree in the case of resource constraints or high task complexity. In addition, the present invention introduces a dynamic adjustment mechanism in the process of task logic generation, which can update the process path in real time according to changes in the task environment (such as module call failure or resource allocation problems). BRIEF DESCRIPTION OF THE DRAWINGS

[0029] In order to more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the following will briefly introduce the drawings required in the description of the embodiments or the prior art. Obviously, the drawings in the following description are only the embodiments of the present invention. For those of ordinary skill in the art, other drawings can be obtained according to the provided drawings without creative efforts.

[0030] Figure 1 It is a schematic structural diagram of the intelligent control system for primary frequency regulation of the power grid provided by the embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0031] The following will further elaborate on the method of the present invention in conjunction with the drawings and the embodiments of the present invention.

[0032] Embodiment 1, refer to Figure 1 : A zero-code agent construction platform, which includes: a module database, a semantic parsing and intention decomposition unit, a task process tree generation unit, and an agent construction unit; multiple function modules that perform a single function are stored in the module database at fixed positions, and each function module is connected to the adjacent stored function module; there are at least N function modules with the same function, and N is a set value; the semantic parsing and intention decomposition unit is used to perform image language parsing on the natural language instructions input by the user, decompose the natural language instructions into multiple intention units with a sequential order, use each intention unit as an element in the vector, and construct an intention vector according to the sequential order of the intention units; the task process tree generation unit is used to generate corresponding multiple task process trees according to the intention vector; the agent construction unit is used to analyze all the task process trees, find the optimal task process tree, and call all the target function modules in the task process tree according to the order of the target function modules in the optimal task process tree to complete the construction of the agent.

[0033] Specifically, the principle of the module database is based on the modular, redundant storage, and structured connection of functional modules to achieve efficient module calls and task execution. Each functional module is an independent unit that implements a single function, such as data input, information processing, result output, etc. The module database adopts a fixed-position storage method, arranging and connecting these functional modules according to their logical relevance, making the call path of the modules deterministic and predictable. The advantage of this storage method is that when the intelligent agent construction unit accesses the module database according to the task flow tree, it can quickly find the target functional module without additional index calculation or complex path search, thereby significantly reducing the latency of task execution.

[0034] In addition, to enhance the stability of the system, there are multiple redundant versions of each functional module in the module database. The design of multiple versions mainly takes into account the possible problems of module call failure or resource competition in actual application scenarios. By introducing redundant modules, the system can dynamically switch to alternative modules when the main module cannot be normally called, achieving seamless recovery of tasks. Taking the construction of an agent as an example, if a certain task flow tree needs to call the "semantic analysis module", but the main module fails due to resource occupation or calculation errors, the system can immediately select other redundant modules for replacement to ensure the continuity of the task. This design greatly improves the fault tolerance and robustness of the platform, enabling the entire system to remain stable when facing high-concurrency tasks or sudden failures. There is a structured connection between the functional modules in the module database. This connection is not random, but is designed based on the relevance of module functions and task logic. The direct connection between adjacent modules not only provides an efficient call path for the task flow tree, but also makes it possible to dynamically adjust the task flow. For example, when the task flow tree analysis finds that the execution time of a certain module call is long or the computational load is too high, the system can re-plan the process through the module connection path and select another more efficient path to complete the task. This flexibility stems from the tight coupling between modules in the module database and the efficient data interaction mechanism. Different from traditional modular design, the module database also plays the role of implicit knowledge in the zero-code agent construction platform, that is, the module database is not only a collection of functions, but also an embedding point for task flow rules. For example, each functional module contains the specifications of its inputs and outputs, as well as the interface definitions with other modules when stored. This standardized design makes the combination between modules more concise and clear, thus realizing the dynamic generation of agents. Users only need to provide high-level natural language instructions, and the module database can quickly determine the functional modules required for the task and complete the call in logical order under the guidance of the semantic parsing and intention decomposition unit, avoiding the complex code writing and module configuration processes in traditional development. Another key function of the module database is to support dynamic expansion and hot update. As business requirements change, new functional modules can be directly added to the database without interrupting the operation of the existing system. This dynamic expansion ability enables the zero-code agent construction platform to quickly adapt to new scenarios and new requirements, maintaining its competitiveness in technological evolution. At the same time, the hot update function of the module database ensures that the maintenance and optimization of modules can be completed during operation. For example, when the algorithm of a certain functional module is improved, only need to update it to the module database, and the system can automatically identify and preferentially call the latest version to further improve the intelligence level of the platform.

[0035] When using the platform, the user only needs to input a natural language sentence, such as "Analyze this set of data and generate a bar chart". This unit will first perform syntactic and semantic parsing on the instruction, understand its true meaning in combination with the context, and gradually decompose it into a series of intention units with a clear logical order. The core of semantic parsing lies in understanding human language in a model-based way, including lexical analysis, syntax tree construction, semantic rule mapping, and context-dependent parsing. Through this process, the system can identify the main actions, target objects, and constraints contained in the user's instruction. For example, "Analyze" is the action, the data is the target object, and "generate a bar chart" constitutes the subsequent specific goal. After completing the semantic parsing, the intention decomposition unit will further decompose the parsed instruction into a set of intention units according to its logical level. Each intention unit represents an independent execution step in the instruction, with a clear execution goal and sequence. For example, "Analyze this set of data and generate a bar chart" can be decomposed into two intention units: "Data analysis" and "Generate a bar chart". There is an order relationship between these two units, that is, data analysis needs to be completed before generating the bar chart. To achieve this goal, the intention decomposition unit will use a pre-trained model (such as BERT or GPT) combined with the task context to transform the instruction into a high-dimensional vector representation. This vector representation is called an intention vector and is an important input for the system to generate the subsequent task process. Through the construction of the intention vector, the semantic parsing and intention decomposition unit maps complex natural language problems into structured data that can be processed by machines, thus completing the conversion of the user's language into the system's task logic.

[0036] It is worth noting that when processing user instructions, the semantic parsing and intent decomposition unit not only focuses on the surface meaning of a single instruction, but also needs to reason about and complete ambiguous or omitted expressions in combination with the context. For example, a user may input "Analyze the data first, and then draw a graph", where the specific data set and graph type are omitted in the instruction. In this case, the system needs to identify the implicit information in the user instruction through context reasoning, such as determining the specific data set involved in the current task, or judging the type of graph to be drawn based on the user's historical operation habits. After completing this reasoning, the system will automatically complete the missing parts so that the generated intent vector can completely describe the task logic. The principle of the semantic parsing and intent decomposition unit is also reflected in its ability to decompose complex instructions at multiple levels. In practical applications, the natural language input by users may not be a single task, but a complex logic with multiple levels and branches. For example, "Analyze data set A, then compare the results with data set B, and generate a report". This instruction can be decomposed into multiple intent units with nested relationships, including "Analyze data set A", "Analyze data set B", "Compare the two sets of results", and "Generate a report". This decomposition requires the system to have the ability to understand logical dependencies and the ability to judge task priorities. The semantic parsing and intent decomposition unit realizes the decomposition and encoding of complex instructions through a deep learning model combined with task tree generation rules, ensuring that each intent unit is independent and operable. Furthermore, the implementation principle of the semantic parsing and intent decomposition unit also incorporates a mechanism of real-time learning and dynamic adjustment. When a user inputs a new instruction, the system will update the language model in real time to adapt to the new semantic patterns. For example, a user may habitually use certain specific terms or phrases, and these expressions may be different from the training corpus of the conventional language model. Through the real-time learning mechanism, the system can dynamically adjust the weights of the model to better adapt to the user's language style and improve the accuracy of semantic parsing. At the same time, when the intent decomposition unit fails to parse or the result does not meet the user's expectations, it can further optimize the task decomposition process through interaction with the user, such as prompting the user to provide more details or automatically recommending possible task decomposition methods.

[0037] The task flow tree generation unit is a key component of the zero-code agent construction platform. It transforms the intent vectors generated by the semantic parsing and intent decomposition unit into the logical structure for agent task execution, providing a clear operation path for agent construction. Its core principle lies in using a graphical data structure - the task flow tree - to represent and organize the hierarchical, dependency, and execution order relationships among tasks, thus achieving efficient task planning and execution. The work process of the task flow tree generation unit starts with the parsing of intent vectors, which contain the task elements and their logical order in the user input instructions. By parsing the intent vectors, the task flow tree generation unit maps each intent unit to a node in the tree structure, and the connections between these nodes represent the dependency relationships of the intent units. Through this mapping process, the system can formalize the user's natural language instructions into an executable task model.

[0038] The process of generating the task flow tree not only focuses on the surface logic of intent units but also requires an in-depth understanding of the implicit dependency relationships among tasks. For example, when the user inputs a complex instruction such as "Analyze sales data, predict future trends, and generate a report", the task flow tree generation unit will identify the hierarchy and sequence of these tasks: data analysis is a prerequisite for prediction, and a report can only be generated after the prediction is completed. This hierarchical relationship is the basis for generating the task flow tree, enabling the system to correctly organize the order of tasks. The task flow tree generation unit ensures the logical consistency of the generated flow tree through dependency graph modeling techniques and the parsing of task constraint conditions. Each task node not only contains a description of the intent unit but also attaches the module information required for its execution, input-output constraints, and possible branching paths to support flexible task orchestration. During the process of generating the task flow tree, this unit also comprehensively considers the parallelism and dependency of tasks to optimize the execution efficiency. For example, for independent tasks, if there are no dependency relationships between them, the task flow tree generation unit can arrange them in parallel to save time costs. This parallelization ability is especially applicable to scenarios involving multi-module collaboration, such as data processing and chart generation can be carried out simultaneously without interfering with each other. However, when there are strong dependencies between tasks, the task flow tree generation unit will strictly arrange the execution order according to the dependency relationships to avoid errors or failures caused by task conflicts.

[0039] The innovation of the task flow tree generation unit also lies in its optimization ability. In many cases, the user's natural language instructions may result in the generation of multiple task flow trees. The task flow tree generation unit will analyze and optimize these candidate trees to select the optimal execution path. This optimization process is based on multi-dimensional evaluation criteria, such as execution time, resource consumption, and the reliability of module calls. Taking the task of "generating a report" as an example, the system may generate multiple implementation paths according to the available module versions, such as calling different chart generation modules or choosing different data processing methods. The task flow tree generation unit will evaluate the advantages and disadvantages of each path through cost function calculation and heuristic search algorithms, and select the task flow tree with the lowest cost and the highest execution efficiency as the final generation result. In addition, the task flow tree generation unit has the ability of dynamic adjustment. During actual operation, the execution environment of the task may change, such as module call failure or resource unavailability. At this time, the task flow tree generation unit can adjust the task flow tree in real time. By regenerating local subtrees or adjusting the task path, the system can ensure the stability and continuity of the entire process. This dynamic adjustment ability depends on the modular design of the task flow tree generation unit, and each node and edge can be updated independently without affecting the structure of the entire tree. This flexibility enables the zero-code agent construction platform to cope with complex task environments and provide reliable task execution guarantees. Another important function of the task flow tree generation unit is to support extensibility and reusability. In multi-task scenarios, the instructions of different users may involve similar tasks, such as data preprocessing or specific analysis logics. Through the mechanism of task templates, the task flow tree generation unit can quickly generate standardized process trees for these common tasks and make personalized adjustments according to the specific needs of users. This templated method of process tree generation not only significantly improves the speed of task generation but also reduces the workload of repeated modeling, demonstrating the efficiency of the zero-code development platform.

[0040] During the construction of the agent, this unit first parses the node information of the task flow tree and identifies the specific functional modules to be called for each task node. Since the module database adopts a redundant storage design for functional modules, when the agent construction unit makes module calls, it does not simply directly call the main module. Instead, based on the status and availability of the modules, it preferentially selects the module version with the highest execution efficiency or the least resource consumption. For some high-concurrency scenarios, the agent construction unit can also, according to the parallelization characteristics of the modules, simultaneously assign multiple task nodes in the flow tree to different modules for parallel calls, thus significantly improving the task execution efficiency. For example, in the task flow tree, if data preprocessing and preliminary analysis are two independent tasks, the agent construction unit can simultaneously schedule the corresponding functional modules to execute these two tasks and finally summarize the results to subsequent nodes, thereby reducing the overall execution time of the task. Another key function of the agent construction unit is the dynamic management of task logic. In actual execution, the logical path described by the task flow tree is not immutable. Module calls may be interrupted due to insufficient resources, execution failures, or input / output inconsistencies. At this time, the agent construction unit needs to monitor the execution status of the modules in real time and re-plan the task path according to the dynamic adjustment rules of the task flow tree. For example, when a functional module corresponding to a certain node fails, the agent construction unit will quickly call the redundant module in the module database to complete the replacement operation and update the status of the task flow tree at the same time, so that the entire task flow can continue to execute. This dynamic management ability depends on the real-time monitoring of the flow tree by the agent construction unit and the efficient access to the module database, reflecting the high fault tolerance and robustness of the platform.

[0041] To further optimize the agent construction process, this unit also dynamically adjusts the module call strategy through real-time analysis of task execution. For example, for complex multi-stage tasks, the agent construction unit will optimize the module call order and allocation strategy by combining the structure of the task flow tree and the execution performance of task nodes. In some scenarios, the user's task requirements may require cross-module data flow, such as from the data collection module to the analysis module and then to the report generation module. The agent construction unit realizes efficient data sharing and transfer between modules by constructing a unified task context, avoiding execution delays caused by data inconsistency or repeated loading. The management of the context is a major technical highlight of the agent construction unit. By standardizing the input and output of each task node, the system can ensure data compatibility and operation continuity between module calls. The principle of the agent construction unit is also reflected in the automated generation ability of the agent. Traditional agent construction usually requires users to define the logic process, call API interfaces, and write configuration files by themselves. However, in the zero-code agent construction platform, the agent construction unit completely hides these cumbersome operations from the user's view. Through the complete parsing of the task flow tree and the seamless scheduling of modules, the system can complete the construction of the agent with little manual intervention. Taking the user input "analyze financial data and generate a trend chart" as an example, the agent construction unit will sequentially call the data loading module, data cleaning module, analysis module, and chart generation module from the database according to the flow tree, and finally output the results required by the user. In this process, the user does not need to understand the underlying implementation details, and the entire construction and operation of the agent are completely automated.

[0042] Embodiment 2: The update process of the module database specifically includes: If any functional module in the module database needs to be deleted, directly put the functional module into permanent sleep; If a functional module needs to be added to the module database, directly add and store the functional module in any idle position in the module database and connect it to other adjacent functional modules.

[0043] Specifically, when deleting a function module, the system adopts a strategy of permanent dormancy rather than direct deletion. This design concept fully considers the traceability of the module database and the fault tolerance of the system. Permanent dormancy means that the module marked for deletion is not physically cleared but logically disabled. The advantage of this approach is that if the subsequent task flow tree accidentally attempts to call this module, the system can detect it in time and take remedial measures, such as automatically replacing it through redundant modules, to avoid task interruption caused by module deletion. At the same time, permanent dormancy also facilitates the possible future restoration of the module. Users or system administrators can reactivate the module when needed without having to redevelop or redeploy it. In addition, the permanent dormancy mechanism has a low technical implementation cost. It only needs to mark the module status as "dormant" or "disabled" without involving complex storage operations, thus maintaining the stability and efficiency of the module database. When adding a new function module, the design of the module database is more flexible. The new module is directly stored in any available space in the module database, avoiding common problems such as index reconstruction or storage structure adjustment in traditional databases. This storage method reflects the decentralized design of the module database. The logical connection between function modules is achieved through the direct association of adjacent modules without relying on fixed positions or global indexes. This mechanism is very efficient in technical implementation: when a new module is added, the system automatically detects the available space in the database, stores the module in that space, and connects it to adjacent modules according to logical requirements. The connection method can be determined through preset interface specifications and dependencies between modules, enabling the new module to seamlessly integrate into the existing module network.

[0044] This dynamic insertion mechanism also provides technical support for the scalability of the module database. In practical applications, the zero-code intelligent agent construction platform may need to frequently update the module database to cope with the emergence of new scenarios or new requirements. For example, users may want to add a data analysis module to support the latest algorithms or processing capabilities. At this time, the new module can be quickly inserted into the module database and be immediately available without the need to shut down or reconfigure the system. Through connection with adjacent modules, the new module can quickly integrate into the generation and execution processes of the task flow tree, ensuring that the task scheduling ability and execution efficiency of the entire system are not affected. From the perspective of technical implementation, the storage and connection of new modules need to solve two core problems: one is the matching problem of the input and output interfaces of the module, and the other is the parsing problem of the dependencies between the new module and the existing modules. The module database ensures the compatibility of the interfaces of new modules with adjacent modules through standardized interface definitions and module metadata management. Each module records its function description, input and output specifications, and possible dependencies when stored. When a new module is inserted, the system automatically parses its dependencies with adjacent modules and generates connection rules to enable smooth data flow and function calls between modules.

[0045] Embodiment 3: The process of the task flow tree generation unit generating any task flow tree specifically includes: finding all the functional modules corresponding to each intention unit in the intention vector in the module database as the target functional modules of each intention unit; each functional module includes a keyword set for matching the intention unit; in the keyword set, each keyword is represented by a feature code, and each intention unit is also a code; for each intention unit, forming a set of all the corresponding target functional modules as the target functional module set of this intention unit; arbitrarily selecting a target functional module from each target functional module set and connecting the target functional modules in other target functional module sets in the order of the intention units to generate a corresponding target task tree; during the connection process, if the functional module adjacent to the target functional module is not a target functional module, then this functional module is put into a dormant state and grayed out.

[0046] Specifically, in the process of generating the task flow tree, the first step is to parse each intention unit in the intention vector and find all the corresponding target functional modules in the module database. Each functional module contains a keyword set, and these keywords are abstract descriptions of the module functions. The system matches the intention unit code with the feature codes in the module keyword set to identify all the modules that can implement the function of this intention unit. This matching method is essentially a semantic mapping operation. The keyword set expresses the function of the module through the feature code, while the code of the intention unit reflects the requirements in the user instruction. Through this matching, the system can quickly screen out the functional modules that meet the requirements from the module database, thereby generating a target functional module set for the intention unit. After the target functional module set is determined, the system organizes the target functional module sets of each intention unit in sequence to gradually generate a task flow tree. The generation process of the task flow tree needs to consider the logical connection between modules and the order of intention units. For each intention unit, select a functional module from the target functional module set and connect it with the target functional modules of other intention units in the order of the intention units. Such a design ensures that the task flow tree can faithfully reflect the logical structure of the user instruction. At the same time, the flexibility in selecting the target functional module (i.e., "arbitrarily select") provides the possibility for generating diverse task flow trees, and this diversity provides a basis for subsequent process tree optimization and the selection of the optimal task path.

[0047] During the connection process of the task flow tree, the system also needs to dynamically adjust the status of function modules to ensure the clarity of the process and the efficiency of execution. Specifically, if the function modules adjacent to the target function module are not the target function modules required for the current task, these irrelevant function modules will be marked as "dormant and grayed out". "Dormant and grayed out" is a logical disabling operation, which means that these modules will not be activated or called in the current task flow, but they still remain in the module database for use when subsequent task requirements arise. This design not only ensures the simplicity of the task flow tree but also avoids problems such as changes in the module database structure or breaks in the task dependency chain caused by physically deleting modules. This embodiment also has important technical features and advantages. First, through the matching of the module keyword set with the feature encoding of the intention unit, the system realizes a fast mapping from the user's natural language instructions to function modules. This mapping mechanism can tolerate a certain degree of ambiguity or diversity in the user input, making the platform more accurate and robust in understanding the user's intention. Second, the construction process of the target function module set supports the redundant invocation of modules. By selecting one from multiple alternative function modules for connection, the system realizes the flexibility of module selection and the diversification of task flows. Especially in the face of resource-constrained or high-concurrency scenarios, this flexibility provides more possibilities for system performance optimization. In addition, the dynamic adjustment ability of the task flow tree generation unit during module connection is also a highlight. When non-target function modules are dormant and grayed out, the structure of the task flow tree is simplified, avoiding resource waste or execution delays caused by unnecessary module invocations. This dynamic adjustment ability not only improves the execution efficiency of the task flow tree but also enhances the fault tolerance of the system. For example, if a certain target function module fails during execution, the system can select another module from the corresponding target function module set as a replacement to ensure the continuity of the task flow. From the overall system architecture, the task flow tree generation process in Embodiment 3 lays a solid foundation for the automation and intelligence of the zero-code agent construction platform. It seamlessly connects the module database with the intention vector, transforms the user's high-level requirements into low-level execution logic, and optimizes the executability and efficiency of the task flow through mechanisms such as dormant and graying out. This design not only simplifies the construction process of complex tasks but also improves the system's adaptability to diverse application scenarios, providing highly flexible and reliable agent construction support for users.

[0048] Embodiment 4: The agent construction unit analyzes all the task flow trees, and the process of finding the optimal task flow tree includes: regarding the task flow tree with the fewest dormant and grayed-out function modules as the optimal task flow tree.

[0049] Specifically, during the generation of the task flow tree, different task flow trees may contain multiple paths or implementation methods, which correspond to different functional module call sequences and resource usage situations. Since the module database contains a large number of functional modules, and these modules may have redundant connections or be marked as dormant and grayed out, the number of dormant and grayed out modules in the task flow tree becomes an important indicator to measure its optimization level. Dormant and grayed out modules represent modules that are logically disabled but physically present in the current task flow. Although they do not directly participate in task execution, their existence may cause unnecessary complexity or resource redundancy in the module database. Therefore, minimizing the number of dormant and grayed out modules not only simplifies the structure of the task flow tree but also improves the accuracy of resource allocation and the efficiency of overall task execution. When analyzing the task flow tree, the agent construction unit will comprehensively scan each tree, count the states of all nodes (i.e., functional modules) in it, and record the number of dormant and grayed out modules. This counting process is not a simple counting operation but combines the parsing of task logic and the dynamic judgment of module states. For example, a certain module may be dormant and grayed out due to the current task logic, but in a specific scenario (such as fault recovery or dynamic adjustment), it may participate in execution again. Therefore, the agent construction unit also needs to consider the potential usage possibilities of modules during the counting process to ensure the comprehensiveness and accuracy of the counting results.

[0050] Among all the task process trees, the agent construction unit selects the optimal task process tree with the goal of minimizing the number of dormant and grayed-out modules. This selection strategy has important practical significance. First of all, minimizing the number of dormant and grayed-out modules can directly reduce the redundant consumption of the system during task execution. For example, in a task process tree, if a certain branch path contains a large number of dormant and grayed-out modules, then this path may contain unnecessary complex logic or resource occupancy, and these logics and resources do not bring any benefits to the current task. By selecting the task process tree with the fewest dormant and grayed-out modules, the system can avoid the invocation of invalid paths and use more computing and storage resources for actual task execution, thereby improving the overall performance. Secondly, this strategy can enhance the certainty and reliability of task execution. When the number of dormant and grayed-out modules decreases, the structure of the task process tree becomes clearer, and the call path of the modules becomes more stable, thus reducing the potential error risk caused by path complexity. For example, in a high-concurrency scenario, fewer dormant and grayed-out modules mean that the invocation of functional modules in the task process is more concentrated, the possibility of resource competition is reduced, and the system can complete tasks with higher efficiency. It should be noted that the optimization process of the agent construction unit is not limited to the selection of a single task process tree, but also has dynamic adaptability. During actual operation, the task environment may change, such as the update of module status, the dynamic allocation of resources, or the adjustment of user requirements. At this time, the agent construction unit can re-analyze all task process trees and, based on the optimization principle of the number of dormant and grayed-out modules, adjust the selection of the optimal task process tree in real time. This dynamic adjustment ability enables the zero-code agent construction platform to maintain high efficiency and stability in a changing operating environment.

[0051] Embodiment 5: The method for the semantic parsing and intention decomposition unit to perform image language parsing on the natural language instruction input by the user and decompose the natural language instruction into multiple intention units with a sequential order specifically includes: obtaining an image containing the natural language instruction, analyzing the fractal geometric feature vector of the image, and constructing a multifractal spectrum; based on the multifractal spectrum, constructing a dynamic topological structure vector of the strokes; constructing a high-dimensional feature space vector according to the multifractal spectrum and the dynamic topological structure vector; mapping the high-dimensional feature space vector into a discriminant manifold space to obtain a discriminant manifold vector; performing a transformation based on the prior probability on each element in the discriminant manifold vector to obtain the corresponding intention unit.

[0052] Specifically, first, the method starts with obtaining images containing natural language instructions. These images may be sourced from scanned copies of user handwritten instructions, picture uploads, or even real-time handwritten input. The system analyzes the fractal geometric features of the images to extract fractal geometric feature vectors that reflect the shape, structure, and distribution patterns of the text. Fractal geometric features can capture the subtle structures and complex variations in the text within the images, and this information far exceeds the parsing ability of traditional optical character recognition (OCR) technology for simple character shapes. For example, the fractal geometric feature vector can capture the differences in stroke thickness changes, writing speed, and its continuity in user handwritten input, thus providing more refined data support for subsequent task logic modeling. After extracting the fractal geometric features, the system further constructs a multifractal spectrum. The multifractal spectrum is a mathematical tool that reflects the non-uniformity in the distribution within the image. It describes the global and local complexities of natural language instruction images through changes in the distribution dimension. Through the multifractal spectrum, the system can extract hidden patterns of semantic information from the image, such as the arrangement of text strokes and the changing trends of shapes. This process provides global context information for image language parsing, enabling the system to understand complex handwritten text inputs or image instructions with a certain degree of ambiguity. Next, the system constructs a dynamic topological structure vector for the strokes based on the multifractal spectrum. The dynamic topological structure vector of the strokes captures the geometric connectivity and spatial distribution relationships in the image. By describing the relative positions and interactions between text strokes, it further refines the semantic level of image language parsing. For example, the stroke order of a Chinese character can be accurately modeled through the dynamic topological structure vector, enabling the system to not only parse the appearance of the text but also understand the logical order of text writing. This ability is particularly important in handwritten input or non-standard font parsing because there may be significant differences in the writing styles of users, and traditional OCR methods often perform inadequately in these scenarios. Based on the above, the system combines the multifractal spectrum and the dynamic topological structure vector to further construct a high-dimensional feature space vector. The high-dimensional feature space vector is a comprehensive expression of image language information. It integrates the global features and local features of the image and describes the structure of natural language instructions in a highly abstract way. This vector space provides a rich information basis for subsequent semantic parsing and intention decomposition of the system. By mapping the high-dimensional feature space vector to a discriminative manifold space, the system can further extract significant semantic patterns in natural language instructions. The discriminative manifold space is a low-dimensional embedding space that retains the discriminative information related to the task in the high-dimensional feature space while removing redundant features and noise. For example, a complex sentence can be disassembled into multiple key phrases and action words through manifold mapping, thus greatly improving the efficiency and accuracy of semantic parsing. Finally, the system performs a transformation based on prior probabilities on each element in the discriminative manifold vector to generate corresponding intention units.This process comprehensively utilizes the semantic information in the manifold vector and the task background knowledge, gradually parsing complex natural language instructions into structured intent units with a logical order. For example, for a handwritten input instruction like "Analyze this set of data and then generate a bar chart", the system will identify two main intent units, "Analyze data" and "Generate a bar chart", from the fractal features and topological structure of the image, and organize them in sequence. These intent units are then input into the task flow tree generation unit to construct a task logic that meets the user's requirements.

[0053] Example 6: Through the following formula, obtain an image containing natural language instructions, analyze the fractal geometric feature vector of the image, and construct a multifractal spectrum:

[0054] ;

[0055] where is the integration region, representing the region of the image; is the fractal order parameter, which is a set value; is the time scale parameter, which is a set value; is the space curvature parameter, which is a set value; is the th observation window size at a scale; is the gray value of the input image at the position; is the coordinate on the X-axis; is the coordinate on the Y-axis; is the integer subscript index; is the number of scales; is the multifractal spectrum.

[0056] Specifically, in this formula, each part of the input image is represented as a gray-scale distribution function , which takes the pixel position as the independent variable. Through the analysis of the fractal characteristics of the image, the formula aims to reveal the law of the gray value changing with space. This analysis realizes the global observation of the entire image through the definition of the integration region , while also retaining the detailed features of the local region. In the fractal analysis, the introduction of the multi-scale observation window is one of the cores of the formula. The sizes of these windows control the accuracy of the system analysis. Smaller windows capture detailed changes, while larger windows reveal the overall structure of the image. Through the step-by-step analysis at multiple scales, the formula can establish a connection between the global and the local, and accurately quantify the complexity of the image. The numerator part of the formula , by integrating the th power of the gray value difference, extracts the gray value change characteristics of the image at different scales. The parameter is a fractal order parameter used to adjust the sensitivity to different ranges of gray-scale variations. For example, when is small, the formula pays more attention to minute gray-scale fluctuations, which helps capture subtle stroke differences in handwritten text; while when is large, the formula emphasizes significant gray-scale changes, such as character boundaries or prominent stroke features. The integral result accumulates the gray-scale change characteristics across the entire image area, thus providing a preliminary quantitative description of the fractal geometric properties.

[0057] Meanwhile, the denominator part of the formula introduces a normalization and scale adjustment mechanism. Among them, is the time scale parameter, is the spatial curvature parameter, and they jointly adjust the sensitivity of the fractal spectrum to different scale and dimensional features. The time scale parameter emphasizes the dynamic characteristics of gray-scale changes in the image, similar to describing the change rate of the image; while the spatial curvature parameter captures the non-linear characteristics of the gray-scale values with respect to the spatial distribution, reflecting the overall geometric complexity of the image. This normalized design ensures the robustness of the formula, enabling it to maintain consistent feature extraction results on images of different sizes and resolutions. The final output of the formula is the multifractal spectrum , which, by considering different and Analysis of values generates a series of feature points, which form a curve that can reflect the complexity and inhomogeneity of the image. The fractal spectrum not only expresses the static features of the image but also reveals the dynamic behavior of the gray-scale changes in different regions of the image. For example, in an image containing natural language instructions, the fractal spectrum can clearly distinguish the dense part from the sparse part of the characters, providing fundamental support for the subsequent construction of dynamic topological vectors. The multi-scale characteristics of the fractal spectrum also enable it to exhibit higher precision and adaptability when dealing with blurred or handwritten text. The application of this formula in the zero-code agent construction platform greatly expands the platform's adaptability to diverse inputs. Traditional text parsing techniques often rely on structured inputs, such as standardized digital text or high-quality printed characters. However, in actual application scenarios, the natural language instructions input by users may exist in the form of pictures, including handwritten inputs, screenshots, or scanned copies. These input forms often have blurred and irregular features, making it difficult for traditional techniques to accurately parse them. The formula based on fractal geometry extracts features from the multi-scale changes of the image, making up for the deficiencies of traditional methods. It can not only accurately capture the complex geometric information in the image but also reveal hidden semantic patterns through the fractal spectrum. For example, when a user inputs the instruction "Analyze sales data and generate a bar chart" in a handwritten form, this formula can decompose the input image into a gray-scale value matrix, construct a fractal spectrum through multi-scale integration and normalization operations, and thus extract geometric features related to "Analyze", "sales data", and "bar chart". Subsequently, these features can be mapped into a discriminant manifold space and further decomposed into structured intention units. This parsing process not only overcomes the ambiguity of handwritten inputs but also understands the context of the input by capturing writing features (such as stroke order or intensity), providing an accurate basis for the generation of the task flow tree.

[0058] Example 7: Based on the multi-fractal spectrum, construct a dynamic topological structure vector of strokes through the following formula :

[0059] ;

[0060] where is the value that maximizes ; is the highest curvature order; is the integer subscript index; is 's gradient; is the imaginary symbol; is the curvature characteristic scale of the th order, which is a set value with a value range of 0.5 to 0.9; is the regional integral differential element; is the characteristic angle, with a value range of 10 to 30 degrees.

[0061] Specifically, in the formula represents the overall calculation performed over the integration region . This region typically covers the entire image or the part of the image related to the target text. By cumulatively calculating the pixel characteristics within this region, the formula can capture the geometric characteristics of the strokes globally and locally, providing a comprehensive mathematical description for the construction of the dynamic topological structure vector. The first important component of the formula is the multifractal spectrum , where is the value that maximizes . This indicates that the formula particularly focuses on the regions in the image that best reflect the fractal characteristics, i.e., those with the highest geometric complexity. This selection can highlight the regions with the most drastic changes in the strokes, such as inflection points, intersections, or sharp changes at the edges. Combining , which is the gradient of the image grayscale value, the formula further captures the direction and magnitude of the grayscale distribution changes. The gradient is an important feature in image analysis, which directly reflects the direction and intensity of pixel value changes, thus enabling precise localization of the edges and details of the strokes.

[0062] The formula contains the complex form , where is a characteristic angle, with a value range of 10 to 30 degrees. By introducing this complex form, the formula can not only capture the amplitude changes of the strokes but also reflect their directional characteristics. This processing method is very suitable for modeling complex handwritten text because the direction and angle of handwritten strokes often contain rich semantic information. For example, in some characters, strokes in specific directions may have important discriminative features, and the representation in complex form can effectively encode these features. The denominator part of the formula is the normalization of the second derivative of the multifractal spectrum. This part emphasizes the rate of change of the multifractal spectrum at different values, thereby capturing the subtle differences in the fractal characteristics of the strokes. By introducing the denominator into the sum of squares and normalization, the formula smooths the interference of high-frequency noise on feature extraction, making the dynamic topological structure vector more robust and stable. Another key part in the formula is , which introduces the curvature characteristics of the strokes into the modeling process. Among them, represents the curvature of the stroke at the th order, is the corresponding characteristic scale, with a value range from 0.5 to 0.9. The design of this part enables the formula to capture the multi-order curvature characteristics of strokes. Especially at inflection points or curved regions where high-order curvature characteristics are significant, the formula can effectively describe their geometric features. Curvature characteristics are particularly important in stroke analysis because they can distinguish different types of strokes such as straight lines, arcs, and sharp corners, thus providing support for the precise representation of text morphology. The finally output dynamic topological structure vector is a comprehensive expression of all the above features. It integrates fractal characteristics (through ), gradient direction (through ), and curvature information (through ) to form a high-dimensional vector. This vector can comprehensively describe the geometric structure, dynamic changes, and spatial distribution of strokes, providing high-precision feature support for semantic analysis and intention decomposition in the zero-code agent construction platform. At the application level, this formula provides a powerful tool for parsing complex natural language instruction images. For example, for a handwritten instruction "Generate a trend chart of sales data", the formula can extract the stroke structure of each character from the image and accurately describe the geometric shape and writing characteristics of the strokes through the dynamic topological structure vector . These vectors can then be matched with the function module keywords in the module database to complete the semantic mapping from the instruction to the function module.

[0063] Example 8: Construct a high-dimensional feature space vector according to the multifractal spectrum and the dynamic topological structure vector through the following formula:

[0064] ;

[0065] where, is the high-dimensional feature space vector; is the coordinate of the first coordinate axis in the high-dimensional feature space; is the coordinate of the second coordinate axis in the high-dimensional feature space; is the resolution parameter of the high-dimensional feature space; is order Bessel function.

[0066] Specifically, the input of the formula includes the multifractal spectrum and the dynamic topological structure vector , which respectively capture the global geometric characteristics and local stroke structures of the image. The fractal spectrum reveals the self-similarity and complexity of the character structure by modeling the changes in image gray values at multiple scales; the topological structure vector further describes the dynamic connection relationships of character strokes. By combining these two parts of information, the formula can generate a high-dimensional vector with rich semantic features from both the global and local dimensions. The first term in the formula is the core feature coupling mechanism. The dynamic topology structure vector provides a basic description of the stroke morphology, while the mixed second-order partial derivative of the fractal spectrum reveals the complexity of the fractal spectrum changing with parameters and simultaneously. Through the determinant operation, this part of the features is condensed into a scalar value, which is used to express the mutual dependence of the characters in terms of geometric characteristics and local connectivity. This coupling method can capture the complex interaction relationships between strokes and the dynamic changes of the overall structure formed by different strokes in the natural language instruction image. The second term is the distribution regulation factor in the high-dimensional space, where is the resolution parameter, which is used to control the diffusion degree of the features in the high-dimensional space. The design of this part comes from the idea of the Gaussian distribution, aiming to ensure the continuity and consistency of the density and distribution of the features in the high-dimensional feature space. Through this term, the formula can effectively avoid the analytical problems caused by the features being too sparse or too concentrated, making the generated high-dimensional feature vector both expressive and smooth and stable in the high-dimensional space. The third term is the introduction of the -order Bessel function, which further enhances the expression ability of the high-dimensional feature vector for complex stroke structures. The Bessel function is a special function widely used in describing wave and vibration phenomena. In this formula, it captures the periodic changes of the stroke morphology and connection relationship through radial symmetry. By calculating the square root of the sum of the squares of and , the Bessel function can describe the geometric center distribution of different characters and strokes in the natural language instruction image. This feature extraction method is particularly suitable for processing structures with circularity or symmetry, such as the closed circular structures in some letters or symbols.

[0067] The overall formula accumulates the above feature components in through double integral and in two dimensions. The integral region represents the range of the high-dimensional feature space, which may cover the feature distribution of the entire character or be limited to certain specific local regions. The result of the double integral is a high-dimensional feature vector used to represent the semantic characteristics of natural language instruction images in a high-dimensional space. Through this high-dimensional vector, the system can map the features to a discriminative manifold space in subsequent processing to further extract intention units. Example 8 deeply integrates the global geometric information of the fractal spectrum with the local dynamic information of the topological structure, achieving a seamless conversion from natural language images to a high-dimensional feature space. This conversion can capture the diverse stroke styles and geometric relationships in handwritten instruction images, thereby enhancing the input adaptation ability of the platform. Secondly, through the combination of the Gaussian distribution and the Bessel function, the formula ensures that the distribution of high-dimensional features is both continuous and geometrically consistent, laying a solid foundation for subsequent feature discrimination and classification. In application scenarios, the function of this formula is particularly prominent. Suppose a user inputs a piece of instruction by handwriting, such as "Analyze the sales data and generate a line chart". The formula will first extract the stroke structure of each character in the image and generate a high-dimensional feature space vector through the combination of the dynamic topological vector and the fractal spectrum . This high-dimensional feature space vector can not only accurately describe the geometric structure of the text but also reveal the logical relationship between characters, providing high-quality input data for the intention decomposition unit

[0068] Example 9: Through the following formula, map the high-dimensional feature space vector to the discriminative manifold space to obtain a discriminative manifold vector

[0069] ;

[0070] where is a harmonic function in the discriminative manifold space is the F-norm operation is the absolute value operator is the th component of the manifold coordinate system is the characteristic scale of the th component of the manifold coordinate system, which is a set value

[0071] Specifically, the first part of the formula is an input vector generated from the high-dimensional feature space. It has been modeled through the multifractal spectrum and the dynamic topological structure and contains the global geometric features and local connection relationships in natural language images. On this basis, the formula further geometrically optimizes the high-dimensional features to generate a more discriminative feature vector. The introduced in the formula is a key geometric regulation term. Here is the Frobenius norm of the dynamic topological structure vector , which represents the square root of the sum of the squares of all elements in the vector and is a measure of A scalar value of size. Calculating its derivative with respect to the angle captures the rate of change of the topological structure vector in the direction. Subsequently, through taking the logarithmic function and absolute value operation, the formula amplifies the features with significant changes while suppressing the smaller or insignificant features. The design of this part can highlight the key stroke direction information in natural language images, such as the edges, inflection points, and intersections of characters, thus providing strong geometric support for the discrimination of intentions. The second part of the formula is an orthogonal adjustment term in the manifold space, where and are the -th component and its characteristic scale in the manifold coordinate system respectively. Through the introduction of the hyperbolic cosine function , this part non-linearly adjusts the feature distribution in the manifold space. The hyperbolic cosine function has the property of smooth growth, which can effectively suppress the components of features that are too large or too small, making the distribution of the vector more uniform and avoiding information imbalance caused by some feature components being too strong. At the same time, the set value of regulates the feature scale, enabling the components of different dimensions to be reasonably expressed in the same space. The last part of the formula is a harmonic function in the manifold space. Harmonic functions are a class of special functions that satisfy the Laplace equation. They are geometrically smooth and symmetric, which can optimize the feature distribution in the manifold space and further enhance the expression ability of the vector . In practical applications, the harmonic function can also play a role in regularization, avoiding the vector from overfitting the noise in high-dimensional features. The overall result of the formula is to generate the discriminant manifold vector , which is the feature expression in the discriminant manifold space and has higher discriminability and compactness. Through the geometric optimization of , the formula projects the high-dimensional features into a low-dimensional but discriminative manifold space, thus retaining the core semantic information of natural language images and removing redundant features and noise. In this way, the manifold vector It can be directly input into the subsequent intention decomposition unit or task logic generation unit to complete the key transition from image input to task parsing. Through the Frobenius norm calculation and derivative value extraction of the dynamic topological structure vector, the formula can extract the most significant geometric changes from high-dimensional features, especially suitable for capturing the directional features in natural language instructions. This optimization method overcomes the curse of dimensionality problem that easily occurs in traditional high-dimensional feature vectors, making the generated manifold vector not only compact but also have strong discrimination ability. Secondly, the formula combines the hyperbolic cosine function and the smooth harmonic function to reasonably distribute the feature components in the manifold space. This design avoids information loss caused by uneven feature distribution and enhances the discrimination ability of the vector between different intention units. For example, in a complex natural language image containing multiple instructions, the strokes of different characters may overlap or be blurred. This optimization mechanism can accurately separate the intention features with independent semantics from them, providing support for multi-task decomposition. In practical applications, assume that the user inputs a handwritten image, such as "Analyze data and generate a trend chart". The formula extracts global and local features through high-dimensional feature vectors and then generates a vector through discriminative manifold mapping . This vector can not only distinguish the two main tasks of "Analyze data" and "Generate a trend chart", but also capture the semantic features of each task, providing high-quality input for subsequent module matching and task logic generation.

[0072] Example 10: Through the following formula, each element in the discriminant manifold vector is transformed based on the prior probability to obtain the corresponding intention unit:

[0073] ;

[0074] where is the th intention unit; is the prior probability of a Gaussian distribution with both mean and variance being ; is 's gradient; is the th element in the discriminant manifold vector.

[0075] Specifically, the first part of the formula is the gradient-driven feature parsing term . In this part, represents the gradient of the th element in the discriminant manifold vector, directly reflecting the 's change rate and direction in the manifold space. This gradient captures the relationship with Related geometric features, such as mutation points or direction changes in character structures. This local geometric feature is particularly important for semantic discrimination of intent units because it can accurately locate certain image areas with special meanings. At the same time, the formula is The determinant operation further extracts the high-dimensional feature space vector The calculation of the determinant of this second-order derivative reflects the nonlinear changes in the feature space and is used to supplement the details that may be missed in the gradient information. For example, in some complex natural language instructions, the subtle curvature changes of character strokes may be important for semantic discrimination. By combining the gradient and curvature characteristics, the formula can comprehensively capture the geometric information of natural language images and generate a more complete semantic expression. The second part of the formula is a contrast suppression term used to weaken the contribution of features irrelevant to the intent. and plural forms It captures the local changes and directional information of grayscale values in natural language images. This part of the features may contain interference factors, such as local irregularities or noise of handwritten characters. By subtracting these interference factors, the formula can focus on the key features related to the intent during the discrimination process.

[0076] The most important thing is the prior probability term in the formula , which is a value with mean and variance The Gaussian distribution of is used to introduce statistical information to enhance the robustness of intent discrimination. Prior probability The introduction of has important statistical significance: it combines prior knowledge and observed data, so that the discrimination results of intent units can adapt to data characteristics and avoid overfitting to a certain extent. For example, for intent units with higher frequencies, the distribution tendency of prior probability will give them higher weights, thereby ensuring that these common intent units have higher confidence in the discrimination process. The formula as a whole is maximized through a By integrating the above parts, the transformation from discriminant manifold vector to intention unit is realized. The goal of the maximization process is to find a , so that the value of the formula reaches the maximum, that is, select an intention unit that can most accurately represent the current discriminant feature. This process not only integrates geometric information (gradient and curvature), statistical information (prior probability) and dynamic characteristics (feature change rate), but also effectively eliminates interference through feature comparison, ensuring the accuracy of intention unit discrimination. The formula of Example 10 is of great practical significance in the zero-code intelligent agent construction platform. For example, when a user inputs a handwritten instruction image "Generate a line graph to analyze sales data", the formula can be used through the manifold vector Element-by-element parsing is performed to extract geometric features related to "generating a line chart" and "analyzing sales data", and prior probabilities are used to semantically discriminate these features, ultimately generating two independent intent units and . These intent units can then be input into the task flow tree generation unit for constructing task logic. The technical advantage of the formula lies in its ability to jointly model multiple features. Through the integration of gradients, curvatures, and prior probabilities, the formula can achieve high-precision discrimination of intent units in complex scenarios, especially performing excellently when dealing with blurred, handwritten, or irregular characters. In addition, the formula reduces the impact of interference information through the contrast suppression term, improving the robustness of overall discrimination. This characteristic enables the platform to efficiently adapt to diverse natural language image inputs and meet the complex needs of users.

[0077] Although the specific embodiments of the present invention have been described above, those skilled in the art should understand that these specific embodiments are merely illustrative. Without departing from the principles and essence of the present invention, those skilled in the art can make various omissions, substitutions, and changes to the details of the above methods and systems. For example, combining the above method steps so as to perform substantially the same function in a substantially the same way to achieve substantially the same result falls within the scope of the present invention. Therefore, the scope of the present invention is only defined by the appended claims.

Claims

1. A zero-code agent construction platform, characterized in that, It includes: A module database, a semantic parsing and intention decomposition unit, a task flow tree generation unit, and an agent construction unit; in the module database, multiple functional modules that perform single functions are stored at fixed positions, and each functional module is connected to the adjacent stored functional modules; there are at least N functional modules with the same function, where N is a set value; the semantic parsing and intention decomposition unit is used to perform image language parsing on the natural language instructions input by the user, decompose the natural language instructions into multiple intention units with a sequential order, use each intention unit as an element in a vector, and construct an intention vector according to the sequential order of the intention units; The task flow tree generation unit is used to generate corresponding multiple task flow trees according to the intention vector; The agent construction unit is used to analyze all the task flow trees, find the optimal task flow tree, and call all the target functional modules in the optimal task flow tree according to the order of the target functional modules in the optimal task flow tree to complete the construction of the agent; The process of the task flow tree generation unit generating any one task flow tree specifically includes: finding all the functional modules corresponding to each intention unit in the intention vector in the module database as the target functional modules of each intention unit; each functional module includes a keyword set for matching the intention unit; in the keyword set, each keyword is represented by a feature code, and each intention unit is also a code; for each intention unit, form a set of all the corresponding target functional modules as the target functional module set of the intention unit; arbitrarily select one target functional module from each target functional module set and connect it with the target functional modules in other target functional module sets according to the sequential order of the intention units to generate a corresponding target task tree; during the connection process, if the functional module adjacent to the target functional module is not a target functional module, then put the functional module into a dormant state and turn it gray; The method for the semantic parsing and intention decomposition unit to perform image language parsing on the natural language instructions input by the user and decompose the natural language instructions into multiple intention units with a sequential order specifically includes: obtaining an image containing natural language instructions, analyzing the fractal geometric feature vector of the image, and constructing a multifractal spectrum; based on the multifractal spectrum, constructing a dynamic topological structure vector of strokes; constructing a high-dimensional feature space vector according to the multifractal spectrum and the dynamic topological structure vector; mapping the high-dimensional feature space vector into a discriminant manifold space to obtain a discriminant manifold vector; performing a conversion based on the prior probability on each element in the discriminant manifold vector to obtain the corresponding intention unit.

2. The zero-code agent construction platform according to claim 1, wherein The update process of the module database specifically includes: if any functional module in the module database needs to be deleted, directly put the functional module into permanent dormancy; if a functional module needs to be added to the module database, directly add and store the functional module at any idle position in the module database and connect it with other adjacent functional modules.

3. The zero-code agent construction platform according to claim 2, characterized in that The agent construction unit analyzes all the task flow trees, and the process of finding the optimal task flow tree includes: taking the task flow tree with the fewest function modules with hibernation set to gray as the optimal task flow tree.

4. The zero-code agent construction platform according to claim 3, wherein Through the following formula, an image containing natural language instructions is obtained, the fractal geometric feature vector of the image is analyzed, and a multifractal spectrum is constructed: Among them, Ω is the integration region, representing the region of the image; q is the fractal order parameter, which is a set value; τ is the time scale parameter, which is a set value; γ is the spatial curvature parameter, which is a set value; ∈ i is the size of the observation window at the i-th scale; I(x, y) is the gray value of the input image at the position (x, y); x is the coordinate of the X-axis; y is the coordinate of the Y-axis; i is an integer subscript index; N is the number of scales; D(q, τ) is the multifractal spectrum.

5. The zero-code agent construction platform according to claim 4, wherein Through the following formula, based on the multifractal spectrum, a dynamic topological structure vector T of the stroke is constructed: where q * is the q value that maximizes D(q,τ); K is the highest curvature order; k is an integer subscript index; is the gradient of I(x,y); j is the imaginary symbol; λ k is the curvature characteristic scale of the k-th order, which is a set value, and the value range is from 0.5 to 0.9; dΩ is the regional integral element; θ is the characteristic angle, and the value range is from 10 to 30 degrees.

6. The zero-code agent construction platform according to claim 5, wherein Through the following formula, a high-dimensional feature space vector is constructed according to the multifractal spectrum and the dynamic topological structure vector: Among them, H(v, w) is a high-dimensional feature space vector; v is the coordinate of the first coordinate axis in the high-dimensional feature space; w is the coordinate of the second coordinate axis in the high-dimensional feature space; σ is the resolution parameter of the high-dimensional feature space; J n is the Bessel function of order n.

7. The zero-code agent construction platform according to claim 6, characterized in that, Through the following formula, the high-dimensional feature space vector is mapped into the discriminant manifold space to obtain a discriminant manifold vector: where Ψ is a harmonic function in the discriminant manifold space; ||·|| F is the F-norm operation; |·| is the absolute value operator; ξ t is the t-th component of the manifold coordinate system; η t is the characteristic scale of the t-th component of the manifold coordinate system, which is a set value.

8. The zero-code agent construction platform according to claim 7, characterized in that Through the following formula, each element in the discriminant manifold vector is transformed based on the prior probability to obtain the corresponding intention unit: Among them, L s is the s-th intention unit; P s is the prior probability of a Gaussian distribution with both mean and variance being s; is the gradient of M s ; M s is the s-th element in the discriminant manifold vector.

Images