Intelligent low-code development control method based on multi-modal interaction driving

Abstract

The invention provides an intelligent low-code development control method based on multi-modal interaction driving, and belongs to the technical field of development control, and the method comprises the steps: 1, constructing a front-end subsystem for low-code development control; and step 2, constructing a back-end subsystem for low-code development control. Aiming at the problems that a traditional low-code system component is low in dragging efficiency and difficult to adapt to a complex business scene, automatic generation of a prototype graph / voice / character-front-end interface and detailed design document-back-end code is realized through deep fusion of a visual large model, a code large model and a multi-modal interaction technology, and the method is high in practicability and high in practicability. The purposes of reducing the development time by more than 50%, reducing the code error rate and unifying the code style are achieved, and an efficient and high-quality solution is provided for enterprise software development.

Description

Technical Field

[0001] This invention belongs to the field of development control technology, specifically relating to an intelligent low-code development control method based on multimodal interaction. It is applicable to various software development scenarios such as enterprise-level applications, business process systems, and small and medium-sized customized software. It can cover the entire process of front-end interface construction and back-end business logic implementation, reducing the development threshold and improving development efficiency. Background Technology

[0002] In today's era of rapid information technology development, software development has become a core support for enterprise digital transformation. However, traditional software development models face many insurmountable bottlenecks: High labor costs: Traditional development requires professional programmers to master multiple programming languages ​​(such as Java, JavaScript, Python, etc.) and frameworks (such as Spring, React, Vue, etc.). The training cycle for a mature developer can take 3-5 years. In addition, companies need to equip their teams with multiple roles such as product, testing, and operation and maintenance. Labor costs account for more than 60% of the total cost of software development.

[0003] Lengthy delivery cycle: For a medium-complexity enterprise application (such as a customer relationship management system), the traditional development process requires stages such as requirements analysis (2-4 weeks), architecture design (1-2 weeks), coding implementation (8-12 weeks), and testing and debugging (4-6 weeks). The total delivery cycle usually exceeds 6 months, which is difficult to meet the enterprise's need for rapid market response.

[0004] Inconsistent code quality: Different developers have different coding habits and technical capabilities. Even with coding standards, problems such as code redundancy (redundancy rate can reach 15%-20%) and logical vulnerabilities (an average of about 2-3 vulnerabilities per thousand lines of code) will still occur, leading to increased maintenance costs in the later stage (maintenance costs account for about 70% of the total cost of the software life cycle).

[0005] To address these issues, low-code platforms have rapidly emerged in recent years. These platforms transform some coding work into visual operations by providing visual drag-and-drop components (such as buttons, forms, and tables) and preset template libraries (such as login templates and data list templates). This allows non-professional developers (such as business personnel) to build simple applications, demonstrating certain advantages in small to medium-sized projects (such as departmental data statistics tools) and business process optimization (such as leave approval processes).

[0006] However, traditional low-code platforms still have significant drawbacks: Low component operation efficiency: When building a front-end page containing more than 20 components, developers need to manually drag and drop components onto the canvas and adjust the position, size, and attributes of each component one by one. The whole process takes about 1-2 hours. In addition, searching for the target component from a component library containing hundreds of components takes an average of 5-10 minutes per search.

[0007] Poor adaptability to complex business logic: The components and templates of traditional low-code platforms are mostly general-purpose and difficult to support complex business scenarios (such as risk control rule calculation in the financial industry and order revenue sharing logic in the e-commerce industry). When enterprises need to achieve highly customized requirements, professional developers still need to write a lot of custom code (custom code can account for 40%-50%), thus losing the core advantages of low-code and low threshold.

[0008] Insufficient code maintainability: The code generated by the platform is mostly automatically assembled black-box code with a messy code structure and missing comments. If it is necessary to modify the function or fix the vulnerability later, the developer needs to spend a lot of time understanding the code logic. The maintenance efficiency is 30%-40% lower than that of manually written standard code.

[0009] In summary, traditional low-code platforms cannot fundamentally meet enterprises' demands for high-quality and high-efficiency business system development. There is an urgent need for a more efficient and intelligent low-code development control solution to solve core problems such as cumbersome component operations and difficulty in adapting to complex requirements. Summary of the Invention

[0010] To address the issues of low efficiency and difficulty in adapting to complex business scenarios in traditional low-code system component drag-and-drop, this invention provides an intelligent low-code development control method based on multimodal interaction. By deeply integrating visual large models, code large models, and multimodal interaction technologies, it achieves automated generation of prototype diagrams / voice / text → front-end interface, detailed design documents → back-end code. This aims to reduce development time by more than 50%, lower code error rates, and unify code style, providing an efficient and high-quality solution for enterprise software development.

[0011] The present invention employs the following technical solution.

[0012] A smart low-code development control method based on multimodal interaction, comprising: Step 1: Build a front-end subsystem for low-code development control; Step 2: Build a backend subsystem for low-code development control.

[0013] Preferably, step 1 specifically includes: Step 1-1: Design the front-end low-code business components and data format of the front-end subsystem; Steps 1-2: Based on the low-code business components of the front-end, construct a front-end component supervision and fine-tuning dataset for the front-end subsystem; Steps 1-3: After constructing the front-end component supervised fine-tuning dataset, perform supervised fine-tuning of the large visual model; Steps 1-4: After fine-tuning the base model one, perform an effect evaluation of the base model one; Steps 1-5: Integrate the finely tuned base model one into the front-end low-code platform.

[0014] Preferably, step 1-1 specifically includes: For common business scenarios in enterprises, we have abstracted and designed general-purpose low-code front-end business components. These general-purpose low-code front-end business components cover three categories: basic components, composite components, and business components used in common business scenarios in enterprises. We have defined a standardized data format for each component.

[0015] Preferably, steps 1-2 specifically include: The front-end component supervised fine-tuning dataset has no fewer than 10,000 samples, and each sample contains three parts: a component graph, a text description, and an attribute description. Component graphics: These are screenshots or design drafts that cover the appearance of components under different styles and resolutions. Each component has 20-30 graphic samples. Text description: Includes component function description and scenario description, with 5-10 text descriptions for each component; Attribute descriptions: Field data in the standardized data format of the defined components are used as attribute descriptions, with 10-15 attribute description samples for each component.

[0016] Preferably, steps 1-3 specifically include: Qwen2.5-VL-72B was selected as the base model one, and then the base model one was fine-tuned. The fine-tuning process adopted a supervised learning mode.

[0017] Preferably, steps 1-4 specifically include: Construct an evaluation dataset containing 1000 product prototype images from different business scenarios within an enterprise. Each prototype image corresponds to a manually annotated JSON attribute description used as component properties. Input the prototype image into the fine-tuned base model 1, and obtain the JSON attribute descriptions output by the fine-tuned base model 1 as component properties. Evaluate the effectiveness of the output attribute descriptions using the following metrics: The format compliance rate is the percentage of samples whose component attribute JSON output from the fine-tuned base model conforms to the standardized data format of the component. The formula for calculating the format compliance rate is: Format compliance rate = (Number of format-compliant samples / Total number of samples evaluated) × 100%; Acceptance standard: Format compliance rate ≥ 98%; Attribute accuracy is the percentage of fields in the component attribute JSON output by the fine-tuned base model that match the attribute description in the standard answer. The formula for calculating attribute accuracy is: Attribute accuracy = (Number of fields in the matched attribute description / Total number of fields in the attribute description) × 100%; Acceptance criteria: Attribute accuracy ≥ 95%; The component recognition rate is the percentage of samples in the prototype diagram that accurately identify the component type after fine-tuning the base model. The formula for calculating the component recognition rate is: Component recognition rate = (Number of samples with correctly identified component types / Total number of evaluated samples) × 100%; Acceptance criteria: Component recognition rate ≥ 97%; If any indicator fails to meet the standard, the fine-tuning is deemed a failure and readjustment is required. The specific methods for readjustment include: Prompt word optimization: Add prompt word templates to the front-end component supervised fine-tuning dataset; Adjust the training parameters of the supervised learning mode: adjust the learning rate to 1e-5 or 3e-5, and increase the number of training rounds to 6-7 rounds; Supplement the front-end component supervision and fine-tuning dataset: For components with a format compliance rate, attribute accuracy rate, or component recognition rate of less than 90%, supplement with 500-1000 samples; After readjustment, return to steps 1-2, rebuild the front-end component supervised fine-tuning dataset and perform fine-tuning; if all indicators meet the standards, proceed to steps 1-5 to execute.

[0018] Preferably, steps 1-5 specifically include: The modification is based on a low-code front-end platform, specifically by adding the following functional modules to the low-code front-end platform: The multimodal input module has the following functions: Image input: Supports uploading product prototype images in PNG and JPG formats, which are then converted into image data that the model can recognize via Base64 encoding; Voice input: Voice is collected via WebRTC and converted into text descriptions using Baidu's speech recognition API; Text input: Provides a rich text editor that supports inputting component attribute descriptions; The multimodal input module is used to provide standardized input for the fine-tuned base model 1; The large model calling module has the following functions: Develop a model call interface using either HTTP or HTTPS protocols. The request parameters for the large model call module include the input type, input data, and format requirements for the data input to the fine-tuned base model 1. The response parameters for the large model call module include the component attribute JSON output by the fine-tuned base model 1 and the generation time. The large model calling module is used to pass the standardized input processed by the multimodal input module to the fine-tuned base model one, and to receive the output of the fine-tuned base model one; The results parsing and rendering module has the following functions: Develop a JSON parser to validate the component attribute JSON output by the fine-tuned base model. Once the validation is successful, map the JSON data of the component attribute JSON to an instance of the front-end low-code platform component, call the front-end low-code platform's visual rendering engine, and automatically generate the front-end interface. The Result Parsing and Rendering module is used to convert the JSON component attribute output from the fine-tuned base model into a visual interface.

[0019] Preferably, step 2 specifically includes: Step 2-1: Perform prompt word engineering and detailed document template design for the back-end subsystems used for low-code development control; Step 2-2: After designing the prompt word project and detailed documentation template, construct the dataset for fine-tuning the backend code; Steps 2-3: After constructing the dataset for fine-tuning the backend code, perform supervised fine-tuning of the large code model; Steps 2-4: After performing supervised fine-tuning of the large code model, the backend code is automatically generated.

[0020] Preferably, step 2-1 specifically includes: Step 2-1-1: Perform prompt word engineering design, and design a structured prompt word template in accordance with backend development specifications; Step 2-1-2: Execute the standardized detailed design document template design, that is, the standardized detailed design document template obtained contains the corresponding core modules.

[0021] Preferably, step 2-2 specifically includes: Collect backend project code from the past 3 years, totaling 100-150 projects with a total code volume of ≥500,000 lines. Use this code to construct a backend code fine-tuning dataset. The construction process for the backend code fine-tuning dataset is as follows: Code filtering: Remove low-quality code and duplicate code; Code categorization: Categorize code by technical module and by business scenario to ensure the dataset covers core backend development scenarios; Data format conversion: Convert code files into requirement description-code pairing samples. Each sample contains business requirement text and code content, and the samples are stored in JSON format.

[0022] Preferably, steps 2-3 specifically include: Qwen2.5-Coder-32B was selected as the second base model. Then, the second base model was fine-tuned using a supervised learning mode.

[0023] Preferably, steps 2-4 specifically include: Step 2-4-1, Document Completion: Developers fill in the standardized detailed design document template according to specific business requirements, ensuring that the content is complete and accurate; Step 2-4-2, Document Input: Submit the completed standardized detailed design document template to the code generation interface of the back-end subsystem; Steps 2-4-3, Model Parsing and Code Generation: The back-end subsystem concatenates the document content of the standardized detailed design document template with the design prompts, and passes it as input to the fine-tuned Qwen2.5-Coder-32B model. The Qwen2.5-Coder-32B model automatically parses the content in the document and generates complete back-end code. Step 2-4-4, Code Output and Export: The back-end subsystem will display the generated code categorized by technical module and support online editing.

[0024] The beneficial effects of the present invention are as follows: Compared with the prior art, the technical effects of the present invention include: I. Overcome the shortcomings of low-code platform component operation efficiency, and achieve a qualitative leap in front-end interface development efficiency. Traditional low-code platforms require developers to manually drag and drop components and adjust their properties one by one to build the interface. For example, a moderately complex page with 20 components would take developers 1-2 hours to complete, and finding the target component from hundreds of component libraries would require repeated filtering (averaging 5-10 minutes per search). This invention completely changes this model through a large visual model and multimodal input: Efficient input methods: Supports three multimodal input methods: product prototype images (PNG / JPG), voice descriptions (such as "top navigation bar contains 3 menus, background color #2c3e50"), and text requirements (input via rich text editor). No need to manually search for components, the model can be parsed within 1-2 seconds after input. Automated Interface Generation: The finely tuned Qwen2.5-VL-72B model can directly convert input into component attribute configurations that conform to the standardized JSON format. The system automatically renders them into a visual interface. The time required to generate a page with the same 20 components is reduced to less than 30 seconds, which is 120-240 times more efficient than traditional low-code platforms. Minimal human intervention: Only "fine-tuning and optimization" of the generated interface is required (such as adjusting component spacing). The proportion of manual operation time is reduced from 80% in traditional low-code to less than 5%, allowing developers to focus on requirement design rather than repetitive operations.

[0025] Second, overcome the shortcomings of traditional low-code platforms in adapting to complex business logic, and achieve full coverage of highly customized requirements. Traditional low-code platforms' generic components / templates cannot support complex business scenarios (such as financial risk control calculations, e-commerce order revenue sharing, and multi-level government approvals). Such requirements necessitate professional developers writing 40%-50% custom code, negating the "low barrier to entry" advantage. This invention overcomes this limitation through fine-tuning of a large code model and standardized detailed documentation. Complex requirement parsing capability: Based on the Qwen2.5-Coder-32B model, which has been fine-tuned from 120,000 lines of backend code across multiple industries, it can accurately identify business rules in detailed design documents (such as order amount = Σ quantity of goods × unit price, and it is necessary to verify that the inventory of goods is greater than or equal to the quantity purchased), without the need for manual writing of core logic code; Customized code generation rate: For 5 typical complex scenarios (order splitting, risk control rules, multi-level approval, data access control, and high concurrency rate limiting), 80% of the scenarios do not require custom code, and the remaining 20% ​​of the scenarios only require ≤100 lines of personalized logic (such as compliance verification in special industries). Compared with the traditional low-code platform where the proportion of custom code is 40%-50%, the customization cost is reduced by more than 80%. Technology stack compatibility: Supports mainstream development frameworks such as Java (SpringBoot), Python, and PHP. The generated code can be directly integrated into existing enterprise projects without the need to refactor the technology stack due to platform limitations, adapting to complex enterprise IT architectures.

[0026] Third, overcome the shortcomings of poor code quality and low maintainability in traditional development and low-code platforms, and achieve code standardization and low maintenance costs. Traditional development suffers from code redundancy (15%-20%) and numerous vulnerabilities (2-3 per thousand lines of code) due to varying developer skills. Traditional low-code platforms generate black-box, poorly written code with missing comments and disorganized structure, resulting in maintenance costs accounting for 70% of the total software lifecycle cost. This invention addresses these issues through large-scale model specifications and standardized processes. Significantly reduced code error rate: The model-generated code follows pre-defined development specifications (such as Alibaba Java Development Manual and RESTful API standard). Tests have verified that the average error rate is only 0.63 per thousand lines of code, which is 77.7% lower than traditional development (2.83 per thousand lines of code) and 65.6% lower than traditional low-code platforms (1.83 per thousand lines of code), greatly reducing the workload of testing and debugging. Highly consistent code style: Code formatting (such as variable naming, commenting standards, and class structure) is enforced through prompts. The CheckStyle tool shows a code style compliance rate of 98%, far exceeding traditional development (75%) and traditional low-code platforms (80%). Teams do not need to spend time understanding different styles of code when collaborating. Maintenance costs are significantly reduced: the generated code includes complete comments (such as field meanings and business logic descriptions) and a clear layered structure (Entity→Mapper→Service→Controller). When modifying features or fixing vulnerabilities later, developers can understand the code in 60% less time, and maintenance efficiency is improved by 1.5 times.

[0027] IV. Overcome the shortcomings of high labor costs and long delivery cycles in traditional software development to achieve cost reduction, efficiency improvement, and rapid delivery. Traditional software development requires a professional team (product + development + testing), and the delivery cycle for moderately complex enterprise applications (such as customer relationship management systems) exceeds 6 months, with labor costs accounting for more than 60% of the total cost. This invention breaks through this predicament through full-process automation and low-barrier operation: Development time has been significantly reduced: Comparative tests show that the development time of the e-commerce order module (medium complexity) has been reduced from 120 hours of traditional development and 60 hours of traditional low-code development to 45 hours, an average reduction of 61%; the development time of the high-complexity financial user management module has been reduced from 200 hours to 80 hours, a reduction of 60%, fully achieving the goal of "reducing development time by more than 50%". Reduced labor costs: Non-specialized developers (such as product managers familiar with the business) can complete 80% of the development work through multimodal input, while professional developers only need to handle a small amount of complex logic. Enterprises can reduce the number of professional developers by 30%-40%, and reduce labor costs by 25%-35%. Accelerated delivery cycle: The delivery cycle for medium-complexity projects has been shortened from the traditional 6 months to less than 2 months, enabling enterprises to respond to market demands more quickly (such as e-commerce platforms quickly launching promotional activities and government systems rapidly iterating service functions), and core business launch time is 2-3 times earlier.

[0028] In summary, this invention not only solves the core defects of traditional low-code platforms, but also makes up for the efficiency and cost deficiencies of traditional development, providing the software development industry with a brand-new solution that is efficient, high-quality, and has low barriers to entry. Attached Figure Description

[0029] Figure 1 This is a flowchart of the construction of the front-end subsystem in the intelligent low-code development and control method based on multimodal interaction driving described in this invention; Figure 2This is a flowchart of the construction of the back-end subsystem in the intelligent low-code development and control method based on multimodal interaction driving described in this invention. Detailed Implementation

[0030] To make the objectives, technical solutions, and advantages of this invention clearer, the technical solutions of this invention will be clearly and completely described below in conjunction with the accompanying drawings of the embodiments of this invention. The embodiments described in this application are merely some embodiments of this invention, and not all embodiments. Based on the spirit of this invention, any other embodiments obtained by those skilled in the art without creative effort are within the protection scope of this invention.

[0031] like Figure 1 and Figure 2 As shown, the intelligent low-code development and control method based on multimodal interaction driving according to the present invention includes: The specific steps for constructing the front-end and back-end subsystems are as follows: Step 1: Build a front-end subsystem for low-code development control; In a preferred but non-limiting embodiment of the present invention, step 1 specifically includes: Step 1-1: Design the front-end low-code business components and data format of the front-end subsystem; In a preferred but non-limiting embodiment of the present invention, step 1-1 specifically includes: For common enterprise business scenarios (such as data display, form submission, and workflow approval), we abstract and design general-purpose low-code front-end business components. These components cover three main categories: basic components (buttons, input boxes, dropdown lists, etc.), composite components (forms, tables, pop-ups, etc.), and business components (order cards, user information panels, etc.), totaling 50-80 core components. A standardized data format is defined for each component. The standardized data format can use JSON as the core description format (with support for XML format extensions). The standardized data format must include the following fields: { "componentId": "Unique component identifier (string, such as "btn_001")", "componentType": "Component type (string, such as "button" or "form")", "style": { "width": "Component width (number / string, e.g., 100 / "100px")", "height": "Component height (number / string, e.g., 40 / "40px")", "position": { "x": "x-axis coordinate (number, e.g., 200)", "y": "Y-axis coordinate (number, e.g., 150)" }, "color": "Font color (string, such as "#333333")", "backgroundColor": "Background color (string, such as "#ffffff")" }, "props": { "label": "The component displays text (a string, such as "Submit")", "disabled": "Whether to disable (boolean, true / false)", "onClick": "Click event binding (string, such as "submitForm()")" }, "dataSource": "Data source (string, such as "api / user / list")" }; The componentId is generated using the format rule of component type_serial number to ensure global uniqueness; the style field follows CSS standard properties and supports responsive design (such as width:"100%"); the props field is dynamically expanded according to the component type (such as adding a placeholder field to an input box component).

[0032] Steps 1-2: Based on the low-code business components of the front-end, construct a front-end component supervision and fine-tuning dataset for the front-end subsystem; In a preferred but non-limiting embodiment of the present invention, steps 1-2 specifically include: Based on the low-code business components designed in step 1-1, construct a front-end component supervised fine-tuning dataset suitable for supervised fine-tuning of large visual models. The front-end component supervised fine-tuning dataset should have no fewer than 10,000 samples, and each sample should contain three parts: a component graph, a text description, and an attribute description. Component graphics: These are screenshots or design drafts that cover the performance of components under different styles (such as default, hover, and disabled states) and different resolutions (such as 1920×1080 and 375×667). Each component has 20-30 graphic samples. Text description: Includes component function description (e.g., "a blue button for form submission that triggers form validation when clicked") and scenario description (e.g., "located at the bottom center of the login form, next to the cancel button"). Each component corresponds to 5-10 text descriptions. Attribute description: Use the standardized data format (JSON format) field data of the component defined in step 1-1 as the attribute description to ensure that the fields are complete and the values ​​are accurate. Each component corresponds to 10-15 attribute description samples (covering different attribute combinations).

[0033] The front-end component supervises the fine-tuning dataset and stores it in JSONLines (.jsonl) format. The structure of each sample is as follows: { "imagePath": "Component image file path (string, such as "data / images / button_01.png")", "textDescription": "Component text description (string)", "attributeJson": "Component attribute description (JSON string)" }

[0034] The dataset for front-end component supervision and fine-tuning needs to be cleaned: blurry images (resolution lower than 720p), erroneous text descriptions (inconsistent with component functionality), and incorrectly formatted attribute descriptions are removed to ensure data accuracy ≥ 98%.

[0035] Steps 1-3: After constructing the front-end component supervised fine-tuning dataset, perform supervised fine-tuning of the large visual model; In a preferred but non-limiting embodiment of the present invention, steps 1-3 specifically include: Qwen2.5-VL-72B was selected as the base model one. This base model one (i.e., the large visual model) supports cross-modal understanding of images and text and has strong visual feature extraction and semantic mapping capabilities. Next, base model one was fine-tuned using supervised learning. The specific parameter settings for the fine-tuning of base model one are shown in Table 1 below: Table 1. Specific parameter settings for fine-tuning of the base model.

[0036] Steps 1-4: After fine-tuning the base model one, perform an effect evaluation of the base model one; In a preferred but non-limiting embodiment of the present invention, steps 1-4 specifically include: An evaluation dataset was constructed, containing 1000 product prototype images from different business scenarios (such as e-commerce homepages, backend management lists, and user registration forms; these products refer to enterprise-level software products or business systems, covering various needs and scenarios of digital application interface design drafts). Each prototype image corresponds to a manually annotated JSON attribute description (as a standard answer) used as component properties. The prototype image was input into the fine-tuned base model 1, and the attribute descriptions output by the fine-tuned base model 1 as component properties were obtained. The effectiveness of the output attribute descriptions was evaluated using the following metrics: format compliance rate, attribute accuracy rate, and component recognition rate: The format compliance rate is the percentage of samples whose component attribute JSON output from the fine-tuned base model meets the standardized data format of the components as required by step 1-1. The formula for calculating the format compliance rate is: Format compliance rate = (Number of format-compliant samples / Total number of samples evaluated) × 100%; Acceptance standard: Format compliance rate ≥ 98%; Attribute accuracy is the percentage of fields in the component attribute JSON output by the fine-tuned base model that match the attribute description in the standard answer. The formula for calculating attribute accuracy is: Attribute accuracy = (Number of fields in the matched attribute description / Total number of fields in the attribute description) × 100%; Acceptance criteria: Attribute accuracy ≥ 95%; The component recognition rate is the percentage of samples in the prototype diagram that the fine-tuned base model accurately identifies (component types include buttons, input boxes, dropdown lists in basic components, forms, tables, pop-ups in composite components, and order cards, user information panels, etc. in business components). The formula for calculating the component recognition rate is: Component recognition rate = (Number of samples with correctly identified component types / Total number of evaluated samples) × 100%; Acceptance criteria: Component recognition rate ≥ 97%; If any indicator fails to meet the standard (meaning that the indicator does not meet the corresponding qualification standard), the supervision and fine-tuning is deemed a failure and readjustment is required. The specific methods for readjustment include: Optimize prompt words: Add prompt word templates (such as "Please analyze the components in the prototype diagram and output the component properties according to {JSON format example}") to the front-end component supervision and fine-tuning dataset. Adjust the training parameters of the supervised learning mode: adjust the learning rate to 1e-5 or 3e-5, and increase the number of training rounds to 6-7 rounds; Supplement the front-end component supervision and fine-tuning dataset: For components with a format compliance rate, attribute accuracy rate, or component recognition rate of less than 90% (such as composite form components), supplement with 500-1000 samples; After readjustment, return to steps 1-2, rebuild the front-end component supervised fine-tuning dataset and perform fine-tuning; if all indicators meet the standards, proceed to steps 1-5 to execute.

[0037] Steps 1-5: Integrate the finely tuned base model one into the front-end low-code platform.

[0038] In a preferred but non-limiting embodiment of the present invention, steps 1-5 specifically include: This project involves modifying an existing low-code front-end platform (which supports project frameworks such as Spring Boot, Spring MVC, .NET, PHP, and Python) by adding the following functional modules: The multimodal input module has the following functions: Image input: Supports uploading product prototype images in PNG and JPG formats (resolution within 1080p), which are then converted into image data that the model can recognize via Base64 encoding; Voice input: Integrates WebRTC to capture voice (supports Chinese and English, sampling rate 16kHz), and converts it into text description through Baidu speech recognition API; Text input: Provides a rich text editor that supports inputting component attribute descriptions (such as "top navigation bar, containing three menus: logo, home / products / about us, background color #2c3e50"). The multimodal input module is used to provide standardized inputs (image input, voice input, and text input) for the fine-tuned base model 1. The large model calling module has the following functions: Develop a model call interface using either HTTP or HTTPS protocols. The request parameters for the large model call module include the input type (data type image / text / voice) of the data input to the fine-tuned base model 1, the input data (data input to the multimodal input module), and the format requirements (format requirements of the input data to the multimodal input module). The response parameters for the large model call module include the component attribute JSON output by the fine-tuned base model 1 and the generation time (total time taken from receiving the request parameters to outputting the result for the fine-tuned base model 1). The timeout for the model call interface is set to 30 seconds, and a retry mechanism is supported (maximum of 3 retries).

[0039] The large model calling module is used to pass the standardized input processed by the multimodal input module to the fine-tuned base model one, and to receive the output of the fine-tuned base model one; The results parsing and rendering module has the following functions: Develop a JSON parser to validate the component attribute JSON output by the fine-tuned base model (field integrity, data type correctness). After the validation is successful, map the JSON data of the component attribute JSON to an instance of the front-end low-code platform component, call the front-end low-code platform's visual rendering engine, and automatically generate the front-end interface (rendering time ≤ 2s / page). The Result Parsing and Rendering module is used to convert the JSON component attribute output from the fine-tuned base model into a visual interface.

[0040] Step 2: Build a backend subsystem for low-code development control.

[0041] In a preferred but non-limiting embodiment of the present invention, step 2 specifically includes: Step 2-1: Perform prompt word engineering and detailed document template design for the back-end subsystems used for low-code development control; In a preferred but non-limiting embodiment of the present invention, step 2-1 specifically includes: Step 2-1-1: Perform prompt word engineering design, and design a structured prompt word template in conjunction with backend development specifications (such as RESTful API design and database design paradigms); an example of a structured prompt word template is as follows: Task: Generate backend code based on the detailed design document. Technology stack requirements: Programming Language: Java (JDK11+) Frameworks: Spring Boot 2.7.x, MyBatis-Plus 3.5.x Database: MySQL 8.0 - Interface specification: RESTful API, return format is { "code": Status code (200 = Success, 400 = Incorrect parameters, 500 = Server error). "message": A notification message. "data": Business data } Code requirements: - Includes entity classes, data access layer (Mapper), business logic layer (Service), and controller layer (Controller). - Entity classes need to have field comments and JSR380 validation annotations (such as @NotNull and @Size). The Service layer must include an interface and an implementation class; the implementation class should be annotated with @Service. - The controller layer needs to be annotated with @RequestMapping, @GetMapping / @PostMapping, etc., and the parameters need to be annotated with @RequestParam / @RequestBody. - Exception handling: Unify the capture of business exceptions and return the corresponding error codes and prompts.

[0042] Optimize prompts through multiple rounds of testing: Each round of testing involves inputting requirements from 10 different business scenarios, checking whether the code meets the requirements, and if there are problems (such as missing exception handling or incorrect annotations), adjust the prompt content (such as adding the explicit requirement that "exception handling must include XXX") until the code compliance rate is ≥95%.

[0043] Step 2-1-2: Execute the standardized detailed design document template design. The resulting standardized detailed design document template supports Markdown, Word, and XML formats and includes the corresponding core modules shown in Table 2 below.

[0044] Table 2 Core Modules

[0045] Step 2-2: After designing the prompt word project and detailed documentation template, construct the dataset for fine-tuning the backend code; In a preferred but non-limiting embodiment of the present invention, step 2-2 specifically includes: Collect backend project code from the past 3 years (covering 5-8 industries such as e-commerce, finance, and government affairs), totaling 100-150 projects with a total code volume of ≥500,000 lines. Use this code to construct a backend code fine-tuning dataset. The construction process for the backend code fine-tuning dataset is as follows: Code screening: Remove low-quality code (such as code with syntax errors, incomplete test code, or code with more than 30% redundant comments) and duplicate code (using Simian tool for detection, only one copy of code with a duplication rate of more than 80% is kept). Code categorization: Categorize code by technical modules (e.g., entity classes, Mapper, Service, Controller, utility classes) and by business scenarios (e.g., user management, order processing, payment interface) to ensure the dataset covers core backend development scenarios; Data format conversion: Convert code files into requirement description-code pairing samples. Each sample contains business requirement text (extracted from the project requirements document) and code content (the complete code for the corresponding function), and stores the samples in JSON format; the JSON format is: "businessRequirement": "User registration function: Receives username, mobile phone number, and password; verifies the mobile phone number format (11 digits) and password strength (≥8 characters, including letters and numbers); after successful verification, inserts the user into the user table and returns the user ID." "codeContent": " / / Entity class User.java\n@Data\n@TableName(\"t_user\")\npublic class User {\n @TableId(type = IdType.ASSIGN_UUID)\n private String userId;\n @NotBlank(message = \"Username cannot be empty\")\n private String username;\n @Pattern(regexp = \"^1[3-9]\\\\d{9}$\", message = \"Incorrect phone number format\")\nprivate String phone;\n @NotBlank(message = \"Password cannot be empty\")\n @Size(min =8, message = \"Password length cannot be less than 8 characters\")\n private String password;\n privateLocalDateTime createTime;\n}\n / / Service interface UserService.java\npublic interface UserService {\n String register(UserRegisterDTO userRegisterDTO);\n}\n / / Service implementation class UserServiceImpl.java\n@Service\npublic classUserServiceImpl implements UserService {\n @Autowired\n private UserMapperuserMapper;\n @Override\n public String register(UserRegisterDTOuserRegisterDTO) {\n / / Password strength verification (specific logic omitted)\n User user = new User();\n BeanUtils.copyProperties(userRegisterDTO, user);\n user.setCreateTime(LocalDateTime.now());\n userMapper.insert(user);\n return user.getUserId();\n}\n}\n / / Controller UserController.java\n@RestController\n@RequestMapping(\" / api / user\")\npublic class UserController {\n @Autowired\nprivate UserService userService;\n @PostMapping(\" / register\")\n publicResult. <string>register(@RequestBody @Valid UserRegisterDTO userRegisterDTO){\n String userId = userService.register(userRegisterDTO);\n returnResult.success(userId);\n}\n}\n" }

[0046] Data cleaning: Samples are manually reviewed to ensure that the requirement description is consistent with the code function, and contradictory samples are deleted (such as the requirement description is to query users, but the code is to delete users). The final dataset size is ≥100,000 samples, and the accuracy is ≥99%.

[0047] Steps 2-3: After constructing the dataset for fine-tuning the backend code, perform supervised fine-tuning of the large code model; In a preferred but non-limiting embodiment of the present invention, steps 2-3 specifically include: Qwen2.5-Coder-32B was selected as the second base model (i.e., the large code model). This model exhibits high syntactic correctness and business logic adaptability in code generation tasks. Next, the second base model was fine-tuned using a supervised learning model. Specific parameters for fine-tuning the second base model are shown in Table 3. Table 3 Specific parameters for fine-tuning base model two

[0048] Steps 2-4: After performing supervised fine-tuning of the large code model, the backend code is automatically generated.

[0049] In a preferred but non-limiting embodiment of the present invention, steps 2-4 specifically include: Step 2-4-1, Document Completion: Developers should complete the standardized detailed design document template designed in Step 2-1 according to specific business requirements, ensuring that the content of its business requirement description, database design, interface design and other modules is complete and accurate; Step 2-4-2, Document Input: Submit the completed standardized detailed design document template (supports uploading Markdown / Word / XML files, or directly entering text in the front-end interface) to the code generation interface of the back-end subsystem; Step 2-4-3, Model Parsing and Code Generation: The back-end subsystem concatenates the document content of the standardized detailed design document template with the prompt words designed in Step 2-1, and passes it as input to the fine-tuned Qwen2.5-Coder-32B model. The Qwen2.5-Coder-32B model automatically parses the business requirements and other content in the document to generate complete back-end code (including entity classes, Mapper, Service, and Controller). Step 2-4-4, Code Output and Export: The back-end subsystem will display the generated code according to technical modules (e.g., the left menu will display "UserEntity.java" and "UserService.java"), supporting online editing (modifying field names, adding comments, etc.) and downloading (ZIP compressed package format, files organized by package path).

[0050] Methods for performing visual large-scale model-supervised fine-tuning and code large-scale model-supervised fine-tuning include: This invention employs supervised fine-tuning (SFT) mode for both the visual large model (Qwen2.5-VL-72B) and the code large model (Qwen2.5-Coder-32B).

[0051] 1. Data Preparation Visual large model: The samples are a front-end component supervised fine-tuning dataset, totaling 10,000 entries, of which 80% are the training set, 10% are the validation set, and 10% are the test set.

[0052] Large code model: The samples are a fine-tuned dataset of backend code, totaling 120,000 entries, divided into training / validation / test sets in an 8:1:1 ratio.

[0053] 2. Model Input / Output Construction Visual large model: The input is the image encoding of the front-end component supervised fine-tuning dataset plus text prompts (such as "Please parse the components in the image and output JSON format attributes"), and the output is the component attributes JSON in a standardized format.

[0054] Large code model: The input is the detailed design document text of the backend code fine-tuning dataset + technical specification prompts (such as "generate code according to Java + Spring Boot specifications"), and the output is the complete backend code text (including entity classes, services, controllers, etc.).

[0055] 3. Training Optimization Process Iterative training is adopted: the effect is evaluated on the validation set after each round of training. If the target is not met, the learning rate, sample weights or additional samples are adjusted until the model performance meets the preset threshold (such as component recognition rate ≥97% and code syntax accuracy ≥99%).

[0056] To verify the technical effectiveness of this invention, three projects with different business scenarios (e-commerce order module, government approval process, and financial user management) were selected. Comparative tests were conducted using this invention with traditional development methods and traditional low-code platforms. The testing team consisted of five professional developers (with over three years of development experience). The evaluation results are as follows: This invention reduces development time by an average of 61%, far exceeding the goal of reducing development time by more than 50%, and its advantages are even more obvious in highly complex projects (33.3% shorter than traditional low-code). The code generated by this invention has a style compliance rate of up to 98%, which is significantly better than traditional development (75%) and traditional low-code platforms (80%), effectively unifying the team's code style and reducing later maintenance costs. The average error rate of the code generated by this invention is only 0.63 / thousand lines, which is 77.7% lower than traditional development, effectively reducing the workload of testing and debugging. This invention has extremely strong adaptability in complex business scenarios, with 80% of scenarios requiring no custom code and the remaining 20% ​​requiring only a small amount of code adjustment, far exceeding traditional low-code platforms (only 20% of scenarios do not require custom code).

[0057] The beneficial effects of the present invention are as follows: Compared with the prior art, the technical effects of the present invention include: I. Overcome the shortcomings of low-code platform component operation efficiency, and achieve a qualitative leap in front-end interface development efficiency. Traditional low-code platforms require developers to manually drag and drop components and adjust their properties one by one to build the interface. For example, a moderately complex page with 20 components would take developers 1-2 hours to complete, and finding the target component from hundreds of component libraries would require repeated filtering (averaging 5-10 minutes per search). This invention completely changes this model through a large visual model and multimodal input: Efficient input methods: Supports three multimodal input methods: product prototype images (PNG / JPG), voice descriptions (such as "top navigation bar contains 3 menus, background color #2c3e50"), and text requirements (input via rich text editor). No need to manually search for components, the model can be parsed within 1-2 seconds after input. Automated Interface Generation: The finely tuned Qwen2.5-VL-72B model can directly convert input into component attribute configurations that conform to the standardized JSON format. The system automatically renders them into a visual interface. The time required to generate a page with the same 20 components is reduced to less than 30 seconds, which is 120-240 times more efficient than traditional low-code platforms. Minimal human intervention: Only "fine-tuning and optimization" of the generated interface is required (such as adjusting component spacing). The proportion of manual operation time is reduced from 80% in traditional low-code to less than 5%, allowing developers to focus on requirement design rather than repetitive operations.

[0058] Second, overcome the shortcomings of traditional low-code platforms in adapting to complex business logic, and achieve full coverage of highly customized requirements. Traditional low-code platforms' generic components / templates cannot support complex business scenarios (such as financial risk control calculations, e-commerce order revenue sharing, and multi-level government approvals). Such requirements necessitate professional developers writing 40%-50% custom code, negating the "low barrier to entry" advantage. This invention overcomes this limitation through fine-tuning of a large code model and standardized detailed documentation. Complex requirement parsing capability: Based on the Qwen2.5-Coder-32B model, which has been fine-tuned from 120,000 lines of backend code across multiple industries, it can accurately identify business rules in detailed design documents (such as order amount = Σ quantity of goods × unit price, and it is necessary to verify that the inventory of goods is greater than or equal to the quantity purchased), without the need for manual writing of core logic code; Customized code generation rate: For 5 typical complex scenarios (order splitting, risk control rules, multi-level approval, data access control, and high concurrency rate limiting), 80% of the scenarios do not require custom code, and the remaining 20% ​​of the scenarios only require ≤100 lines of personalized logic (such as compliance verification in special industries). Compared with the traditional low-code platform where the proportion of custom code is 40%-50%, the customization cost is reduced by more than 80%. Technology stack compatibility: Supports mainstream development frameworks such as Java (SpringBoot), Python, and PHP. The generated code can be directly integrated into existing enterprise projects without the need to refactor the technology stack due to platform limitations, adapting to complex enterprise IT architectures.

[0059] Third, overcome the shortcomings of poor code quality and low maintainability in traditional development and low-code platforms, and achieve code standardization and low maintenance costs. Traditional development suffers from code redundancy (15%-20%) and numerous vulnerabilities (2-3 per thousand lines of code) due to varying developer skills. Traditional low-code platforms generate black-box, poorly written code with missing comments and disorganized structure, resulting in maintenance costs accounting for 70% of the total software lifecycle cost. This invention addresses these issues through large-scale model specifications and standardized processes. Significantly reduced code error rate: The model-generated code follows pre-defined development specifications (such as Alibaba Java Development Manual and RESTful API standard). Tests have verified that the average error rate is only 0.63 per thousand lines of code, which is 77.7% lower than traditional development (2.83 per thousand lines of code) and 65.6% lower than traditional low-code platforms (1.83 per thousand lines of code), greatly reducing the workload of testing and debugging. Highly consistent code style: Code formatting (such as variable naming, commenting standards, and class structure) is enforced through prompts. The CheckStyle tool shows a code style compliance rate of 98%, far exceeding traditional development (75%) and traditional low-code platforms (80%). Teams do not need to spend time understanding different styles of code when collaborating. Maintenance costs are significantly reduced: the generated code includes complete comments (such as field meanings and business logic descriptions) and a clear layered structure (Entity→Mapper→Service→Controller). When modifying features or fixing vulnerabilities later, developers can understand the code in 60% less time, and maintenance efficiency is improved by 1.5 times.

[0060] IV. Overcome the shortcomings of high labor costs and long delivery cycles in traditional software development to achieve cost reduction, efficiency improvement, and rapid delivery. Traditional software development requires a professional team (product + development + testing), and the delivery cycle for moderately complex enterprise applications (such as customer relationship management systems) exceeds 6 months, with labor costs accounting for more than 60% of the total cost. This invention breaks through this predicament through full-process automation and low-barrier operation: Development time has been significantly reduced: Comparative tests show that the development time of the e-commerce order module (medium complexity) has been reduced from 120 hours of traditional development and 60 hours of traditional low-code development to 45 hours, an average reduction of 61%; the development time of the high-complexity financial user management module has been reduced from 200 hours to 80 hours, a reduction of 60%, fully achieving the goal of "reducing development time by more than 50%"; Reduced labor costs: Non-specialized developers (such as product managers familiar with the business) can complete 80% of the development work through multimodal input, while professional developers only need to handle a small amount of complex logic. Enterprises can reduce the number of professional developers by 30%-40%, and reduce labor costs by 25%-35%. Accelerated delivery cycle: The delivery cycle for medium-complexity projects has been shortened from the traditional 6 months to less than 2 months, enabling enterprises to respond to market demands more quickly (such as e-commerce platforms quickly launching promotional activities and government systems rapidly iterating service functions), and core business launch time is 2-3 times earlier.

[0061] In summary, this invention not only solves the core defects of traditional low-code platforms, but also makes up for the efficiency and cost deficiencies of traditional development, providing the software development industry with a brand-new solution that is efficient, high-quality, and has low barriers to entry.

[0062] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and not to limit it. Although the present invention has been described in detail with reference to the above embodiments, those skilled in the art should understand that modifications or equivalent substitutions can still be made to the specific implementation of the present invention without departing from the spirit and scope of the present invention. Any modifications or equivalent substitutions should be covered within the scope of protection of the claims of the present invention.< / string>

Claims

1. A smart low-code development and control method based on multimodal interaction, characterized in that, include: Step 1: Build a front-end subsystem for low-code development control; Step 2: Build the backend subsystem for low-code development control; Step 1 specifically includes: Step 1-1: Design the front-end low-code business components and data format of the front-end subsystem; Steps 1-2: Based on the low-code business components of the front-end, construct a front-end component supervision and fine-tuning dataset for the front-end subsystem; Steps 1-3: After constructing the front-end component supervised fine-tuning dataset, perform supervised fine-tuning of the large visual model; Steps 1-4: After fine-tuning the base model one, perform an effect evaluation of the base model one; Steps 1-5: Integrate the finely tuned base model one into the front-end low-code platform.

2. The intelligent low-code development and control method based on multimodal interaction driving according to claim 1, characterized in that, Step 1-1 specifically includes: For common business scenarios in enterprises, we have abstracted and designed general-purpose low-code front-end business components. These general-purpose low-code front-end business components cover three major categories: basic components, composite components, and business components used in common business scenarios in enterprises. We have defined a standardized data format for each component. Steps 1-2 specifically include: The front-end component supervised fine-tuning dataset has no fewer than 10,000 samples, and each sample contains three parts: a component graph, a text description, and an attribute description. Component graphics: These are screenshots or design drafts that cover the appearance of components under different styles and resolutions. Each component has 20-30 graphic samples. Text description: Includes component function description and scenario description, with 5-10 text descriptions for each component; Attribute descriptions: Field data in the standardized data format of the defined components are used as attribute descriptions, with 10-15 attribute description samples for each component.

3. The intelligent low-code development and control method based on multimodal interaction driving according to claim 2, characterized in that, Steps 1-3 specifically include: Qwen2.5-VL-72B was selected as the base model one, and then the base model one was fine-tuned. The fine-tuning process adopted a supervised learning mode.

4. The intelligent low-code development and control method based on multimodal interaction driving according to claim 3, characterized in that, Steps 1-4 specifically include: Construct an evaluation dataset containing 1000 product prototype images from different business scenarios within an enterprise. Each prototype image corresponds to a manually annotated JSON attribute description used as component properties. Input the prototype image into the fine-tuned base model 1, and obtain the JSON attribute descriptions output by the fine-tuned base model 1 as component properties. Evaluate the effectiveness of the output attribute descriptions using the following metrics: The format compliance rate is the percentage of samples whose component attribute JSON output from the fine-tuned base model conforms to the standardized data format of the component. The formula for calculating the format compliance rate is: Format compliance rate = (Number of format-compliant samples / Total number of samples evaluated) × 100%; Acceptance standard: Format compliance rate ≥ 98%; Attribute accuracy is the percentage of fields in the component attribute JSON output by the fine-tuned base model that match the attribute description in the standard answer. The formula for calculating attribute accuracy is: Attribute accuracy = (Number of fields in the matched attribute description / Total number of fields in the attribute description) × 100%; Acceptance criteria: Attribute accuracy ≥ 95%; The component recognition rate is the percentage of samples in the prototype diagram that accurately identify the component type after the fine-tuning of the base model. The formula for calculating the component recognition rate is: Component recognition rate = (Number of samples with correctly identified component types / Total number of evaluated samples) × 100%; Acceptance criteria: Component recognition rate ≥ 97%; If any indicator fails to meet the standard, the fine-tuning is deemed a failure and readjustment is required. The specific methods for readjustment include: Prompt word optimization: Add prompt word templates to the front-end component supervised fine-tuning dataset; Adjust the training parameters of the supervised learning mode: adjust the learning rate to 1e-5 or 3e-5, and increase the number of training rounds to 6-7 rounds; Supplement the front-end component supervision and fine-tuning dataset: For components with a format compliance rate, attribute accuracy rate, or component recognition rate of less than 90%, supplement with 500-1000 samples; After readjustment, return to steps 1-2, rebuild the front-end component supervised fine-tuning dataset and perform fine-tuning; if all indicators meet the standards, proceed to steps 1-5 to execute.

5. The intelligent low-code development and control method based on multimodal interaction driving according to claim 4, characterized in that, Steps 1-5 specifically include: The modification is based on a low-code front-end platform, specifically by adding the following functional modules to the low-code front-end platform: The multimodal input module has the following functions: Image input: Supports uploading product prototype images in PNG and JPG formats, which are then converted into image data that the model can recognize via Base64 encoding; Voice input: Voice is collected via WebRTC and converted into text descriptions using Baidu's speech recognition API; Text input: Provides a rich text editor that supports inputting component attribute descriptions; The multimodal input module is used to provide standardized input for the fine-tuned base model 1; The large model calling module has the following functions: Develop a model call interface using either HTTP or HTTPS protocols. The request parameters for the large model call module include the input type, input data, and format requirements for the data input to the fine-tuned base model 1. The response parameters for the large model call module include the component attribute JSON output by the fine-tuned base model 1 and the generation time. The large model calling module is used to pass the standardized input processed by the multimodal input module to the fine-tuned base model one, and to receive the output of the fine-tuned base model one; The results parsing and rendering module has the following functions: Develop a JSON parser to validate the component attribute JSON output by the fine-tuned base model. Once the validation is successful, map the JSON data of the component attribute JSON to an instance of the front-end low-code platform component, call the front-end low-code platform's visual rendering engine, and automatically generate the front-end interface. The Result Parsing and Rendering module is used to convert the JSON component attribute output from the fine-tuned base model into a visual interface.

6. The intelligent low-code development and control method based on multimodal interaction driving according to claim 5, characterized in that, Step 2 specifically includes: Step 2-1: Perform prompt word engineering and detailed document template design for the back-end subsystems used for low-code development control; Step 2-2: After designing the prompt word project and detailed documentation template, construct the dataset for fine-tuning the backend code; Steps 2-3: After constructing the dataset for fine-tuning the backend code, perform supervised fine-tuning of the large code model; Steps 2-4: After performing supervised fine-tuning of the large code model, the backend code is automatically generated.

7. The intelligent low-code development and control method based on multimodal interaction driving according to claim 6, characterized in that, Step 2-1 specifically includes: Step 2-1-1: Perform prompt word engineering design, and design a structured prompt word template in accordance with backend development specifications; Step 2-1-2: Execute the standardized detailed design document template design, that is, the standardized detailed design document template obtained contains the corresponding core modules.

8. The intelligent low-code development and control method based on multimodal interaction driving according to claim 7, characterized in that, Step 2-2 specifically includes: Collect backend project code from the past 3 years, totaling 100-150 projects with a total code volume of ≥500,000 lines. Use this code to construct a backend code fine-tuning dataset. The construction process for the backend code fine-tuning dataset is as follows: Code filtering: Remove low-quality code and duplicate code; Code categorization: Categorize code by technical module and by business scenario to ensure the dataset covers core backend development scenarios; Data format conversion: Convert code files into requirement description-code pairing samples. Each sample contains business requirement text and code content, and the samples are stored in JSON format.

9. The intelligent low-code development and control method based on multimodal interaction driving according to claim 8, characterized in that, Steps 2-3 specifically include: Qwen2.5-Coder-32B was selected as the second base model. Then, the second base model was fine-tuned. The fine-tuning process adopted a supervised learning mode. Steps 2-4 specifically include: Step 2-4-1, Document Completion: Developers fill in the standardized detailed design document template according to specific business requirements, ensuring that the content is complete and accurate; Step 2-4-2, Document Input: Submit the completed standardized detailed design document template to the code generation interface of the back-end subsystem; Steps 2-4-3, Model Parsing and Code Generation: The back-end subsystem concatenates the document content of the standardized detailed design document template with the design prompts, and passes it as input to the fine-tuned Qwen2.5-Coder-32B model. The Qwen2.5-Coder-32B model automatically parses the content in the document and generates complete back-end code. Step 2-4-4, Code Output and Export: The back-end subsystem will display the generated code categorized by technical module and support online editing.

Images