Quick function interface development method and device based on LLM and form engine

Abstract

The invention provides a function interface rapid development method and device based on LLM and a form engine, and the method comprises the steps: defining the structure attribute of each component type, limiting each component type, enabling a keyword in a demand text of a user to correspond to the component type, and carrying out the corresponding operation; according to the method, keywords and corresponding structure attributes are assembled to obtain pre-assembly codes, then the pre-assembly codes are analyzed through a large language model according to the corresponding structure attributes to obtain field assembly codes, and standardization and safety verification are performed on the field assembly codes to ensure the compliance of generated codes. A function interface is obtained after front-end rendering and back-end service integration; due to the limitation of structural attributes, the instability that the large language model randomly generates attributes is avoided, the compliance of generated codes is ensured through back-end service integration, and on the basis of the beneficial effects, the development efficiency and flexibility of large language model programming are further achieved.

Description

Technical Field

[0001] This invention belongs to the field of AI programming technology, and more specifically, relates to a method and apparatus for rapid development of functional interfaces based on LLM and form engine. Background Technology

[0002] Based on the traditional native code development model, two technological development paths have evolved in the field of software development: one is low-code platforms with form engines at their core; the other is AI programming represented by large language models.

[0003] One problem with AI programming, exemplified by large language models, is that the code output by pure AI models lacks unified structural constraints and standards, easily leading to component illusions or attribute illusions. While the generated code may functionally meet requirements, it presents significant uncertainties in engineering maintenance, resulting in extremely high costs for subsequent modifications, debugging, and version upgrades. Furthermore, large language models may choose suboptimal or unconventional technical implementations when generating code, making it difficult to integrate the code into existing engineering systems and similarly leading to poor stability.

[0004] For low-code platforms, the corresponding programming challenges are as follows: While the form engine of a low-code platform has a stable structure, when faced with complex forms with multiple fields and multi-level logic, the process of manually dragging and dropping elements and configuring attributes is time-consuming and error-prone, significantly lagging behind the automated generation speed of AI. On the other hand, the platform's component library is fixed. When business requirements exceed the scope of preset components or need to modify the core rendering logic, intrusive modifications to the platform framework are necessary. This is not only costly but also affects the platform's upgrades and stability. Therefore, low-code platforms have poor flexibility in programming.

[0005] Therefore, overcoming the shortcomings of the existing technology is an urgent problem to be solved in this technical field. Summary of the Invention

[0006] The problem this invention aims to solve is how to improve the efficiency and stability of large language model programming.

[0007] Firstly, it provides a rapid development method for functional interfaces based on LLM and form engines, including: Predefine the structural properties of different component types; Receive the user's request text; Keyword extraction is performed on the requirement text, each keyword is matched with the corresponding component type, and the keywords and the structural attributes of the corresponding component types are assembled to obtain pre-assembled code; The pre-assembled code is input into the large language model to obtain the domain-assembled code; The assembly code in the aforementioned domain is standardized and security verified to obtain optimized assembly code; Based on all the optimized assembly code, front-end page rendering and back-end service integration are performed to obtain the functional interface corresponding to the required text.

[0008] Preferably, the predefined structural attributes for different component types specifically include: For each component type, the defined structural properties include: component name, component property name, component expected type, component default value, component semantic tag, illusion property map, and component API path.

[0009] Preferably, the step of associating each keyword with its corresponding component type and assembling the structural attributes of the keywords and their corresponding component types to obtain pre-assembled code specifically includes: For each keyword, a similarity search is performed on all component attribute names, component expected types, component default values, component semantic tags, and illusion attribute mapping tables to obtain the corresponding component attribute names, component expected types, component default values, component semantic tags, and illusion attribute mapping tables. Based on the component attribute name corresponding to the keyword, the expected type of the component, the default value of the component, the semantic tag of the component, and the illusion attribute mapping table, the component type corresponding to the keyword is obtained; All structural properties of the corresponding component type are assembled with the keyword to obtain the pre-assembled code corresponding to the keyword.

[0010] Preferably, the step of inputting the pre-assembled code into a large language model to obtain domain-assembled code specifically includes: The large language model obtains the structural attributes assembled by keywords in the pre-assembled code, as well as the attribute values ​​corresponding to each structural attribute; The structural attributes and attribute values ​​assembled from keywords are mapped and transformed using the platform domain language to obtain the domain attributes and their corresponding domain attribute values; Based on the illusion attribute mapping table corresponding to the relevant keywords, the domain attributes of the relevant keywords are optimized to obtain the optimized domain attributes; Based on the optimization domain attributes and domain attribute values ​​corresponding to the keywords, the domain assembly code corresponding to the keywords is obtained.

[0011] Preferably, the step of optimizing the domain attributes of the corresponding keywords based on the illusion attribute mapping table to obtain optimized domain attributes specifically includes: Based on the illusion attribute mapping table corresponding to the keyword, obtain all illusion attributes in all domain attributes corresponding to the keyword; Map all hallucination attributes to standard attributes according to the hallucination attribute mapping table; All standard attributes and original domain attributes are treated as optimized domain attributes.

[0012] Preferably, the standardization and security verification of the assembly code in the domain to obtain optimized assembly code specifically includes: Map the component names of keywords in the domain assembly code to standard component names; Map all optimized domain attribute values ​​of keywords in the domain assembly code to standard attribute values; The standardized domain assembly code is subjected to security verification to obtain optimized assembly code.

[0013] Preferably, the step of performing security verification on the standardized domain assembly code to obtain optimized assembly code specifically includes: Determine whether the number of optimized domain attributes of the corresponding keywords in the standardized domain assembly code is the preset standard number. If the number of optimized domain attributes of the corresponding keywords is the preset standard number, then the number of optimized domain attributes of the corresponding keywords is compliant. If the number of optimized domain attributes of the corresponding keywords is inconsistent with the preset standard number, then the number of optimized domain attributes of the corresponding keywords is corrected. Determine whether the attribute values ​​of each optimized domain attribute of the corresponding keyword in the standardized domain assembly code are within the specified range. If the attribute value of the corresponding optimized domain attribute is within the specified range, the attribute value of the corresponding optimized domain attribute is compliant. If the attribute value of the corresponding optimized domain attribute is outside the specified range, the corresponding optimized domain attribute is treated as a phantom attribute and ignored in the future. When the number of optimized domain attributes of the corresponding keyword is compliant and the number of optimized domain attributes of the corresponding keyword is within the specified range, the domain assembly code security verification of the corresponding keyword is completed, and the optimized assembly code of the corresponding keyword is obtained.

[0014] Preferably, when the number of optimization domain attributes of the corresponding keyword is inconsistent with the preset standard number, the correction of the number of optimization domain attributes of the corresponding keyword specifically includes: When the number of optimization domain attributes of a corresponding keyword exceeds the preset standard number, all optimization domain attributes of the keyword are checked to find the illusory attributes and ignore them in the future. When the number of optimization domain attributes for a corresponding keyword is less than the preset standard number, a default attribute is added to the keyword as the optimization domain attribute for that keyword, until the number of optimization domain attributes for the corresponding keyword is the same as the preset standard number.

[0015] Secondly, a rapid development apparatus for functional interfaces based on LLM and a form engine is provided, comprising at least one processor and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the processor to perform the rapid development method for functional interfaces based on LLM and a form engine.

[0016] Thirdly, the present invention also provides a non-volatile computer storage medium storing computer-executable instructions that are executed by one or more processors to perform the method described in the first aspect.

[0017] Fourthly, a chip is provided, comprising: a processor and an interface for calling and running a computer program stored in memory, performing the method as described in the first aspect.

[0018] Fifthly, a computer program product containing instructions is provided that, when executed on a computer or processor, causes the computer or processor to perform the method as described in the first aspect.

[0019] Sixthly, a rapid development system for functional interfaces based on LLM and a form engine is provided, including the rapid development apparatus for functional interfaces based on LLM and a form engine as described in the second aspect, and using the rapid development method for functional interfaces based on LLM and a form engine as described in the first aspect.

[0020] Unlike existing technologies, the present invention has at least the following beneficial effects: This invention provides a method and apparatus for rapid development of functional interfaces based on LLM and a form engine. First, it defines the structural attributes of each component type to limit the component types. Then, it maps keywords from the user's requirement text to the component types, assembling the keywords and corresponding structural attributes to obtain pre-assembled code. Next, it uses a large language model to parse the pre-assembled code according to the corresponding structural attributes to obtain domain-specific assembly code. The domain-specific assembly code is standardized and security-verified to ensure the compliance of the generated code. After front-end rendering and back-end service integration, the functional interface is obtained. Due to the limitation of structural attributes, the instability of arbitrary attribute generation by the large language model is avoided, and the compliance of the generated code is ensured through back-end service integration. In addition to the above beneficial effects, it also possesses the development efficiency and flexibility of large language model programming. Attached Figure Description

[0021] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the embodiments of the present invention will be briefly described below. Obviously, the drawings described below are merely some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without any creative effort.

[0022] Figure 1 This is a flowchart of a method for rapid development of functional interfaces based on LLM and form engine provided by an embodiment of the present invention; Figure 2 This is a flowchart of a method for obtaining pre-assembled code in a rapid development method for functional interfaces based on LLM and a form engine provided in an embodiment of the present invention; Figure 3 This is a flowchart of a method for obtaining domain assembly code in a rapid development method for functional interfaces based on LLM and form engine provided in an embodiment of the present invention; Figure 4 This is a flowchart of a method for obtaining optimized assembly code in a rapid development method for functional interfaces based on LLM and a form engine provided in an embodiment of the present invention; Figure 5 This is a flowchart of the correction method in a rapid development method for functional interfaces based on LLM and form engine provided in an embodiment of the present invention; Figure 6 This is a schematic diagram of a device for rapid development of functional interfaces based on LLM and form engine, provided in an embodiment of the present invention. Detailed Implementation

[0023] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the invention.

[0024] Unless the context otherwise requires, throughout the specification and claims, the term "comprising" is interpreted as openly inclusive, meaning "including, but not limited to." In the description of the specification, terms such as "one embodiment," "some embodiments," "exemplary embodiment," "example," "specific example," or "some examples" are intended to indicate that a particular feature, structure, material, or characteristic associated with that embodiment or example is included in at least one embodiment or example of this disclosure. The illustrative representations of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics mentioned may be included in any suitable manner in any one or more embodiments or examples; that is, although they may be incorporated into embodiments or examples using the above terms for reasons such as order and position, it does not limit them to be incorporated in combination by a single embodiment or example.

[0025] In the description of this invention, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined with "first" or "second" may explicitly or implicitly include one or more of that feature. In the description of embodiments of this disclosure, unless otherwise stated, "a plurality of" means two or more. Furthermore, for example, the description may use the prefix "A" or "B" to describe the same type of nouns as two independent entities. In this case, the corresponding features defined with "A" and "B" are used only to distinguish between similar entities and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features.

[0026] In the description of this invention, the expression “A and / or B” (where A and B are used to formally represent specific features) will be used. The corresponding expression includes the following three combinations: only A, only B, and a combination of A and B.

[0027] As used in this invention, “about,” “approximately,” or “approximately” includes the stated value and the average value within an acceptable range of deviation from a particular value, wherein the acceptable range of deviation is determined by a person skilled in the art taking into account the measurement under discussion and the error associated with the measurement of the particular quantity (i.e., the limitations of the measurement system).

[0028] Furthermore, the technical features involved in the various embodiments of the present invention described below can be combined with each other as long as they do not conflict with each other.

[0029] Example 1: This embodiment provides a rapid development method for functional interfaces based on a Large Language Model (LLM) and a form engine, such as... Figure 1 As shown, the method flow includes: In step 101, structural properties for different component types are predefined.

[0030] The component type refers to the feature type used to construct the functional interface, such as input boxes, name fields, age fields, and date pickers on the functional interface. A complete functional interface includes multiple different types of component types. The structural attributes are the attribute features of the component type, such as the component name, component attribute name, and expected component type of a single component type. The structural attributes of different component types are different. In this embodiment, considering that the large language model will subsequently map the keywords of the user's input language and the component types corresponding to the keywords, due to the instability and uncertainty of the existing large language model, a large number of illusory attributes (i.e., erroneous attributes) may be generated during this process, causing the component types corresponding to the keywords to change, ultimately leading to errors in the generated functional interface. Therefore, in step 101, the structural attributes of the component types need to be defined first to avoid the large language model generating a large number of illusory attributes and causing errors.

[0031] In step 102, the user's request text is received.

[0032] In this embodiment, the user can submit the request text through a front-end interface (such as a chat box or input area). The request text is in everyday language and is used to fully describe the functional interface. In order to improve the parsing efficiency of the subsequent large language model, the request text should contain the completeness of the intent, for example: "I need an employee information registration form, which includes name (text input, required), age (numeric input, range 18-60), department (drop-down selection, options from / api / departments), start date (date selector), and a submit button."

[0033] In step 103, keywords are extracted from the requirement text, each keyword is matched with the corresponding component type, and the structural attributes of the keywords and the corresponding component types are assembled to obtain pre-assembled code.

[0034] In this embodiment, after obtaining the requirement text, semantic recognition is first performed on the requirement text to obtain each keyword in the semantically recognized requirement text. Subsequently, the functional interface needs to be constructed based on each keyword. However, since different users have different ways of describing the same object, different users may refer to the same object in different ways. For example, for the speed of a vehicle, some users may use "vehicle speed" while others may use "vehicle speed". Therefore, for different ways of describing, it is necessary to first distinguish the meaning of each keyword through semantic recognition, and then obtain the structural attributes of the keyword based on the meaning of the keyword. Each structural attribute has a corresponding attribute value, thereby finding the component type corresponding to the keyword, so as to map keywords with different descriptions under the same semantics to standard component types, which facilitates the subsequent construction of the functional interface based on the corresponding component types. Since different component types are determined by their own defined structural attributes, all structural attributes of the component type and the corresponding keywords are assembled, which completes the mapping between keywords and corresponding component types. After assembly, the pre-assembled code corresponding to the keyword can be obtained.

[0035] In step 104, the pre-assembled code is input into the large language model to obtain the domain-assembled code.

[0036] The pre-assembled code corresponding to the keywords is input into the large language model. The large language model transforms the structural attributes and attribute values ​​corresponding to the keywords in the pre-assembled code and maps them to the language corresponding to the platform. This allows for code generation through the large language model, improving programming efficiency and flexibility. Furthermore, since the keywords and various structural attributes are already mapped in the pre-assembled code, the large language model transforms the structural attributes that the keywords already correspond to. Therefore, the transformation process obtains domain-assembled code under the constraint of structural attributes, avoiding the large language model from simply generating a large number of illusion attributes from keywords, which would lead to error-prone code structure and poor controllability.

[0037] In step 105, the domain assembly code is standardized and security verified to obtain optimized assembly code.

[0038] Furthermore, to avoid errors in subsequent functional interface implementation caused by non-compliant attributes or attribute values ​​obtained during the transformation of keyword structural attributes by the large language model, this embodiment standardizes and performs security verification on the domain assembly code to filter out problematic attributes or attribute values ​​and make corresponding adjustments to obtain the optimized assembly code.

[0039] In step 106, front-end page rendering and back-end service integration are performed based on all the optimized assembly code to obtain the functional interface corresponding to the requirement text.

[0040] In this embodiment, the structural attributes of each component type are first defined to limit the component types. Then, the keywords in the user's requirement text are mapped to the component types, and the keywords and corresponding structural attributes are assembled to obtain pre-assembled code. The pre-assembled code is then parsed according to the corresponding structural attributes by a large language model to obtain domain assembly code. The domain assembly code is standardized and security verified to ensure the compliance of the generated code. After front-end rendering and back-end service integration, the functional interface is obtained. Due to the limitation of structural attributes, the instability of arbitrary attribute generation by the large language model is avoided, and the compliance of the generated code is ensured by back-end service integration. On the basis of the above beneficial effects, it also has the development efficiency and flexibility of large language model programming.

[0041] Furthermore, in this embodiment, it is necessary to pre-generate a large number of component types and define multiple corresponding structural attributes according to the characteristics of the component types. This avoids the subsequent addition of a large number of other structural attributes to the large language model for the component type, which could lead to illusion attributes affecting the code programming of the entire functional interface. Therefore, this embodiment also involves the following design: The predefined structural attributes for different component types specifically include: for each component type, the defined structural attributes include: component name, component attribute name, expected component type, default component value, component semantic tag, illusion attribute mapping table, and component API path.

[0042] The component name can be componentName, such as H_DatePicker, H_TextInput; the component property name, expected type, and default value can be propertyWhitelist, where the expected type is, for example, string, boolean, and expression; the component semantic tags can be semanticTags, such as date, time, selection, and text; the illusion property mapping table can be mappingRules; and the component API path can be apiPath.

[0043] In this embodiment, the illusion attribute mapping table can be a mapping table between illusion attributes that may be generated by the large language model scene and standard attributes. This is used when the pre-assembled code is subsequently parsed by the large language model; if structural attributes are converted into illusion attributes, the illusion attributes can be converted into standard attributes according to the illusion attribute mapping table. It is worth mentioning that the illusion attribute mapping table can be updated during multiple generation processes of functional interfaces. New illusion attributes generated by the large language model during this process are recorded, and corresponding standard attributes are selected for mapping, and then updated in the illusion attribute mapping table.

[0044] Furthermore, in this embodiment, when all keywords are obtained based on the user's required text, the keywords are matched with their corresponding component types according to predefined component types and structural attributes, and the corresponding structural attributes and keywords are assembled. The design is as follows: Matching each keyword with its corresponding component type and assembling the keywords with the structural attributes of the corresponding component type yields pre-assembled code, such as... Figure 2 As shown, the method flow includes: In step 201, the similarity of each keyword is searched across all component attribute names, component expected types, component default values, component semantic tags, and illusion attribute mapping tables to obtain the corresponding component attribute names, component expected types, component default values, component semantic tags, and illusion attribute mapping tables.

[0045] In this embodiment, the similarity retrieval can use a vector database to calculate cosine similarity.

[0046] In step 202, the component type corresponding to the keyword is obtained based on the component attribute name, expected component type, default component value, semantic component tag, and illusion attribute mapping table.

[0047] In step 203, all structural attributes of the corresponding component type are assembled with the keyword to obtain the pre-assembled code corresponding to the keyword.

[0048] In this embodiment, the pre-assembled code example is as follows:

[0049] Furthermore, in this embodiment, after obtaining the pre-assembled code, the pre-assembled code is input into the large language model, and the pre-assembled code is language-converted according to the platform corresponding to the large language model, so as to generate domain assembly code through the large language model. Therefore, this embodiment also involves the following design: the pre-assembled code is input into the large language model to obtain domain assembly code, such as... Figure 3 As shown, the method flow includes: In step 301, the large language model obtains the structural attributes assembled by keywords in the pre-assembled code, as well as the attribute values ​​corresponding to each structural attribute.

[0050] In step 302, the structural attributes and attribute values ​​assembled by the keywords are mapped and converted using the platform domain language to obtain the domain attributes and their corresponding domain attribute values.

[0051] It should be noted that in this embodiment, since the pre-assembled code has already assembled the corresponding structural attributes and keywords, the large language model will not generate other attributes or reference unauthorized APIs, thus avoiding the generation of additional illusion attributes.

[0052] Furthermore, since large language models may still convert the structural attributes assembled from keywords into illusory attributes when transforming them, the following steps are involved to avoid this situation.

[0053] In step 303, the domain attributes of the corresponding keywords are optimized according to the illusion attribute mapping table corresponding to the corresponding keywords to obtain optimized domain attributes.

[0054] Based on the illusion attribute mapping table corresponding to the keyword, obtain all illusion attributes in all domain attributes corresponding to the keyword; map all illusion attributes to standard attributes according to the illusion attribute mapping table; and use all standard attributes and original domain attributes as optimized domain attributes corresponding to the keyword.

[0055] In step 304, the domain assembly code corresponding to the keyword is obtained based on the optimized domain attributes and domain attribute values.

[0056] In this embodiment, the domain assembly code is the output code of the large language model after it is input into the pre-assembled model. An example of the domain assembly code is as follows:

[0057] Furthermore, in this embodiment, to ensure the compliance and strict control of the generated domain assembly code, it is also necessary to perform security verification on the domain assembly code, and the corresponding design is as follows: The assembly code in the aforementioned domain is standardized and security verified to obtain optimized assembly code, such as... Figure 4 As shown, the method flow includes the following.

[0058] In step 401, the component names of keywords in the domain assembly code are mapped to standard component names.

[0059] In this embodiment, the type field is mapped to the standard component name defined in the RAG knowledge base, for example, text-input is converted to H_TextInput.

[0060] In step 402, the attribute values ​​of all optimized domain attributes of the keywords in the domain assembly code are mapped to standard attribute values.

[0061] In this embodiment, non-standard values ​​in the attribute values ​​are converted into strongly typed values ​​(i.e., the standard attribute values) required by the target system, for example, "yes" is converted into "true", and "18" is converted into "18.0".

[0062] In this embodiment, the domain assembly code is standardized so that during subsequent security verification, each optimized domain attribute can be matched with the calibration sample, and the attribute values ​​of each optimized domain attribute can be unified and compared with the corresponding standard value range.

[0063] In step 403, the standardized domain assembly code is subjected to security verification to obtain optimized assembly code.

[0064] After standardizing the domain assembly code, a security check is performed on the standardized domain assembly code. The corresponding design is as follows: The standardized domain assembly code undergoes a security check to obtain optimized assembly code, such as... Figure 5 As shown, the method flow includes the following.

[0065] In step 501, it is determined whether the number of optimized domain attributes of the corresponding keywords in the standardized domain assembly code is the preset standard number. When the number of optimized domain attributes of the corresponding keywords is the preset standard number, the number of optimized domain attributes of the corresponding keywords is compliant. When the number of optimized domain attributes of the corresponding keywords is inconsistent with the preset standard number, the number of optimized domain attributes of the corresponding keywords is corrected.

[0066] In this embodiment, the preset standard number is set by those skilled in the art based on actual conditions. When the number of optimization domain attributes of the corresponding keyword is inconsistent with the preset standard number, the number of optimization domain attributes of the corresponding keyword is corrected. This embodiment includes the following design: when the number of optimization domain attributes of the corresponding keyword is greater than the preset standard number, all optimization domain attributes of the keyword are checked to find the illusory attributes and ignore them in the future; when the number of optimization domain attributes of the corresponding keyword is less than the preset standard number, a default attribute is added to the keyword as the optimization domain attribute of the corresponding keyword until the number of optimization domain attributes of the corresponding keyword is consistent with the preset standard number.

[0067] In step 502, it is determined whether the attribute values ​​of each optimized domain attribute of the corresponding keyword in the standardized domain assembly code are within the specified range. When the attribute value of the corresponding optimized domain attribute is within the specified range, the attribute value of the corresponding optimized domain attribute is compliant. When the attribute value of the corresponding optimized domain attribute is outside the specified range, the corresponding optimized domain attribute is treated as a phantom attribute and ignored in the subsequent steps.

[0068] In this embodiment, the specified interval is pre-defined by those skilled in the art for each attribute individually.

[0069] In step 503, when the number of optimized domain attributes of the corresponding keyword is compliant and the number of optimized domain attributes of the corresponding keyword is within the specified range, the domain assembly code security verification of the corresponding keyword is completed, and the optimized assembly code of the corresponding keyword is obtained.

[0070] In this embodiment, the pseudocode example for obtaining the optimized assembly code is as follows.

[0071]

[0072] Furthermore, in this embodiment, after obtaining the optimized assembly code of all keywords in the requirement text, the front-end page rendering and back-end service integration can be performed based on all the optimized assembly code to obtain the functional interface corresponding to the requirement text. The front-end page rendering design is as follows.

[0073] The renderer receives the optimized assembly code for all keywords, leverages the dynamic component features of the front-end framework, creates a reactive data structure based on the standard component name (e.g., H_TextInput) defined in the optimized assembly code, and injects the initial values ​​of all fields, default validation rules, and API configurations into the Form Runtime instance. The Form Runtime centrally manages component state and uniformly dispatches events, as detailed below.

[0074] (1) State-responsive binding: All dynamically rendered components are bound to a unique reactive data object in the Form Runtime instance through two-way data binding directives or similar mechanisms.

[0075] (2) Event abstraction: Runtime is responsible for triggering real-time or delayed validation when the user inputs, based on the form validation rules defined by the optimized assembly code or the form validation expression after security validation.

[0076] (3) Submission scheduling: When the user clicks the submit button, the Runtime is responsible for performing global verification and encapsulating all data into a standard format for sending to subsequent steps.

[0077] The backend service integration design is as follows: A unified backend service proxy is adopted to forward and process data requests submitted by the frontend based on the application programming interface (API) metadata defined in the optimized assembly code.

[0078] The functions of the backend unified service proxy are as follows: Request interception and parsing: The adapter intercepts requests and parses the API metadata within them.

[0079] Security pre-verification: Before forwarding, a final data format and permission check is performed.

[0080] Dynamic forwarding: The Adapter uses the Hypertext Transfer Protocol (HTTP) client to dynamically construct and forward requests to the actual business backend service based on metadata.

[0081] Unified Response: Unified processing of return codes and error messages from business services, and returning them to the front-end runtime.

[0082] In this way, the business logic of the front end and the back end are completely connected through the metadata of the optimized assembly code, achieving standardized data integration.

[0083] Furthermore, the following improvements are also provided in this embodiment.

[0084] (1) Front-end framework replacement: The form engine's rendering layer can be replaced with other mainstream front-end frameworks, such as React or Angular. The core idea remains the same: maintain a fixed and high-quality component library, and perform metadata-driven rendering by assembling code through domain.

[0085] (2) Example of an alternative solution: Use React's JavaScript XML (abbreviated as JSX) and hook function mechanism to implement an equivalent form renderer component, and change the component mapping table to a reference to the React component.

[0086] (3) Form schema definition function extension (dynamic validation): Add descriptions of complex conditional logic to the existing schema specification, such as: "Field B is only displayed and is required when the value of field A is 'specific value'". The large language model needs to parse these complex conditions and express them in the schema in a standardized format (such as attributes such as visibilityIf and requiredIf), which are then executed by the runtime logic of the form engine.

[0087] (4) Multi-platform adaptation extension: Extend the domain assembly code specifications and add style and layout configuration fields (such as form layout configuration and responsive breakpoints). The large language model can generate responsive layout schemas according to requirements, so that the same schema can be parsed and rendered by the form engines of Web and mobile (such as React Native or Flutter), realizing multi-platform integrated development.

[0088] Furthermore, this embodiment also provides the following upstream and downstream alternatives, namely, vertically improveable points.

[0089] (1) Replacement and optimization of large language models: Large language models can be replaced with other models with advanced structured output capabilities, such as using lighter models (such as the fine-tuned version of the open-source large language model series), deployed locally or in a private cloud to improve response speed and data security.

[0090] (2) Schema dynamic optimization and feedback: Add a model feedback loop. When the schema verification fails or the front-end rendering fails, the error log and schema fragment are fed back to the large language model, requiring it to perform self-correction and optimization, realize closed-loop iteration, and further improve the schema generation success rate.

[0091] In this embodiment, the following beneficial effects are achieved through the following design: This invention combines the efficient intent parsing capabilities of a large language model with the structured stability of a form engine, resulting in the following significant benefits: Significantly improved development efficiency: Compared to the manual drag-and-drop configuration of traditional low-code platforms, this method reduces the time from requirement to page from 1 hour to 30 minutes. The large language model generates form configuration metadata in one go, improving development efficiency by over 50%, especially for complex forms with more than 20 fields, where the efficiency improvement is even more significant.

[0092] Maintenance costs are significantly reduced: By forcing the output of domain-specifically assembled code (rather than flexible code) from the large language model, issues such as component or attribute illusions and inconsistent code structure are avoided from the outset. Since all pages are rendered by the same set of form engine components, the costs of later debugging, modification, and maintenance are greatly reduced, shortening the maintenance cycle by 40%.

[0093] Enhanced engineering quality and stability: The role of the large language model is limited to metadata converter, and it does not participate in the specific implementation of front-end components. The front-end components have undergone rigorous testing and optimization in advance, ensuring the engineering quality and operational stability of the system and avoiding potential security risks and performance issues caused by code generated by the large language model.

[0094] Balancing customization with versatility: For customization needs, there's no need to modify the core framework of the form engine. Simply introduce new attribute types into the domain assembly code and simultaneously add a new, compliant component to the Vue 3 platform. This decoupling approach allows the platform to maintain versatility while possessing powerful extensibility.

[0095] Example 2: like Figure 6The diagram shown is a schematic representation of a rapid development apparatus for functional interfaces based on LLM and a form engine according to an embodiment of the present invention. This rapid development apparatus for functional interfaces based on LLM and a form engine includes one or more processors 41 and a memory 42.

[0096] Processor 41 and memory 42 can be connected via a bus or other means. Figure 6 Taking the example of a connection between China and Israel via a bus.

[0097] The memory 42, as a non-volatile computer-readable storage medium, can be used to store non-volatile software programs and non-volatile computer-executable programs, such as the rapid development method for functional interfaces based on LLM and form engine in the above embodiment. The processor 41 executes the rapid development method for functional interfaces based on LLM and form engine by running the non-volatile software programs and instructions stored in the memory 42.

[0098] Memory 42 may include high-speed random access memory, and may also include non-volatile memory, such as at least one disk storage device, flash memory device, or other non-volatile solid-state storage device. In some embodiments, memory 42 may optionally include memory remotely located relative to processor 41, which can be connected to processor 41 via a network. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof.

[0099] The program instructions / modules are stored in the memory 42. When executed by one or more processors 41, they execute the rapid development method for functional interfaces based on LLM and form engine in the above embodiments.

[0100] This invention also provides a computer storage medium storing computer program instructions; when these computer program instructions are executed by a processor, they implement the rapid development method for functional interfaces based on LLM and form engine provided in this invention.

[0101] Those skilled in the art will readily understand that the above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A method for rapid development of a functional interface based on LLM and form engine, characterized in that, include: Predefine the structural properties of different component types; Receive the user's request text; Keyword extraction is performed on the requirement text, each keyword is matched with the corresponding component type, and the keywords and the structural attributes of the corresponding component types are assembled to obtain pre-assembled code; The pre-assembled code is input into the large language model to obtain the domain-assembled code; The assembly code in the aforementioned domain is standardized and security verified to obtain optimized assembly code; Based on all the optimized assembly code, front-end page rendering and back-end service integration are performed to obtain the functional interface corresponding to the required text.

2. The method of claim 1, wherein, The predefined structural attributes for different component types specifically include: For each component type, the defined structural properties include: component name, component property name, expected component type, component default value, component semantic tag, illusion property map, and component API path.

3. The method of claim 2, wherein, The process of associating each keyword with its corresponding component type and assembling the structural attributes of the keywords and their corresponding component types to obtain pre-assembled code specifically includes: For each keyword, a similarity search is performed on all component attribute names, component expected types, component default values, component semantic tags, and illusion attribute mapping tables to obtain the corresponding component attribute names, component expected types, component default values, component semantic tags, and illusion attribute mapping tables. Based on the component attribute name corresponding to the keyword, the expected type of the component, the default value of the component, the semantic tag of the component, and the illusion attribute mapping table, the component type corresponding to the keyword is obtained; All structural properties of the corresponding component type are assembled with the keyword to obtain the pre-assembled code corresponding to the keyword.

4. The method of claim 2, wherein, The step of inputting the pre-assembled code into the large language model to obtain the domain-assembled code specifically includes: The large language model obtains the structural attributes assembled by keywords in the pre-assembled code, as well as the attribute values ​​corresponding to each structural attribute; The structural attributes and attribute values ​​assembled from keywords are mapped and transformed using the platform domain language to obtain the domain attributes and their corresponding domain attribute values; Based on the illusion attribute mapping table corresponding to the relevant keywords, the domain attributes of the relevant keywords are optimized to obtain the optimized domain attributes; Based on the optimization domain attributes and domain attribute values ​​corresponding to the keywords, the domain assembly code corresponding to the keywords is obtained.

5. The method of claim 4, wherein, The step of optimizing the domain attributes of corresponding keywords based on the illusion attribute mapping table to obtain optimized domain attributes specifically includes: Based on the illusion attribute mapping table corresponding to the keyword, obtain all illusion attributes in all domain attributes corresponding to the keyword; Map all hallucination attributes to standard attributes according to the hallucination attribute mapping table; All standard attributes and original domain attributes are treated as optimized domain attributes.

6. The method of claim 2, wherein the method further comprises: The standardization and security verification of the assembly code in the aforementioned domain to obtain optimized assembly code specifically includes: Map the component names of keywords in the domain assembly code to standard component names; Map all optimized domain attribute values ​​of keywords in the domain assembly code to standard attribute values; The standardized domain assembly code is subjected to security verification to obtain optimized assembly code.

7. The method of claim 6, wherein the method further comprises: The process of performing security verification on the standardized domain assembly code to obtain optimized assembly code specifically includes: Determine whether the number of optimized domain attributes of the corresponding keywords in the standardized domain assembly code is the preset standard number. If the number of optimized domain attributes of the corresponding keywords is the preset standard number, then the number of optimized domain attributes of the corresponding keywords is compliant. If the number of optimized domain attributes of the corresponding keywords is inconsistent with the preset standard number, then the number of optimized domain attributes of the corresponding keywords is corrected. Determine whether the attribute values ​​of each optimized domain attribute of the corresponding keyword in the standardized domain assembly code are within the specified range. If the attribute value of the corresponding optimized domain attribute is within the specified range, the attribute value of the corresponding optimized domain attribute is compliant. If the attribute value of the corresponding optimized domain attribute is outside the specified range, the corresponding optimized domain attribute is treated as a phantom attribute and ignored in the future. When the number of optimized domain attributes of the corresponding keyword is compliant and the number of optimized domain attributes of the corresponding keyword is within the specified range, the domain assembly code security verification of the corresponding keyword is completed, and the optimized assembly code of the corresponding keyword is obtained.

8. The method of claim 7, wherein, When the number of optimization domain attributes of a corresponding keyword is inconsistent with the preset standard number, the number of optimization domain attributes of the corresponding keyword is corrected, specifically including: When the number of optimization domain attributes of a corresponding keyword exceeds the preset standard number, all optimization domain attributes of the keyword are checked to find the illusory attributes and ignore them in the future. When the number of optimization domain attributes for a corresponding keyword is less than the preset standard number, a default attribute is added to the keyword as the optimization domain attribute for that keyword, until the number of optimization domain attributes for the corresponding keyword is the same as the preset standard number.

9. An apparatus for rapid development of a functional interface based on LLM and form engine, characterized by, The method includes at least one processor and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the processor for performing the rapid development method for a functional interface based on LLM and a form engine as described in any one of claims 1-8.

10. A non-transitory computer storage medium, comprising, The computer storage medium stores computer program instructions that, when executed by one or more processors, implement the rapid development method for functional interfaces based on LLM and form engine as described in any one of claims 1-8.

Images