CN117215550A - LLM-based low-code component generation method and system - Google Patents
LLM-based low-code component generation method and system Download PDFInfo
- Publication number
- CN117215550A CN117215550A CN202311105967.1A CN202311105967A CN117215550A CN 117215550 A CN117215550 A CN 117215550A CN 202311105967 A CN202311105967 A CN 202311105967A CN 117215550 A CN117215550 A CN 117215550A
- Authority
- CN
- China
- Prior art keywords
- component
- user
- user interface
- code
- low
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000000034 method Methods 0.000 title claims abstract description 38
- 230000006870 function Effects 0.000 claims abstract description 109
- 238000012360 testing method Methods 0.000 claims abstract description 75
- 238000012549 training Methods 0.000 claims abstract description 16
- 238000012795 verification Methods 0.000 claims description 19
- 238000010276 construction Methods 0.000 claims description 18
- 238000012423 maintenance Methods 0.000 claims description 18
- 230000002159 abnormal effect Effects 0.000 claims description 16
- 238000000605 extraction Methods 0.000 claims description 4
- 230000018109 developmental process Effects 0.000 description 58
- 238000011161 development Methods 0.000 description 56
- 230000008569 process Effects 0.000 description 12
- 230000000694 effects Effects 0.000 description 10
- 238000013459 approach Methods 0.000 description 4
- 230000002708 enhancing effect Effects 0.000 description 4
- 238000011990 functional testing Methods 0.000 description 4
- 238000001514 detection method Methods 0.000 description 3
- 230000000737 periodic effect Effects 0.000 description 3
- 239000000284 extract Substances 0.000 description 2
- 230000007246 mechanism Effects 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 238000012544 monitoring process Methods 0.000 description 2
- 238000003058 natural language processing Methods 0.000 description 2
- 238000000275 quality assurance Methods 0.000 description 2
- 230000009467 reduction Effects 0.000 description 2
- 230000004044 response Effects 0.000 description 2
- 230000004075 alteration Effects 0.000 description 1
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000008901 benefit Effects 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 239000000203 mixture Substances 0.000 description 1
- 230000008929 regeneration Effects 0.000 description 1
- 238000011069 regeneration method Methods 0.000 description 1
Landscapes
- Stored Programmes (AREA)
Abstract
The invention provides a LLM-based low code component generation method and system. The low code component generation method comprises the following steps: collecting component codes in a low-code component library; training the language model by utilizing the component codes to obtain a trained language model; detecting whether demand information input by a user is received or not in real time, and automatically constructing a user interface according to the demand information input by the user; analyzing instruction information input by a user by utilizing a language model, and loading functions on a user interface according to the analysis result and the user requirements; and testing and verifying the user interface after the function loading, and deploying the user interface with the function loading which is tested and verified to a low-code platform. The system comprises modules corresponding to the method steps.
Description
Technical Field
The invention provides a low-code component generation method and system based on LLM, and belongs to the technical field of code composition.
Background
Currently, one common practice of low code application development platforms is to hand the task of component development to users or developers of the application, providing them with a component development document that allows them to develop the required components according to the specifications and requirements in the document. While this approach is effective in some situations, there are also problems and challenges.
First, the cost of this approach tends to be relatively high. Users or developers need to spend time and effort learning the specifications and technical requirements in the component development document. This may require additional training and resources, increasing the cost of development. Furthermore, a developer may need to have some programming and technical background, otherwise it may be difficult to understand the content and requirements in the document. Second, this approach may limit the flexibility and creativity of the user. Users may be limited by specifications in the document and have difficulty implementing custom functions or interfaces that they want. This may result in limited functionality of the application and failure to meet specific business needs.
Most importantly, this approach may reduce the major advantage of the low code platform, namely the development threshold. The low code platform was initially designed to allow non-professional developers to build applications quickly as well, but this goal may be difficult to achieve if they need to learn deep about the component development techniques and specifications.
Disclosure of Invention
The invention provides a LLM-based low code component generation method and system, which are used for solving the problems of high cost and overlarge difficulty of low code component generation in the prior art, and adopts the following technical scheme:
a LLM-based low code component generation method, the low code component generation method comprising:
collecting component codes in a low-code component library;
training the language model by utilizing the component codes to obtain a trained language model;
detecting whether demand information input by a user is received or not in real time, and automatically constructing a user interface according to the demand information input by the user;
analyzing instruction information input by a user by utilizing a language model, and loading functions on a user interface according to the analysis result and the user requirements;
and testing and verifying the user interface after the function loading, and deploying the user interface with the function loading which is tested and verified to a low-code platform.
Further, collecting component code in a low code component library, comprising:
scanning the first code component library to obtain component types in the first code component library;
sequentially acquiring corresponding component codes of each component type and the components contained in the components;
wherein the component type forms, charts, data displays and the like.
Further, detecting in real time whether the demand information input by the user is received, and automatically constructing a user interface according to the demand information input by the user, including:
detecting whether demand information input by a user is received or not in real time;
after detecting that demand information input by a user is received, extracting the demand information to obtain a demand instruction corresponding to the demand information;
and according to the requirements, automatically constructing a user interface by the instruction.
Further, the method includes analyzing instruction information input by a user by using a language model, and loading functions on a user interface according to the analysis result and user requirements, including:
after the user interface is built, automatically building a virtual server, wherein the virtual server is used for receiving the component demands of a user;
after receiving the component demands of the user, the virtual server sends the component demands to a language model, and a component calling instruction corresponding to the component demands is obtained through analysis of the language model;
and calling a target component corresponding to the instruction into a low-code component library according to the component calling instruction, and loading the target component into a user interface until all functions required by the user are loaded.
Further, testing and verifying the user interface after function loading, and deploying the user interface with function loading after testing and verifying to a low-code platform, wherein the method comprises the following steps:
after all functions required by a user are loaded, testing and verifying the user interface after the functions are loaded; when the test result shows that the function operation is abnormal, continuing to perform abnormal operation alarm;
after the user interface with the loaded function completes testing and verification, and the testing and verification result shows that the function of the user interface is normal, deploying the user interface to a low-code platform;
the low code platform manages the user interface, periodically tests functions and maintains and manages.
A LLM based low code component generating system, the low code component generating system comprising:
the component code collection module is used for collecting component codes in the low-code component library;
the language model training module is used for training the language model by utilizing the component codes to obtain a trained language model;
the automatic user interface construction module is used for detecting whether the demand information input by the user is received or not in real time and automatically constructing a user interface according to the demand information input by the user;
the interface function automatic loading module is used for analyzing instruction information input by a user by utilizing the language model and loading functions on a user interface according to the analysis result and the user requirement;
the interface testing and deploying module is used for testing and verifying the user interface after the function loading and deploying the user interface with the function loading to the low-code platform after the testing and verifying are completed.
Further, the component code collection module includes:
the component library scanning module is used for scanning the first code component library to acquire the component types in the first code component library;
the code acquisition module is used for sequentially acquiring corresponding component codes of the components contained in each component type;
wherein the component type forms, charts, data displays and the like.
Further, the user interface automatic construction module includes:
the demand information receiving module is used for detecting whether demand information input by a user is received or not in real time;
the extraction module is used for extracting the demand information after detecting the demand information input by a user, and obtaining a demand instruction corresponding to the demand information;
and the interface automatic construction module is used for automatically constructing a user interface according to the requirement.
Further, the interface function automatic loading module includes:
the server building module is used for automatically building a virtual server after the user interface is built, wherein the virtual server is used for receiving the assembly requirements of a user;
the instruction acquisition module is used for sending the component requirements to a language model after the virtual server receives the component requirements of a user, and acquiring component calling instructions corresponding to the component requirements through analysis of the language model;
and the automatic function loading execution module is used for calling a target component corresponding to the instruction into the low-code component library according to the component calling instruction, and loading the target component into a user interface until all functions required by the user are loaded.
Further, the interface testing and deploying module comprises:
the testing module is used for testing and verifying the user interface after the functions required by the user are loaded after all the functions are loaded; when the test result shows that the function operation is abnormal, continuing to perform abnormal operation alarm;
the deployment module is used for deploying the user interface to the low-code platform after the user interface with the loaded function completes testing and verification and the testing and verification result shows that the function of the user interface is normal;
and the operation and maintenance module is used for managing, periodically testing the functions and maintaining and managing the user interface by the low-code platform.
The invention has the beneficial effects that:
the LLM-based low-code component generating method and system provided by the invention can generate the components which can be imported in the low-code platform by further training the existing LLM. The user inputs the component requirement, the requirement is sent to the back end to call the LLM to generate corresponding component codes, and the back end returns the generated codes to the front end to be loaded and displayed. Component requirements that do not meet user requirements may click on regeneration. The LLM-based low code component generation method and system provided by the invention can be used for rapidly generating the low code component which is not originally available for the user through the LLM, so that the user can have more flexible low code experience, and the LLM can be used for customizing the low code development platform component required by the user at will.
Drawings
FIG. 1 is a flow chart of the method of the present invention;
fig. 2 is a system block diagram of the system of the present invention.
Detailed Description
The preferred embodiments of the present invention will be described below with reference to the accompanying drawings, it being understood that the preferred embodiments described herein are for illustration and explanation of the present invention only, and are not intended to limit the present invention.
The embodiment of the invention provides a low-code component generating method based on LLM, as shown in figure 1, comprising the following steps:
s1, collecting component codes in a low-code component library;
s2, training the language model by utilizing the component codes to obtain a trained language model;
s3, detecting whether the demand information input by the user is received or not in real time, and automatically constructing a user interface according to the demand information input by the user;
s4, analyzing instruction information input by a user by utilizing a language model, and loading functions on a user interface according to the analysis result and the user requirements;
s5, testing and verifying the user interface after the function loading, and deploying the user interface with the function loading to the low-code platform after the testing and verifying are completed.
The working principle of the technical scheme is as follows: component code collection (S1): code is collected for various components in the low code component library, which may include interface elements, functional modules, business logic, and the like.
Language model training (S2): the collected component codes are utilized to train the language model. This training process enables the language model to understand and generate natural language descriptions related to application development.
Demand information detection and user interface construction (S3): the system detects the user's input of demand information in real time, possibly a natural language description or instruction of the user. Based on this demand information, the system automatically constructs a user interface, selecting the appropriate components and layout to meet the user's demand.
Instruction information parsing and function loading (S4): the system analyzes instruction information input by the user by using the trained language model. The parsing results determine the user's needs, and the system then automatically loads the corresponding functional modules and components on the user interface according to these needs.
Test, verification and deployment (S5): the system tests and verifies the user interface after the function loading, and ensures that each component and each function module normally operate. After testing and verification, the system deploys the user interface with function loading onto the low code platform so that it can be further edited and used by the user.
The technical scheme has the effects that: and (3) automatic development: the technical scheme of the embodiment realizes the automation of the development of the application program, and a developer does not need to manually write most codes, so that the development efficiency is improved.
The development threshold is reduced: the user only needs to provide the requirement information, does not need to know the details of programming or components in depth, reduces the development threshold, and enables more people to participate in the development of the application program.
Fast iteration: due to the automated generation and construction, development teams can iterate and adjust more quickly to meet the changes in user demand.
Error rate reduction: automatically generated code and user interfaces typically have fewer errors and consistency problems because they are generated from language models and component libraries.
In a word, the above technical solution of the embodiment realizes the goal of automatic application program development by combining the language model and the low-code component library, improves the development efficiency, reduces the development threshold, reduces errors, accelerates the release period of the application program, and enhances the reliability and stability of the application program.
In one embodiment of the invention, collecting component code in a low code component library includes:
s101, scanning the first code component library to obtain component types in the first code component library;
s102, sequentially acquiring corresponding component codes of each component type and the components contained in the components;
wherein the component type forms, charts, data displays and the like.
The working principle of the technical scheme is as follows: component type scan (S101): the system scans the first code component library to obtain a list of different component types therein. These component types may include buttons, forms, charts, text boxes, and the like.
Component code acquisition (S102): next, the system traverses each component type in turn and obtains the code of the specific component contained within each component type. This may be accomplished by accessing a code store or repository of component libraries to extract the source code for each component.
The technical scheme has the effects that: component library content collection: the above-mentioned technical solution of the present embodiment enables the system to automatically collect various component codes in the low-code component library without manual collection or writing.
And (3) resource arrangement: by retrieving code for each component type, the system can better organize and manage the resources in the component library, making it easy to access and use.
Enhancing development usability: collecting component code may provide example code for developers, helping them know how to use different types of components, thereby enhancing the usability of the low code platform.
Development efficiency is improved: the collected component codes can be used for automatically generating interfaces and functions of application programs, so that development efficiency is improved, and the workload of manually writing codes is reduced.
In a word, the above technical solution of the present embodiment helps a developer to access and use the components more easily by automatically collecting component codes in the low-code component library, thereby improving development efficiency and developer experience.
In one embodiment of the present invention, detecting in real time whether demand information input by a user is received, and automatically constructing a user interface according to the demand information input by the user includes:
s301, detecting whether demand information input by a user is received or not in real time;
s302, after detecting that demand information input by a user is received, extracting the demand information to obtain a demand instruction corresponding to the demand information;
s303, automatically constructing a user interface according to the requirement.
The working principle of the technical scheme is as follows: demand information detection (S301): the system monitors the user's input in real time to determine if the user's demand information is received. This may be a natural language description, instructions, or other form of demand information entered by the user in the application.
Demand information extraction (S302): once the system detects the demand information entered by the user, it extracts and parses the information to obtain specific demand instructions corresponding to the demand information. This process may include natural language processing, text analysis, etc. techniques to understand the intent of the user.
User interface construction (S303): based on the obtained demand instructions, the system automatically builds a user interface. This may include selecting appropriate interface elements, layouts, and components to meet the needs of the user. The interface may be built using existing libraries and templates of low-code components or dynamically generated code.
The technical scheme has the effects that: responding to the user demand in real time: the technical scheme of the embodiment can monitor and respond to the requirement information input by the user in real time, so that the user can quickly acquire the interface which the user wants.
The user threshold is reduced: users do not need to know the technical details of application development deeply, and only need to describe the requirements of the users, the system can help the users to construct interfaces, and the threshold of application development is reduced.
Development efficiency is improved: the automatic construction of the user interface reduces the effort of manually writing code, improving development efficiency, especially for rapid prototyping or small applications.
And the user experience is improved: users can directly participate in the interface construction process according to the requirements of the users, so that the expectations of the users are better met, and the user experience is improved.
In a word, the technical scheme of the embodiment enables the development process of the application program to be more intelligent, efficient and user-friendly by detecting and analyzing the user demand information in real time and automatically constructing the user interface.
In one embodiment of the present invention, the language model is used to analyze the instruction information input by the user, and the function loading is performed on the user interface according to the analysis result and the user's requirement, including:
s401, after the user interface is built, automatically building a virtual server, wherein the virtual server is used for receiving the assembly requirements of a user;
s402, after receiving the component demands of a user, the virtual server sends the component demands to a language model, and component calling instructions corresponding to the component demands are obtained through analysis of the language model;
s403, calling a target component corresponding to the instruction into a low-code component library according to the component calling instruction, and loading the target component into a user interface until all functions required by all users are loaded.
The working principle of the technical scheme is as follows: virtual server build (S401): firstly, after the user interface is constructed, the system automatically builds a virtual server. The role of this virtual server is to receive the user's component requirements and to handle the resolution of those requirements.
Component demand reception (S402): when the virtual server receives the user's component requirements, it sends those requirements into the language model for parsing. The language model analyzes the requirements and identifies the type, nature, and behavior of the components requested by the user.
Component loading (S403): and according to the analysis result of the language model, the system sends a corresponding component calling instruction to the low-code component library. The low code component library loads the target components required by the user according to the instructions and dynamically integrates these components into the user interface. This process is repeated until all of the functions required by the user are fully loaded.
The technical scheme has the effects that: automated component loading: the technical scheme of the embodiment realizes automatic analysis and component loading of the user demands without manual operation. This greatly simplifies the development process of the application.
Flexibility: users can describe their needs in natural language to achieve corresponding component loading. This increases the flexibility of the application program, enabling the user to dynamically modify interfaces and functions as desired.
Development efficiency is improved: automated component loading reduces the effort of manually writing and integrating code, improving development efficiency, especially when dealing with rapidly changing demands.
The method is user-friendly: the user does not need to go deep into technical details, but only needs to provide the natural language requirement description, so that the development of the application program is more user-friendly.
In a word, the above technical solution of the present embodiment combines the language model and the low-code component library, so as to implement intelligent analysis and function loading of user requirements, and make development of application programs more intelligent, efficient and user-friendly.
In one embodiment of the present invention, testing and verifying a user interface after function loading, and deploying the user interface with function loading after testing and verifying to a low code platform, including:
s501, testing and verifying a user interface after all functions required by a user are loaded; when the test result shows that the function operation is abnormal, continuing to perform abnormal operation alarm;
s502, after the user interface with the loaded function completes testing and verification, and the testing and verification result shows that the function of the user interface is normal, deploying the user interface to a low-code platform;
s503, the low-code platform manages the user interface, performs periodic function test and performs maintenance management.
The working principle of the technical scheme is as follows: functional test and verification (S501): once the function loading required by the user is completed, the system tests and verifies the user interface after the function loading. This includes testing the individual functional modules to ensure that they are functioning properly. If the test result shows that some functions are abnormal, the system can trigger an abnormal alarm to inform relevant maintenance personnel or developers.
User interface deployment (S502): when the user interface with the loaded function is tested and verified, and the test result shows that all the functions are normally operated, the system deploys the user interface on the low-code platform so that the user interface can be used by a user or a client.
Management and maintenance (S503): the low code platform will manage and regularly test the functionality of the deployed user interface. This includes monitoring the performance, safety and stability of the interface and performing maintenance management if necessary. Maintenance management may include repairing potential problems, updating components, extending functionality, and the like.
The technical scheme has the effects that: and (3) quality assurance: through functional test and verification, the system can ensure that each functional module of the user interface operates normally and provides high-quality application programs.
Stability and reliability: periodic functional testing and maintenance management may enhance the stability and reliability of the user interface, reducing potential failures and problems.
User satisfaction: the maintenance and management ensures good performance and user experience of the user interface, and improves user satisfaction.
Quick response problem: the anomaly alarm mechanism can quickly notify the relevant maintenance personnel or developers, enabling them to quickly respond and resolve potential problems, thereby reducing downtime of the system.
In a word, the above technical solution of the present embodiment ensures the quality and stability of the user interface after function loading through testing, verifying and maintaining the management flow, and improves the reliability and user satisfaction of the application program.
The embodiment of the invention provides a low-code component generating system based on LLM, as shown in figure 2, comprising:
the component code collection module is used for collecting component codes in the low-code component library;
the language model training module is used for training the language model by utilizing the component codes to obtain a trained language model;
the automatic user interface construction module is used for detecting whether the demand information input by the user is received or not in real time and automatically constructing a user interface according to the demand information input by the user;
the interface function automatic loading module is used for analyzing instruction information input by a user by utilizing the language model and loading functions on a user interface according to the analysis result and the user requirement;
the interface testing and deploying module is used for testing and verifying the user interface after the function loading and deploying the user interface with the function loading to the low-code platform after the testing and verifying are completed.
The working principle of the technical scheme is as follows: component code collection: code is collected for various components in the low code component library, which may include interface elements, functional modules, business logic, and the like.
Training a language model: the collected component codes are utilized to train the language model. This training process enables the language model to understand and generate natural language descriptions related to application development.
Demand information detection and user interface construction: the system detects the user's input of demand information in real time, possibly a natural language description or instruction of the user. Based on this demand information, the system automatically constructs a user interface, selecting the appropriate components and layout to meet the user's demand.
Instruction information parsing and function loading: the system analyzes instruction information input by the user by using the trained language model. The parsing results determine the user's needs, and the system then automatically loads the corresponding functional modules and components on the user interface according to these needs.
Testing, verifying and deploying: the system tests and verifies the user interface after the function loading, and ensures that each component and each function module normally operate. After testing and verification, the system deploys the user interface with function loading onto the low code platform so that it can be further edited and used by the user.
The technical scheme has the effects that: and (3) automatic development: the technical scheme of the embodiment realizes the automation of the development of the application program, and a developer does not need to manually write most codes, so that the development efficiency is improved.
The development threshold is reduced: the user only needs to provide the requirement information, does not need to know the details of programming or components in depth, reduces the development threshold, and enables more people to participate in the development of the application program.
Fast iteration: due to the automated generation and construction, development teams can iterate and adjust more quickly to meet the changes in user demand.
Error rate reduction: automatically generated code and user interfaces typically have fewer errors and consistency problems because they are generated from language models and component libraries.
In a word, the above technical solution of the embodiment realizes the goal of automatic application program development by combining the language model and the low-code component library, improves the development efficiency, reduces the development threshold, reduces errors, accelerates the release period of the application program, and enhances the reliability and stability of the application program.
In one embodiment of the present invention, the component code collection module includes:
the component library scanning module is used for scanning the first code component library to acquire the component types in the first code component library;
the code acquisition module is used for sequentially acquiring corresponding component codes of the components contained in each component type;
wherein the component type forms, charts, data displays and the like.
The working principle of the technical scheme is as follows: component type scanning: the system scans the first code component library to obtain a list of different component types therein. These component types may include buttons, forms, charts, text boxes, and the like.
Component code acquisition: next, the system traverses each component type in turn and obtains the code of the specific component contained within each component type. This may be accomplished by accessing a code store or repository of component libraries to extract the source code for each component.
The technical scheme has the effects that: component library content collection: the above-mentioned technical solution of the present embodiment enables the system to automatically collect various component codes in the low-code component library without manual collection or writing.
And (3) resource arrangement: by retrieving code for each component type, the system can better organize and manage the resources in the component library, making it easy to access and use.
Enhancing development usability: collecting component code may provide example code for developers, helping them know how to use different types of components, thereby enhancing the usability of the low code platform.
Development efficiency is improved: the collected component codes can be used for automatically generating interfaces and functions of application programs, so that development efficiency is improved, and the workload of manually writing codes is reduced.
In a word, the above technical solution of the present embodiment helps a developer to access and use the components more easily by automatically collecting component codes in the low-code component library, thereby improving development efficiency and developer experience.
In one embodiment of the present invention, the user interface automatic construction module includes:
the demand information receiving module is used for detecting whether demand information input by a user is received or not in real time;
the extraction module is used for extracting the demand information after detecting the demand information input by a user, and obtaining a demand instruction corresponding to the demand information;
and the interface automatic construction module is used for automatically constructing a user interface according to the requirement.
The working principle of the technical scheme is as follows: and (3) detecting the demand information: the system monitors the user's input in real time to determine if the user's demand information is received. This may be a natural language description, instructions, or other form of demand information entered by the user in the application.
And (3) extracting demand information: once the system detects the demand information entered by the user, it extracts and parses the information to obtain specific demand instructions corresponding to the demand information. This process may include natural language processing, text analysis, etc. techniques to understand the intent of the user.
User interface construction: based on the obtained demand instructions, the system automatically builds a user interface. This may include selecting appropriate interface elements, layouts, and components to meet the needs of the user. The interface may be built using existing libraries and templates of low-code components or dynamically generated code.
The technical scheme has the effects that: responding to the user demand in real time: the technical scheme of the embodiment can monitor and respond to the requirement information input by the user in real time, so that the user can quickly acquire the interface which the user wants.
The user threshold is reduced: users do not need to know the technical details of application development deeply, and only need to describe the requirements of the users, the system can help the users to construct interfaces, and the threshold of application development is reduced.
Development efficiency is improved: the automatic construction of the user interface reduces the effort of manually writing code, improving development efficiency, especially for rapid prototyping or small applications.
And the user experience is improved: users can directly participate in the interface construction process according to the requirements of the users, so that the expectations of the users are better met, and the user experience is improved.
In a word, the technical scheme of the embodiment enables the development process of the application program to be more intelligent, efficient and user-friendly by detecting and analyzing the user demand information in real time and automatically constructing the user interface.
In one embodiment of the present invention, the automatic interface function loading module includes:
the server building module is used for automatically building a virtual server after the user interface is built, wherein the virtual server is used for receiving the assembly requirements of a user;
the instruction acquisition module is used for sending the component requirements to a language model after the virtual server receives the component requirements of a user, and acquiring component calling instructions corresponding to the component requirements through analysis of the language model;
and the automatic function loading execution module is used for calling a target component corresponding to the instruction into the low-code component library according to the component calling instruction, and loading the target component into a user interface until all functions required by the user are loaded.
The working principle of the technical scheme is as follows: building a virtual server: firstly, after the user interface is constructed, the system automatically builds a virtual server. The role of this virtual server is to receive the user's component requirements and to handle the resolution of those requirements.
And (3) receiving component requirements: when the virtual server receives the user's component requirements, it sends those requirements into the language model for parsing. The language model analyzes the requirements and identifies the type, nature, and behavior of the components requested by the user.
Component loading: and according to the analysis result of the language model, the system sends a corresponding component calling instruction to the low-code component library. The low code component library loads the target components required by the user according to the instructions and dynamically integrates these components into the user interface. This process is repeated until all of the functions required by the user are fully loaded.
The technical scheme has the effects that: automated component loading: the technical scheme of the embodiment realizes automatic analysis and component loading of the user demands without manual operation. This greatly simplifies the development process of the application.
Flexibility: users can describe their needs in natural language to achieve corresponding component loading. This increases the flexibility of the application program, enabling the user to dynamically modify interfaces and functions as desired.
Development efficiency is improved: automated component loading reduces the effort of manually writing and integrating code, improving development efficiency, especially when dealing with rapidly changing demands.
The method is user-friendly: the user does not need to go deep into technical details, but only needs to provide the natural language requirement description, so that the development of the application program is more user-friendly.
In a word, the above technical solution of the present embodiment combines the language model and the low-code component library, so as to implement intelligent analysis and function loading of user requirements, and make development of application programs more intelligent, efficient and user-friendly.
In one embodiment of the present invention, the interface testing and deploying module comprises:
the testing module is used for testing and verifying the user interface after the functions required by the user are loaded after all the functions are loaded; when the test result shows that the function operation is abnormal, continuing to perform abnormal operation alarm;
the deployment module is used for deploying the user interface to the low-code platform after the user interface with the loaded function completes testing and verification and the testing and verification result shows that the function of the user interface is normal;
and the operation and maintenance module is used for managing, periodically testing the functions and maintaining and managing the user interface by the low-code platform.
The working principle of the technical scheme is as follows: functional test and verification: once the function loading required by the user is completed, the system tests and verifies the user interface after the function loading. This includes testing the individual functional modules to ensure that they are functioning properly. If the test result shows that some functions are abnormal, the system can trigger an abnormal alarm to inform relevant maintenance personnel or developers.
User interface deployment: when the user interface with the loaded function is tested and verified, and the test result shows that all the functions are normally operated, the system deploys the user interface on the low-code platform so that the user interface can be used by a user or a client.
Management and maintenance: the low code platform will manage and regularly test the functionality of the deployed user interface. This includes monitoring the performance, safety and stability of the interface and performing maintenance management if necessary. Maintenance management may include repairing potential problems, updating components, extending functionality, and the like.
The technical scheme has the effects that: and (3) quality assurance: through functional test and verification, the system can ensure that each functional module of the user interface operates normally and provides high-quality application programs.
Stability and reliability: periodic functional testing and maintenance management may enhance the stability and reliability of the user interface, reducing potential failures and problems.
User satisfaction: the maintenance and management ensures good performance and user experience of the user interface, and improves user satisfaction.
Quick response problem: the anomaly alarm mechanism can quickly notify the relevant maintenance personnel or developers, enabling them to quickly respond and resolve potential problems, thereby reducing downtime of the system.
In a word, the above technical solution of the present embodiment ensures the quality and stability of the user interface after function loading through testing, verifying and maintaining the management flow, and improves the reliability and user satisfaction of the application program.
It will be apparent to those skilled in the art that various modifications and variations can be made to the present invention without departing from the spirit or scope of the invention. Thus, it is intended that the present invention also include such modifications and alterations insofar as they come within the scope of the appended claims or the equivalents thereof.
Claims (10)
1. A LLM-based low code component generating method, the low code component generating method comprising:
collecting component codes in a low-code component library;
training the language model by utilizing the component codes to obtain a trained language model;
detecting whether demand information input by a user is received or not in real time, and automatically constructing a user interface according to the demand information input by the user;
analyzing instruction information input by a user by utilizing a language model, and loading functions on a user interface according to the analysis result and the user requirements;
and testing and verifying the user interface after the function loading, and deploying the user interface with the function loading which is tested and verified to a low-code platform.
2. The low code component generation method of claim 1, wherein collecting component code in a low code component library comprises:
scanning the first code component library to obtain component types in the first code component library;
sequentially acquiring corresponding component codes of each component type and the components contained in the components;
wherein the component type forms, charts, data displays and the like.
3. The low-code component generating method according to claim 1, wherein detecting in real time whether demand information input by a user is received, and automatically constructing a user interface according to the demand information input by the user, comprises:
detecting whether demand information input by a user is received or not in real time;
after detecting that demand information input by a user is received, extracting the demand information to obtain a demand instruction corresponding to the demand information;
and according to the requirements, automatically constructing a user interface by the instruction.
4. The low-code component generating method according to claim 1, wherein parsing instruction information input by a user using a language model, and performing function loading on a user interface according to a user's requirement according to a parsing result, comprises:
after the user interface is built, automatically building a virtual server, wherein the virtual server is used for receiving the component demands of a user;
after receiving the component demands of the user, the virtual server sends the component demands to a language model, and a component calling instruction corresponding to the component demands is obtained through analysis of the language model;
and calling a target component corresponding to the instruction into a low-code component library according to the component calling instruction, and loading the target component into a user interface until all functions required by the user are loaded.
5. The low code component generating method according to claim 1, wherein testing and verifying the function loaded user interface and deploying the tested and verified user interface with the function loaded to the low code platform comprises:
after all functions required by a user are loaded, testing and verifying the user interface after the functions are loaded; when the test result shows that the function operation is abnormal, continuing to perform abnormal operation alarm;
after the user interface with the loaded function completes testing and verification, and the testing and verification result shows that the function of the user interface is normal, deploying the user interface to a low-code platform;
the low code platform manages the user interface, periodically tests functions and maintains and manages.
6. A LLM based low code component generating system, the low code component generating system comprising:
the component code collection module is used for collecting component codes in the low-code component library;
the language model training module is used for training the language model by utilizing the component codes to obtain a trained language model;
the automatic user interface construction module is used for detecting whether the demand information input by the user is received or not in real time and automatically constructing a user interface according to the demand information input by the user;
the interface function automatic loading module is used for analyzing instruction information input by a user by utilizing the language model and loading functions on a user interface according to the analysis result and the user requirement;
the interface testing and deploying module is used for testing and verifying the user interface after the function loading and deploying the user interface with the function loading to the low-code platform after the testing and verifying are completed.
7. The low code component generation system of claim 6, wherein the component code collection module comprises:
the component library scanning module is used for scanning the first code component library to acquire the component types in the first code component library;
the code acquisition module is used for sequentially acquiring corresponding component codes of the components contained in each component type;
wherein the component type forms, charts, data displays and the like.
8. The low code component generation system of claim 6, wherein the user interface auto-build module comprises:
the demand information receiving module is used for detecting whether demand information input by a user is received or not in real time;
the extraction module is used for extracting the demand information after detecting the demand information input by a user, and obtaining a demand instruction corresponding to the demand information;
and the interface automatic construction module is used for automatically constructing a user interface according to the requirement.
9. The low code component generation system of claim 6, wherein the interface function auto-load module comprises:
the server building module is used for automatically building a virtual server after the user interface is built, wherein the virtual server is used for receiving the assembly requirements of a user;
the instruction acquisition module is used for sending the component requirements to a language model after the virtual server receives the component requirements of a user, and acquiring component calling instructions corresponding to the component requirements through analysis of the language model;
and the automatic function loading execution module is used for calling a target component corresponding to the instruction into the low-code component library according to the component calling instruction, and loading the target component into a user interface until all functions required by the user are loaded.
10. The low code component generation system of claim 6, wherein the interface test and deployment module comprises:
the testing module is used for testing and verifying the user interface after the functions required by the user are loaded after all the functions are loaded; when the test result shows that the function operation is abnormal, continuing to perform abnormal operation alarm;
the deployment module is used for deploying the user interface to the low-code platform after the user interface with the loaded function completes testing and verification and the testing and verification result shows that the function of the user interface is normal;
and the operation and maintenance module is used for managing, periodically testing the functions and maintaining and managing the user interface by the low-code platform.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311105967.1A CN117215550A (en) | 2023-08-30 | 2023-08-30 | LLM-based low-code component generation method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311105967.1A CN117215550A (en) | 2023-08-30 | 2023-08-30 | LLM-based low-code component generation method and system |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117215550A true CN117215550A (en) | 2023-12-12 |
Family
ID=89043462
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311105967.1A Pending CN117215550A (en) | 2023-08-30 | 2023-08-30 | LLM-based low-code component generation method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117215550A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117492736A (en) * | 2023-10-31 | 2024-02-02 | 慧之安信息技术股份有限公司 | Low-code platform construction method and system based on large model |
| CN117806621A (en) * | 2024-03-01 | 2024-04-02 | 彩虹无线（北京）新技术有限公司 | Model building system, method and device for creating custom assembly and electronic equipment |
-
2023
- 2023-08-30 CN CN202311105967.1A patent/CN117215550A/en active Pending
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117492736A (en) * | 2023-10-31 | 2024-02-02 | 慧之安信息技术股份有限公司 | Low-code platform construction method and system based on large model |
| CN117806621A (en) * | 2024-03-01 | 2024-04-02 | 彩虹无线（北京）新技术有限公司 | Model building system, method and device for creating custom assembly and electronic equipment |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN117215550A (en) | LLM-based low-code component generation method and system | |
| US8584079B2 (en) | Quality on submit process | |
| US20170329687A1 (en) | Functional Behaviour Test System and Method | |
| US8731896B2 (en) | Virtual testbed for system verification test | |
| Roehm et al. | Monitoring user interactions for supporting failure reproduction | |
| US20220107882A1 (en) | Rendering engine component abstraction system | |
| CN111221729B (en) | Automatic testing method and system for separating platform service from testing service | |
| CN117215551A (en) | LLM-based low-code application development method and system | |
| CN106354629A (en) | Construction method of iOS system mobile application automatic test system based on multiple stages of servers | |
| CN104199767A (en) | Test method and device | |
| Martinie et al. | DREAMER: a design rationale environment for argumentation, modeling and engineering requirements | |
| CN105513443A (en) | System and method for updating learning record by learning process to recover learning schedule | |
| CN112911283B (en) | Smart television testing method and device | |
| CN112667517A (en) | Method, device, equipment and storage medium for acquiring automatic test script | |
| Parkhomenko | Implementation of reusable solutions for remote laboratory development | |
| CN111176624B (en) | Method and device for generating stream type calculation index | |
| US9477492B2 (en) | Deploying multi-channel or device agnostic applications | |
| CN111078524A (en) | Continuous integration test method based on electric power 6+1 system | |
| CN116225441B (en) | Code hosting method and system for online coding system | |
| Barcelona et al. | Applying a model-based methodology to develop web-based systems of systems | |
| US20240104004A1 (en) | Intelligent accessibility testing | |
| Butt et al. | Usability Evaluation Techniques for Agile Software Model. | |
| CN112579455B (en) | Automatic interface testing method and device, electronic equipment and storage medium | |
| CN117055940A (en) | Application inspection method and system | |
| Baumgartner et al. | Use of Tools in Agile Projects |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |