Low-code automatic development method and system based on AI and medium

Abstract

The invention discloses an AI-based low-code automatic development method and system and a medium, mainly relates to the technical field of image processing, and is used for solving the existing problems that the demand conversion efficiency is low, the code quality depends on manpower, and the complex scene support is insufficient. Comprising the steps of extracting a current functional entity corresponding to a code function core feature; based on the current functional entity and the historical functional entity, extracting an associated sub-graph containing the current functional entity and the historical functional entity from a preset knowledge graph corresponding to the demand technical field; dSL grammar corresponding to the demand technical field is obtained, entity nodes related to the associated sub-atlas, inter-node interaction logic rules and code function core features are input into the DSL grammar, and intermediate representation IR is obtained; and according to the intermediate representation IR, the code function core features and the current function entity, a model trained by a large-scale code library is utilized to generate a specific code.

Description

Technical Field

[0001] This application relates to the field of intelligent robot control technology, and in particular to an AI-based low-code automated development method, system and medium. Background Art

[0002] Traditional low-code development platforms significantly lower the technical barriers to software development through visual components and drag-and-drop operations, enabling non-professional developers to quickly build applications. However, existing technologies still have the following core issues: Low demand conversion efficiency: User requirements must be manually broken down and mapped to visual components. This process is not only time-consuming and labor-intensive, but also prone to errors in demand conversion due to misunderstandings. For example, complex business logic (such as multiple conditional branches or cross-module interactions) cannot be implemented through simple drag-and-drop operations, requiring repeated adjustments to component configurations, further reducing development efficiency.

[0003] Code quality relies on manual effort: Code generated by traditional platforms often lacks a standardized structure and relies on manual review and optimization by developers. This manual intervention leads to inconsistent code quality, making consistency and maintainability difficult to ensure. For example, redundant logic, suboptimal algorithm implementations, or potential security vulnerabilities in the code may go undetected due to manual oversight.

[0004] Insufficient support for complex scenes: Existing low-code platforms have limited support for complex business scenarios (such as high-concurrency processing, cross-system integration, and dynamic rule engines), requiring frequent involvement of professional developers to write custom code. This not only increases development costs but also undermines the original "no-code" principle of low-code platforms, extending project cycles. Summary of the Invention

[0005] This application provides an AI-based low-code automated development method, system and medium to solve the problems of low demand conversion efficiency, manual dependence on code quality, and insufficient support for complex scenarios in existing solutions.

[0006] In the first aspect, this application provides an AI-based low-code automated development method, the method comprising: Obtain user requirement text through the preset requirement acquisition interface, and then obtain the core features of the code function and the required technical field through semantic analysis; Extract the current functional entity corresponding to the core features of the code function; obtain the historical functional entity corresponding to the historical user demand text corresponding to the preset demand acquisition interface; Based on the current functional entity and the historical functional entity, an associated subgraph containing the current functional entity and the historical functional entity is extracted from the preset knowledge graph corresponding to the required technical field; wherein the associated subgraph is composed of entity nodes and the interaction logic between nodes, and the entity nodes contain the current functional entity and the historical functional entity; Obtain the DSL syntax corresponding to the required technical field, input the entity nodes involved in the associated subgraph, the logic rules for interaction between nodes, and the core features of the code functions into the DSL syntax to obtain the intermediate representation IR; Generate specific code based on the intermediate representation IR, the core features of the code function, and the current functional entity using a model trained on a large-scale code base.

[0007] In one implementation of the present application, after generating the specific code, the method further includes: Extract test scenarios from user requirement texts and generate boundary test samples; Generate abnormal test data using genetic algorithms; Based on boundary test samples and abnormal sample data, use the preset code to run the integrated framework to run specific codes and obtain the running results; Determine whether the current code is qualified based on the corresponding relationship between the running results and the preset results; Use containerization technology to simulate multi-server interactions and achieve compatibility of interfaces involved in current code.

[0008] In one implementation of the present application, based on the current functional entity and the historical functional entity, an associated subgraph containing the current functional entity and the historical functional entity is extracted from a preset knowledge graph corresponding to the required technical field, specifically including: Obtain a knowledge graph query statement, execute the query statement in the knowledge graph storage system, and obtain query results; wherein the query results include: all entities and relationships related to the current functional entity and historical functional entities in the preset knowledge graph; Use graph visualization tools or programmatically construct the extracted entities and relationships into a connected subgraph.

[0009] In one implementation of the present application, a DSL syntax corresponding to the required technical field is obtained, and the entity nodes involved in the associated subgraph, the interaction logic rules between nodes, and the core features of the code functions are input into the DSL syntax to obtain an intermediate representation (IR). Specifically, the following steps are performed: Obtain the DSL syntax corresponding to the required technical field through the preset syntax acquisition interface; wherein the DSL syntax includes at least: entity definition syntax, relationship representation syntax and function description syntax; Use DSL's entity definition syntax to write the extracted entity nodes into DSL code; Use DSL’s relational representation syntax to write the extracted node-to-node interaction logic rules into DSL code; Use the DSL function description syntax to write the extracted core features of the code function into DSL code.

[0010] According to the grammatical rules of DSL, build a parser to parse the DSL code; Use a parser to parse the written DSL code into an abstract intermediate representation IR.

[0011] In one implementation of the present application, before generating specific code based on the intermediate representation IR, the core features of the code function, and the current functional entity using a model trained on a large-scale code library, the method includes: Convert the intermediate representation IR into a serialized graph structure that can be processed by the model; Convert the core features of code functions into preset high-dimensional vectors through graph embedding or word embedding technology; The description of the current functional entity is encoded into preset structured data, which is then concatenated with the serialized graph structure and the preset high-dimensional vector to form a complete input.

[0012] Secondly, this application provides an AI-based low-code automated development system, which includes: The acquisition module is used to obtain user demand text through the preset demand acquisition interface, and then obtain the core features of the code function and the technical field of demand through semantic analysis; extract the current functional entity corresponding to the core features of the code function; and obtain the historical functional entity corresponding to the historical user demand text corresponding to the preset demand acquisition interface; A graph module is used to extract, based on the current functional entity and the historical functional entity, an associated subgraph containing the current functional entity and the historical functional entity from a preset knowledge graph corresponding to the required technical field; wherein the associated subgraph is composed of entity nodes and interaction logic between nodes, and the entity nodes include the current functional entity and the historical functional entity; The generation module is used to obtain the DSL syntax corresponding to the required technical field, input the entity nodes involved in the associated sub-graph and the interaction logic rules between nodes, and the core features of the code functions into the DSL syntax to obtain the intermediate representation IR; based on the intermediate representation IR, the core features of the code functions, and the current functional entity, the model trained by the large-scale code library is used to generate specific code.

[0013] In one implementation of the present application, the system further includes a testing module for extracting test scenarios from user requirement texts and generating boundary test samples; Generate abnormal test data using genetic algorithms; Based on boundary test samples and abnormal sample data, use the preset code to run the integrated framework to run specific codes and obtain the running results; Determine whether the current code is qualified based on the corresponding relationship between the running results and the preset results; Use containerization technology to simulate multi-server interactions and achieve compatibility of interfaces involved in current code.

[0014] In one implementation of the present application, the atlas module includes an atlas unit, Used to obtain knowledge graph query statements, execute query statements in the knowledge graph storage system, and obtain query results; wherein the query results include: all entities and relationships related to the current functional entity and historical functional entities in the preset knowledge graph; Use graph visualization tools or programmatically construct the extracted entities and relationships into a connected subgraph.

[0015] In one implementation of the present application, the generation module includes a generation unit for obtaining a DSL grammar corresponding to the required technical field through a preset grammar acquisition interface; wherein the DSL grammar includes at least: entity definition grammar, relationship representation grammar, and function description grammar; Use DSL's entity definition syntax to write the extracted entity nodes into DSL code; Use DSL’s relational representation syntax to write the extracted node-to-node interaction logic rules into DSL code; Use the DSL function description syntax to write the extracted core features of the code function into DSL code.

[0016] According to the grammatical rules of DSL, build a parser to parse the DSL code; Use a parser to parse the written DSL code into an abstract intermediate representation IR.

[0017] In a third aspect, the present application provides a non-volatile computer storage medium on which computer instructions are stored. When the computer instructions are executed, they implement an AI-based low-code automated development method such as any of the above.

[0018] It can be seen from the above technical solutions that this application has the following advantages: Improved demand conversion efficiency‌ The pre-set requirements acquisition interface automatically captures user requirements text and directly extracts the core functional features and technical field tags of the code based on semantic parsing technology, avoiding the time-consuming and high-error rate of traditional manual requirements analysis. Furthermore, combined with correlation analysis of historical functional entities, it can quickly locate reusable business logic modules, reducing repetitive development workload and improving the efficiency of requirements conversion.

[0019] ‌Automated code quality assurance is achieved:‌ This method converts the entity interaction logic rules and functional features in the knowledge graph into a standardized intermediate representation (IR) through DSL syntax, and uses the AI ​​model trained on a large-scale code base to generate code to ensure that the code structure conforms to industry best practices.

[0020] Enhanced support for complex business scenarios: The associated sub-graph extraction mechanism based on the knowledge graph can dynamically integrate current needs and cross-domain knowledge in historical projects (such as payment systems, supply chain management, etc.), and generate customized codes adapted to complex scenarios through AI models.

[0021] Furthermore, the accumulation of historical functional entities and the iterative update mechanism of the knowledge graph enable the platform to continuously accumulate domain knowledge assets. The fully automated design allows non-professional developers (such as business personnel) to directly participate in code generation, reducing reliance on experienced developers. BRIEF DESCRIPTION OF THE DRAWINGS

[0022] In order to more clearly illustrate the technical solution of the present invention, the following is a brief introduction to the drawings required for the description. Obviously, the drawings described below are only some embodiments of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0023] Figure 1 This is a flow chart of an AI-based low-code automated development method provided in an embodiment of the present application.

[0024] Figure 2 This is a schematic diagram of the internal structure of an AI-based low-code automated development system provided in an embodiment of the present application. DETAILED DESCRIPTION

[0025] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0026] It should be understood by those skilled in the art that the embodiments described below are merely preferred embodiments of the present disclosure and do not imply that the present disclosure can only be implemented through these preferred embodiments. These preferred embodiments are merely intended to explain the technical principles of the present disclosure and are not intended to limit the scope of protection of the present disclosure. Based on the preferred embodiments provided by the present disclosure, all other embodiments obtained by those skilled in the art without creative effort should still fall within the scope of protection of the present disclosure.

[0027] It should also be noted that the terms "comprises," "includes," or any other variations thereof are intended to encompass non-exclusive inclusion, such that a process, method, commodity, or apparatus that includes a series of elements includes not only those elements but also other elements not explicitly listed, or includes elements inherent to such process, method, commodity, or apparatus. In the absence of further limitations, an element defined by the phrase "comprises a ..." does not exclude the presence of other identical elements in the process, method, commodity, or apparatus that includes the element.

[0028] The technical solutions proposed in the embodiments of the present application are described in detail below with reference to the accompanying drawings.

[0029] The embodiment provides an AI-based low-code automated development method, such as Figure 1 As shown, the method provided in the embodiment of the present application mainly includes the following steps: Step 110: Obtain user requirement text through the preset requirement acquisition interface, and then obtain the core features of the code function and the technical field of requirement through semantic analysis; extract the current functional entity corresponding to the core features of the code function; obtain the historical functional entity corresponding to the historical user requirement text corresponding to the preset requirement acquisition interface.

[0030] It should be noted that this step obtains user requirement text through a preset requirement acquisition interface and performs semantic analysis, accurately extracting the core features of the code function and the required technical fields. This allows the development team to clearly define the development goals and direction from the outset, avoiding misunderstandings or directional errors during the development process, thereby improving development efficiency and success rate. At the same time, extracting the current functional entity corresponding to the core features of the code function provides specific operation objects for subsequent development work, making the development process more focused and targeted.

[0031] Obtaining historical functional entities corresponding to historical user requirement texts from the preset requirement acquisition interface allows you to leverage experience and knowledge from past projects. Historical functional entities may contain proven solutions, common functional modules, or best practices. Referencing these historical functional entities in new projects can avoid duplication of effort and reduce development time and costs. Furthermore, by comparing current functional entities with historical functional entities, you can identify potential issues or areas for improvement, further optimizing the development process.

[0032] This step enables the system to continuously learn and accumulate information related to user needs. As historical functional entities continue to grow, the system can better understand the demand patterns and characteristics of different users, thereby providing more personalized and intelligent solutions in subsequent development. This increased adaptability and intelligence helps improve the overall system performance and user satisfaction.

[0033] Specific examples: Suppose we are developing an order management system for an e-commerce platform.

[0034] The user enters the requirement text in the preset requirement acquisition interface: "I hope the order management system can track the order status in real time and automatically send a notification text message to the user when the order status changes to shipped." The system performs semantic analysis on the demand text and obtains the core features of the code functions as "real-time tracking of order status", "order status changes to shipped", and "sending notification SMS", and the demand technical field is "e-commerce order management".

[0035] Extract the current functional entities corresponding to the core features of the code, such as "order status tracking module," "order status judgment logic," and "SMS sending function." This way, the development team will have a clear idea of ​​the specific functional modules to be developed, and subsequent development work will be carried out around these functional entities.

[0036] In the historical user demand text corresponding to the preset demand acquisition interface, there is a similar demand: "When the order payment is successful, a confirmation email is automatically sent to the user." Its corresponding historical function entities include "order payment status judgment logic" and "email sending function".

[0037] When developing the current order management system, the development team could refer to the "order payment status determination logic" in the historical functional entity and design similar "order status determination logic" to determine whether an order has been shipped. Furthermore, for the "Send SMS" feature, since previous projects already had experience with email sending, the development team could draw on the implementation of the email sending feature to quickly develop the SMS sending feature, avoiding design and development from scratch and improving development efficiency.

[0038] Step 120: Based on the current functional entity and the historical functional entity, extract the associated subgraph containing the current functional entity and the historical functional entity from the preset knowledge graph corresponding to the required technical field.

[0039] It should be noted that the associated subgraph consists of entity nodes and the interaction logic between nodes, and the entity nodes include current functional entities and historical functional entities.

[0040] Among them, based on the current functional entity and the historical functional entity, the associated subgraph containing the current functional entity and the historical functional entity is extracted from the preset knowledge graph corresponding to the required technical field, which can be: Obtain a knowledge graph query statement, execute the query statement in the knowledge graph storage system, and obtain query results; wherein the query results include: all entities and relationships related to the current functional entity and historical functional entities in the preset knowledge graph; Use graph visualization tools or programmatically construct the extracted entities and relationships into a connected subgraph.

[0041] Those skilled in the art will appreciate that this step, by combining the current functional entity with historical functional entities and extracting associated subgraphs from the preset knowledge graph, can integrate various types of knowledge and experience related to the current development task. The knowledge graph stores a wealth of domain knowledge and information from past projects. By extracting associated subgraphs, related entities and relationships scattered across different projects can be centrally presented, providing developers with a comprehensive reference to help them better understand the application scenarios and interaction logic of the current functional entity in historical projects, thereby enabling them to make more reasonable development decisions.

[0042] The association subgraph not only includes current and historical functional entities but also displays the interaction logic between them. This helps developers discover potential connections and patterns, such as how different functional entities work together and potential optimization points. These potential connections can provide developers with innovative ideas, inspiring them to design more efficient and high-quality solutions, and improving the quality and competitiveness of their development results.

[0043] By extracting related subgraphs from the knowledge graph, developers can quickly access existing knowledge and experience relevant to the current development task, avoiding exploration and research from scratch. This saves development time and improves efficiency. Furthermore, the entities and interaction logic in the related subgraphs can be directly used as the basis for development, reducing duplication of effort and allowing developers to focus more on solving specific problems in the current task.

[0044] Pre-built knowledge graphs typically adhere to certain standards and specifications, and the associated subgraphs extracted from them also inherit these characteristics. Developers can use these associated subgraphs as a reference to ensure consistency and standardization during development, making the generated code more unified in structure, style, and logic, and reducing the difficulty of subsequent maintenance and expansion.

[0045] Specific examples: Suppose we are developing a patient medical record management module for a medical information management system.

[0046] The current functional entity is "electronic medical record entry function" and the historical functional entity is "paper medical record digital conversion function".

[0047] By extracting associated sub-graphs from the preset knowledge graph in the field of medical information management, the query results may include other entities related to these two functional entities, such as "patient basic information", "medical record template", "data storage format", etc., as well as the relationships between them. For example, the "electronic medical record entry function" depends on the "patient basic information" and "medical record template", and the "paper medical record digital conversion function" will generate an electronic medical record with a specific "data storage format".

[0048] By viewing the associated subgraph, developers can fully understand the position and role of these two functional entities in the entire system, as well as their relationship with other entities, providing a reference for how to work with existing functions when developing electronic medical record entry functions.

[0049] In the associated subgraph, developers found that the "paper medical record digital conversion function" would format and standardize the medical record content during the conversion process.

[0050] This inspires developers to introduce similar formatting and standardization mechanisms when designing the "electronic medical record entry function" to improve the quality and consistency of electronic medical records, while facilitating subsequent retrieval and analysis.

[0051] Developers can directly obtain the data storage format and related processing logic used in the "paper medical record digital conversion function" from the associated sub-graph.

[0052] When developing the "electronic medical record entry function", you can refer to this existing information to avoid redesigning and implementing the data storage format and processing logic, saving development time and improving development efficiency.

[0053] Step 130: Obtain the DSL syntax corresponding to the required technical field, input the entity nodes involved in the associated sub-graph, the interaction logic rules between nodes, and the core features of the code functions into the DSL syntax to obtain the intermediate representation IR; based on the intermediate representation IR, the core features of the code functions, and the current functional entity, use the model trained by the large-scale code library to generate specific code.

[0054] It should be noted that this step obtains the DSL (Domain Specific Language) syntax corresponding to the technical domain of the requirement. The entity nodes involved in the associated subgraph, the logical rules for interactions between nodes, and the core features of the code functionality are input into the DSL syntax to generate an intermediate representation (IR). DSL syntax provides a standardized expression for a specific domain, enabling unified processing of requirement information from different sources and in different forms. This standardization avoids misunderstandings caused by the ambiguity and diversity of natural language descriptions and improves the accuracy of subsequent code generation. The intermediate representation (IR) is an abstract expression of requirement information, stripping away specific implementation details and focusing on the core logic and functionality of the code. This abstraction helps the model better understand the essence of the requirement, reducing interference caused by differences in implementation details, and thus generating code that better meets the requirements.

[0055] The associated subgraph contains rich knowledge about the required technical domain, such as relationships between entity nodes and common interaction logic. Combining this knowledge with the core functional characteristics of the code and feeding it into a model trained on a large-scale codebase can ensure that the generated code better conforms to the best practices and standards in that domain. For example, in the field of medical software development, the model can generate code that meets medical industry standards based on the medical entity relationships and interaction logic in the associated subgraph.

[0056] Models trained on large-scale code bases learn from numerous code examples and patterns, enabling them to generate high-quality, maintainable code based on input information. This model can help avoid common coding errors and improve code reliability and performance. Furthermore, the model generates code with good structure and style, facilitating subsequent maintenance and expansion. This step automates the process from requirements information to specific code, reducing the manual coding workload for developers. Developers only need to focus on the accuracy and completeness of requirements, rather than spending significant time on code writing and debugging, thereby improving development efficiency.

[0057] When requirements change, we can quickly respond to them by simply updating the associated subgraphs and the core features of the code, regenerating the intermediate representation (IR), and using the model to generate new code. This flexibility makes the development process more agile and reduces the development costs associated with changing requirements.

[0058] The DSL syntax corresponding to the required technical field is obtained, and the entity nodes involved in the associated subgraph, the interaction logic rules between nodes, and the core features of the code functions are input into the DSL syntax to obtain the intermediate representation IR. Specifically, the following steps are involved: Obtain the DSL syntax corresponding to the required technical field through the preset syntax acquisition interface; wherein the DSL syntax includes at least: entity definition syntax, relationship representation syntax and function description syntax; Use DSL's entity definition syntax to write the extracted entity nodes into DSL code; Use DSL’s relational representation syntax to write the extracted node-to-node interaction logic rules into DSL code; Use the DSL function description syntax to write the extracted core features of the code function into DSL code.

[0059] According to the grammatical rules of DSL, build a parser to parse the DSL code; Use a parser to parse the written DSL code into an abstract intermediate representation IR.

[0060] It's important to note that by deriving the DSL (Domain-Specific Language) syntax corresponding to the technical domain of the requirements, the entity nodes, the logical rules for interactions between nodes, and the core functional features of the code in the associated subgraph are converted into DSL code, achieving standardized expression of requirements. The DSL syntax, including entity definition syntax, relationship representation syntax, and functional description syntax, provides clear ways to express different types of requirements information, avoiding the ambiguity and ambiguity of natural language descriptions and enabling developers to more accurately understand requirements.

[0061] Parsing the DSL code into an abstract intermediate representation (IR) further abstracts the requirements. IR strips away specific syntax details, focusing on the core logic and functionality of the code. This provides clearer guidance for subsequent code generation, reduces interference caused by syntax differences and implementation details, and improves the accuracy of code generation.

[0062] Using DSL syntax to write code creates a clear structure. Entity definition syntax clarifies the various entities in the system, relationship representation syntax describes the interactions between entities, and function description syntax defines the core functionality of the system. This structured code generation approach helps developers better understand and maintain the code, while also facilitating code extension and modification as requirements change.

[0063] The abstract intermediate representation (IR) provides a flexible middle layer for code generation. When requirements change, only the DSL code needs to be modified and reparsed to generate a new IR, without requiring a major overhaul of the entire code generation process. This flexibility allows the system to better adapt to changing requirements and reduces maintenance costs.

[0064] Before generating specific code based on the intermediate representation IR, the core features of the code function, and the current functional entity using a model trained on a large-scale code base, the method includes: Convert the intermediate representation IR into a serialized graph structure that can be processed by the model; Convert the core features of code functions into preset high-dimensional vectors through graph embedding or word embedding technology; The description of the current functional entity is encoded into preset structured data, which is then concatenated with the serialized graph structure and the preset high-dimensional vector to form a complete input.

[0065] In some embodiments, after generating the specific code, the method further includes: Extract test scenarios from user requirement texts and generate boundary test samples; Generate abnormal test data using genetic algorithms; Based on boundary test samples and abnormal sample data, use the preset code to run the integrated framework to run specific codes and obtain the running results; Determine whether the current code is qualified based on the corresponding relationship between the running results and the preset results; Use containerization technology to simulate multi-server interactions and achieve compatibility of interfaces involved in current code.

[0066] Based on the previous description, it can be seen that this embodiment directly obtains user requirement text through a preset requirement acquisition interface, and uses semantic analysis to quickly obtain the core features of the code function and the technical field of requirements, which changes the cumbersome and time-consuming communication and analysis process in the traditional requirement conversion process, and can quickly convert user requirements into key information that can be used for subsequent development, shortening the requirement conversion cycle and improving overall development efficiency.

[0067] Traditional development methods rely heavily on manual effort, making code quality prone to human error and subjective discrepancies. This application leverages AI technology to extract related subgraphs from a pre-set knowledge graph based on current and historical functional entities. This is combined with a DSL syntax to generate an intermediate representation (IR). The model, trained on a large-scale codebase, then generates the specific code. This entire process reduces manual coding steps, lowering the risk of errors caused by human error, resulting in more standardized and accurate generated code, effectively improving code quality.

[0068] By obtaining historical functional entities corresponding to historical user requirement texts and extracting associated subgraphs from a pre-set knowledge graph based on the current and historical functional entities, we can fully leverage knowledge and experience from past projects. This effective use of historical data and knowledge helps quickly identify similar cases and solutions for new development tasks, avoiding duplication of effort. It also helps ensure that newly generated code is consistent in style and logic with previous projects, further improving development efficiency and code quality.

[0069] The entire process, from capturing user requirements to generating specific code, is highly automated with the help of AI. Developers no longer need to manually write extensive code, focusing solely on the critical steps of capturing requirements and reviewing the results. This significantly reduces their workload, allowing them to focus on more creative and strategic work, driving the intelligent development of the software development industry.

[0070] In addition, this application Figure 2 An AI-based low-code automated development system is provided in the embodiment of this application. Figure 2 As shown, the system provided in the embodiment of the present application mainly includes: The acquisition module 210 is used to obtain user demand text through the preset demand acquisition interface, and then perform semantic analysis to obtain the core features of the code function and the required technical field; extract the current functional entity corresponding to the core features of the code function; and obtain the historical functional entity corresponding to the historical user demand text corresponding to the preset demand acquisition interface; The graph module 220 is used to extract an associated sub-graph containing the current functional entity and the historical functional entity from a preset knowledge graph corresponding to the required technical field based on the current functional entity and the historical functional entity; wherein the associated sub-graph is composed of entity nodes and interaction logic between nodes, and the entity nodes contain the current functional entity and the historical functional entity.

[0071] The atlas module 220 includes an atlas unit, Used to obtain knowledge graph query statements, execute query statements in the knowledge graph storage system, and obtain query results; wherein the query results include: all entities and relationships related to the current functional entity and historical functional entities in the preset knowledge graph; Use graph visualization tools or programmatically construct the extracted entities and relationships into a connected subgraph.

[0072] Generation module 230 is used to obtain the DSL syntax corresponding to the required technical field, input the entity nodes involved in the associated sub-graph and the interaction logic rules between nodes, and the core features of the code functions into the DSL syntax to obtain the intermediate representation IR; based on the intermediate representation IR, the core features of the code functions, and the current functional entity, specific code is generated using a model trained with a large-scale code library.

[0073] The generation module 230 includes a generation unit, Used to obtain the DSL syntax corresponding to the required technical field through the preset syntax acquisition interface; wherein the DSL syntax includes at least: entity definition syntax, relationship representation syntax and function description syntax; Use DSL's entity definition syntax to write the extracted entity nodes into DSL code; Use DSL’s relational representation syntax to write the extracted node-to-node interaction logic rules into DSL code; Use the DSL function description syntax to write the extracted core features of the code function into DSL code.

[0074] According to the grammatical rules of DSL, build a parser to parse the DSL code; Use a parser to parse the written DSL code into an abstract intermediate representation IR.

[0075] The system also includes a test module, Used to extract test scenarios from user requirement texts and generate boundary test samples; Generate abnormal test data using genetic algorithms; Based on boundary test samples and abnormal sample data, use the preset code to run the integrated framework to run specific codes and obtain the running results; Determine whether the current code is qualified based on the corresponding relationship between the running results and the preset results; Use containerization technology to simulate multi-server interactions and achieve compatibility of interfaces involved in current code.

[0076] In addition, an embodiment of the present application also provides a non-volatile computer storage medium on which executable instructions are stored. When the executable instructions are executed, an AI-based low-code automated development method as described above is implemented.

[0077] The above description of the disclosed embodiments is intended to enable one skilled in the art to implement or use the present invention. Various modifications to these embodiments will be readily apparent to one skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the present invention. Therefore, the present invention is not limited to the embodiments shown herein but is intended to conform to the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A low-code automated development method based on AI, characterized by: The method comprises: Obtain user requirement text through the preset requirement acquisition interface, and then obtain the core features of the code function and the required technical field through semantic analysis; Extract the current functional entity corresponding to the core features of the code function; obtain the historical functional entity corresponding to the historical user demand text corresponding to the preset demand acquisition interface; Based on the current functional entity and the historical functional entity, an associated subgraph containing the current functional entity and the historical functional entity is extracted from the preset knowledge graph corresponding to the required technical field; wherein the associated subgraph is composed of entity nodes and the interaction logic between nodes, and the entity nodes contain the current functional entity and the historical functional entity; Obtain the DSL syntax corresponding to the required technical field, input the entity nodes involved in the associated subgraph, the logic rules for interaction between nodes, and the core features of the code functions into the DSL syntax to obtain the intermediate representation IR; Generate specific code based on the intermediate representation IR, the core features of the code function, and the current functional entity using a model trained on a large-scale code base.

2. The AI-based low-code automated development method according to claim 1, characterized in that: After generating the specific code, the method further includes: Extract test scenarios from user requirement texts and generate boundary test samples; Generate abnormal test data using genetic algorithms; Based on boundary test samples and abnormal sample data, use the preset code to run the integrated framework to run specific codes and obtain the running results; Determine whether the current code is qualified based on the corresponding relationship between the running results and the preset results; Use containerization technology to simulate multi-server interactions and achieve compatibility of interfaces involved in current code.

3. The AI-based low-code automated development method according to claim 1, characterized in that: Based on the current functional entity and the historical functional entity, the associated subgraph containing the current functional entity and the historical functional entity is extracted from the preset knowledge graph corresponding to the required technical field, specifically including: Obtain a knowledge graph query statement, execute the query statement in the knowledge graph storage system, and obtain query results; wherein the query results include: all entities and relationships related to the current functional entity and historical functional entities in the preset knowledge graph; Use graph visualization tools or programmatically construct the extracted entities and relationships into a connected subgraph.

4. The AI-based low-code automated development method according to claim 1, characterized in that: Obtain the DSL syntax corresponding to the required technical field, input the entity nodes involved in the associated subgraph, the logic rules for interaction between nodes, and the core features of the code functions into the DSL syntax, and obtain the intermediate representation IR, which includes: Obtain the DSL syntax corresponding to the required technical field through the preset syntax acquisition interface; wherein the DSL syntax includes at least: entity definition syntax, relationship representation syntax and function description syntax; Use DSL's entity definition syntax to write the extracted entity nodes into DSL code; Use DSL’s relational representation syntax to write the extracted node-to-node interaction logic rules into DSL code; Use the DSL function description syntax to write the extracted core features of the code function into DSL code; build a parser based on the DSL syntax rules to parse the DSL code; Use a parser to parse the written DSL code into an abstract intermediate representation IR.

5. The AI-based low-code automated development method according to claim 1, characterized in that: Before generating specific code based on the intermediate representation IR, the core features of the code function, and the current functional entity using a model trained on a large-scale code base, the method includes: Convert the intermediate representation IR into a serialized graph structure that can be processed by the model; Convert the core features of code functions into preset high-dimensional vectors through graph embedding or word embedding technology; The description of the current functional entity is encoded into preset structured data, which is then concatenated with the serialized graph structure and the preset high-dimensional vector to form a complete input.

6. An AI-based low-code automated development system, characterized by: The system comprises: The acquisition module is used to obtain user demand text through the preset demand acquisition interface, and then obtain the core features of the code function and the technical field of demand through semantic analysis; extract the current functional entity corresponding to the core features of the code function; and obtain the historical functional entity corresponding to the historical user demand text corresponding to the preset demand acquisition interface; A graph module is used to extract, based on the current functional entity and the historical functional entity, an associated subgraph containing the current functional entity and the historical functional entity from a preset knowledge graph corresponding to the required technical field; wherein the associated subgraph is composed of entity nodes and interaction logic between nodes, and the entity nodes include the current functional entity and the historical functional entity; The generation module is used to obtain the DSL syntax corresponding to the required technical field, input the entity nodes involved in the associated sub-graph and the interaction logic rules between nodes, and the core features of the code functions into the DSL syntax to obtain the intermediate representation IR; based on the intermediate representation IR, the core features of the code functions, and the current functional entity, the model trained by the large-scale code library is used to generate specific code.

7. The AI-based low-code automated development system according to claim 6, characterized in that: The system further comprises a testing module, Used to extract test scenarios from user requirement texts and generate boundary test samples; Generate abnormal test data using genetic algorithms; Based on boundary test samples and abnormal sample data, use the preset code to run the integrated framework to run specific codes and obtain the running results; Determine whether the current code is qualified based on the corresponding relationship between the running results and the preset results; Use containerization technology to simulate multi-server interactions and achieve compatibility of interfaces involved in current code.

8. The AI-based low-code automated development system according to claim 6, characterized in that: The atlas module includes an atlas unit, Used to obtain knowledge graph query statements, execute query statements in the knowledge graph storage system, and obtain query results; wherein the query results include: all entities and relationships related to the current functional entity and historical functional entities in the preset knowledge graph; Use graph visualization tools or programmatically construct the extracted entities and relationships into a connected subgraph.

9. The AI-based low-code automated development system according to claim 6, characterized in that: The generation module includes a generation unit, Used to obtain the DSL syntax corresponding to the required technical field through the preset syntax acquisition interface; wherein the DSL syntax includes at least: entity definition syntax, relationship representation syntax and function description syntax; Use DSL's entity definition syntax to write the extracted entity nodes into DSL code; Use DSL’s relational representation syntax to write the extracted node-to-node interaction logic rules into DSL code; Use DSL's functional description syntax to write the extracted core features of the code into DSL code; According to the grammatical rules of DSL, build a parser to parse the DSL code; Use a parser to parse the written DSL code into an abstract intermediate representation IR.

10. A non-volatile computer storage medium, characterized in that Computer instructions are stored thereon, and when the computer instructions are executed, they implement an AI-based low-code automated development method as described in any one of claims 1-5.

Images