Artificial intelligence-based business function no-code generation method, system and medium
By parsing users' natural language requirements and reverse-engineering component libraries to generate black-box modules, the problem of no-code platforms being unable to identify entirely new requirements is solved, enabling automated development and efficient module generation.
Patent Information
- Application Number
- CN202610383019.1
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-03-26
- Publication Date
- 2026-07-31
AI Technical Summary
Existing no-code platforms cannot identify and respond to new business requirements, and users still need to manually assemble functions, requiring a high level of logic assembly ability.
By acquiring users' natural language function description text, structured functional requirements are generated, software functional component libraries are searched in reverse, logical chains are automatically planned, black-box business function modules are generated, and standardized interfaces are provided.
The system can proactively understand new business requirements, automatically generate complete and runnable modules, significantly reduce the barrier to entry, improve development efficiency, and provide commercial application value.
Smart Images
Figure CN122489057A_ABST
Abstract
Description
Technical Field
[0001] This invention belongs to the field of data processing technology, specifically, it relates to a method, system, and medium for generating business functions without code based on artificial intelligence. Background Technology
[0002] No-code / low-code development platforms significantly lower the technical barrier to software development through visual drag-and-drop and model-driven approaches, enabling non-professional developers to participate in application building. Existing mainstream no-code platforms build their core capabilities on rich pre-built component or module libraries. Users assemble the required applications by selecting components from the library, configuring attributes, and defining simple interaction relationships between components. Chinese patent document CN119847498A discloses an AI-based no-code application generation method. This method analyzes users' historical drag-and-drop behavior data on the platform (such as module usage frequency and combination complexity) to establish a user influence coefficient model, and then dynamically optimizes and recommends the front-end module library based on this model. The above technical solution improves the utilization rate of the module library and user satisfaction to a certain extent. However, it still has the following shortcomings: its optimization relies entirely on historical operation data that users have successfully implemented. It can only summarize and optimize existing needs and cannot identify and respond to new business needs that users have failed to express or that the current platform components cannot meet. As a result, when users face an unprecedented business scenario, the system cannot provide effective guidance. At the same time, this solution is essentially a screening and sorting of the existing module library. Users still need to manually select, drag and drop, and connect to build functions, which does not reduce the requirements for users' logical assembly capabilities. Summary of the Invention
[0003] The purpose of this invention is to provide a no-code method for generating business functions based on artificial intelligence, so as to solve the technical problems existing in the prior art.
[0004] To achieve the above objectives, the technical solution adopted by the present invention is as follows: A no-code method for generating business functions based on artificial intelligence includes the following steps: Step S1: Obtain and parse the natural language function description text input by the user, extract the business intent, and generate structured functional requirements; Step S2: Determine the expected business output based on the functional requirements; Step S3: Using the desired business output as the starting target node, perform a reverse search in the preset software function component library to obtain a sequence of software function component combinations that can generate the desired business output. The software function component library stores multiple software function components decoupled from the interface components. Each software function component defines an input type, an output type, and execution logic. Step S4: Based on the software functional component combination sequence, instantiate the code template corresponding to each software functional component in the sequence, and generate data interface adaptation code between software functional components to form a black box business function module. The black box business function module provides standardized input and output interfaces to the outside world. Step S5: Deploy the black-box business function module to the sandbox environment for verification, and publish it to the component library after successful verification; Step S6: Collect user feedback on the module and store the mapping relationship between functional requirements and software functional component combination sequence during this generation process in the case knowledge base.
[0005] Preferably, the specific method of step S1 is as follows: Step S1.1: Use a natural language processing model to perform semantic analysis on the natural language function description text to identify business elements, including core operation actions, operation objects, business rules, and constraints. Step S1.2: Convert the business elements into a structured functional requirement representation, which includes function type, input data pattern, processing logic description and output format requirements.
[0006] Preferably, the specific method of step S2 is as follows: Step S2.1: From the structured functional requirements, parse and extract statements that clearly describe the final result, data product, or system state change, as the output target description; Step S2.2: Match and map the output target description with the predefined standardized output types in the software functional component library. The standardized output types include data object type, file format, event signal type, or status identifier. Step S2.3: Based on the matching mapping results, determine one or more software functional components as the starting target nodes for the reverse search.
[0007] Preferably, the specific method for reverse search in step S3 is as follows: Step S3.1: Starting from the initial target node, search for all predecessor software functional components in the software functional component library whose output type is compatible with the input type of the software functional component; Step S3.2: Recursively execute the above search process for each found precursor software functional component until all necessary inputs can find corresponding data sources or user input interfaces; Step S3.3: From all the feasible paths found, select the optimal path as the final software functional component combination sequence based on path length, component complexity, and execution efficiency.
[0008] Preferably, in step S4, generating data interface adaptation code between software functional components includes: (1) if the output type of the previous software functional component does not completely match the input type of the next software functional component, automatically inserting type conversion code; (2) if it is necessary to aggregate the outputs of multiple software functional components as a single input, automatically generating data aggregation code; (3) generating unified exception capture and processing logic for the entire software functional component combination sequence.
[0009] Preferably, in step S4, the specific method for constructing the black-box business function module is as follows: based on the software function component combination sequence and the generated data interface adaptation code, all executable logic is encapsulated into an independent software module; a standardized application programming interface and a corresponding interface description file are generated for the software module, wherein the application programming interface is used to receive input configuration and return processing results.
[0010] Preferably, the verification in step S5 includes: using simulated data generated by a preset test case set, executing the logic of the black-box business function module, and verifying whether its output meets expectations.
[0011] To achieve the above objectives, the present invention also provides an AI-based no-code business function generation system, comprising: The natural language parsing module acquires and parses the natural language function description text input by the user, extracts the business intent, and generates structured functional requirements. The business output determination module determines the expected business output based on the aforementioned functional requirements. Planning engine module: Taking the desired business output as the starting target node, it performs a reverse search in the pre-set software function component library to obtain a sequence of software function component combinations that can generate the desired business output; Code synthesis module: Based on the software functional component combination sequence, instantiate the code template corresponding to each software functional component in the sequence, and generate data interface adaptation code between software functional components to form a black box business function module. The black box business function module provides standardized input and output interfaces to the outside world. The verification module deploys the black-box business function module to a sandbox environment for verification, and publishes it to the component library after successful verification. The feedback learning module collects user feedback on the module and stores the mapping relationship between functional requirements and software functional component combination sequence during the generation process in the case knowledge base; The software functional component library stores multiple software functional components that are decoupled from the interface components. Each software functional component defines an input type, an output type, and execution logic.
[0012] To achieve the above objectives, the present invention also provides a computer-readable storage medium having a computer program stored thereon, the computer program being executed by a processor to implement the AI-based no-code generation method for business functions as described above.
[0013] Compared with the prior art, the present invention has the following beneficial effects: (1) This invention abandons the optimization mode that relies on historical operation data and directly processes the user's most original natural language needs. The system can proactively understand and respond to new business scenario needs that have not appeared in historical data.
[0014] (2) The present invention can automatically plan the functional logic chain and generate a complete and runnable black box functional module. Users do not need to perform tedious component dragging and logic connection, which significantly reduces the threshold of use and improves development efficiency.
[0015] (3) The black-box business function module generated by the present invention has complete internal logic and standardized interface, and can be directly integrated into complex systems as a service, providing greater commercial application value. Attached Figure Description
[0016] Figure 1 This is a flowchart of Embodiment 1 of the present invention.
[0017] Figure 2 This is a principle block diagram of Embodiment 3 of the present invention. Detailed Implementation
[0018] To enable those skilled in the art to have a clearer understanding of the present invention, the present invention will be further described in detail below with reference to embodiments. It should be understood that the specific embodiments described below are merely for illustrative purposes and to facilitate understanding. The technical solutions provided by the present invention are not limited to those provided in the following embodiments, nor should they limit the scope of protection of the present invention.
[0019] It should be noted that the illustrations provided in the following embodiments are only schematic representations of the basic concept of the present invention. Therefore, the drawings only show the components related to the present invention and are not drawn according to the actual number, shape and size of the components in the actual implementation. In the actual implementation, the shape, quantity and proportion of each component can be arbitrarily changed, and the layout of the components may also be more complex. Example 2
[0020] like Figure 1 As shown, this embodiment provides a no-code method for generating business functions based on artificial intelligence, which includes the following steps: Step S1: Obtain and parse the natural language function description text input by the user, extract the business intent, and generate structured functional requirements.
[0021] Suppose a user enters something like, "I need a function that can automatically scan all Excel files in a specified folder, extract the sales data, calculate the sum and average, and finally generate a summary report PDF, which will then be sent to the manager via email."
[0022] Based on the aforementioned natural language, the system invokes a pre-trained Natural Language Processing (NLP) model (such as BERT based on the Transformer architecture) to perform word segmentation, dependency parsing, and semantic role labeling on the input text. This step is a mature existing technology and will not be elaborated upon. Through analysis, the following elements are identified: Core operations: scanning, extraction, calculation (sum, average), generation, and sending; Operation objects: Excel files, sales columns, data, summary report PDFs, and emails; Business rules: operate on all files in a specified folder; calculate the sum and average; Constraints: output format is PDF; send to a specific recipient (Manager XX).
[0023] The above elements are converted into a structured JSON object as a functional requirement. This conversion can be achieved using mature existing technologies, such as rule-based template filling or lightweight machine learning models, to convert them into a structured JSON object as a functional requirement, for example: { "function_type": "data_processing_and_report", “input_schema”: { "source_type": "local_folder", "file_pattern": "*.xlsx", "target_column": "Sales revenue" }, "process_logic": "aggregate_sum_and_average", “output_spec”: { “format”: “PDF”, "delivery": "email", “recipient”: “manager” } }
[0024] Step S2: Determine the expected business outputs based on functional requirements.
[0025] The system analyzes the above structured functional requirements and performs the following operations: (1) Extracting the output target description: "Generate a summary report PDF" and "Send via email" are identified as the final output targets; (2) Matching standardized output types: The system queries the output type directory in the preset "Software Functional Component Library" and finds two standardized output types, "PDF_Document" and "Email_Notification", which match the description; (3) Determining the starting target node: In the Software Functional Component Library, the system finds the software functional component with output type "PDF_Document" (e.g., GeneratePdfReportComponent) and the software functional component with output type "Email_Notification" (e.g., SendEmailComponent). The above components are determined as the starting target node for reverse search.
[0026] Step S3: Reverse search to obtain the combination sequence of software functional components.
[0027] Using the two software functional components mentioned above as the starting target nodes for reverse search, find all predecessor software functional components in the software functional component library whose output type is compatible with the input type of the software functional component.
[0028] The software component library stores several software components decoupled from the interface components, such as: ReadExcelFileComponent: input (file path, worksheet name), output (structured data object, such as DataFrame); ExtractColumnComponent: input (structured data object, column name), output (list of specific data types, such as List). <float>); CalculateSumComponent: Input (a list of numbers, such as List) <float>), Output (number); CalculateAverageComponent: Input (array of numbers), Output (number); AggregateToReportDataComponent: Input (multiple numbers, labels), Output (ReportData structure); GeneratePdfReportComponent: Input (ReportData structure), Output (PDF_Document); SendEmailComponent: Input (PDF_Document, recipient), Output (Email_Notification); ListFilesInFolderComponent: Input (folder path, file extension), Output (list of file paths); ForEachLoopControlComponent: Input (list, components to be executed), Output (list of processing results).
[0029] The reverse search process uses a mature graph search algorithm (such as depth-first search). For example, its process is as follows: (1) The system synchronously launches a reverse search from all starting target nodes (GeneratePdfReportComponent and SendEmailComponent in this example). (2) Taking GeneratePdfReportComponent as an example, it reversely searches for the component AggregateToReportDataComponent that can provide its required input (ReportData structure) and continues to search recursively. (3) Taking SendEmailComponent as an example, it reversely searches for the component that can provide its required input (PDF_Document), and it will also find GeneratePdfReportComponent, thus merging with the first path to form a complete data flow graph containing common sub-paths.
[0030] (4) The system integrates all the searched components and their connections, and selects the optimal path as the combination sequence of software functional components.
[0031] During the reverse search process, when the system identifies a data set that needs to be processed (such as "all Excel files in a specified folder"), it will automatically plan and introduce loop control logic. Specifically, the system will: introduce ForEachLoopControlComponent as the component to manage the loop; connect the output (list of file paths) of ListFilesInFolderComponent to the list input interface of ForEachLoopControlComponent; configure the sequence of components that need to be executed in a loop (such as ReadExcelFileComponent, ExtractColumnComponent, etc.) as a sub-logical unit as the "component to be executed" input of ForEachLoopControlComponent; the output of ForEachLoopControlComponent will be the list of processing results, which will be used by subsequent components (such as CalculateSumComponent, which needs to aggregate all results).
[0032] Step S4: Program synthesis to generate black-box business function modules.
[0033] Instantiated code templates: Each component in the sequence is associated with a specific code template (e.g., function template, class template, or configuration file template), and the system loads and instantiates these templates in sequence; for example, according to the sequence order, the templates of software functions such as ListFilesInFolderComponent, ForEachLoopComponent, and ReadExcelFileComponent are loaded.
[0034] Parameter population and interface adaptation: Fill the specific parameter values into the template and automatically generate data conversion and transmission code between components (such as type conversion and data aggregation), while adding unified exception handling logic, for example: (1) Type conversion: ExtractColumnComponent may output a List <float>, while the input of a certain downstream component requires double[], the system automatically inserts type conversion code; (2) Data aggregation: AggregateToReportDataComponent needs to receive two outputs, CalculateSumComponent and CalculateAverageComponent, and the system generates code to assemble the two results into a structure; (3) Exception handling: Add unified exception capture and handling logic to the entire sequence, such as adding try-catch blocks to uniformly capture and log exceptions such as file not found, column name error, and network sending failure.
[0035] Encapsulation and Interface Generation: Integrate all code into a single, cohesive software module (such as a Java class or Python package), and generate clear public APIs and descriptive documentation for it. For example, name it AutoSalesReportGenerator, and generate clear public methods for this class as standardized input interfaces, such as generateReport(folderPath: String): ReportResult; at the same time, automatically generate a description file for this interface, such as a simple JSON schema, explicitly declaring the calling method, parameters, and return value.
[0036] Step S5: Deploy the black-box business function module to the sandbox environment for verification, and publish it to the component library after successful verification.
[0037] Deploy the generated AutoSalesReportGenerator module to an isolated sandbox runtime environment and then test it: use simulated data generated by a pre-built test case set to execute the logic of the black-box business function module and verify whether its output meets expectations.
[0038] Output verification: Check whether the module successfully outputs a PDF file and whether it simulates sending an email (or records the sending request), and verify whether the output results meet the established criteria for successful output.
[0039] Release: After verification, the system will release this module to the platform's "Intelligent Generation Component Library" and label it with tags such as "Data Report" and "Email Notification" for users to drag and drop directly.
[0040] Step S6: Feedback and Learning.
[0041] After users apply the generated modules to real-world business applications, the system collects feedback through logs or user-generated ratings. Simultaneously, the system stores this successful generated case as a knowledge package in the case knowledge base. This knowledge package includes: the original natural language requirement text, structured functional requirements (JSON), the final sequence of software functional components used, the generated black-box module identifiers, and performance metrics.
[0042] When users request similar order statistics and email delivery in the future, the system can prioritize retrieving similar cases from the case library, reusing or fine-tuning their software functional component sequences, thereby accelerating the generation process and improving the success rate, thus optimizing the system. Example 2
[0043] This embodiment provides a computer-readable storage medium on which a computer program is stored. The computer program is executed by a processor to implement the no-code generation method for business functions based on artificial intelligence provided in Embodiment 1. Those skilled in the art will understand that all or part of the steps of the method provided in Embodiment 1 can be implemented by hardware related to the computer program. The aforementioned computer program can be stored in a computer-readable storage medium. When the program is executed, it performs the steps of the method provided in Embodiment 1. The aforementioned storage medium includes various media capable of storing program code, such as ROM, RAM, magnetic disks, or optical disks. Example 3
[0044] like Figure 2 As shown, this embodiment provides an AI-based no-code business function generation system, including: The natural language parsing module acquires and parses the natural language function description text input by the user, extracts the business intent, and generates structured functional requirements. The business output determination module determines the expected business output based on functional requirements. Planning Engine Module: Taking the desired business output as the starting target node, it performs a reverse search in the pre-built software functional component library to obtain a sequence of software functional component combinations that can produce the desired business output; Code synthesis module: Based on the combination sequence of software functional components, instantiate the code template corresponding to each software functional component in the sequence, and generate data interface adaptation code between software functional components to form a black box business function module. The black box business function module provides standardized input and output interfaces to the outside world. The verification module deploys black-box business function modules to a sandbox environment for verification, and publishes them to the component library after successful verification. The feedback learning module collects user feedback on the module and stores the mapping relationship between functional requirements and software functional component combination sequence during the generation process in the case knowledge base; The software functional component library stores multiple software functional components that are decoupled from the interface components. Each software functional component defines an input type, an output type, and execution logic.
[0045] The functions of each module correspond one-to-one with the steps described above, and will not be repeated here.
[0046] The above embodiments are merely illustrative of the principles and effects of the present invention and are not intended to limit the invention. Any person skilled in the art can modify or alter the above embodiments without departing from the spirit and scope of the present invention. Therefore, all equivalent modifications or alterations made by those skilled in the art without departing from the spirit and technical concept disclosed in the present invention should still be covered by the claims of the present invention.< / float> < / float> < / float>
Claims
1. A method for generating business functions without code based on artificial intelligence, characterized in that, Includes the following steps: Step S1: Obtain and parse the natural language function description text input by the user, extract the business intent, and generate structured functional requirements; Step S2: Determine the expected business output based on the functional requirements; Step S3: Using the desired business output as the starting target node, perform a reverse search in the preset software function component library to obtain a sequence of software function component combinations that can generate the desired business output. The software function component library stores multiple software function components decoupled from the interface components. Each software function component defines an input type, an output type, and execution logic. Step S4: Based on the software functional component combination sequence, instantiate the code template corresponding to each software functional component in the sequence, and generate data interface adaptation code between software functional components to form a black box business function module. The black box business function module provides standardized input and output interfaces to the outside world. Step S5: Deploy the black-box business function module to the sandbox environment for verification, and publish it to the component library after successful verification; Step S6: Collect user feedback on the module and store the mapping relationship between functional requirements and software functional component combination sequence during this generation process in the case knowledge base.
2. The method for generating business functions without code based on artificial intelligence according to claim 1, characterized in that, The specific method for step S1 is as follows: Step S1.1: Use a natural language processing model to perform semantic analysis on the natural language function description text to identify business elements, including core operation actions, operation objects, business rules, and constraints. Step S1.2: Convert the business elements into a structured functional requirement representation, which includes function type, input data pattern, processing logic description and output format requirements.
3. The method for generating business functions without code based on artificial intelligence according to claim 2, characterized in that, The specific method for step S2 is as follows: Step S2.1: From the structured functional requirements, parse and extract statements that clearly describe the final result, data product, or system state change, as the output target description; Step S2.2: Match and map the output target description with the predefined standardized output types in the software functional component library. The standardized output types include data object type, file format, event signal type, or status identifier. Step S2.3: Based on the matching mapping results, determine one or more software functional components as the starting target nodes for the reverse search.
4. The method for generating business functions without code based on artificial intelligence according to claim 3, characterized in that, In step S3, the specific method for reverse search is as follows: Step S3.1: Starting from the initial target node, search for all predecessor software functional components in the software functional component library whose output type is compatible with the input type of the software functional component; Step S3.2: Recursively execute the above search process for each found precursor software functional component until all necessary inputs can find corresponding data sources or user input interfaces; Step S3.3: From all the feasible paths found, select the optimal path as the final software functional component combination sequence based on path length, component complexity, and execution efficiency.
5. The method for generating business functions without code based on artificial intelligence according to claim 4, characterized in that, In step S4, generating data interface adaptation code between software functional components includes: (1) if the output type of the previous software functional component does not completely match the input type of the next software functional component, automatically insert type conversion code; (2) if it is necessary to aggregate the outputs of multiple software functional components as a single input, automatically generate data aggregation code; (3) generate unified exception capture and processing logic for the entire software functional component combination sequence.
6. The method for generating business functions without code based on artificial intelligence according to claim 5, characterized in that, In step S4, the specific method for constructing the black-box business function module is as follows: based on the software function component combination sequence and the generated data interface adaptation code, all executable logic is encapsulated into an independent software module; a standardized application programming interface and a corresponding interface description file are generated for the software module, wherein the application programming interface is used to receive input configuration and return processing results.
7. The method for generating business functions without code based on artificial intelligence according to claim 6, characterized in that, The verification in step S5 includes: using simulated data generated by a pre-set test case set, executing the logic of the black-box business function module, and verifying whether its output meets expectations.
8. A business function no-code generation system based on artificial intelligence, characterized in that: include: The natural language parsing module acquires and parses the natural language function description text input by the user, extracts the business intent, and generates structured functional requirements. The business output determination module determines the expected business output based on the aforementioned functional requirements. Planning engine module: Taking the desired business output as the starting target node, it performs a reverse search in the pre-set software function component library to obtain a sequence of software function component combinations that can generate the desired business output; Code synthesis module: Based on the software functional component combination sequence, instantiate the code template corresponding to each software functional component in the sequence, and generate data interface adaptation code between software functional components to form a black box business function module. The black box business function module provides standardized input and output interfaces to the outside world. The verification module deploys the black-box business function module to a sandbox environment for verification, and publishes it to the component library after successful verification. The feedback learning module collects user feedback on the module and stores the mapping relationship between functional requirements and software functional component combination sequence during the generation process in the case knowledge base; The software functional component library stores multiple software functional components that are decoupled from the interface components. Each software functional component defines an input type, an output type, and execution logic.
9. A computer-readable storage medium having a computer program stored thereon, characterized in that, The computer program is executed by a processor to implement the no-code generation method for business functions based on artificial intelligence as described in any one of claims 1 to 7.