Software development processing method and electronic device

Abstract

The present disclosure provides a software development processing method, device and electronic equipment, constructs a software development knowledge base in which software development documents and relationships between software function nodes are stored based on software developed by an enterprise, after obtaining an original requirement text, calls a software development framework based on a large model, and obtains a target requirement text with clear and standard semantics based on requirement analysis of the software development knowledge base, further calls the software development framework, and performs knowledge retrieval in the software development knowledge base based on the target requirement text to generate software code corresponding to the original requirement text. In the development stage of requirement analysis and code generation, the software development knowledge base assists the large model in understanding the specific business knowledge of the enterprise, solves the problem that the generation result of a general code generation tool deviates greatly from the actual requirement of the enterprise, thereby effectively improving the code quality and improving the software development efficiency.

Description

Technical Field

[0001] This disclosure relates to artificial intelligence technology, software development technology, and in particular a software development processing method and an electronic device. Background Technology

[0002] In the process of software development and system design, developers often face the problem of how to efficiently create suitable implementation solutions and how to translate those solutions into concrete code.

[0003] Traditional software development relies on the knowledge and experience of developers, requiring significant time and effort in conceptualizing solutions and manual coding, resulting in low efficiency. Code generation tools often employ pre-designed, fixed rules, offering limited flexibility and adaptability, leading to code that deviates considerably from actual business scenarios and requirements. Summary of the Invention

[0004] This disclosure provides a software development processing method and an electronic device that can solve the problem that the generated results of general code generation tools deviate significantly from actual needs.

[0005] One aspect of this disclosure provides a software development processing method, including: In response to the development requirement input operation, obtain the original requirement text input by the development requirement input operation; The software development framework based on a large model is invoked, and the original requirement text is parsed based on the software development knowledge base to generate target requirement text. The target requirement text is used to display the software function nodes to be developed. The software development knowledge base stores the software development documents of the enterprise's developed software and the relationship between software function nodes. The software function nodes include the function execution subject and the function operation object. The software development framework is invoked to perform a knowledge retrieval in the software development knowledge base based on the target requirement text, and software code corresponding to the original requirement text is generated based on the retrieval results. Optionally, the software development knowledge base includes a first knowledge base and a second knowledge base, wherein the first knowledge base stores the software development documents and the second knowledge base stores the relationships between the software functional nodes; The invocation of a software development framework built on a large model, and the parsing of the original requirement text based on a software development knowledge base to generate target requirement text, includes: The software development framework is invoked to parse the original requirement text based on the first knowledge base and the second knowledge base, thereby generating the target requirement text. The process of invoking the software development framework, performing a knowledge retrieval in the software development knowledge base based on the target requirement text, and generating software code corresponding to the original requirement text based on the retrieval results includes: The software development framework is invoked to perform knowledge retrieval in the first and second knowledge bases based on the target requirement text, and a software architecture is generated based on the retrieval results. The software development framework is invoked, and knowledge is retrieved from the first knowledge base based on the software architecture. The software code is then generated based on the retrieval results.

[0006] Optionally, the method further includes: The software development document is segmented to obtain document fragments. Using a database that supports vector retrieval as the storage engine, the document fragments and metadata are associated and stored to generate the first knowledge base. The metadata represents the software development document to which the document fragment belongs. The functional node identification model is invoked to identify node relationships based on the software development document, and the relationships between the software functional nodes are stored using a graph database as the storage engine to generate the second knowledge base.

[0007] Optionally, the step of invoking the software development framework to parse the original requirement text based on the first knowledge base and the second knowledge base, and generating the target requirement text, includes: The software development framework is invoked to convert the original requirement text into a requirement text vector, and keywords are extracted from the original requirement text to obtain requirement keywords; Based on the required text vector, document fragment matching is performed in the first knowledge base to obtain the target software development document; Based on the required keywords, node matching is performed in the second knowledge base to obtain the target node and the relationship between the target nodes; The software development framework is invoked to integrate the target software development document, the target node, and the relationship between the target nodes to generate the target requirement text.

[0008] Optionally, after generating the software code corresponding to the original requirement text based on the search results, the method further includes: The software development framework is invoked, and test knowledge is retrieved in the software development knowledge base based on the software code and the target requirement text. At least one test case is generated based on the retrieval results. Run at least one test case in the sandbox system and collect test data; The software development framework is invoked to iteratively optimize the software code based on the test data.

[0009] Optionally, the software development framework includes at least one thinking-based large language model, at least one creative large model, and at least one programming large model; The step of invoking the software development framework to parse the original requirement text based on the first and second knowledge bases and generate the target requirement text includes: The at least one thinking-based large language model is invoked to perform requirement parsing on the original requirement text based on the first knowledge base and the second knowledge base, thereby generating the target requirement text. The process of invoking the software development framework, performing knowledge retrieval in the first and second knowledge bases based on the target requirement text, and generating a software architecture based on the retrieval results includes: The software architecture is generated based on the search results by calling at least one creative large model and performing knowledge retrieval in the first and second knowledge bases based on the target requirement text. The step of invoking the software development framework, performing knowledge retrieval in the first knowledge base based on the software architecture, and generating the software code based on the retrieval results includes: The software code is generated by invoking at least one programmable large model, performing knowledge retrieval in the first knowledge base based on the software architecture, and generating the software code based on the retrieval results.

[0010] Optionally, the step of invoking the at least one thinking-based large language model to perform requirement parsing on the original requirement text based on the first knowledge base and the second knowledge base, and generating the target requirement text, includes: The at least one candidate demand text generated by the at least one thinking-based large language model is scored based on a preset scoring index, and the target demand text is determined based on the scoring results. The preset scoring index includes at least one of the following: historical performance of the model, complexity of the output result, quality of the output result, and model response time. The process of invoking at least one creative large model, performing knowledge retrieval in the first and second knowledge bases based on the target requirement text, and generating the software architecture based on the retrieval results includes: The software architecture is then scored based on the preset scoring criteria at least one candidate software architecture generated by the at least one creative large model, and the software architecture is determined based on the second scoring result. The method further includes: The software code is determined based on the third scoring result after scoring at least one candidate software code generated by the at least one large programming model according to the preset scoring index.

[0011] Optionally, after generating the software architecture based on the search results, the method further includes: The software architecture diagram corresponding to the software architecture is displayed through the architecture editor interface. The editable nodes in the software architecture diagram represent the corresponding software function nodes, and the connection relationship between the editable nodes represents the relationship between the software function nodes. In response to the adjustment operation on the editable node and / or the connection relationship, the software architecture diagram is updated and the software architecture is adjusted based on the updated software architecture diagram.

[0012] Optionally, the step of obtaining the original requirement text input by the development requirement input operation in response to the development requirement input operation includes: In response to receiving the development requirement input operation through the development assistance dialog box, the original requirement text is obtained, and a project identifier corresponding to the development assistance dialog box is generated; The method further includes: The software development data displayed in the development assistance dialog box and the project identifier are associated and stored. The software development data includes the original requirement text, the target requirement text, and the software code. In response to the activation operation of the historical development assistance dialog box, the software development data corresponding to the target project identifier of the historical development assistance dialog box is obtained, and the obtained software development data is displayed through the historical development assistance dialog box; In response to detecting an update to the dialog content within the historical development assistance dialog box, the software development data corresponding to the target project identifier is updated synchronously.

[0013] In another aspect of this disclosure, an electronic device is provided, comprising: Memory, used to store computer programs; A processor is configured to execute a computer program stored in the memory, wherein, when the computer program is executed, it implements the methods described above.

[0014] In another aspect of this disclosure, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, implements the methods described above.

[0015] In another aspect of this disclosure, a computer program product is provided, including computer program instructions that, when executed by a processor, implement the method described above.

[0016] The technical solutions of this disclosure will be further described in detail below with reference to the accompanying drawings and embodiments. Attached Figure Description

[0017] The accompanying drawings, which form part of this specification, illustrate embodiments of this disclosure and, together with the description, serve to explain the principles of this disclosure.

[0018] This disclosure will become clearer with reference to the accompanying drawings and the following detailed description, wherein: Figure 1 A flowchart illustrating one embodiment of the software development processing method disclosed herein; Figure 2 A flowchart of another embodiment of the software development processing method disclosed herein; Figure 3 A flowchart of another embodiment of the software development processing method disclosed herein; Figure 4 A flowchart of another embodiment of the software development processing method disclosed herein; Figure 5 A flowchart of another embodiment of the software development processing method disclosed herein; Figure 6 This is a structural block diagram of one embodiment of the software development processing apparatus disclosed herein; Figure 7 This is a structural block diagram of another embodiment of the software development processing apparatus disclosed herein; Figure 8 This is a schematic diagram of the structure of an application embodiment of the electronic device disclosed herein. Detailed Implementation

[0019] Various exemplary embodiments of the present disclosure will now be described in detail with reference to the accompanying drawings. It should be noted that, unless otherwise specifically stated, the relative arrangement, numerical expressions, and values ​​of the components and steps set forth in these embodiments do not limit the scope of the present disclosure.

[0020] Those skilled in the art will understand that the terms "first," "second," etc., in the embodiments of this disclosure are only used to distinguish different steps, devices, or modules, and do not represent any specific technical meaning, nor do they indicate a necessary logical order between them.

[0021] It should also be understood that in the embodiments disclosed herein, "a plurality of" may refer to two or more, and "at least one" may refer to one, two or more.

[0022] It should also be understood that any component, data or structure mentioned in the embodiments of this disclosure can generally be understood as one or more unless expressly defined or given to the contrary in the context.

[0023] Furthermore, the term "and / or" in this disclosure is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, or B existing alone. Additionally, the character " / " in this disclosure generally indicates that the preceding and following related objects have an "or" relationship.

[0024] It should also be understood that the description of the various embodiments in this disclosure emphasizes the differences between the various embodiments, and the similarities or similarities can be referred to each other. For the sake of brevity, they will not be described in detail.

[0025] At the same time, it should be understood that, for ease of description, the dimensions of the various parts shown in the accompanying drawings are not drawn according to actual scale.

[0026] The following description of at least one exemplary embodiment is merely illustrative and is in no way intended to limit this disclosure or its application or use.

[0027] Techniques, methods, and equipment known to those skilled in the art may not be discussed in detail, but where appropriate, such techniques, methods, and equipment should be considered part of the specification.

[0028] It should be noted that similar labels and letters in the following figures indicate similar items; therefore, once an item is defined in one figure, it does not need to be discussed further in subsequent figures.

[0029] To improve the efficiency of developers writing code, the industry has developed some rule-based code generation tools: integrated development environments (IDEs), code generation plugins (such as Mybatis-Generator), and low-code platforms that enable rapid construction of software systems through visualization. However, these methods usually have fixed code generation rules pre-designed by humans, resulting in relatively weak flexibility and adaptability.

[0030] With the advent of the Artificial Intelligence (AI) era, large language models such as ChatGPT and DeepSeek are widely used in various stages of software development, including requirements analysis, solution design, and code generation. However, while improving development efficiency, they still have the following shortcomings: 1. Lack of enterprise business knowledge. General-purpose large models cannot directly understand the internal business logic and data structure of enterprises, resulting in significant deviations between generated results and actual requirements. 2. Single model call. Existing solutions mostly use single-model calls, lacking multi-model collaboration and dynamic switching mechanisms, leading to unstable generation quality. 3. Optimization relies on manual intervention. Code optimization largely depends on manual debugging and feedback, lacking automated verification and data-driven optimization loops. 4. Lack of context and version management. Insufficient support for continuous development across sessions, making it difficult to effectively manage different versions of solutions and code.

[0031] Figure 1 A flowchart illustrating a software development process method provided as an exemplary embodiment of this disclosure. (See flowchart for example.) Figure 1 As shown, the method includes the following steps: Step 101: In response to the development requirement input operation, obtain the original requirement text input by the development requirement input operation.

[0032] In one possible implementation, the electronic device of this disclosure runs a software development framework that supports visual dialog boxes, through which users can trigger development requirement input operations. Illustratively, when natural language text is received through the dialog box and preset keywords (e.g., "code development," "software development," "code writing," etc.) are identified from the natural language text, it is determined that a development requirement input operation has been received.

[0033] Optionally, the original requirement text can be natural language text entered by the user in the dialog box, or it can be a Product Requirements Document (PRD) imported into the dialog box.

[0034] Step 102: Invoke the software development framework built on the large model, and use the software development knowledge base to parse the original requirement text and generate the target requirement text.

[0035] The target requirements text is used to display the software function nodes to be developed. The software development knowledge base stores the software development documents of the enterprise's existing software and the relationships between software function nodes. The software function nodes include the function execution subject and the function operation object.

[0036] In a schematic representation, software functional nodes include the functional execution entities (such as software modules, interfaces, databases, etc.) used to implement certain business functions or services, as well as the functional operation objects (such as orders, customers, products, user identities, user permissions, etc.). Software development documentation includes relevant documents of the software already developed within the enterprise, such as requirement texts, interface descriptions of various interfaces, enterprise software design specifications, historical code and comments, etc.

[0037] By invoking a software development framework and leveraging a software development knowledge base, the original requirement text is parsed to extract key information such as software functions, interface definitions, performance metrics, and constraints. Based on this extracted information, relevant knowledge is retrieved from the software development knowledge base, ensuring that the generated target requirement text meets the actual needs of the enterprise project development. This target requirement text includes modular requirement content; for example, software function nodes include functional modules and their internal components and interfaces, and it also marks the software function nodes to be developed and those that can be directly reused.

[0038] Step 103: Invoke the software development framework, perform knowledge retrieval in the software development knowledge base based on the target requirement text, and generate software code corresponding to the original requirement text based on the retrieval results.

[0039] Optionally, the system can directly invoke the software development framework after generating the target requirement text, perform a knowledge retrieval in the software development knowledge base based on the target requirement text, and generate software code corresponding to the original requirement text based on the retrieval results. Alternatively, the system can display the target requirement text through a dialog box for user review and modification after generation. If an update operation is detected, the system will perform a knowledge retrieval in the software development knowledge base based on the updated target requirement text and generate software code corresponding to the original requirement text based on the retrieval results.

[0040] Based on the embodiments of this disclosure, a software development knowledge base storing software development documents and relationships between software functional nodes is constructed based on the enterprise's already developed software. After obtaining the original requirement text, a software development framework built on a large model is invoked, and the requirement is parsed based on the software development knowledge base to obtain semantically clear and standardized target requirement text. The software development framework is further invoked, and knowledge is retrieved from the software development knowledge base based on the target requirement text to generate software code corresponding to the original requirement text. In the development stages such as requirement parsing and code generation, the software development knowledge base helps the large model understand the enterprise's specific business knowledge, solving the problem that the generated results of general code generation tools deviate significantly from the actual needs of the enterprise, thereby effectively improving code quality and increasing software development efficiency.

[0041] In one possible implementation, the software development knowledge base includes a first knowledge base and a second knowledge base. The first knowledge base stores software development documents, and the second knowledge base stores relationships between software functional nodes. The method provided in this disclosure further includes the following steps: Step 1: The software development document is segmented to obtain document fragments. Using a database that supports vector retrieval as the storage engine, the document fragments and metadata are associated and stored to generate the first knowledge base.

[0042] Metadata represents the software development document to which the document fragment belongs. For example, metadata may include the document identifier of the software development document to which the document fragment belongs, as well as document tags with attributes such as the update time of the software development document, the software development project to which it belongs, and the development department to which it belongs.

[0043] Optionally, the software development document is segmented based on a preset segment length range, such as 300 to 500 tokens. The resulting document segments are converted into vectors using an open-source embedding model (e.g., text-embedding-ada-002 or bge-large-zh), and the vector-form document segments are associated with their corresponding metadata and stored in a database supporting vector retrieval (e.g., Milvus, Pinecone, Weaviate) to obtain the first knowledge base.

[0044] Step two involves calling the functional node recognition model to identify node relationships based on the software development documentation, and using a graph database as the storage engine to store the relationships between software functional nodes, thereby generating a second knowledge base.

[0045] Optionally, the functional node identification model can employ a deep learning-based target identification model (e.g., BERT-CRF). The software development documentation is input into the functional node identification model, which extracts software functional nodes (e.g., orders, customers, payment gateways) and the relationships between them (e.g., order-belongs-customer, order-calls-payment gateway). These functional nodes and their relationships are then stored in a graph database (e.g., Neo4j, Janus Graph) to obtain a second knowledge base.

[0046] In one possible implementation, the knowledge base required at different stages of software development may differ. Specifically, step 102 above may include the following steps: Step 102a: Invoke the software development framework, and perform requirement parsing on the original requirement text based on the first knowledge base and the second knowledge base to generate the target requirement text.

[0047] In the requirements analysis phase, the software development framework can retrieve requirement texts and software function nodes corresponding to software with similar functions through a first knowledge base, and then retrieve existing software function nodes through a second knowledge base to determine the software function nodes to be developed and those that can be reused, generating modular target requirement texts. For example, consider the target requirement text for an order management system, which records the software function nodes to be developed, including an order creation module, a payment module, and an order status query module, with each module further containing at least one internal component. Based on this target requirement text, the software development framework performs knowledge retrieval, finding the order creation module and payment module, as well as their dependencies and interface call relationships, through the second knowledge base. In the generated software architecture, the order creation module and payment module are marked as reusable nodes, while the order status query module is marked as a node requiring custom development.

[0048] Accordingly, the process of generating software code based on target requirement text can specifically include two stages: software architecture generation and software code writing. Step 103 above includes the following steps: Step 103a: Invoke the software development framework, perform knowledge retrieval in the first and second knowledge bases based on the target requirement text, and generate the software architecture based on the retrieval results.

[0049] Optionally, the target requirements text contains a list of software functional nodes. By invoking the software development framework, information such as software design specifications and historical software architectures can be retrieved from the first knowledge base, and software functional nodes can be matched and their relationships extracted from the second knowledge base. This integrated knowledge generates the software architecture. Illustratively, the software architecture may specifically include a software architecture diagram, the composition of each software functional node, interface definitions, and data flow descriptions between software functional nodes.

[0050] Step 103b: Invoke the software development framework, perform knowledge retrieval in the first knowledge base based on the software architecture, and generate software code based on the retrieval results.

[0051] Optionally, the large model in the software development framework can be retrieved from the first knowledge base based on the software architecture to obtain directly reusable code blocks. For the parts for which no relevant code was retrieved, the code can be written by combining the enterprise's software design specifications and other documents to obtain the software code.

[0052] In one possible implementation, such as Figure 2 As shown, step 102a above may specifically include the following steps: Step 201: Call the software development framework to convert the original requirement text into a requirement text vector, and extract keywords from the original requirement text to obtain requirement keywords.

[0053] Optionally, an open-source embedding model can be used to convert the original requirement text into requirement text vectors for subsequent document fragment matching. Simultaneously, a keyword recognition model can be used to extract keywords from the original requirement text to obtain requirement keywords for subsequent node matching. These requirement keywords can include, but are not limited to, keywords related to software function nodes such as functional descriptions and interface definitions.

[0054] Step 202: Based on the requirement text vector, perform document fragment matching in the first knowledge base to obtain the target software development document.

[0055] Step 203: Based on the requirement keywords, perform node matching in the second knowledge base to obtain the target node and the relationship between the target nodes.

[0056] Optionally, the similarity between the demand text vector and the vectors corresponding to each document fragment in the first knowledge base is calculated, and the document fragments (or their software development documents) with vector similarity higher than the first similarity threshold are selected as the target software development documents, or the n document fragments (or their software development documents) with the highest similarity are selected as the target software development documents, where n is a positive integer.

[0057] Similarity calculations are performed on the requirement keywords and the node names and node description texts of each software function node in the second knowledge base. Software function nodes with similarity higher than the second similarity threshold are identified as target nodes, and the relationships between target nodes are determined. The relationships between target nodes can include node relationships directly related to the target node, and can also include node relationships starting from the target node and within a preset step size.

[0058] Optionally, after obtaining the target software development document through document fragment matching, keywords can be extracted from the target software development document to expand the requirement keywords. Based on the expanded requirement keywords, node matching is performed in the second knowledge base to obtain the target node and the relationship between the target nodes.

[0059] Step 204: Invoke the software development framework to integrate the target software development documents, target nodes, and target node relationships to generate the target requirements text.

[0060] For illustration, if the original requirement text is obtained as "A system for creating orders, making payments, and viewing order status is required," this original requirement text is input into the software development framework. By calling the software development framework to perform document fragment matching based on the first knowledge base, the target software development document is obtained: "Order creation process: The front-end calls the order creation interface, passing in the product ID and quantity, and returns the order ID. The payment module connects to payment platform A and payment platform B. After successful payment, a callback updates the order status. Order status includes pending payment, paid, shipped, and completed." Based on the second knowledge base, node matching is performed on the requirement keywords "order" and "payment," resulting in the target nodes "payment module" and "order module," as well as the target node relationships: "payment module - call - payment platform A interface," "payment module - call - payment platform B interface," and "order module - dependency - inventory interface." By integrating the above target software development document, target nodes, and target node relationships, the user requirement is parsed into modular target requirement text. For example, the target requirement text includes: "Order creation module: responsible for receiving product information and generating orders; payment module: connects to third-party payment platforms and handles payment callbacks; order status query module: queries the current order status."

[0061] Optionally, after the code development is completed for the original requirement text, the system can update the first and second knowledge bases based on the corresponding software architecture and software code.

[0062] Based on the embodiments of this disclosure, by calling the software development framework, document fragment matching is performed based on the first knowledge base to parse out structured development requirements, and node matching is performed based on the second knowledge base to identify reusable software function nodes and software function nodes that need to be customized, thereby obtaining a standardized, clear target requirement text that fits the actual needs of the enterprise.

[0063] In one possible implementation, the software development framework can also automatically test and optimize the generated software code. For example... Figure 3 As shown, after step 103 above, the method provided in this embodiment may further include the following steps: Step 301: Invoke the software development framework, retrieve test knowledge from the software development knowledge base based on the software code and target requirement text, and generate at least one test case based on the retrieval results.

[0064] Optionally, the software development documents in the software development knowledge base may include historical test cases, test strategy documents, performance indicator requirements, and other related documents. By retrieving test knowledge from the software development knowledge base and generating test cases based on the search results, the generated test cases can be made more closely aligned with the company's actual business scenarios and business rules.

[0065] As an example, for the order management system in the above example, order creation test cases can be generated to verify whether the inventory changes normally after an order is created, and payment test cases can be generated to simulate calling a third-party payment platform to verify whether the payment process is normal.

[0066] Step 302: Run at least one test case in the sandbox system and collect test data.

[0067] The test data includes static analysis data and dynamic analysis data. Static analysis data may include at least one of the following: security vulnerabilities, code style defects, and performance bottlenecks. Dynamic analysis data may include at least one of the following: memory usage, code response time, and processor utilization. Electronic devices can collect dynamic analysis data such as memory usage, code response time, and processor utilization by running at least one test case in a sandbox system, and collect static analysis data such as security vulnerabilities, code style defects, and performance bottlenecks by using static analysis tools (such as SonarQube and Bandit).

[0068] Step 303: Invoke the software development framework and iteratively optimize the software code based on the test data.

[0069] Optionally, the test data can be structured into a preset format (e.g., JSON format) and input into a large model in the software development framework to trigger secondary or multiple iterations of optimization until preset conditions are met. These preset conditions include at least one of the following: the number of iterations reaches a preset number, the test data conforms to a preset numerical range, and the test pass rate reaches a preset pass rate threshold.

[0070] In addition, during the generation of software code and subsequent iterative optimization, a version number is automatically generated for each version of the software code, and metadata such as generation time, large model used, and model input data are recorded to facilitate backtracking. The system also supports version difference comparison.

[0071] Based on the embodiments of this disclosure, static analysis and dynamic testing are automatically performed after code generation. Test cases are automatically generated based on the software development knowledge base through the software development framework, and the test cases are run in a sandbox environment. Test data is collected and fed back to the software development framework, driving the software development framework to iteratively optimize the code until the preset quality and performance requirements are met. This changes the traditional optimization mode that relies on manual debugging and feedback, realizes an automated optimization closed loop, and improves code quality.

[0072] In one possible implementation, the software development framework includes at least one large thinking language model, at least one large creative model, and at least one large programming model. Different types of large models are used to perform corresponding tasks at different stages of software development. The software development framework supports parallel generation of multiple models and result evaluation and filtering through multi-model collaboration and dynamic switching mechanisms, and also supports model role division, thereby further improving code quality. The system can assign role labels to each large model in the software development framework, with each role label corresponding to a Prompt template, thereby controlling the execution of corresponding tasks by each large model.

[0073] Step 102a above may specifically include the following steps: Invoke at least one thinking-based large language model, and perform requirement parsing on the original requirement text based on the first knowledge base and the second knowledge base to generate the target requirement text.

[0074] As an illustration, a thought-based large language model, such as DeepSeekR1, can be used to analyze and decompose the original requirement text, combining a business knowledge base and a knowledge graph. Each thought-based large language model performs parallel parsing of the original requirement text to obtain the target requirement text, thus yielding at least one target requirement text.

[0075] Accordingly, step 103a above may specifically include the following steps: Call at least one creative large model, perform knowledge retrieval in the first and second knowledge bases based on the target requirement text, and generate the software architecture based on the retrieval results.

[0076] As an illustration, creative large-scale models can be employed, such as GPT-4 and DeepSeek V3. Each creative large-scale model performs business knowledge retrieval in parallel based on the target requirement text, generating a software architecture, thereby obtaining at least one software architecture.

[0077] Optionally, each creative big model generates software architecture for at least one target requirement text generated by at least one thinking big language model; or, the system selects a target requirement text from at least one target requirement text generated by at least one thinking big language model according to preset rules, so that each creative big model generates software architecture for the selected target requirement text; or, the user can select a target requirement text from at least one target requirement text generated by at least one thinking big language model, so that each creative big model generates software architecture for the user-selected target requirement text.

[0078] Step 103b above may specifically include the following steps: Call at least one large programmable model, perform knowledge retrieval in the first knowledge base based on the software architecture, and generate software code based on the retrieval results.

[0079] As an illustration, large-scale programming models can be implemented using DeepSeek R1, CodeLlama, or similar models. Each large-scale programming model performs code retrieval and code generation in parallel based on the software architecture output by the large-scale creative model, resulting in at least one version of the software code.

[0080] Optionally, each programmatic large model may write code for at least one software architecture generated by at least one creative large model; alternatively, the system may select a software architecture from at least one software architecture generated by at least one creative large model according to preset rules, so that each programmatic large model may write code for the selected software architecture; or, the user may select a software architecture from at least one software architecture generated by at least one creative large model, so that each programmatic large model may write code for the user-selected software architecture.

[0081] Furthermore, the software development framework can also include test engineer models, such as StarCoder or CodeT5+, used during the test optimization phase to perform test knowledge retrieval based on at least one version of software code generated by at least one large programming model, generating at least one test case. Alternatively, the system can select a version of software code from at least one version of software code generated by at least one large programming model according to preset rules, so that each test engineer model can generate test cases for the selected version of software code. Or, the user can select a version of software code from at least one version of software code generated by at least one large programming model, so that each test engineer model can generate test cases for the user-selected version of software code.

[0082] In one possible implementation, in order to improve code quality while reducing data processing volume and improving code generation efficiency, the software development framework can evaluate and filter the results of the output of the large model running in parallel at each stage, and dynamically select and combine the model outputs.

[0083] For example, given at least one target requirement text generated by at least one thinking-based large language model, the system can select one target requirement text according to preset rules, so that each creative large model can generate software architecture based on the selected target requirement text. The steps described above, which involve calling at least one thinking-based large language model to parse the original requirement text based on a first knowledge base and a second knowledge base to generate the target requirement text, may further include the following steps: The target requirement text is determined based on the score results generated by at least one candidate requirement text generated by at least one thinking-based large language model, based on the preset scoring index.

[0084] The preset scoring metrics include at least one of the following: historical model performance, output complexity, output quality, and model response time. The target requirement text can be the candidate requirement text with the highest score.

[0085] Optionally, the system can periodically maintain a performance metric database for each model to provide historical model performance. Historical model performance includes, but is not limited to, historical average response time, historical result complexity (e.g., lines of code, component dependency complexity), and historical result quality (e.g., code compilation success rate). Different types of models may have different historical performance metrics. For example, historical average response time can be calculated for all models, historical result complexity can be calculated for creative large models, and historical result complexity and quality can be calculated for programming large models. Correspondingly, the preset scoring metrics for thinking large models may include historical average response time and model response time.

[0086] In a schematic manner, the scores for each candidate requirement document are obtained by quantifying the information corresponding to the preset scoring indicators and performing a weighted summation calculation based on the corresponding weights. The weights corresponding to historical model performance are lower than those corresponding to real-time model performance. For example, the weight corresponding to historical average response time is lower than the weight corresponding to model response time; the weight corresponding to historical result complexity is lower than the weight corresponding to output result complexity; and the weight corresponding to historical result quality is lower than the weight corresponding to output result quality.

[0087] Accordingly, the steps described above, including calling at least one creative large model, performing knowledge retrieval based on the target requirement text in the first and second knowledge bases, and generating the software architecture based on the retrieval results, may further include: The software architecture is determined based on the second scoring result after scoring at least one candidate software architecture generated by at least one creative large model according to the preset scoring index.

[0088] Optionally, the preset scoring metrics for creative large-scale models may include historical average response time, historical result complexity, and model response time. By quantifying the information corresponding to the preset scoring metrics and combining them with appropriate weights for weighted summation, a score for each software architecture solution is obtained. The selected software architecture can be the candidate software architecture with the highest score.

[0089] Accordingly, the embodiments of this disclosure may also include the following steps: At least one candidate software code generated by at least one large programming model is scored based on a preset scoring index, and the software code is determined based on the third scoring result.

[0090] Optionally, the preset scoring metrics for the programmatic large model may include, for example, historical average response time, historical result complexity (e.g., number of lines of code, component dependency complexity, etc.), historical result quality (e.g., code compilation success rate), output result complexity, output result quality, and model response time.

[0091] Optionally, reusable models may exist among the above types of large models. For example, DeepSeekR1 can run simultaneously as a thinking-based large language model and a programming-based large model.

[0092] Based on the embodiments of this disclosure, by introducing a multi-model collaboration and dynamic model switching mechanism, different models are assigned roles according to task type (requirement analysis, solution design, code generation, code testing). At the same time, by combining the historical performance and real-time performance of the models, the optimal output result of each stage is dynamically selected. Compared with the single model calling method, it can give full play to the advantages of various models in specific tasks, thereby significantly improving the code compilation success rate and the stability of the output results.

[0093] In one possible implementation, the software development framework supports visually representing and modifying the software architecture. For example... Figure 4 As shown, after step 103a above, the method provided in this embodiment may further include the following steps: Step 401: Display the software architecture diagram corresponding to the software architecture through the architecture editor interface.

[0094] In the software architecture diagram, editable nodes represent corresponding software function nodes, and the connection relationships between editable nodes represent the relationships between software function nodes.

[0095] Step 402: In response to the adjustment operation on the editable nodes and / or connection relationships, update the software architecture diagram and adjust the software architecture based on the updated software architecture diagram.

[0096] Optionally, after generating the software architecture or software code, the software development framework can display an architecture editor interface through a visual window, showcasing the software architecture in the form of an architecture diagram or flowchart. For example, a software architecture diagram can represent code components through nodes, and the connections between nodes can represent the relationships between components. Users can adjust the software architecture diagram by dragging and dropping nodes, modifying connections, etc., and the software development framework will synchronously update the software architecture based on the adjusted diagram.

[0097] Based on the embodiments of this disclosure, by providing a visual solution editor, users can modify the software architecture by dragging and dropping nodes and connecting lines, or adjust the solution through natural language commands. This lowers the technical understanding threshold and shortens the time for problem location and repair, making the software development process more intuitive and efficient.

[0098] In one possible implementation, the software development framework achieves context persistence by assigning a unique identifier to each project. Step 101 above may specifically include the following steps: In response to receiving a development requirement input operation through the development assistance dialog box, the original requirement text is obtained, and a project identifier corresponding to the development assistance dialog box is generated.

[0099] Accordingly, the method provided in this disclosure may further include the following steps: The software development data and project identifiers displayed in the development assistance dialog box are associated and stored. The software development data includes the original requirement text, the target requirement text, and the software code. In response to the activation operation of the historical development assistance dialog box, the software development data corresponding to the target project identifier in the historical development assistance dialog box is obtained and displayed through the historical development assistance dialog box. In response to the detection of an update in the dialog box content of the historical development assistance dialog box, the software development data corresponding to the target project identifier is updated synchronously.

[0100] As an illustration, the project identifier corresponding to the development assistance dialog box can be associated with and stored in the database along with the software development data. When a user opens a new development assistance dialog box and enters the target requirement text, the system automatically creates a project identifier, for example, based on keywords in the target requirement text and the time the target requirement text was entered. Subsequent software development framework content generated and displayed through this development assistance dialog box, as well as other requirement text entered by the user, are all stored in the database in chronological order, associated with the project identifier.

[0101] Based on the above mechanism, when a user opens a historical development assistance dialog box, the system can retrieve the associated stored software development data from the database based on the target project identifier corresponding to the historical development assistance dialog box, and display the retrieved software development data through the historical development assistance dialog box to show the user the corresponding context. If new input is received through the historical development assistance dialog box, the software development framework can combine the context (i.e., the stored software development data) and the newly entered text content to generate results and update the software development data associated with the target project identifier.

[0102] Based on the embodiments of this disclosure, software development data such as target requirement text, software architecture and initial code, as well as test cases and test analysis data are stored in a database, and a unique project identifier is assigned to each project. When called across sessions, the corresponding context is loaded, which enables the continuous generation of long-cycle projects.

[0103] In combination with the above embodiments, Figure 5 A flowchart illustrating a software development process is shown. For example... Figure 5 As shown, the system receives natural language requirements or PRD document links input by the user. It then uses a thinking-based large language model to call the software development knowledge base (including a first and second knowledge base) for business knowledge and node relationship retrieval. The system analyzes and decomposes the user input to generate a detailed modular requirement document (target requirement text). This modular requirement document is then input into at least one architect model (a creative large model), which again calls the software development knowledge base for business knowledge and business relationship retrieval. A solution is designed based on the modular requirement document to obtain a technical implementation solution (i.e., software architecture). The evaluated and selected technical implementation solution is input into at least one development engineer model (i.e., a programming large model), which again calls the software development knowledge base for business knowledge and node relationship retrieval. Code is generated for the technical implementation solution, and the project code is evaluated and selected. This project code is then input into at least one test engineer model, which again calls the software development knowledge base for business knowledge and business relationship retrieval. Test cases are generated for the project code, and dynamic and static analysis data are collected during test case execution. The project code is iteratively optimized until all test cases pass.

[0104] Please refer to Figure 6 This illustration shows a structural block diagram of a software development processing apparatus provided in an exemplary embodiment of the present disclosure. The apparatus provided in this embodiment includes: The requirement acquisition module 601 is used to obtain the original requirement text input by the development requirement input operation in response to the development requirement input operation; The requirement parsing module 602 is used to call the software development framework built on the large model, and to parse the original requirement text based on the software development knowledge base to generate the target requirement text. The target requirement text is used to display the software function nodes to be developed. The software development knowledge base stores the software development documents of the enterprise's developed software and the relationship between the software function nodes. The software function nodes include the function execution subject and the function operation object. The code generation module 603 is used to call the software development framework, perform knowledge retrieval in the software development knowledge base based on the target requirement text, and generate software code corresponding to the original requirement text based on the retrieval results.

[0105] Optionally, the software development knowledge base includes a first knowledge base and a second knowledge base. The first knowledge base stores software development documents, and the second knowledge base stores the relationships between software functional nodes. The aforementioned requirement parsing module 602 can be further used for: The software development framework is invoked to parse the original requirement text based on the first knowledge base and the second knowledge base, thereby generating the target requirement text. The code generation module 603 described above can be further used for: The software development framework is invoked to perform knowledge retrieval in the first and second knowledge bases based on the target requirement text, and the software architecture is generated based on the retrieval results. The software development framework is invoked, and knowledge is retrieved from the first knowledge base based on the software architecture. Software code is then generated based on the retrieval results.

[0106] Optionally, the apparatus provided in this disclosure may further include: The first knowledge base construction module is used to segment software development documents to obtain document fragments. Using a database that supports vector retrieval as the storage engine, the document fragments and metadata are associated and stored to generate the first knowledge base. The metadata represents the software development document to which the document fragment belongs. The second knowledge base construction module is used to call the functional node identification model to identify node relationships based on the software development documents, and to store the relationships between software functional nodes using a graph database as the storage engine, thereby generating the second knowledge base.

[0107] Optionally, the aforementioned requirement parsing module 602 can be further used for: The software development framework is invoked to convert the original requirement text into a requirement text vector, and keywords are extracted from the original requirement text to obtain the requirement keywords. Based on the requirement text vector, document fragment matching is performed in the first knowledge base to obtain the target software development document; Based on the keywords of the requirements, node matching is performed in the second knowledge base to obtain the target node and the relationship between the target nodes; The software development framework is invoked to integrate the target software development documents, target nodes, and relationships between target nodes, generating the target requirements text.

[0108] Optional, such as Figure 7 As shown, the apparatus provided in this embodiment may further include: The test case generation module 701 is used to call the software development framework, perform test knowledge retrieval in the software development knowledge base based on the software code and target requirement text, and generate at least one test case based on the retrieval results. Test case execution module 702 is used to run at least one test case in the sandbox system and collect test data; The iterative optimization module 703 is used to call the software development framework and perform iterative optimization of the software code based on test data.

[0109] Optionally, the software development framework includes at least one thinking-based large language model, at least one creative large model, and at least one programming large model; The aforementioned requirement parsing module 602 can be further used for: Call at least one thinking-based large language model, and perform requirement parsing on the original requirement text based on the first and second knowledge bases to generate the target requirement text; The code generation module 603 described above can be further used for: Call at least one creative large model, perform knowledge retrieval in the first and second knowledge bases based on the target requirement text, and generate software architecture based on the retrieval results; Call at least one large programmable model, perform knowledge retrieval in the first knowledge base based on the software architecture, and generate software code based on the retrieval results.

[0110] Optionally, the aforementioned requirement parsing module 602 can be further used for: At least one candidate requirement text generated by at least one thinking-based large language model is scored based on a preset scoring metric. The target requirement text is then determined based on the scoring results. The preset scoring metric includes at least one of the following: model historical performance, output complexity, output quality, and model response time. The code generation module 603 described above can be further used for: The software architecture is determined based on the second scoring result by scoring at least one candidate software architecture generated by at least one creative large model based on the preset scoring index. At least one candidate software code generated by at least one large programming model is scored based on a preset scoring index, and the software code is determined based on the third scoring result.

[0111] Optionally, the apparatus provided in this disclosure may further include: The software architecture diagram corresponding to the software architecture is displayed through the architecture editor interface. The editable nodes in the software architecture diagram represent the corresponding software function nodes, and the connection relationship between the editable nodes represents the relationship between the software function nodes. In response to adjustments to editable nodes and / or connections, update the software architecture diagram and adjust the software architecture based on the updated diagram.

[0112] Optionally, the aforementioned requirement acquisition module 601 can be further used for: In response to receiving a development requirement input operation through the development assistance dialog box, the original requirement text is obtained, and a project identifier corresponding to the development assistance dialog box is generated; The apparatus provided in this disclosure may further include: The storage module is used to associate and store the software development data and project identifiers displayed in the development assistance dialog box. The software development data includes the original requirement text, the target requirement text, and the software code. The data acquisition module is used to respond to the activation operation of the historical development assistance dialog box, acquire the software development data corresponding to the target project identifier of the historical development assistance dialog box, and display the acquired software development data through the historical development assistance dialog box. The data update module is used to synchronously update the software development data corresponding to the target project identifier in response to the detection of updates to the dialog content in the historical development assistance dialog box.

[0113] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar, identical, or corresponding parts between embodiments can be referred to mutually. Since the method, apparatus, and device embodiments are basically corresponding, relevant parts can be referred to the corresponding descriptions. The methods, apparatus, and devices in the embodiments of this disclosure also correspond to each other in specific implementation and beneficial technical effects; related content can be referred to mutually and will not be repeated here.

[0114] In addition, this disclosure also provides an electronic device, including: Memory, used to store computer programs; A processor is configured to execute a computer program stored in the memory, wherein when the computer program is executed, it implements the software development processing method described in any of the above embodiments of the present disclosure.

[0115] Figure 8 This is a schematic diagram illustrating the structure of an application embodiment of the electronic device disclosed herein. Below, reference is made to… Figure 8 This describes an electronic device according to embodiments of the present disclosure. The electronic device may be either or both of a first device and a second device, or a standalone device independent of them, which may communicate with the first device and the second device to receive acquired input signals from them.

[0116] like Figure 8 As shown, the electronic device includes one or more processors and memory.

[0117] A processor can be a central processing unit (CPU) or other form of processing unit with data processing and / or instruction execution capabilities, and can control other components in an electronic device to perform desired functions.

[0118] The memory may include one or more computer program products, which may include various forms of computer-readable storage media, such as volatile memory and / or non-volatile memory. The volatile memory may include, for example, random access memory (RAM) and / or cache memory. The non-volatile memory may include, for example, read-only memory (ROM), hard disk, flash memory, etc. One or more computer program instructions may be stored on the computer-readable storage medium, and a processor may execute the program instructions to implement the software development processing methods of the various embodiments of this disclosure described above, and / or other desired functions.

[0119] In one example, the electronic device may also include input devices and output devices, which are interconnected via a bus system and / or other forms of connection mechanism (not shown).

[0120] In addition, the input device may include, for example, a keyboard, a mouse, etc.

[0121] This output device can output various information to the outside, including determined distance information, direction information, etc. The output device may include, for example, a display, a speaker, a printer, and a communication network and its connected remote output devices, etc.

[0122] Of course, for the sake of simplicity, Figure 8 Only some of the components of the electronic device relevant to this disclosure are shown, omitting components such as buses, input / output interfaces, etc. In addition, the electronic device may include any other suitable components depending on the specific application.

[0123] In addition to the methods and apparatus described above, embodiments of this disclosure may also be computer program products, including computer program instructions that, when executed by a processor, cause the processor to perform the steps in the software development processing methods according to various embodiments of this disclosure as described in the foregoing portions of this specification.

[0124] The computer program product can be written in any combination of one or more programming languages ​​to perform the operations of the embodiments of this disclosure. The programming languages ​​include object-oriented programming languages ​​such as Java and C++, as well as conventional procedural programming languages ​​such as C or similar languages. The program code can be executed entirely on a user's computing device, partially on a user's computing device, as a standalone software package, partially on a user's computing device and partially on a remote computing device, or entirely on a remote computing device or server.

[0125] Furthermore, embodiments of this disclosure may also be computer-readable storage media storing computer program instructions thereon, which, when executed by a processor, cause the processor to perform the steps in the software development processing method according to various embodiments of this disclosure as described in the foregoing portion of this specification.

[0126] The computer-readable storage medium may be any combination of one or more readable media. A readable medium may be a readable signal medium or a readable storage medium. A readable storage medium may be, for example, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of readable storage media (a non-exhaustive list) include: an electrical connection having one or more wires, a portable disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof.

[0127] Those skilled in the art will understand that all or part of the steps of the above method embodiments can be implemented by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When the program is executed, it performs the steps of the above method embodiments. The aforementioned storage medium includes various media that can store program code, such as ROM, RAM, magnetic disk, or optical disk.

[0128] The basic principles of this disclosure have been described above with reference to specific embodiments. However, it should be noted that the advantages, benefits, and effects mentioned in this disclosure are merely examples and not limitations, and should not be considered as essential features of each embodiment of this disclosure. Furthermore, the specific details disclosed above are for illustrative and facilitative purposes only, and are not limitations. These details do not limit the scope of this disclosure to the necessity of employing the aforementioned specific details for implementation.

[0129] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on its differences from other embodiments. Similar or identical parts between embodiments can be referred to interchangeably. For system embodiments, since they largely correspond to method embodiments, the description is relatively simple; relevant parts can be referred to the descriptions in the method embodiments.

[0130] The block diagrams of devices, apparatuses, devices, and systems disclosed herein are merely illustrative examples and are not intended to require or imply that they must be connected, arranged, or configured in the manner shown in the block diagrams. As those skilled in the art will recognize, these devices, apparatuses, devices, and systems can be connected, arranged, and configured in any manner. Words such as “comprising,” “including,” “having,” etc., are open-ended terms meaning “including but not limited to,” and are used interchangeably with them. The terms “or” and “and” as used herein refer to the terms “and / or,” and are used interchangeably with them unless the context clearly indicates otherwise. The term “such as” as used herein refers to the phrase “such as but not limited to,” and is used interchangeably with it.

[0131] The methods and apparatus of this disclosure may be implemented in many ways. For example, they may be implemented by software, hardware, firmware, or any combination of software, hardware, and firmware. The above-described order of steps for the methods is for illustrative purposes only, and the steps of the methods of this disclosure are not limited to the order specifically described above unless otherwise specifically stated. Furthermore, in some embodiments, this disclosure may also be implemented as a program recorded on a recording medium, the program including machine-readable instructions for implementing the methods according to this disclosure. Thus, this disclosure also covers recording media storing programs for performing the methods according to this disclosure.

[0132] It should also be noted that in the apparatus, devices, and methods of this disclosure, the components or steps can be disassembled and / or recombined. These disassemblies and / or recombinations should be considered as equivalent solutions to this disclosure.

[0133] The above description of the disclosed aspects is provided to enable any person skilled in the art to make or use this disclosure. Various modifications to these aspects will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other aspects without departing from the scope of this disclosure. Therefore, this disclosure is not intended to be limited to the aspects shown herein, but rather to be carried out within the widest scope consistent with the principles and novel features disclosed herein.

[0134] The above description has been given for purposes of illustration and description. Furthermore, this description is not intended to limit the embodiments of this disclosure to the forms disclosed herein. Although numerous exemplary aspects and embodiments have been discussed above, those skilled in the art will recognize certain variations, modifications, alterations, additions, and sub-combinations therein.

Claims

1. A software development processing method, characterized in that, include: In response to the development requirement input operation, obtain the original requirement text input by the development requirement input operation; The software development framework based on a large model is invoked, and the original requirement text is parsed based on the software development knowledge base to generate target requirement text. The target requirement text is used to display the software function nodes to be developed. The software development knowledge base stores the software development documents of the enterprise's developed software and the relationship between software function nodes. The software function nodes include the function execution subject and the function operation object. The software development framework is invoked, and knowledge is retrieved from the software development knowledge base based on the target requirement text. Based on the retrieval results, software code corresponding to the original requirement text is generated.

2. The method according to claim 1, characterized in that, The software development knowledge base includes a first knowledge base and a second knowledge base. The first knowledge base stores the software development documents, and the second knowledge base stores the relationships between the software functional nodes. The invocation of a software development framework built on a large model, and the parsing of the original requirement text based on a software development knowledge base to generate target requirement text, includes: The software development framework is invoked to parse the original requirement text based on the first knowledge base and the second knowledge base, thereby generating the target requirement text. The process of invoking the software development framework, performing a knowledge retrieval in the software development knowledge base based on the target requirement text, and generating software code corresponding to the original requirement text based on the retrieval results includes: The software development framework is invoked to perform knowledge retrieval in the first and second knowledge bases based on the target requirement text, and a software architecture is generated based on the retrieval results. The software development framework is invoked, and knowledge is retrieved from the first knowledge base based on the software architecture. The software code is then generated based on the retrieval results.

3. The method according to claim 2, characterized in that, The method further includes: The software development document is segmented to obtain document fragments. Using a database that supports vector retrieval as the storage engine, the document fragments and metadata are associated and stored to generate the first knowledge base. The metadata represents the software development document to which the document fragment belongs. The functional node identification model is invoked to identify node relationships based on the software development document, and the relationships between the software functional nodes are stored using a graph database as the storage engine to generate the second knowledge base.

4. The method according to claim 2, characterized in that, The step of invoking the software development framework to parse the original requirement text based on the first and second knowledge bases and generate the target requirement text includes: The software development framework is invoked to convert the original requirement text into a requirement text vector, and keywords are extracted from the original requirement text to obtain requirement keywords; Based on the required text vector, document fragment matching is performed in the first knowledge base to obtain the target software development document; Based on the required keywords, node matching is performed in the second knowledge base to obtain the target node and the relationship between the target nodes; The software development framework is invoked to integrate the target software development document, the target node, and the relationship between the target nodes to generate the target requirement text.

5. The method according to claim 1, characterized in that, After generating the software code corresponding to the original requirement text based on the search results, the method further includes: The software development framework is invoked, and test knowledge is retrieved in the software development knowledge base based on the software code and the target requirement text. At least one test case is generated based on the retrieval results. Run at least one test case in the sandbox system and collect test data; The software development framework is invoked to iteratively optimize the software code based on the test data.

6. The method according to any one of claims 2 to 5, characterized in that, The software development framework includes at least one thinking-based large language model, at least one creative large model, and at least one programming large model; The step of invoking the software development framework to parse the original requirement text based on the first and second knowledge bases and generate the target requirement text includes: The at least one thinking-based large language model is invoked to perform requirement parsing on the original requirement text based on the first knowledge base and the second knowledge base, thereby generating the target requirement text. The process of invoking the software development framework, performing knowledge retrieval in the first and second knowledge bases based on the target requirement text, and generating a software architecture based on the retrieval results includes: The software architecture is generated based on the search results by calling at least one creative large model and performing knowledge retrieval in the first and second knowledge bases based on the target requirement text. The process of invoking the software development framework, performing knowledge retrieval in the first knowledge base based on the software architecture, and generating the software code based on the retrieval results includes: The software code is generated by invoking at least one programmable large model, performing knowledge retrieval in the first knowledge base based on the software architecture, and generating the software code based on the retrieval results.

7. The method according to claim 6, characterized in that, The step of invoking at least one thinking-based large language model to perform requirement parsing on the original requirement text based on the first knowledge base and the second knowledge base, and generating the target requirement text, includes: The at least one candidate demand text generated by the at least one thinking-based large language model is scored based on a preset scoring index, and the target demand text is determined based on the scoring results. The preset scoring index includes at least one of the following: historical performance of the model, complexity of the output result, quality of the output result, and model response time. The process of invoking at least one creative large model, performing knowledge retrieval in the first and second knowledge bases based on the target requirement text, and generating the software architecture based on the retrieval results includes: The software architecture is then scored based on the preset scoring criteria at least one candidate software architecture generated by the at least one creative large model, and the software architecture is determined based on the second scoring result. The method further includes: The software code is determined based on the third scoring result after scoring at least one candidate software code generated by the at least one large programming model according to the preset scoring index.

8. The method according to any one of claims 2 to 5, characterized in that, After generating the software architecture based on the search results, the method further includes: The software architecture diagram corresponding to the software architecture is displayed through the architecture editor interface. The editable nodes in the software architecture diagram represent the corresponding software function nodes, and the connection relationship between the editable nodes represents the relationship between the software function nodes. In response to the adjustment operation on the editable node and / or the connection relationship, the software architecture diagram is updated and the software architecture is adjusted based on the updated software architecture diagram.

9. The method according to any one of claims 1 to 5, characterized in that, The step of responding to a development requirement input operation by obtaining the original requirement text input by the development requirement input operation includes: In response to receiving the development requirement input operation through the development assistance dialog box, the original requirement text is obtained, and a project identifier corresponding to the development assistance dialog box is generated; The method further includes: The software development data displayed in the development assistance dialog box and the project identifier are associated and stored. The software development data includes the original requirement text, the target requirement text, and the software code. In response to the activation operation of the historical development assistance dialog box, the software development data corresponding to the target project identifier of the historical development assistance dialog box is obtained, and the obtained software development data is displayed through the historical development assistance dialog box; In response to detecting an update to the dialog content within the historical development assistance dialog box, the software development data corresponding to the target project identifier is updated synchronously.

10. An electronic device, characterized in that, include: Memory, used to store computer programs; A processor for executing a computer program stored in the memory, wherein when the computer program is executed, it implements the method described in any one of claims 1-9.

Images