Automatic page generation method of software construction platform based on large language model

Abstract

The invention discloses an automatic page generation method of a software construction platform based on a large language model, which comprises the following steps of: extracting a scene, a page and constraint description from a natural language demand, and generating JSON (JavaScript Object Notation) content containing a data model, a query condition, a table column and static data through the large language model; according to component type constraints and verification rules, the JSON is mapped to components and combinations of buttons, labels, texts, pictures, pull-down selection, multi-choice, single choice, tables, dates and the like of the code-free construction platform; and automatically filling a component set based on the upper and lower partition templates, and injecting static data and verification logic. Through industry knowledge adaptation, component semantic binding and dynamic constraint, it is ensured that the page conforms to field specifications and interaction logic, the learning cost is reduced, manual intervention is reduced, and the method is suitable for the fields of smart cities, natural resources, urban and rural residence construction, emergency management, enterprise digital transformation and the like.

Description

TECHNICAL FIELD

[0001] The application belongs to the technical field of software development, and particularly relates to a page automatic generation method of a software construction platform based on a large language model. BACKGROUND

[0002] In the current field of software development, no-code development platforms significantly reduce the programming threshold by encapsulating general components (such as buttons, tables, input boxes, etc.) and providing drag-and-drop page design functions. Users can quickly build software pages through visual operations, for example, in the homestead approval scenario in the agricultural and rural field, the "right of use person" field is represented by combining labels and text boxes, and its read-only or editing state is controlled. However, the existing no-code platform still has significant defects: complex operation (manual dragging of components and configuration of attributes), dependence on user experience (page effectiveness and aesthetics are limited by individual ability), low efficiency (complex scenarios require repeated adjustments to the design), and difficulty in meeting the rapid iteration requirements.

[0003] At the same time, although the large language model (LLM) can generate code according to natural language requirements, its application has limitations. For example, generating a complete page requires multiple rounds of requirement dialogues, and the accuracy of the questions asked to the user is extremely high; the generated code may not meet the platform specifications and requires manual secondary adjustment; and there is a lack of deep integration of industry knowledge (such as natural resource management), resulting in a disconnection between the results and actual business requirements.

[0004] The existing technology has not effectively combined the component specifications of the no-code platform and the natural language parsing capabilities of the large language model. For example, in the traditional no-code platform, the user needs to manually design the combination of labels and input boxes for the "right of use person" field and configure constraint rules (such as text length, date format); and a page generated solely relying on the large language model may miss key constraints and need to be repeatedly corrected. This separation results in low development efficiency and uncontrollable page quality.

[0005] Therefore, there is an urgent need for a technical solution that can automatically generate page designs that meet industry specifications and can be directly run through natural language requirements, while reducing the operation threshold and reducing human intervention, to solve the dual bottleneck of efficiency and quality in the existing technology. SUMMARY

[0006] To solve the above technical problems, the application provides a page automatic generation method of a software construction platform based on a large language model to solve the problems existing in the prior art.

[0007] In the first aspect, to achieve the above object, the application provides a page automatic generation method of a software construction platform based on a large language model, comprising the following steps:

[0008] Based on the natural language requirement description, the large language model extracts the scene description, page description and constraint description, and supplements the missing field and constraint information;

[0009] The scene description, page description and constraint description are converted into JSON format content by the large language model, and the JSON format content includes data model, query condition, table column and table static data;

[0010] The JSON format content is mapped to a component set of a code-free development platform, and the component set includes a query component set, a table component and a function button;

[0011] According to a preset upper and lower partition page template, the query component set is filled into the query area of the template, the table component is filled into the table area of the template, and the table static data is injected;

[0012] Based on the check rules and component type constraints in the constraint description, the attributes of the query component set and the table component are automatically configured.

[0013] Optionally, the process of extracting the scene description, page description and constraint description includes:

[0014] Separating industry domain and application scenario information from the natural language requirement as the scene description;

[0015] Extracting field name, field type and page function requirement from the natural language requirement as the page description;

[0016] Extracting field quantity limit, component type constraint and data check rule from the natural language requirement as the constraint description;

[0017] When the field quantity of the page description does not meet the field quantity limit of the constraint description, the missing field and constraint information are supplemented based on the scene description by the large language model.

[0018] Optionally, the JSON format content includes DataModels, QueryConditions, TableItems and TableDatas;

[0019] The DataModels are a collection of data models, and each element in the data model is defined by Chinese name, English name, field type and default value;

[0020] The QueryConditions are a collection of query conditions, the TableItems are a collection of table columns, and the TableDatas are a collection of table static data;

[0021] The fields in the QueryConditions and TableItems correspond one-to-one with the fields in the DataModels.

[0022] Optionally, the process of mapping to the set of components of the code-free development platform comprises:

[0023] According to the component type constraint in the constraint description, the fields in the QueryConditions are mapped to input boxes, drop-down selection or date selection components;

[0024] According to the field type of the data model, the fields in the TableItems are mapped to text, numerical value or date components;

[0025] The static data in the TableDatas is injected into the table component according to the field order of the TableItems, and is bound with the verification rules.

[0026] Optionally, the process of filling the upper and lower partition page templates comprises:

[0027] The query components are arranged in the query area, and a query button and a clear button are added;

[0028] The table columns are set in the table area according to the field order of the TableItems, and the table header style is configured;

[0029] The static data in the TableDatas is filled into the table component by rows, and each row of data is consistent with the field order of the table columns.

[0030] Optionally, the verification rules in the constraint description include text length limit, numerical value range constraint and date format verification;

[0031] The verification rules are defined by JSON nesting, and are bound with the attributes of the query components and the table components;

[0032] The numerical value range constraint includes minimum value, maximum value and integer type limit, and the date format verification includes date separator and year-month-day order.

[0033] In a second aspect, the present application further provides a page automatic generation system of a software construction platform based on a large language model, for implementing a page automatic generation method of a software construction platform based on a large language model, the system comprising:

[0034] A requirement analysis module is configured to extract scene description, page description and constraint description from natural language requirements, and supplement missing field information.

[0035] The model processing module is configured to convert the scene description, the page description, and the constraint description into JSON format content including a data model, a query condition, a table column, and table static data by using a large language model.

[0036] The component mapping module is configured to map the JSON format content to a query component, a table component, and a function button of a code-free development platform.

[0037] The page generation module is configured to fill the query component into a query area of a template, fill the table component into a table area of the template, and inject the table static data according to an upper-lower partition page template.

[0038] The rule configuration module is configured to configure attributes of the query component and the table component based on a check rule and a component type constraint in the constraint description.

[0039] Optionally, the requirement analysis module includes:

[0040] The scene description separation unit is configured to separate industry domain and application scenario information from the natural language requirement.

[0041] The page description extraction unit is configured to extract a field name, a field type, and a page function requirement.

[0042] The constraint description extraction unit is configured to extract a field quantity limit, a component type constraint, and a data check rule.

[0043] The field supplement unit is configured to call a large language model to supplement missing field information when the field quantity of the page description does not meet the field quantity limit of the constraint description.

[0044] In a third aspect, the present application further provides a computer terminal device, including:

[0045] One or more processors;

[0046] A memory coupled to the processor, configured to store one or more programs;

[0047] When the one or more programs are executed by the one or more processors, the one or more processors implement a page automatic generation method of a software construction platform based on a large language model.

[0048] In a fourth aspect, the present application further provides a computer readable storage medium having a computer program stored thereon, and the computer program is executed by a processor to implement a page automatic generation method of a software construction platform based on a large language model.

[0049] Compared with the prior art, the present application has the following advantages and technical effects:

[0050] The application provides a page automatic generation method of a software construction platform based on a large language model. BRIEF DESCRIPTION OF DRAWINGS

[0051] The accompanying drawings, which form a part of the specification, are included to provide a further understanding of the application and are incorporated herein in conjunction with the description of the application. The embodiments of the present application, together with its advantages, can be understood by reference to the following detailed description, taken in conjunction with the accompanying drawings, in which:

[0052] Figure 1 The design framework schematic diagram of the application platform of the embodiments of the present application;

[0053] Figure 2 The page schematic diagram of the embodiments of the present application;

[0054] Figure 3 The generation process schematic diagram of the page of the embodiments of the present application;

[0055] Figure 4 The extraction process step schematic diagram of the requirement information of the embodiments of the present application;

[0056] Figure 5 The automatic mapping step schematic diagram of the page query component set of the embodiments of the present application;

[0057] Figure 6 The automatic mapping step schematic diagram of the table column set of the embodiments of the present application. DETAILED DESCRIPTION

[0058] It should be noted that the embodiments in the present application and the features in the embodiments can be combined with each other without conflict. The present application will be described in detail below with reference to the accompanying drawings and in conjunction with the embodiments.

[0059] It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a group of computer executable instructions, and although the logical order is shown in the flowchart, in some cases, the steps shown or described herein can be executed in an order different from that shown herein.

[0060] The no-code development platform is a kind of platform that can support the combination of various software components and objects to form a page by means of dragging, realizes the encapsulation of general components and objects, and can reduce the engineering quantity of programming to a certain extent, but the manual dragging form of page combination has a high learning threshold, and the building process is time-consuming and laborious. Although the large language model can design a software page according to the natural language demand and generate code, it may need to go through dozens of rounds of demand dialogue to generate a complete page, and the questioning level of the user is too high. The present application provides a large language model introduced into the no-code development platform, which combines the platform use requirements, implants the thinking chain prompt of the large language model in the platform, so that the platform can automatically generate the main components of the software including the data model, the software page, the process form and the API service, which not only reduces the learning cost of the no-code platform, but also reduces the communication frequency and illusion with the large language model, and improves the efficiency of software development.

[0061] In various software applications, the combination of query conditions, buttons and tables for displaying query results is the most common type of page, the query conditions come from the business knowledge of the field, and are represented by a combination of labels and other assignable components, for example, in the field of agriculture and rural areas, the homestead right user field is represented by a combination of labels and texts in the page, the label identifies its field name "right user", and the text is used to represent the actual value of the right user, and the read-only or edit state of the text component is controlled by whether the value is allowed to be modified. In the traditional no-code platform, the user analyzes the representation method of each type of knowledge according to the business demand, and manually designs the page in the canvas, which is time-consuming and laborious, and the effectiveness and aesthetics of the page design are limited by the personal experience of the user. The present application provides a method for automatically generating a page through natural language demand, which extracts key information from the page demand description through a large language model, and finds more comprehensive industry knowledge according to the key information, and outputs the solution to the demand in the format agreed by the no-code platform, and finally completes the design of the page through the intelligent guide of the no-code platform.

[0062] First, the technical terms involved in the following embodiments are described.

[0063] The platform can support software architecture automatic generation and runtime construction through natural language demand description, the platform adopts a micro-service-based architecture, which is divided into a data and knowledge layer, a service layer, a network layer and an application layer, as shown in Figure 1 .

[0064] (1) Data and knowledge layer

[0065] Data includes two types of basic data and application data, basic data refers to the function support data provided by the platform for data model design, user interface element combination design and software behavior chain design, including all objects and their metadata for constructing scene user interface, service and other software behavior model data, configuration model and dependency model data for runtime automatic construction, framework data of software architecture, user and permission data of the platform, etc.; application data refers to the data generated by the data model, user interface element combination and software behavior chain of the software constructed through the basic data and capabilities of the platform, and software architecture data. Knowledge includes spatial data model knowledge, user interface visualization knowledge, user interface template knowledge, service model knowledge and prompt template knowledge, etc.

[0066] (2) Service layer

[0067] The service layer includes various micro-service instances and agent services, micro-service instances cover services used by the platform for software design visualization and runtime construction through human-computer interaction, including data model design service, interface design service, software behavior chain design service, process design service, API design service, code generation service, application construction service, map service, user authentication service and resource management service; agent service is a combination of a series of behaviors after the agent receives the demand described in natural language with a large language model as the core, including natural language understanding, vectorization, knowledge retrieval, tool set management, task reasoning and task execution.

[0068] (3) Network layer

[0069] The network layer is a connection layer for micro-services and agent services to be used in language user interface terminals, providing service scheduling and security capabilities in the Internet environment. Micro-service architecture divides complex systems into multiple independently running services, relying on the dependency relationship between services for service orchestration, and each service solves a single business goal.

[0070] (4) Application layer

[0071] The application layer is manifested as task orchestration and runtime automatic construction during software design in the language user interface LUI, during design, through human-computer interaction with LUI and agent, defining the data model, user interface element set, software behavior chain set and their association of the software in a visual way, based on the analysis model, encapsulation method and dependency model of software architecture, realizing the automatic generation and construction of runtime software, supporting applications in multiple fields such as smart city, natural resources, urban and rural housing, emergency management, etc.

[0072] Page automatic generation method:

[0073] The components involved in the present application include basic components (buttons, labels, text, pictures), container components (layout containers, flexible containers, pop-up windows), input components (input boxes, text fields, drop-down selections, multiple selection boxes, single selection boxes, date selections, file uploads), and data components (table components, query components). The common attributes of each component include width, height, position, and margin, and each type of component has independent special attributes. The basic components include font size, color, font, background style, etc. The container components include alignment, overflow hiding, positioning, etc. The input components include label width, prompt, input restrictions, disable, read-only, etc. The data components include zebra texture, border style, table header style, pagination parameters, line spacing, etc. The description of the attributes is represented in JSON format in multiple levels. The business model is derived from industry knowledge and is represented as a combination of fields. Each field is defined by metadata. The metadata description includes field type, page expression method, and field constraints. The field type includes text, number, decimal, date, long text, date and time, and Boolean. The page expression method includes the binding of fields and components, such as the binding of the file name to the input box, the binding of the file type to the drop-down selection, and the binding of the warehouse time to the date selection. The field constraints are represented in JSON and include text length, phone number, email, and numerical range. For example, in the homestead approval scenario, the "user" field is described as:

[0074] {Type:text,VisualType:text,Constraint:{Length:128}}.

[0075] The page is represented in an upper and lower partition structure. The upper part is the query component set visualization area, and the lower part is the table used to display the query structure set. The structure is divided by the container component. The schematic diagram is shown in Figure 2 . The upper part is filled with components representing query conditions, buttons triggering queries and clearing queries, and the lower part is filled with tables representing query result sets. The fields of the query conditions and the query result sets come from the aforementioned business model. The page generation process is shown in Figure 3 .

[0076] Embodiment One

[0077] As shown in Figure 3 , the present embodiment provides a page automatic generation method based on a large language model software construction platform, which includes:

[0078] Based on the natural language requirement description, the large language model extracts the scene description, page description, and constraint description, and supplements the missing field and constraint information.

[0079] The scene description, the page description and the constraint description are converted into JSON format content by a large language model, the JSON format content including a data model, a query condition, a table column and table static data;

[0080] The JSON format content is mapped to a component set of a code-free development platform, the component set including a query component set, a table component and a function button;

[0081] According to a preset upper and lower partition page template, the query component set is filled into a query area of the template, the table component is filled into a table area of the template, and the table static data is injected;

[0082] Based on the check rules and the component type constraints in the constraint description, the attributes of the query component set and the table component are automatically configured.

[0083] As an implementation manner in the embodiment, the process of extracting the scene description, the page description and the constraint description includes:

[0084] Industry domain and application scenario information is separated from the natural language requirement as the scene description;

[0085] Field name, field type and page function requirement are extracted from the natural language requirement as the page description;

[0086] Field quantity limit, component type constraint and data check rule are extracted from the natural language requirement as the constraint description;

[0087] When the field quantity of the page description does not meet the field quantity limit of the constraint description, missing fields and constraint information are supplemented based on the scene description by a large language model.

[0088] Specifically, the first step is to construct an extraction method of page requirement information and a specification of large language model output content, so as to limit the understanding and reasoning range of the large language model.

[0089] The output content is represented in JSON format. The requirement information includes three types of necessary content: scenario description, page description, and constraint description. The scenario description includes industry description and application description, such as natural resource field, urban renewal field, and emergency management field, which constitute the macro constraints for large language model reasoning. The application description is further refined based on the industry description, such as the archive digital management system in the natural resource field as the behavior background, providing more detailed constraints for the large model. The page description is used to prompt the large language model to express the industry knowledge of the current page, such as: "generate a natural resource industry archive management detail page, including at least archive name, archive number, archive status, archive type, archive classification, and storage time fields". The constraint description includes quantity limitation of expression content, field expression form constraint, and expression content verification rules, etc. For example, the quantity limitation of expression content can be described as "not less than 15 common fields" and "provide fields according to importance with a total number not more than 20". The field expression form constraint can be described as "archive number is displayed in read-only form" and "archive source is represented in drop-down selection form". The expression content verification rules can be described as "the components displaying phone numbers need to be verified in mobile phone number format", "the components displaying email addresses need to be verified in email format", and "archive page number can only be a positive integer".

[0090] The extraction of requirement information is grouped and organized according to the above three types of necessary content. The large language model is guided to understand and reason through prompt words, which contain thinking chain logic. The original input is represented by Requirements, and the available component set, interpretation, and value verification rules in the no-code platform are used as prompt word information. The steps of requirement information extraction are shown in Figure 4 , as follows:

[0091] (1) Extract industry and specific application information ScenarioInfo from Requirements;

[0092] (2) Extract page description information PageInfo from Requirements;

[0093] (3) Extract constraint information Constraints from Requirements;

[0094] (4) If ScenarioInfo is empty, prompt the user for information supplement and exit; otherwise, go to (5);

[0095] (5) If PageInfo is empty, go to (6); if PageInfo is not empty and the number of fields in PageInfo is less than the field number constraint value in Constraints, go to (6); otherwise, go to (7);

[0096] (6) The large language model queries the field information for supplementing the PageInfo from the Internet with ScenarioInfo, PageInfo, and Constraints as constraints;

[0097] (7) According to semantics and field types, the field display constraints not contained in Constraints are found and supplemented into Constraints, and the constraints include component types and check rules;

[0098] (8) The large language model structures the information of PageInfo and Constraints according to the prompt rules and outputs.

[0099] As an embodiment in the embodiment, the JSON format content includes DataModels, QueryConditions, TableItems, and TableDatas;

[0100] The DataModels are a collection of data models, and each element in the data model is defined by a Chinese name, an English name, a field type, and a default value;

[0101] The QueryConditions are a collection of query conditions, the TableItems are a collection of table columns, and the TableDatas are a collection of table static data;

[0102] The fields in QueryConditions and TableItems correspond one-to-one to the fields in DataModels.

[0103] Specifically, the output content of the large language model is represented in JSON format, and the output specification includes two layers of structure. It is formally represented as a five-tuple:

[0104] Output = <DataModels, QueryConditions, TableItems, TableData, Constraints>;

[0105] Wherein DataModels, QueryConditions, TableItems, and TableDatas represent data models, query conditions, table columns, and table static data, respectively. The conventions are:

[0106] DataModels = {DM1, DM2, DM3, …, DM d};

[0107] QueryConditions={QC1,QC2,QC3,......,QC q};

[0108] TableItems={TI1,TI2,TI3,......,TI m};

[0109] TableData={TD1,TD2,TD3,......,TD n};

[0110] where d, q, m, n are positive integers greater than 0, and there is a relationship:

[0111] DataModels=QueryConditions∪TableItems.

[0112] When any DM∈DataModels, the octuple formalization of DM is DM=<AliasName,Name,Type,DefaultValue>, where AliasName, Name, Type, DefaultValue represent Chinese name, English name, field type, default value respectively, and the data model is represented in the form of a set.

[0113] As an implementation in this embodiment, the second step: the large language model extracts the requirement information according to the specification, carries out scheme reasoning and outputs the JSON format content. The large language model relies on its natural language understanding and reasoning ability, carries out original requirement information disassembly, extraction, Internet information search, requirement splicing according to the requirement information extraction method agreed in the previous step, and finally outputs the JSON content containing data model, query condition, table column and table static data.

[0114] As an implementation in this embodiment, the process of mapping to the set of components of the codeless development platform includes:

[0115] According to the component type constraint in the constraint description, the fields in QueryConditions are mapped to input boxes, drop-down selection or date selection components;

[0116] According to the field type of the data model, the fields in TableItems are mapped to text, numerical value or date components;

[0117] The static data in TableDatas is injected into the table component according to the field order of TableItems, and is bound with the verification rule.

[0118] Specifically, the third step is to map the JSON format content output by the large language model to the component set of the code-free development platform. For any QC∈QueryConditions, TI∈TableItems, there is a relationship QC∈DataModels, TI∈DataModels, that is, QC and TI can be extended to the eight-tuple representation of DM. TableData is a static data set of the table, and the assignment order of the data is defined by the element order of TableItems. Constraints include three types of constraints: field number constraints, field display component constraints, and field semantic constraints, wherein the field number constraints are used to constrain the inference and query of the large model together with PageInfo, the field display component constraints are the component type requirements for the fields in the page, and when the display component is not explicitly constrained, the suggestion result of the large language model is retrieved through the Internet, and the field semantic constraints consider the field display requirements in a specific context. Therefore, Constraints can be formally represented as a triple:

[0119] Constraints=<FieldNum,ComponentTypes,Semantics>;

[0120] wherein FieldNum, ComponentTypes, and Semantics represent field number constraints, field display component type constraints, and semantic constraints, respectively, ComponentTypes and Semantics are sets of <Key, Value> key-value pairs, the keys of which are identified by DM.Name, the values of ComponentTypes are identified by the component types of the code-free platform, defined as ComType, any ComType must be a component type that can be operated and rendered in the code-free platform, and the values of Semantics are a set of constraint identifiers supported by the code-free platform. When there is no semantic constraint for the field, Semantics.Value=null.

[0121] As an embodiment in this embodiment, the filling process of the upper and lower partition page template includes:

[0122] arranging the query components in the query area, and adding a query button and a clear button;

[0123] setting table columns in the table area according to the field order of TableItems, and configuring table header styles;

[0124] filling the static data in TableDatas into the table component by row, and each row of data is consistent with the field order of the table column.

[0125] Specifically, the fourth step is to fill the component set into the page template of the upper and lower structures. The upper part is the query component set visualization area, and the lower part is the table for displaying the query structure set. The mapping of any field to the component is determined by Constraints.ComponentTypes. Define that any QueryConditions is not empty, QC∈QueryConditions, CT∈ComponentTypes=Constraints.ComponentTypes, S∈Semantics=Constraints.Semantics, and the page query component set QueryComs={}. As shown in Figure 5 the automatic mapping steps are as follows:

[0126] (1) i=0, j=0;

[0127] (2) QC=QueryConditions[i], if QC is empty, go to (8);

[0128] (3) CT=ComponentTypes[j], S=Semantics[j];

[0129] (4) if QC.Name==CT.Key, go to (5); otherwise, j++, go to (3);

[0130] (5) initialize the component QCCom for displaying the field represented by QC according to CT.Value, and assign QCCom.Constraint=S to the attribute Constraint of QCCom;

[0131] (6) QueryComs=QueryComs∪QCCom;

[0132] (7) i++, j=0, go to (2);

[0133] (8) initialize the "query" and "clear" button components StartBtn and ClearBtn respectively, QueryComs=QueryComs∪{StartBtn,ClearBtn};

[0134] (9) end.

[0135] The table column is set according to the element content in the TableItems set, and it is agreed that TableItems is not empty;

[0136] Define that any TI∈TableItems;

[0137] Define CT∈ComponentTypes=Constraints.ComponentTypes;

[0138] Define S∈Semantics=Constraints.Semantics;

[0139] TableColumns = {}, as shown in Figure 6 The automatic mapping steps are as follows:

[0140] (1) i = 0, j = 0;

[0141] (2) TI = TableItems[i], if TI is empty, go to (8);

[0142] (3) CT = ComponentTypes[j], S = Semantics[j];

[0143] (4) if TI.Name == CT.Key, go to (5); otherwise j++, go to (3);

[0144] (5) initialize a column TIColumn for displaying the field represented by CT according to TI.Value, and assign TIColumn.Constraint = S to the attribute Constraint of TIColumn;

[0145] (6) TableColumns = TableColumns∪TIColumn;

[0146] (7) i++, j = 0, go to (2);

[0147] (8) end.

[0148] So far, the extraction and initialization tasks of the query component set and the table have been completed.

[0149] As an embodiment in this embodiment, the check rules in the constraint description include text length limit, numerical range constraint and date format verification;

[0150] The check rules are defined by JSON nesting and are bound to the attributes of the query component and the table component;

[0151] The numerical range constraint includes minimum value, maximum value and integer type limit, and the date format verification includes date separator and year-month-day order.

[0152] Specifically, after the extraction and initialization tasks of the query component set and the table are completed, static data, i.e., TableDatas, needs to be displayed in the table of the page. The TableDatas output by the large language model has the following format:

[0153] {{Value 1,1 ,Value 1,2 ,......,Value 1,n},{Value 2,1 ,Value 2,2 ,......,Value 2,n},......,{Value m,1 ,Value m,2 ,......,Value m,n}},wherein m and n are positive integers greater than 0, n is consistent with the number of elements of TableItems, the order of elements in the set {Value m,1 ,Value m,2 ,......,Value m,n} is consistent with the order of elements in TableItems, and any Value m,n obeys the constraint of TableColumns[n].Constraint. Therefore, when generating static data, the large language model needs to follow the conventions of the elements in TableColumns[n].Constraint, such as the time format constraint "2020 / 1 / 3" and the numerical value convention "value is a positive integer greater than 0 and less than 1000".

[0154] Based on this, the embodiment of the application provides a page automatic generation method based on a software construction platform of a large language model. The large language model is combined with a no-code development platform, the operation threshold of a user is significantly reduced, and automatic generation from natural language requirements to a page is realized. The user does not need to manually drag components or adjust multiple conversations, and a single input can generate a data model, a page layout and a verification rule conforming to industry specifications; the generated page components automatically adapt to domain knowledge (such as agriculture and rural areas and emergency management), ensure the accuracy of field expression and the rigor of interactive logic, unify the page style through a preset template, and improve the aesthetic degree and consistency. The scheme effectively reduces manual intervention, shortens the development cycle, supports rapid expansion in multiple fields, and meets the efficient construction requirements of complex business scenarios.

[0155] The present application is based on a platform, extracts the demand information in the natural language input, takes the industry, scene information, page detailed demand and constraint information as constraints, outputs the results meeting the demand according to the specification of the no-code platform by the large language model, and maps the output results to the displayable industry field information and the component set with related value constraints in the no-code platform, so as to realize the automatic generation of the page.

[0156] Embodiment two

[0157] In the embodiment, a computer terminal device is provided, comprising:

[0158] one or more processors;

[0159] a memory, coupled to the processor, for storing one or more programs;

[0160] When the one or more programs are executed by the one or more processors, the one or more processors implement the method in the above embodiments.

[0161] In the embodiment, a computer readable storage medium having a computer program stored thereon is also provided, and the computer program is executed by a processor to implement the method in the above embodiments.

[0162] In the embodiment, an electronic device is also provided, comprising a memory and a processor, the memory has a computer program stored therein, and the processor is configured to run the computer program to execute the method in the above embodiments.

[0163] The above program can be run in the processor, or can also be stored in the memory (or computer readable medium), and the computer readable medium includes permanent and non-permanent, removable and non-removable media, which can be realized by any method or technology to store information. The information can be computer readable instructions, data structure, program module or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassette, magnetic tape disk storage or other magnetic storage device, or any other non-transmission medium that can be used to store information accessible by a computing device.

[0164] These computer programs (also known as programs, software, software applications programs, applications, components, program components, or code) include any electronic component for providing Figure 1 The steps of a method or algorithm described in connection with the Figure 1 The steps of a method or algorithm described in connection with the

[0165] The present embodiment provides such a device or system. The system is called a page automatic generation system based on a large language model software construction platform, which comprises:

[0166] A requirement analysis module is configured to extract scene description, page description and constraint description from the natural language requirement, and supplement missing field information.

[0167] A model processing module is configured to convert the scene description, page description and constraint description into JSON format content containing data model, query condition, table column and table static data through a large language model.

[0168] A component mapping module is configured to map the JSON format content to query components, table components and function buttons of a code-free development platform.

[0169] A page generation module is configured to fill the query components into the query area of a template, fill the table components into the table area of the template, and inject the table static data according to an upper and lower partition page template.

[0170] A rule configuration module is configured to configure the attributes of the query components and table components based on the check rules and component type constraints in the constraint description.

[0171] As an embodiment of the present embodiment, the requirement analysis module comprises:

[0172] A scene description separation unit is configured to separate industry domain and application scene information from the natural language requirement.

[0173] A page description extraction unit is configured to extract field name, field type and page function requirement.

[0174] A constraint description extraction unit is configured to extract field quantity limit, component type constraint and data check rule.

[0175] A field supplement unit is configured to call a large language model to supplement missing field information when the field quantity of the page description does not meet the field quantity limit of the constraint description.

[0176] As an implementation in the embodiment, the model processing module comprises:

[0177] a data structuring unit configured to generate JSON format content comprising DataModels, QueryConditions, TableItems and TableDatas;

[0178] a model defining unit configured to define Chinese name, English name, field type and default value of each field in the data model;

[0179] a data association unit configured to establish one-to-one correspondence between fields in QueryConditions and TableItems and fields in DataModels.

[0180] As an implementation in the embodiment, the component mapping module comprises:

[0181] a query component mapping unit configured to map fields in QueryConditions into input box, drop-down selection or date selection component according to component type constraint;

[0182] a table column mapping unit configured to map fields in TableItems into text, numerical value or date component according to field type;

[0183] a data injection unit configured to inject static data in TableDatas into table component according to field order of TableItems and bind with verification rule.

[0184] As an implementation in the embodiment, the page generation module comprises:

[0185] a query area layout unit configured to arrange query components in the query area and add query button and clear button;

[0186] a table column configuration unit configured to set table columns according to field order of TableItems and configure table header style;

[0187] a data filling unit configured to fill static data in TableDatas into table component according to row, and each row of data is consistent with field order of table columns.

[0188] As an implementation in the embodiment, the rule configuration module comprises:

[0189] a verification rule binding unit configured to define text length limit, numerical value range constraint and date format verification through JSON nesting and bind with component attribute;

[0190] A numerical constraint unit is configured to set a minimum value, a maximum value and an integer type limit of a numerical range;

[0191] A date format unit is configured to define a format rule of a date separator and a year-month-day sequence.

[0192] The system or device is used to realize the functions of the methods in the above-mentioned embodiments. Each module in the system or device corresponds to each step in the method, which has been described in the method and will not be repeated here.

[0193] Through the above embodiments, the problem of automatic generation of pages of a software construction platform based on a large language model in the related art is solved, thereby being able to guarantee to solve the problems in the prior art.

[0194] The above is only a preferred specific embodiment of the present application, but the protection scope of the present application is not limited thereto, any person skilled in the art can easily think of changes or replacements within the technical range disclosed by the present application, which should be covered within the protection scope of the present application. Therefore, the protection scope of the present application should be subject to the protection scope of the claims.

Claims

1. A method for automatically generating pages in a software building platform based on a large language model, characterized in that, Includes the following steps: Based on the natural language requirement description, the large language model extracts the scene description, page description and constraint description, and fills in the missing fields and constraint information; The scene description, page description, and constraint description are converted into JSON format content through a large language model. The JSON format content includes data model, query conditions, table columns, and table static data. The JSON format content is mapped to a component set of the no-code development platform, the component set including a query component set, a table component, and function buttons; According to the preset upper and lower partition page template, the query component set is filled into the query area of ​​the template, the table component is filled into the table area of ​​the template, and the table static data is injected. Based on the validation rules and component type constraints in the constraint description, the attributes of the query component set and table component are automatically configured.

2. The method according to claim 1, characterized in that, The process of extracting scene description, page description, and constraint description includes: Separate industry domain and application scenario information from natural language requirements to serve as scenario descriptions; Extract field names, field types, and page function requirements from natural language requirements to create a page description; Extract field quantity limits, component type constraints, and data validation rules from natural language requirements as constraint descriptions; When the number of fields described on the page does not meet the limit for the number of fields in the constraint description, the missing fields and constraint information are supplemented by a large language model based on the scenario description.

3. The method according to claim 1, characterized in that, The JSON format content includes DataModels, QueryConditions, TableItems, and TableDatas; The DataModels is a collection of data models, and each element in the data model is defined by a Chinese name, an English name, a field type, and a default value. The QueryConditions is a set of query conditions, the TableItems is a set of table columns, and the TableDatas is a set of static table data; The fields in QueryConditions and TableItems correspond one-to-one with the fields in DataModels.

4. The method according to claim 1, characterized in that, The process of mapping to the no-code development platform component set includes: Based on the component type constraints in the constraint description, the fields in QueryConditions are mapped to input boxes, drop-down selections, or date selection components; Based on the field type of the data model, the fields in TableItems are mapped to text, numeric, or date components; The static data in TableDatas is injected into the table component in the field order of TableItems and bound to the validation rules.

5. The method according to claim 1, characterized in that, The process of filling in the upper and lower partition page templates includes: Arrange the query components in the query area, and add a query button and a clear button; Set the table columns in the table area according to the field order of TableItems, and configure the table header style; The static data in the TableDatas is populated into the table component row by row, and the data in each row is in the same order as the fields in the table columns.

6. The method according to claim 1, characterized in that, The validation rules in the constraint description include text length limits, numerical range constraints, and date format validation. The validation rules are defined via nested JSON and bound to the properties of the query component and table component; The numerical range constraints include minimum value, maximum value, and integer type restrictions, and the date format validation includes date separators and year-month-day order.

7. An automatic page generation system for a software building platform based on a large language model, characterized in that, The system includes: The requirement parsing module is used to extract scenario descriptions, page descriptions, and constraint descriptions from natural language requirements, and to supplement missing field information. The model processing module is used to convert the scene description, page description and constraint description into JSON format content including data model, query conditions, table columns and table static data through a large language model; The component mapping module is used to map the JSON format content to the query component, table component, and function button of the no-code development platform; The page generation module is used to fill the query component into the query area of ​​the template and the table component into the table area of ​​the template according to the upper and lower partition page template, and inject the table static data. The rule configuration module is used to configure the attributes of the query component and the table component based on the validation rules and component type constraints in the constraint description.

8. The system according to claim 7, characterized in that, The requirement analysis module includes: The scenario description separation unit is used to separate industry domain and application scenario information from natural language requirements; The page description extraction unit is used to extract field names, field types, and page functional requirements. The constraint description extraction unit is used to extract field quantity limits, component type constraints, and data validation rules. The field supplementation unit is used to call the large language model to supplement missing field information when the number of fields described on the page does not meet the field limit of the constraint description.

9. A computer terminal device, characterized in that, include: One or more processors; A memory, coupled to the processor, for storing one or more programs; When the one or more programs are executed by the one or more processors, the one or more processors implement the automatic page generation method of the software building platform based on a large language model as described in any one of claims 1-6.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by the processor, it implements the automatic page generation method of the software building platform based on a large language model as described in any one of claims 1-6.

Images