Software development device and method based on agent technology

Abstract

The invention provides a software development device and method based on an agent technology, and the device comprises a large model customization module which is used for carrying out the interface adaption of an initial large model and a software development tool chain; the automatic process module is used for constructing one or more software development task sets automatically triggered to run according to the development and delivery process corresponding to the software to be developed, and each software development task set comprises at least one development task; and the agent module is used for respectively configuring one or more task agents for one or more software development task sets or development tasks based on an agent technology, and carrying out privatized deployment on each software development task set or development task through a local area network so as to protect data security. Through deep combination of a large model and an intelligent agent technology, automation and collaboration of whole process links of software development are realized, the software development efficiency is improved, and data security is guaranteed through privatized deployment.

Description

Technical Field

[0001] This application relates to the field of computer software development, and more particularly to a software development apparatus and method based on agent technology. Background Technology

[0002] In the modern software development field, enterprises face increasingly complex development needs and stringent delivery cycle requirements. For example, in industries such as finance, healthcare, and manufacturing, where data security and system stability are extremely critical, software development processes need to balance efficiency and security. In traditional development models, stages such as requirements analysis, architecture design, code writing, testing and verification, and deployment rely heavily on human experience. Development teams must complete a large amount of repetitive work within a limited time, such as code generation and test case design, leading to low development efficiency and significant quality fluctuations.

[0003] Furthermore, as software development and operations move towards a new concept of breaking down team barriers, efficient writing, automation, and continuous delivery—namely, DevOps—enterprises are placing higher demands on the automation level of their continuous integration / continuous deployment (CI / CD) pipelines.

[0004] However, existing toolchains struggle to achieve intelligent collaboration across the entire process. For example, after code submission, the pipeline may be interrupted due to environment configuration errors or test failures, requiring manual intervention for troubleshooting. A lack of scientific basis in the architecture design phase can lead to insufficient system scalability. Relying on human experience in test design may overlook critical scenarios, increasing later maintenance costs. Furthermore, the flow of core enterprise data, such as architecture design documents and test results, in the cloud or public tools poses a risk of data leakage. Therefore, modern software development urgently needs an intelligent tool that can cover the entire software development process. Summary of the Invention

[0005] This application provides a software development device and method based on intelligent agent technology, which aims to achieve automation and collaboration in the entire software development process, including requirements analysis, code generation, and testing verification, through the deep integration of large models and intelligent agent technology. It also ensures data security through private deployment, thereby achieving the technical effect of improving software development efficiency while guaranteeing software quality and core data security.

[0006] In a first aspect, this application provides a software development apparatus based on intelligent agent technology, comprising:

[0007] The large model customization module is used to adapt the interfaces of the initial large model and the software development toolchain;

[0008] An automated process module is used to construct one or more automatically triggered software development task sets according to the development and delivery process corresponding to the software to be developed. Each software development task set includes at least one development task, and the running order between the software development task sets or the development tasks includes at least one of serial and parallel processes.

[0009] The intelligent agent module is used to configure one or more task intelligent agents for one or more software development task sets or development tasks based on intelligent agent technology, and to privately deploy each software development task set or development task through a local area network.

[0010] In one possible implementation, the large model customization module is also used for:

[0011] Based on the application scenario and development requirements corresponding to the software to be developed, the initial large model is optimized and trained in a targeted manner to obtain a customized large model. The customized large model is used to automatically generate software code and / or development documents that meet the application scenario and development requirements.

[0012] In one possible implementation, the agent module includes: a process detection agent module;

[0013] The process detection intelligent agent module is used for:

[0014] Based on the preset monitoring process, build and configure the process monitoring intelligent agent;

[0015] The process monitoring agent monitors the running status of each software development task set or the development task.

[0016] Optimize system resource allocation based on each of the aforementioned operating states, and coordinate the dynamic resource allocation among the various software development task sets or development tasks within the same time period;

[0017] Each monitoring task is deployed privately via the local area network to protect data security.

[0018] In one possible implementation, the agent module includes: an architecture design agent module;

[0019] The architecture design intelligent agent module is used for:

[0020] Based on the development requirements of the software to be developed and the complete set of tools used in software development, construct and configure the architecture design intelligent agent;

[0021] The architecture design agent automatically generates or optimizes the software architecture design scheme of the software to be developed.

[0022] The local area network is used to privately deploy each architecture design task to protect data security.

[0023] In one possible implementation, the agent module includes: a software-designed agent module;

[0024] The software design intelligent agent module is used for:

[0025] Based on the development requirements of the software to be developed and the complete set of tools used in software development, a software design intelligent agent is constructed and configured.

[0026] The software design agent assists developers in performing various software design tasks, which include at least: the functional module division and interface design of the software to be developed.

[0027] Each of the software design tasks is deployed privately via the local area network to protect data security.

[0028] In one possible implementation, the agent module includes: a test design agent module;

[0029] The test design intelligent agent module is used for:

[0030] Based on the development requirements of the software to be developed and the complete set of tools used in software development, a test agent is constructed and configured.

[0031] The test agent automatically generates various test cases for the software to be developed, plans one or more test processes, and analyzes various test results.

[0032] Each software testing task is deployed privately via the local area network to protect data security.

[0033] In one possible implementation, the agent module includes: a conflict detection coordinator;

[0034] The conflict detection coordinator is used to: establish real-time communication among the multiple agents, and detect and resolve operational conflicts that occur or may occur during the execution of the software development task set.

[0035] In one possible implementation, the agent module is also used for:

[0036] Based on the code structure analysis engine, the context information of the current development task is extracted through static code analysis technology, and the context information is input into the target large model of the large model customization module to automatically generate or optimize code.

[0037] In one possible implementation, the software development apparatus further includes: a toolkit generation module;

[0038] The toolkit generation module is used to: construct the software development toolchain based on the application scenario and development requirements corresponding to the software to be developed, wherein the software development toolchain includes at least: an interface configuration tool.

[0039] Secondly, this application provides a software development method based on intelligent agent technology, comprising: invoking the software development device described in the first aspect for initialization configuration, wherein the initialization configuration includes:

[0040] The initial large model and the software development toolchain are interface adapted through the large model customization module in the software development device.

[0041] Through the automated process module in the software development device, one or more software development task sets that are automatically triggered are constructed according to the development and delivery process corresponding to the software to be developed. Each software development task set includes at least one development task, and the running order between each software development task set or each development task includes at least one of serial and parallel processing.

[0042] The software development device uses an agent module to configure one or more task agents for one or more software development task sets or development tasks based on agent technology, and deploys each software development task set or development task privately via a local area network to protect data security.

[0043] After completing the above initialization configuration, in response to the start command from the R&D personnel, start commands are sent to each module in the software development device to execute each development task in the software development task set, and the execution result of each task is fed back to the development terminal, and the target design file and final code corresponding to the software to be developed are output.

[0044] Thirdly, this application provides a software development device based on intelligent agent technology, including: a memory and a processor;

[0045] The memory stores computer-executed instructions;

[0046] The processor executes computer execution instructions stored in the memory, causing the processor to perform the functions corresponding to the modules in the first aspect and / or various possible implementations of the first aspect.

[0047] Fourthly, this application provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, are used to implement the functions corresponding to each module in the first aspect and / or various possible embodiments of the first aspect.

[0048] Fifthly, this application provides a computer program product, including a computer program that, when executed by a processor, implements the functions corresponding to the modules in the first aspect and / or various possible implementations of the first aspect.

[0049] The software development apparatus and method based on intelligent agent technology provided in this application achieve automation and collaboration in the entire software development process, including requirements analysis, code generation, and testing verification, through the deep integration of large models and intelligent agent technology. Furthermore, data security is ensured through private deployment, thereby achieving the technical effect of improving software development efficiency while guaranteeing software quality and core data security. Attached Figure Description

[0050] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0051] Figure 1 A schematic diagram of the software development device based on intelligent agent technology provided in this application. Figure 1 ;

[0052] Figure 2 This application provides a schematic diagram of the internal composition of an intelligent agent module;

[0053] Figure 3 A schematic diagram of the software development device based on intelligent agent technology provided in this application. Figure 2 ;

[0054] Figure 4 A flowchart illustrating the software development method based on intelligent agent technology provided in this application;

[0055] Figure 5 A schematic diagram of the software development equipment provided in this application.

[0056] The accompanying drawings illustrate specific embodiments of this application, which will be described in more detail below. These drawings and descriptions are not intended to limit the scope of the concept in any way, but rather to illustrate the concept of this application to those skilled in the art through reference to particular embodiments. Detailed Implementation

[0057] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with this application. Rather, they are merely examples of apparatuses and methods consistent with some aspects of this application as detailed in the appended claims.

[0058] First, let me explain the terms used in this application:

[0059] Multi-dimensional intelligent agents: also referred to as intelligent agents in this article, refer to software entities with autonomous decision-making, collaboration and learning capabilities, used for the automated management of complex systems;

[0060] A toolchain is a collaborative system composed of multiple specialized tools arranged in a specific sequence to efficiently complete complex tasks or production processes. Its core idea is to break down large tasks into standardized stages and achieve automation and optimization through seamless integration between tools.

[0061] Private deployment refers to an enterprise deploying its application systems or software in its own or dedicated cloud environment or internal servers, relying on public cloud services. In this approach, the system runs within the enterprise's internal network (LAN) and is controlled and managed by the enterprise itself. Private deployment allows for strict control over hardware resources, network environment, and data security, and enables customized development and optimization based on the enterprise's needs.

[0062] SDK (Software Development Kit): refers to a software development kit, which typically includes:

[0063] 1. Libraries: Provide pre-written code to help implement specific functions (such as graphics rendering, network communication, etc.).

[0064] 2. API (Application Programming Interfaces): Defines how to interact with libraries or services;

[0065] 3. Documentation: Explains how to use the library and API;

[0066] 4. Integrated Development Environment (IDE) Plugins or Extensions: Sometimes the SDK provides plugins for specific IDEs;

[0067] 5. Debugging Tools: Help developers test and debug code;

[0068] 6. Sample Code: Demonstrates typical examples of how to use the SDK;

[0069] 7. Compiler or other build tools: Platform-specific compilers.

[0070] The role of an SDK is to provide the tools and interfaces needed to develop specific platforms (such as Android and iOS), frameworks (such as Unity), or services, thereby simplifying development, avoiding duplication, and improving efficiency.

[0071] DevOps (a combination of Development and Operations) refers to a set of processes, methods, and systems used to promote communication, collaboration, and integration among development (application / software engineering), technical operations, and quality assurance (QA) departments. It automates software delivery and architecture change processes, making software building, testing, and release faster, more frequent, and more reliable. DevOps-based software development allows for the application of testing environments and the integration of data packages into the software environment. DevOps takes a holistic approach, analyzing development results and emphasizing collaboration and communication among personnel—key aspects of software development design that should be appropriately prioritized. Within the DevOps framework, software development can be automated, making human-computer interaction solutions feasible.

[0072] With the continuous development of computer technology, there are many auxiliary tools for software development, such as using large artificial intelligence models to automatically generate software code. However, when these large models automatically generate code, the so-called automatic generation actually means that the developers have already conceived and designed the software architecture in advance. The automatically generated code still requires the developers to verify the application environment and adapt the deployment interface. Software testing and packaging still heavily rely on the developers. In other words, the so-called automatic code generation is actually just saving the developers the process of writing code themselves.

[0073] In actual software development projects, software planning and design must be completed first. This includes collecting and analyzing customer requirements, verifying feasibility, planning and designing software functions and architecture, conceptual design and detailed design, adapting and selecting the development environment, and allocating and planning development resources. All of this work is output in the form of design documents, forming the core design work before actual coding. This part of the work currently relies heavily on manual labor.

[0074] When it comes to the actual coding phase, the large model only serves to facilitate manual coding. Code integration, testing, and interface adaptation still rely on developers and have not yet been automated.

[0075] Based on the current state of software development described above, existing technologies that automatically generate code using large models only replace manual code input by developers and mitigate coding errors caused by insufficient developer experience or oversights. A significant amount of core design work and process organization still requires manual intervention. Therefore, modern software development urgently needs an intelligent tool that can cover the entire software development process.

[0076] This application provides a software development device that automates the entire software development process, from design to testing, delivery, and maintenance. The main software development workflow is entirely automated and led by the device, while developers primarily complete the review tasks assigned by the device. This represents a shift from human-led software development to device-led software development.

[0077] To achieve a software development device-driven approach to the entire software development process, this invention aims to deeply integrate large-scale model customization technology with multi-dimensional intelligent agents, combined with a private deployment architecture, to achieve intelligent, automated, and secure control of the entire software development process. The large-scale model is at the core, and its adaptation to software development tasks is achieved through interface adaptation and training optimization. Simultaneously, dedicated intelligent agents are developed for architecture design, software design, test design, DevOps, and other stages, forming a collaborative system between the large-scale model and the intelligent agents, covering the entire process from requirements analysis, code generation, testing and verification, to deployment and delivery. Private deployment ensures the security of core data, ultimately achieving a shift from a human-driven to an intelligence-driven development model.

[0078] It is worth noting that this application is applicable to industries with extremely high requirements for software development efficiency, quality, and data security, such as finance, healthcare, and industry. For example, in the financial industry, enterprises need to complete the development of high-concurrency trading systems in a short period of time while ensuring that sensitive information such as core algorithms and test data is not leaked; in the healthcare field, it is necessary to quickly develop software systems that meet healthcare industry standards and meet Level 3 security requirements through private deployment. The network architecture of this application includes a privately deployed local server cluster, such as for running intelligent agent modules and large model customization modules; an internal enterprise network, such as for data transmission and collaboration; and development terminals, such as for developers to interact with the system.

[0079] The technical solution of this application and how the technical solution of this application solves the above-mentioned technical problems are described in detail below with specific embodiments. These specific embodiments can be combined with each other, and the same or similar concepts or processes may not be described again in some embodiments. The embodiments of this application will now be described with reference to the accompanying drawings.

[0080] Figure 1A schematic diagram of the software development device based on intelligent agent technology provided in this application. Figure 1 ,like Figure 1 As shown, the software development device 100 includes: a large model customization module 110, an automated process module 120, and an intelligent agent module 130.

[0081] Large model customization module 110 is used to: adapt the interface of the initial large model and the software development toolchain;

[0082] Based on the development and delivery process of the software to be developed, construct one or more software development task sets that are automatically triggered.

[0083] Each software development task set includes at least one development task, and the execution order of the various software development task sets or the various development tasks includes at least one of serial and parallel execution.

[0084] In this embodiment, the initial large model can be preset or selected and specified by the developers from the database. The initial large model can be an open-source base model, a model developed based on an open-source model, or a non-open-source, independently developed model.

[0085] In one possible implementation, the large model customization module 110 is further used to: perform targeted optimization training on the initial large model based on the application scenario and development requirements corresponding to the software to be developed, to obtain a customized large model, and the customized large model is used to automatically generate software code and / or development documents that meet the application scenario and development requirements.

[0086] Specifically, custom development can be performed based on the toolchain and a specified large model. By encapsulating the functionality of the toolchain, interfaces can be adapted to the large model. Optionally, the large model can also be trained and optimized to accurately understand various tasks in software development, such as requirements analysis and code generation, and adapt to specific software development scenarios.

[0087] For example, in the development of financial trading systems, large models generate code logic that complies with regulatory requirements by training code samples that include compliance rules.

[0088] It's important to note that interface adaptation refers to connecting the API of the large model with the functionality of the toolchain to ensure consistency in data input and output formats. For example, converting the JSON format of the requirements document into text input that the large model can process.

[0089] In this embodiment, the optimization training of the large model, also known as fine-tuning, refers to updating the parameters of the large model through incremental training to adapt it to a specific domain. For example, in medical software development, the large model is fine-tuned to understand medical industry terminology, such as anonymizing patient data.

[0090] After processing by the large model customization module 110, the adapted and / or optimized large model can be used in code generation and development documentation, reducing the time spent manually correcting requirements analysis documents or code and improving development efficiency.

[0091] In one possible implementation, a code structure analysis engine can be introduced into the large model customization module. This engine uses static code analysis techniques to extract contextual information about the current development task, such as the codebase structure, dependencies, and commit history. Combined with the large model's code generation capabilities, it generates code that better fits the actual scenario. For example, when generating microservice interface code, the engine analyzes the existing service's call chain and data format to ensure the compatibility of the newly generated code.

[0092] In this implementation, static code analysis refers to using code parsing tools, such as Abstract Syntax Trees (ASTs), to analyze the existing code structure and extract information such as function dependencies and class relationships. Extracting contextual information involves using the results of static code analysis as the context input to a larger model, guiding it to generate code that conforms to codebase specifications, software development environment requirements, or application scenario requirements. This significantly improves the compatibility of the generated code with existing systems, reducing integration problems caused by inconsistent coding styles or interface mismatches. For example, in a microservice architecture, newly generated interface code can automatically adapt to existing data formats and calling conventions, reducing manual adjustment costs.

[0093] The automated process module 120 is used to: construct one or more software development task sets that are automatically triggered and run, based on the development and delivery process corresponding to the software to be developed.

[0094] Each software development task set includes at least one development task, and the execution order of the various software development task sets or the various development tasks includes at least one of serial and parallel execution.

[0095] Software development task sets can be divided into two categories: the first category is a single task set that contains only a single development task, and the second category is a multi-task set that contains multiple development tasks.

[0096] For any two software development task sets, they can be set to a serial execution mode with a sequential execution order or a dependency relationship, or they can be set to a parallel execution mode with no order or dependency relationship within the same time or period.

[0097] It is worth noting that for a multi-task set, the execution method between the various software development tasks within it is the same as the execution method between any two software development task sets mentioned above. It can be configured as a serial execution method with a sequential execution order or a dependency relationship, or as a parallel execution method without a sequence or dependency relationship within the same time period.

[0098] This allows for the automatic categorization and hierarchical classification of tasks throughout the entire software development process, ultimately forming an automated software development process network or software development pipeline network. It addresses the inefficiency caused by reliance on human organization and driving of software development projects, shifting process control from individuals to a network of links composed of software development task sets. This decouples human factors and frees up human labor.

[0099] Specifically, as a core automated process in DevOps software design principles, the CI / CD pipeline's automation heavily relies on certain fixed scripts, making it difficult to adapt to increasingly diverse software development requirements. In other words, existing CI / CD pipelines depend on fixed scripts and cannot dynamically handle exceptions during development, such as test failures. For instance, if a test fails after code submission, the CI / CD pipeline may stall because the cause of the error is not identified, requiring manual intervention for troubleshooting. Therefore, the automated process module 120 can also be called the CI / CD pipeline setup module.

[0100] In this embodiment, in order to solve the problem of fixed and inflexible scripts in the prior art, an automated process module 120 is used to build a fully automated pipeline from code submission to product delivery by means of automated scripts, configuration files, etc., covering multiple links such as code inspection, compilation, testing, and deployment, so as to realize the automated advancement of the development process and improve development efficiency.

[0101] The intelligent agent module 130 is used to: configure one or more task intelligent agents for one or more software development task sets or development tasks based on intelligent agent technology, and to privately deploy each software development task set or development task through a local area network to protect data security.

[0102] It is worth noting that configuring one or more task agents for one or more software development task sets or tasks based on agent technology can be understood as follows: one software development task or set of software development tasks corresponds to one agent; multiple software development tasks or sets of software development tasks correspond to one agent; or one software development task or set of software development tasks corresponds to multiple agents. These different implementation methods are determined by the complexity and execution requirements of the specific tasks, or by the hierarchical attributes of the tasks. The more basic and lower-level the task, the simpler it is, meaning that it can be completed by one agent, or one agent can handle multiple basic and lower-level tasks. Conversely, for complex and higher-level tasks, which may contain multiple lower-level tasks, multiple agents need to be configured for assistance.

[0103] It should also be noted that the agent module 130 works in collaboration with the automated process module 120. The automatic execution of the software development task set configured by the automated process module 120 requires the agent module 130 to supervise it, so as to avoid automation stagnation caused by the need for manual intervention when errors occur in the process. The agent module 130 can monitor the operation of the CI / CD pipeline in real time through the process supervision agent.

[0104] Figure 2 This is a schematic diagram illustrating the internal composition of an intelligent agent module provided in this application. Figure 2 As shown, in one possible implementation, an agent module 130 includes at least one of the following sub-modules: process detection agent module 131, architecture design agent module 132, software design agent module 133, test design agent module 134, and conflict detection coordinator 135.

[0105] Process inspection intelligent agent module 131, used for:

[0106] Based on the preset monitoring process, a process monitoring intelligent agent is built and configured; the process monitoring intelligent agent monitors the running status of each software development task set or development task; the system resource configuration is optimized according to each running status, and the dynamic resource allocation between each software development task set or development task within the same time period is coordinated; each monitoring task is privately deployed through a local area network to protect data security.

[0107] Specifically, the process monitoring agent module 131 integrates agent technology into the DevOps process through the development and private deployment of Agentic DevOps. The process monitoring agent can automatically monitor problems in the development process, such as code errors and process bottlenecks. It can also optimize resource allocation, coordinate the work between various development stages, and ensure the security of data and the controllability of the process through private deployment.

[0108] The Agentic DevOps process monitoring agent monitors the pipeline's operational status in real time. Through the adaptation of automated scripts and the agent interface, it enables anomaly handling and optimization. Its processing objects include code commit events and pipeline operational status data, such as test results and deployment logs. For example, if the pipeline is interrupted due to an environment configuration error after a code commit, the agent automatically identifies the cause of the error and generates a repair script, such as updating dependency library versions. This, in conjunction with the automated process module 120, achieves automated anomaly handling and resource optimization for the CI / CD pipeline. This reduces manual intervention and shortens the deployment cycle.

[0109] In this embodiment, the automation script includes a predefined set of execution instructions for automating pipeline tasks such as compilation and testing.

[0110] Interface adapters are used for API integration between agents and pipeline tools (such as GitLab CI) to ensure real-time data exchange. For example, converting JSON formatted test results into text input that the agent can process.

[0111] Optionally, in another possible implementation, the process detection agent module 131 can integrate a resource demand prediction model. This model is trained using historical pipeline data such as build time and resource utilization to dynamically adjust the resource allocation strategy of the CI / CD pipeline. For example, during peak code submission periods, the model predicts server load and preemptively expands computing resources to avoid pipeline blockages due to insufficient resources.

[0112] In some implementations, time series forecasting can be achieved using models such as Long Short-Term Memory (LSTM) networks to predict resource demand trends over a future period. Flexible resource scheduling can be implemented by automatically triggering resource expansion or reclamation mechanisms based on the forecast results.

[0113] As described above, pipeline efficiency can be significantly improved, and resource utilization is more balanced. For example, during off-peak periods of code submission, the system automatically releases idle resources to avoid waste; during peak periods, resources are expanded in advance to ensure that pipeline tasks are completed on time.

[0114] Architecture design intelligent agent module 132, used for:

[0115] Based on the development requirements of the software to be developed and the complete set of tools used in software development, an architecture design agent is built and configured; the architecture design agent automatically generates or optimizes the software architecture design scheme of the software to be developed; and each architecture design task is privately deployed through a local area network to protect data security.

[0116] The architecture design agent module 132 is responsible for the development and private deployment of the architecture design agent. The agent can automatically generate or optimize software architecture design schemes based on project requirements, technology stack and other factors, providing intelligent assistance for architecture design work. At the same time, through private deployment, it ensures the security of core enterprise information related to architecture design.

[0117] Software design intelligent agent module 133, used for:

[0118] Based on the development requirements of the software to be developed and the complete set of tools used in software development, a software design agent is built and configured; the software design agent assists developers in performing various software design tasks, which include at least: the functional module division and interface design of the software to be developed; and each software design task is privately deployed through a local area network to protect data security.

[0119] The software design agent module 133 is responsible for the development and private deployment of the software design agent. The agent can assist in software design work such as module division and interface design, improve the efficiency and rationality of software design, meet the security requirements of enterprise internal software development, and support private deployment.

[0120] Test design intelligent agent module 134, used for:

[0121] Based on the development requirements of the software to be developed and the complete set of tools used in software development, a test agent is built and configured; the test agent automatically generates various test cases for the software to be developed, plans one or more test processes, and analyzes various test results; and each software test task is privately deployed through a local area network to protect data security.

[0122] The Test Design Agent Module 134 is responsible for the development and private deployment of the Test Design Agent. The agent can automatically generate test cases, plan test processes, and analyze test results, thereby improving the comprehensiveness and accuracy of test design. Private deployment ensures the security of test-related data.

[0123] The conflict detection coordinator 135 is used to: establish real-time communication between multiple agents, detect and resolve operational conflicts that occur or may occur while executing software development task sets.

[0124] Specifically, a conflict detection coordinator is introduced between the architecture design agent, software design agent, and test design agent. Through a real-time communication mechanism between the agents, potential conflicts in the development process are detected and resolved. For example, when the module division generated by the architecture design agent is inconsistent with the interface definition of the software design agent, the coordinator automatically triggers a conflict resolution process and generates compatibility suggestions.

[0125] It is also worth noting that the agent module 130 and the large model customization module 110 also work together. Each agent in the agent module 130 automatically generates code and design documents by calling the large model in the large model customization module 110, which has been adapted to the interface and optimized and trained.

[0126] In one possible implementation, the agent module is also used for:

[0127] Based on the code structure analysis engine, the static code analysis technology is used to extract the context information of the current development task, and the context information is input into the target large model of the large model customization module to automatically generate or optimize the code.

[0128] The software development apparatus based on agent technology provided in this application can achieve intelligent and automated software development throughout the entire process through the deep integration of large models and agents. Specifically, the large model automatically generates code frameworks and requirement documents, while agents assist in design work, significantly reducing repetitive manual labor. The CI / CD pipeline and agents collaborate to shorten deployment cycles, thereby improving efficiency. Furthermore, agents make decisions based on algorithms and data, such as generating high-coverage test cases for test design, which can reduce human experience bias, improve design rationality and code standardization, and ensure quality. Moreover, private deployment ensures that core data, such as architecture design documents and test results, circulates within the enterprise, avoiding the risk of external leakage and meeting the security requirements of industries such as finance and healthcare. In addition, the combination of customized large models and agent modules can quickly adapt to the development needs of different industries such as e-commerce and manufacturing, improving the flexibility and versatility of the tool.

[0129] Figure 3 A schematic diagram of the software development device based on intelligent agent technology provided in this application. Figure 2 ,like Figure 3 As shown, the software development device 100 includes: a large model customization module 110, an automated process module 120, an intelligent agent module 130, and a toolkit generation module 140.

[0130] The detailed designs of the large model customization module 110, the automated process module 120, and the intelligent agent module 130 are described above and will not be repeated here.

[0131] The toolkit generation module 140 is used to: build a software development toolchain based on the application scenario and development task requirements corresponding to the software to be developed. The software development toolchain includes at least: an interface configuration tool.

[0132] Specifically, in this embodiment, the toolkit generation module 140 generates customized software development kits (SDKs) and lays the foundation for interface matching of large models in the large model customization module 110. Based on different software development scenarios and needs, it develops application software SDKs with specific functions. These SDKs provide convenient interfaces and tools, making it easy for developers to call relevant functions during software development and reducing repetitive development work.

[0133] Figure 4 This is a flowchart illustrating the software development method based on intelligent agent technology provided in this application. Figure 4 As shown, the method includes:

[0134] S401, Invoke the software development device to perform initial configuration, including:

[0135] S4011. The initial large model and the software development toolchain are adapted through the large model customization module in the software development device.

[0136] S4012. Through the automated process module in the software development device, one or more software development task sets that are automatically triggered are constructed according to the development and delivery process corresponding to the software to be developed. Each software development task set includes at least one development task, and the running order between the software development task sets or between the development tasks includes at least one of serial and parallel processes.

[0137] S4013. Through the intelligent agent module in the software development device, one or more task intelligent agents are configured for one or more software development task sets or development tasks based on intelligent agent technology, and each software development task set or development task is privately deployed through a local area network to protect data security.

[0138] For a detailed explanation of the terms in S4011-S4013, please refer to [link / reference]. Figure 1 The embodiments shown will not be described in detail here.

[0139] S402, in response to the start command from the R&D personnel, sends start commands to each module in the software development device.

[0140] Specifically, the R&D personnel will no longer lead the software development in this application, but the collection and initiation of requirements will need to be initiated by the R&D personnel through the terminal.

[0141] S403. Execute each development task in the software development task set through the software development device.

[0142] This step involves the software development device automatically executing each software design stage. For processes requiring human intervention, the device will send tasks to the developers via the terminal and receive feedback from them. Problems encountered during the monitoring process will also be fed back to the terminal. However, unless the developers actively interrupt the automatic operation of the software development device, the device will handle problems automatically without human intervention.

[0143] S404. Feedback the execution results of each task to the development terminal, and output the target design file and final code corresponding to the software to be developed.

[0144] The software development method based on intelligent agent technology provided in this application combines a large model and an intelligent agent, transferring the leadership of software development to the large model and intelligent agent means, thereby achieving the technical effect of automatic software development and improving software development efficiency.

[0145] Figure 5 A schematic diagram of the structure of the software development equipment provided in this application. (For example...) Figure 5 As shown, the electronic device 50 provided in this embodiment includes at least one processor 501 and a memory 502. Optionally, the device 50 further includes a communication component 503. The processor 501, memory 502, and communication component 503 are connected via a bus.

[0146] In a specific implementation, at least one processor 501 executes computer execution instructions stored in memory 502, causing at least one processor 501 to perform the above-described method.

[0147] For details on the implementation of processor 501, please refer to the above. Figure 1-4 The corresponding embodiments are similar in principle and technical effect, and will not be described again here.

[0148] In the above embodiments, it should be understood that the processor can be a Central Processing Unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), etc. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the method disclosed in this invention can be directly implemented by a hardware processor, or implemented by a combination of hardware and software modules within the processor.

[0149] The memory may include random access memory (RAM) and may also include non-volatile memory (NVM), such as at least one disk storage device.

[0150] The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc. For ease of illustration, the buses shown in the accompanying drawings are not limited to a single bus or a single type of bus.

[0151] This application also provides a computer program product, including a computer program that, when executed by a processor, performs the functions of the aforementioned software development apparatus.

[0152] This application also provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a processor, implement the functions of the aforementioned software development apparatus.

[0153] The aforementioned readable storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk. The readable storage medium can be any available medium accessible to a general-purpose or special-purpose computer.

[0154] An exemplary readable storage medium is coupled to a processor, enabling the processor to read information from and write information to the readable storage medium. Of course, the readable storage medium can also be a component of the processor. The processor and the readable storage medium can reside in an Application Specific Integrated Circuit (ASIC). Alternatively, the processor and the readable storage medium can exist as discrete components in the device.

[0155] The division of units is merely a logical functional division; in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be indirect coupling or communication connection through some interfaces, devices, or units, and may be electrical, mechanical, or other forms.

[0156] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0157] In addition, the functional units in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0158] If a function is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this invention, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

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

[0160] Finally, it should be noted that other embodiments of the invention will readily occur to those skilled in the art upon consideration of the specification and practice of the invention disclosed herein. This invention is intended to cover any variations, uses, or adaptations of the invention that follow the general principles of the invention and include common knowledge or customary techniques in the art not disclosed herein, and is not limited to the precise structures described above and shown in the accompanying drawings, and various modifications and changes can be made without departing from its scope. The scope of the invention is limited only by the appended claims.

Claims

1. A software development device based on intelligent agent technology, characterized in that, include: The large model customization module is used to adapt the interfaces of the initial large model and the software development toolchain; An automated process module is used to construct one or more automatically triggered software development task sets according to the development and delivery process corresponding to the software to be developed. Each software development task set includes at least one development task, and the running order between the software development task sets or the development tasks includes at least one of serial and parallel processes. The intelligent agent module is used to configure one or more task intelligent agents for one or more software development task sets or development tasks based on intelligent agent technology, and to privately deploy each software development task set or development task through a local area network.

2. The software development apparatus according to claim 1, characterized in that, The large model customization module is also used for: Based on the application scenario and development requirements corresponding to the software to be developed, the initial large model is optimized and trained in a targeted manner to obtain a customized large model. The customized large model is used to automatically generate software code and / or development documents that meet the application scenario and development requirements.

3. The software development apparatus according to claim 1, characterized in that, The intelligent agent module includes: a process detection intelligent agent module; The process detection intelligent agent module is used for: Based on the preset monitoring process, build and configure the process monitoring intelligent agent; The process monitoring agent monitors the running status of each software development task set or the development task. Optimize system resource allocation based on each of the aforementioned operating states, and coordinate the dynamic resource allocation among the various software development task sets or development tasks within the same time period; Each monitoring task is deployed privately via the local area network to protect data security.

4. The software development apparatus according to claim 1, characterized in that, The intelligent agent module includes: an architecture design intelligent agent module; The architecture design intelligent agent module is used for: Based on the development requirements of the software to be developed and the complete set of tools used in software development, construct and configure the architecture design intelligent agent; The architecture design agent automatically generates or optimizes the software architecture design scheme of the software to be developed. The local area network is used to privately deploy each architecture design task to protect data security.

5. The software development apparatus according to claim 1, characterized in that, The intelligent agent module includes: a software-designed intelligent agent module; The software design intelligent agent module is used for: Based on the development requirements of the software to be developed and the complete set of tools used in software development, a software design intelligent agent is constructed and configured. The software design agent assists developers in performing various software design tasks, which include at least: the functional module division and interface design of the software to be developed. Each of the software design tasks is deployed privately via the local area network to protect data security.

6. The software development apparatus according to claim 1, characterized in that, The intelligent agent module includes: a test design intelligent agent module; The test design intelligent agent module is used for: Based on the development requirements of the software to be developed and the complete set of tools used in software development, a test agent is constructed and configured. The test agent automatically generates various test cases for the software to be developed, plans one or more test processes, and analyzes various test results. Each software testing task is deployed privately via the local area network to protect data security.

7. The software development apparatus according to claim 1, characterized in that, The intelligent agent module includes: a conflict detection coordinator; The conflict detection coordinator is used to: establish real-time communication among the multiple agents, and detect and resolve operational conflicts that occur or may occur during the execution of the software development task set.

8. The software development apparatus according to claim 1, characterized in that, The intelligent agent module is also used for: Based on the code structure analysis engine, the context information of the current development task is extracted through static code analysis technology, and the context information is input into the target large model of the large model customization module to automatically generate or optimize code.

9. The software development apparatus according to any one of claims 1-8, characterized in that, Also includes: Toolkit generation module; The toolkit generation module is used to construct the software development toolchain based on the application scenario and development requirements corresponding to the software to be developed, and the software development toolchain includes at least an interface configuration tool.

10. A software development method based on intelligent agent technology, characterized in that, include: The software development apparatus according to any one of claims 1-9 is invoked for initialization configuration, the initialization configuration including: The initial large model and the software development toolchain are interface adapted through the large model customization module in the software development device. Through the automated process module in the software development device, one or more software development task sets that are automatically triggered are constructed according to the development and delivery process corresponding to the software to be developed. Each software development task set includes at least one development task, and the running order between each software development task set or each development task includes at least one of serial and parallel processing. The software development device uses an agent module to configure one or more task agents for one or more software development task sets or development tasks based on agent technology, and deploys each software development task set or development task privately via a local area network to protect data security. After completing the above initialization configuration, in response to the start command from the R&D personnel, start commands are sent to each module in the software development device to execute each development task in the software development task set, and the execution result of each task is fed back to the development terminal, and the target design file and final code corresponding to the software to be developed are output.

Images