Interactive intelligent software application construction tool based on large model
By using interactive intelligent software application construction tools based on large models, the problems of time-consuming, labor-intensive, and resource-wasting traditional software development have been solved, achieving efficient and reliable software development and support for complex structures, thereby improving the quality and maintainability of software applications.
Patent Information
- Application Number
- CN202410968286.6
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-07-18
- Publication Date
- 2024-11-12
AI Technical Summary
Traditional software development relies on manual coding, which is time-consuming, labor-intensive, and prone to errors. Furthermore, large model methods lack interaction and collaboration with developers, making it impossible to generate non-linear structures, resulting in wasted resources and low software application quality.
It provides an interactive intelligent software application construction tool based on a large model, including an intelligent software resource library, a task requirement understanding module, a task flow planning module, a service retrieval and selection module, a glue code generation and testing module, a process debugging module, and a human-computer collaboration and continuous learning module. It supports non-linear structure planning, automatic service matching, and glue code generation, and optimizes processes through human-computer interaction.
It significantly improves software development efficiency and quality, reduces time and costs, enhances reliability and maintainability, and supports the construction of reusable and complex software applications.
Smart Images

Figure CN118939261A_ABST
Abstract
Description
Technical Field
[0001] The present invention belongs to the technical field of intelligent software development, and in particular relates to a tool for constructing interactive intelligent software applications using a large language model. Background Art
[0002] Traditional software development processes often rely on manual coding and testing, which is not only time-consuming and labor-intensive, but also prone to errors. With the development of artificial intelligence technology, especially the emergence of big models, it has become possible to develop automated and intelligent software. Big models have powerful understanding, generation and reasoning capabilities, which have profoundly changed the way people interact with computers and have also profoundly changed all walks of life. Big models provide new perspectives and new methods for the construction of intelligent software applications through technologies such as model fine-tuning, prompt engineering, retrieval enhancement, and intelligent agents.
[0003] In the construction of intelligent software applications based on service orchestration, the big model decomposes tasks and plans solutions according to the developer's task description, and then selects and calls external services to construct and execute the final intelligent software application. At present, this type of method mainly faces four limitations and challenges. First, the big model takes care of everything and lacks interaction and collaboration with developers, resulting in problems such as biased developer intentions and unreasonable task decomposition. Given the current status of the capabilities of the big model and the complexity of software application requirements, the interaction and collaboration of developers during the construction process is generally unavoidable. Second, these methods only support process planning of linear structures and do not support complex structures (such as parallel and loop structures). However, there are a large number of nonlinear structure processes in real software business, so the big model needs to have the ability to generate nonlinear structures in process planning. Third, the types of software applications constructed by these methods are relatively single and do not support reuse. Even if the same request is received as before, these methods will still repeatedly construct the corresponding software application, resulting in a large resource overhead. Therefore, it is necessary to support the parameterization of software applications to support software application reuse, so as to cope with the same or similar requirements in the future and reduce the resource overhead of repeated construction. Fourth, most of these methods do not consider the glue code between adjacent services in the process (converting the output of the previous service to meet the input requirements of the next service), resulting in a low probability of successful execution of the software application. Therefore, it is necessary to consider the automatic generation of glue code in the construction of software applications to improve the quality of software applications. Summary of the invention
[0004] The purpose of the present invention is to provide an interactive intelligent software application construction tool based on a large model, aiming to improve the efficiency and quality of software development through an intelligent method, significantly reduce the time and cost of software development, and improve the reliability and maintainability of the software.
[0005] The interactive intelligent software application construction tool based on a large model provided by the present invention includes: a library containing polymorphic resources such as code, model, service, etc. to support resource requirements in the process of software application construction; an intelligent analysis and understanding of the developer's demand description through interaction with the developer to provide accurate input for subsequent task planning: automatically planning the task process according to the understood demand, supporting the process planning of non-linear structure to adapt to complex software development needs; using word embedding technology to achieve efficient retrieval and selection of services to ensure that each subtask can adapt to the most suitable service; automatically generating glue code that adapts to different service interfaces and ensuring its correctness through testing; debugging the entire software application construction process to ensure the execution correctness of each subtask and the connectivity of data and logic; an interactive front-end interface to enable developers to participate in each stage of software application construction and conduct continuous learning and optimization based on feedback; specifically including:
[0006] (1) Intelligent software resource library;
[0007] Used to store and provide intelligent software resources in various forms such as code, models, and services; the resource library integrates multi-source heterogeneous resources through a distributed crawler framework, including but not limited to crawling code resources from GitHub, crawling model resources from HuggingFace, and crawling services and API resources from manufacturers such as Tencent, Alibaba, and iFlytek. Specifically, it includes the following sub-libraries:
[0008] (1.1) Code resource sub-library, which is dedicated to storing and providing code snippets, templates and library files used in software development, mainly obtained from GitHub;
[0009] (1.2) Model resource sub-library, which is dedicated to storing and providing pre-trained machine learning models, including but not limited to classifiers, regressors, generators, etc., mainly obtained from HuggingFace;
[0010] (1.3) Service and API resource sub-library, which is specifically used to store and provide third-party services and application programming interfaces, including authentication and authorization mechanisms to protect the use of APIs, mainly obtained from manufacturers such as Tencent, Alibaba, and iFlytek;
[0011] (2) Task requirement understanding module;
[0012] It is used to interact with developers, collect requirements through a chat interface, and use the analytical capabilities of the big model to provide requirement clarification and solution suggestions to improve the accuracy and completeness of requirements. It specifically includes the following sub-modules:
[0013] (2.1) The multi-turn dialogue management submodule is used to maintain the context information and history of the dialogue to achieve a more natural interaction experience and context-related answers. Through chat-style interaction, developers can more conveniently express their needs, while the big model can help developers clarify vague or incomplete needs through intelligent analysis and powerful understanding capabilities, and provide corresponding suggestions and solutions;
[0014] (2.2) Large model requirement analysis submodule, which uses the large model to analyze the extracted key information and generate a preliminary description of the task requirements;
[0015] (2.3) Interactive feedback mechanism submodule, which allows developers to confirm or modify the task description to ensure the accuracy of the requirements;
[0016] (2.4) Parameterizable object extraction submodule: extracts parameterizable objects from requirements and regards these parameterized objects as configurable components. When faced with similar tasks, different object values can be directly configured to reuse software applications without having to construct software applications from scratch, thus improving software reusability.
[0017] (3) Mission process planning module;
[0018] It is used to describe the automatic planning of task processes according to the needs of developers, and supports the planning of non-linear structural processes, including parallel and loop structures, to meet complex software development needs. It includes the following sub-modules:
[0019] (3.1) The process planning submodule supports non-linear structures, decomposing complex development tasks into executable subtasks, and determining the logical relationship and execution order between subtasks to form a task flow. In order to support the planning of non-linear structure processes, we adopted a task planning method based on preconditions. Each subtask is assigned a precondition, which can be the output result from the previous task flow, or the execution status of other tasks or specific environmental conditions. The subtask can only be executed when the precondition is met. This structure can describe the dependencies and execution order between tasks and control the flow of data, thereby achieving more flexible and complex task flow planning.
[0020] (3.2) Process visualization tools allow developers to view, edit, and verify task flows in a graphical manner.
[0021] (4) Service retrieval and selection module;
[0022] The word embedding model is used to vectorize task descriptions and service documents. By comparing the similarity of vectors, the most relevant services for the current task are retrieved from the intelligent software resource library to achieve efficient service matching. It includes the following sub-modules:
[0023] (4.1) Service document parsing submodule, which uses the embedding model to convert service documents into high-dimensional service text vectors for parsing service documents and extracting key features;
[0024] (4.2) Task description parsing submodule: uses the embedding model to convert the task description into a high-dimensional vector for parsing the task description and extracting key features;
[0025] (4.3) Similarity measurement engine submodule, used to calculate the similarity between the task description vector and the service document vector and select the most relevant service. The most relevant service will be selected first. If the glue code generation and testing results in the next step fail, that is, the service cannot meet the requirements of the subtask, then the next relevant service will be selected and the above logical judgment will be executed in sequence;
[0026] (5) Glue code generation and testing module;
[0027] It is used to automatically generate glue code that adapts to different service interfaces and ensure its correctness through testing. The glue code can be a traditional programming language code or an object adaptation conversion function implemented by calling a large model. It specifically includes the following sub-modules:
[0028] (5.1) Interface information description submodule, used to obtain the input and output variable information of each subtask, as well as the description and parameter information of the selected service, to provide necessary information for glue code generation;
[0029] (5.2) Test case generation submodule, which is used to automatically generate test cases based on the functional description, expected behavior and performance requirements of the service, and supports the automated execution of test cases to verify the correctness of the glue code.
[0030] (5.3) Glue code generation submodule is used to generate glue code that meets the conversion requirements based on the service interface definition and the expected input and output of the subtask. The code can be iteratively modified based on the actual conversion results of the test case. If the traditional code cannot be used to convert the connection, the large model is used as a direct conversion function to implement the conversion function.
[0031] (6) Process debugging module:
[0032] Used to debug the entire software application construction process to ensure the correctness of each subtask execution and the connectivity of data and logic, including verifying input conversion, service call and output consistency. It includes the following submodules:
[0033] (6.1) Initially debug the sub-modules of the process to ensure that each sub-task is executed smoothly as planned and can generate output correctly. This includes verifying whether the input of each sub-task can be converted into a tool-adaptable format through glue code, whether the intelligent software resource library service can be correctly called, and whether the output is consistent with the expected result;
[0034] (6.2) Data flow tracking submodule, used to track the data flow between subtasks, to ensure that the output of each subtask can be used as the input of the subsequent task, and that the data will not be lost or damaged during the transmission process, thus maintaining the integrity and consistency of the data;
[0035] (6.3) Logic verification submodule, used to verify whether the execution logic and conditional control of the subtask meet expectations.
[0036] (6.4) Feedback optimization submodule: If problems are found during process debugging, they will be promptly fed back to the previous process planning link. This may involve re-examining the logical structure of task planning, the setting of preconditions, or adjusting the execution method of specific subtasks. Through continuous debugging and feedback, we can gradually optimize the entire process and ensure the correct operation of the software application;
[0037] (7) Human-machine collaboration and continuous learning module;
[0038] Provide an interactive front-end interface to enable developers to participate in all stages of software application construction and conduct continuous learning and optimization based on feedback, including collecting developer interaction records and manual adjustment results, and improving tool performance by fine-tuning large models. The specific steps include:
[0039] (7.1) User interface: provides an intuitive operation interface, allowing developers to manually adjust task processes and parameter configurations; in the requirements understanding stage, developers can directly communicate with the system to propose task requirements, clarify details or express opinions. After the overall process is planned, developers can make suggestions or opinions, and the tool can automatically adjust the process based on the developer's feedback; developers can also manually modify the process intuitively, including adjusting the order of subtasks, adding and deleting subtasks, or redefining preconditions to optimize the execution efficiency and logical correctness of the entire process; in the external service selection stage, the tool provides a flexible interface, allowing developers to freely select appropriate external services as needed; in addition, developers can edit the glue code and design test cases for debugging;
[0040] (7.2) Feedback collection submodule, which is used to collect the interaction records between developers and tools, as well as the manual adjustment results of developers, and to enable the large model to learn to better plan processes, select services, and generate glue code through fine-tuning;
[0041] The structural framework of the interactive intelligent software application construction tool of the present invention is as follows: Figure 1 The basic process is as follows:
[0042] First, through the interaction between the big model and the developer, the tool continuously understands and improves the task requirement description proposed by the developer; then, the tool automatically plans the task process according to the requirement description through the big model; then, the tool retrieves and selects appropriate services for each subtask from the intelligent software resource library; in order to integrate and interact with the results of each subtask, the glue code is automatically generated and tested before and after the service call; finally, the overall process is debugged. In addition, the tool collects error feedback and readjusts the process planning during the process of service retrieval and selection, glue code generation and testing, and process debugging; at the same time, through the front-end interface, developers can participate in the entire process of the tool in a human-computer interactive way.
[0043] The interactive intelligent software application construction tool based on a large model provided by the present invention improves the efficiency and quality of software development through an intelligent method. The tool realizes the automation and intelligence of the whole process from demand understanding to software application construction by integrating an intelligent software resource library, a task demand understanding module, a task process planning module, a service retrieval and selection module, a glue code generation and testing module, a process debugging module, and a human-computer collaboration and continuous learning module. The tool of the present invention can significantly reduce the time and cost of software development, while improving the reliability and maintainability of the software. BRIEF DESCRIPTION OF THE DRAWINGS
[0044] Figure 1 This is a structural framework diagram of the interactive intelligent software application construction tool based on a large model of the present invention.
[0045] Figure 2 Interface diagram for task requirements understanding.
[0046] Figure 3 This is an interface diagram for task process planning and adjustment.
[0047] Figure 4 This is the interface diagram for service retrieval and selection.
[0048] Figure 5 Interface diagram generated for the test case.
[0049] Figure 6 This is the interface diagram for inputting glue code.
[0050] Figure 7 Interface diagram for service calls and output glue code. DETAILED DESCRIPTION
[0051] The present invention is further described below by way of embodiments in conjunction with the accompanying drawings.
[0052] The tool of the present invention is used to realize the construction of interactive intelligent software applications based on large models. The specific steps are as follows:
[0053] (1) Understanding of task requirements. Figure 2 In the example, the user requirement is "Please help me find the shortest route from Griffith Observatory to Los Angeles International Airport. By the way, recommend the best Indian restaurant on the way." On the right side of the interface is the human-computer dialogue window. The user enters the initial requirement, and the big model asks the user for the missing requirement details. After continuous human-computer interaction, the perfect task requirement is obtained. On the left side of the interface is the task requirement description summarized after each round of dialogue modification.
[0054] (2) Task process planning and adjustment. Figure 3 In the upper left part of the interface, the task description after the parameters are extracted for the specific requirements proposed previously. In the current example, the specific departure point, destination, and restaurant type are set as variable parameters to increase the versatility and reusability of the solution. On the right side of the interface is the solution flowchart automatically generated for the previous task requirements, which supports full-screen viewing and manual addition, deletion, and modification of the flowchart. The lower left part of the interface is the logical description of the automatically generated solution process. The middle part of the interface is the human-computer dialogue window, where users can propose modifications to the automatically generated flowchart. The large model automatically corrects the process according to the user's prompts, and the corrected flowchart and its logical description will be displayed in the interface.
[0055] (3) Service retrieval and selection. Figure 4 In the node information section, the specific information of the currently selected subtask is displayed. When the user clicks the "Service Search" button, the vector similarity retrieval tool is called to automatically select several recommended services from the available service documents and display them as options in the recommended service list for the user to choose.
[0056] (4) Glue code generation and testing. Figure 5 In the example, assuming that a subtask has been selected, click the button "Auto Generate" in the Test Case column to generate a test case. In the Glue Code column, you can choose to automatically generate glue code. Users can view and modify the code in the code editor. Click the "Run" button to use the above test case as input to get the glue code running result. Click the "Service Request" button to use the glue code running result as a service request parameter to request the service and get the call result. According to the service call result and the target output format of the subtask, the large model automatically generates the output glue code. Just like the input glue code, users can view, modify and run it to get the final output of the subtask.
[0057] (5) Process debugging. Process debugging is the last step in the software application construction process, covering the entire process from initial input to final result. Process debugging should ensure the correctness of the execution of each subtask, and also pay attention to the data and logic connectivity between subtasks. First, perform preliminary debugging on the process to ensure that each subtask is executed smoothly according to the plan and can correctly generate output. This includes verifying whether each subtask input can be converted into a tool-adaptable format through glue code, whether the intelligent software resource library service can be correctly called, and whether the output is consistent with the expected result. Secondly, pay attention to the data and logic connectivity between subtasks, that is, it is necessary to ensure that the output of each subtask can be used as the input of the subsequent task and that the data will not be lost or damaged during the transmission process. At the same time, it is also necessary to check whether the logical flow is correct and ensure that the execution order and conditional control between tasks meet expectations. Finally, if problems are found during process debugging, they will be promptly fed back to the previous process planning link. This may involve re-examining the logical structure of the task planning, the setting of preconditions, or adjusting the execution method of specific subtasks. Through continuous debugging and feedback, the entire process can be gradually optimized to ensure the correct operation of the software application.
Claims
1. An interactive intelligent software application construction tool based on a large model, characterized in that: include: (1) Intelligent software resource library, used to store and provide intelligent software resources in various forms such as codes, models, and services; The resource library integrates multi-source heterogeneous resources through a distributed crawler framework, including crawling code resources from GitHub, crawling model resources from HuggingFace, and crawling services and API resources from Tencent, Alibaba, and iFlytek. (2) Task requirement understanding module, which is used to interact with developers, collect requirements through a chat-style interface, and use the analytical capabilities of the big model to provide requirement clarification and solution suggestions to improve the accuracy and completeness of requirements; (3) Task flow planning module, which is used to automatically plan task flows according to the developer's requirements and supports the planning of nonlinear structure flows, including parallel and loop structures, to meet complex software development requirements; (4) Service retrieval and selection module: It uses word embedding models to vectorize task descriptions and service documents. By comparing the similarity of vectors, it retrieves the most relevant services for the current task from the intelligent software resource library to achieve efficient service matching. (5) A glue code generation and testing module, which is used to automatically generate glue codes that adapt to different service interfaces and ensure their correctness through testing. The glue code can be a traditional programming language code or an object adaptation conversion function implemented by calling a large model; (6) Process debugging module, which is used to debug the entire software application construction process to ensure the correctness of the execution of each subtask and the connectivity of data and logic, including verifying input conversion, service call and output consistency; (7) Human-computer collaboration and continuous learning module, which is used to provide an interactive front-end interface, enabling developers to participate in various stages of software application construction and conduct continuous learning and optimization based on feedback, including collecting developer interaction records and manual adjustment results, and improving tool performance by fine-tuning large models.
2. The interactive intelligent software application construction tool based on a large model according to claim 1, characterized in that: The intelligent software resource library specifically Includes the following sub-libraries: (1.1) Code resource sub-library, used to store and provide code snippets, templates and library files used in software development, mainly obtained from GitHub; (1.2) Model resource sub-library, used to store and provide pre-trained machine learning models, including classifiers, regressors, and generators, mainly obtained from HuggingFace; (1.3) Service and API resource sub-library, used to store and provide third-party services and application programming interfaces, including authentication and authorization mechanisms to protect the use of APIs, obtained from Tencent, Alibaba, and iFlytek.
3. The interactive intelligent software application construction tool based on large models according to claim 2 is characterized in that: The task requirement understanding module specifically includes the following submodules: (2.1) The multi-turn dialogue management submodule is used to maintain the context information and history of the dialogue to achieve a more natural interaction experience and context-related answers. Through chat-style interaction, developers can more conveniently express their needs, while the big model helps developers clarify vague or incomplete needs through intelligent analysis and powerful understanding capabilities, and provides corresponding suggestions and solutions; (2.2) Large model requirement analysis submodule, which uses the large model to analyze the extracted key information and generate a preliminary description of the task requirements; (2.3) Interactive feedback mechanism submodule, which allows developers to confirm or modify the task description to ensure the accuracy of the requirements; (2.4) Parameterizable object extraction submodule extracts parameterizable objects from requirements and regards these parameterized objects as configurable components. When faced with similar tasks, different object values can be directly configured to reuse software applications without having to construct software applications from scratch, thereby improving software reusability.
4. The interactive intelligent software application construction tool based on large models according to claim 3 is characterized in that: The task flow planning module specifically includes the following sub-modules: (3.1) The process planning submodule supports nonlinear structures, decomposing complex development tasks into executable subtasks, and determining the logical relationship and execution order between subtasks to form a task process. In order to support the planning of nonlinear structure processes, a task planning method based on preconditions is adopted. Each subtask is assigned a precondition, which is the output result from the previous task process, or the execution status of other tasks or specific environmental conditions. The subtask can only be executed when the precondition is met. This structure can describe the dependency relationship and execution order between tasks, control the data flow, and thus achieve more flexible and complex task process planning. (3.2) Process visualization tools allow developers to view, edit, and verify task flows in a graphical manner.
5. The interactive intelligent software application construction tool based on large models according to claim 4 is characterized in that: The service retrieval and selection module specifically Includes the following submodules: (4.1) Service document parsing submodule, which uses the embedding model to convert service documents into high-dimensional service text vectors for parsing service documents and extracting key features; (4.2) Task description parsing submodule: uses the embedding model to convert the task description into a high-dimensional vector for parsing the task description and extracting key features; (4.3) Similarity measurement engine submodule, used to calculate the similarity between the task description vector and the service document vector and select the most relevant service; first select the most relevant service. If the result of the next step of glue code generation and testing fails, that is, the service cannot meet the requirements of the subtask, then select the next relevant service and execute the above logical judgment in sequence.
6. The interactive intelligent software application construction tool based on large models according to claim 5, characterized in that: The glue code generation and testing module specifically includes the following submodules: (5.1) Interface information description submodule, used to obtain the input and output variable information of each subtask, as well as the description and parameter information of the selected service, to provide necessary information for glue code generation; (5.2) Test case generation submodule, which is used to automatically generate test cases based on the functional description, expected behavior and performance requirements of the service, and supports the automated execution of test cases to verify the correctness of the glue code; (5.3) The glue code generation submodule is used to generate glue code that meets the conversion requirements based on the service interface definition and the expected input and output of the subtask. The code can be iteratively modified with reference to the actual conversion results of the test case. If it is not possible to use traditional code to convert the connection, the large model is used as a direct conversion function to implement the conversion function.
7. The interactive intelligent software application construction tool based on large models according to claim 6 is characterized in that: The process debugging module specifically includes the following submodules: (6.1) Preliminary debugging of sub-modules of the process to ensure that each sub-task is executed smoothly as planned and can generate output correctly, including verifying whether each sub-task input can be converted into a tool-adaptable format through glue code, whether the intelligent software resource library service can be correctly called, and whether the output is consistent with the expected result; (6.2) Data flow tracking submodule, used to track the data flow between subtasks, to ensure that the output of each subtask can be used as the input of the subsequent task, and that the data will not be lost or damaged during the transmission process, thus maintaining the integrity and consistency of the data; (6.3) Logic verification submodule, used to verify whether the execution logic and conditional control of the subtask meet expectations; (6.4) Feedback optimization submodule: If any problem is found during process debugging, it will be fed back to the previous process planning link in a timely manner; the problem involves re-examining the logical structure of task planning, the setting of preconditions, or adjusting the execution method of specific subtasks. Through continuous debugging and feedback, the entire process is gradually optimized to ensure the correct operation of the software application.
8. The interactive intelligent software application construction tool based on large models according to claim 7 is characterized in that: The human-machine collaboration and continuous learning module specifically includes the following modules: (7.1) User interface: provides an intuitive operation interface, allowing developers to manually adjust task processes and parameter configurations. In the requirement understanding stage, developers can directly communicate with the system to propose task requirements, clarify details, or express opinions. After the overall process is planned, developers can make suggestions or opinions, and the tool will automatically adjust the process based on the developer's feedback. Developers can also manually modify the process intuitively, including adjusting the order of subtasks, adding and deleting subtasks, or redefining preconditions to optimize the execution efficiency and logical correctness of the entire process. In the external service selection stage, the tool provides a flexible interface, allowing developers to freely select appropriate external services according to their needs. In addition, developers can edit the glue code and design test cases for debugging; (7.2) Feedback collection submodule is used to collect the interaction records between developers and tools, as well as the manual adjustment results of developers, and through fine-tuning, the large model can learn to better plan processes, select services, and generate glue code.
Citation Information
Cited By
Intelligent agent framework based on large language model
CN119476505A
Code generation optimization method based on adaptive planning framework
CN120085846A
