Software assembly method and equipment based on intelligent agent and medium
Through the agent technology, the software requirement documents are analyzed, the software-defined model and assembly instruction set are generated, and the software components are automatically assembled, which solves the problem of software development relying on professionals, and realizes an efficient and automated software development process to adapt to the needs of rapid iteration.
Patent Information
- Application Number
- CN202411042173.X
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2024-07-31
- Publication Date
- 2024-11-15
AI Technical Summary
The existing software development methods cannot automatically generate software, resulting in high dependence on professional and technical personnel and cannot meet the needs of personalized and rapid iterative software development.
Adopt the software assembly method based on the agent, obtain software requirements documents, determine the software-defined model, and match program components in the pre-built software asset library to generate assembly process instruction sets to realize the orderly assembly of software components and generate the software to meet the software. Application software required.
It realizes automatic assembly of software, reduces development workload and time, improves development efficiency, ensures software quality and reliability, and supports rapid response to demand changes.
Smart Images

Figure CN118963743A_ABST
Abstract
Description
Technical Field
[0001] The present invention relates to the field of computer technology, and more particularly to a method, device and medium for assembling software based on an intelligent agent. Background Art
[0002] In recent years, the market environment has become increasingly complex, and enterprises are facing the challenges of constantly changing and unpredictable market demands and environments. This complexity has led to the development needs of enterprise-level software showing the characteristics of personalization and rapid iteration, which has put forward higher requirements for the software architecture and development model. The traditional hard-coded development model has seriously restricted the innovation and supply capabilities of software providers due to its high cost, low efficiency and quality issues. In order to alleviate this contradiction, low-code development methods came into being. Compared with the manual development model, low-code development has significantly improved software development efficiency and alleviated the contradiction between software supply and demand to a certain extent.
[0003] However, low-code development has not fundamentally solved the contradiction between software supply and demand. It mainly reduces the workload of software coding, but other links in the software development life cycle, such as system design and software testing, still need to be completed manually. This means that the technical threshold for software development is still high, and it is difficult for non-professionals to easily get involved. Although there are large model technologies that can directly convert requirements into small-scale codes, these codes cannot be automatically assembled into software that can be deployed and run.
[0004] In summary, the current software development method cannot automatically generate software, is highly dependent on professional technicians, and cannot meet the needs of personalized and rapidly iterative software development. Summary of the invention
[0005] One or more embodiments of the present specification provide a software assembly method, device and medium based on an intelligent agent, which are used to solve the following technical problems: the current software development method cannot automatically generate software, has a high degree of dependence on professional technicians, and cannot meet the needs of personalized and rapidly iterative software development.
[0006] One or more embodiments of this specification adopt the following technical solutions:
[0007] One or more embodiments of the present specification provide an agent-based software assembly method, the method comprising: obtaining a software requirement document corresponding to the software requirement, and determining a software definition model based on the software requirement document, wherein the software definition model comprises a plurality of software definition units and unit relationships between the plurality of software definition units; matching a plurality of corresponding program components in a pre-built software asset library through the software definition model, determining a program component set, and generating an assembly process instruction set corresponding to the program component set; and assembling the plurality of program components in an orderly manner through a software assembly agent according to the assembly process instruction set, so as to generate application software corresponding to the software requirement.
[0008] Furthermore, based on the software requirement document, a software definition model is determined, specifically including: segmenting the software requirement document according to a preset segmentation rule to determine a plurality of document blocks corresponding to the software requirement document; using an embedded model to perform similarity calculations on the plurality of document blocks to determine similarity result data, and selecting a specified number of texts with the highest similarity based on the similarity result data; dynamically generating a software definition model description file through the specified number of texts and a preset large model to determine the software definition model, wherein the software definition model description file includes a business entity object description, a business function description, a business interface presentation description, a business process logic description, and a business collaboration relationship description.
[0009] Furthermore, through the software definition model, the corresponding multiple program components are matched in the pre-built software asset library, which specifically includes: obtaining multiple software definition units in the software definition model; matching in the pre-built software asset library according to each of the software definition units, and determining the matching program component corresponding to each of the software definition units, wherein the software asset library includes multiple preset program components.
[0010] Furthermore, a program component set is determined, and an assembly process instruction set corresponding to the program component set is generated, specifically including: obtaining access rule data corresponding to each program component in the program component set; generating assembly instructions corresponding to each program component through the access rules of each program component; and arranging multiple assembly instructions according to the software-defined model to determine an ordered assembly process instruction set corresponding to the program component set.
[0011] Furthermore, through the software definition model, before matching the corresponding multiple program components in the pre-built software asset library, the method also includes: building a software asset library according to the software requirement program components of the specified domain software, wherein the software asset library includes any one or more of software services and middleware, business microservice applications and software program components; obtaining component rules and usage information of each software program component in the software asset library, so as to generate component usage description information for each software program component in the software asset library; obtaining software requirement information corresponding to each of the software program components in the software asset library, so as to generate matching requirement description information for each of the software program components in the software asset library; and managing the multiple software program components in the software asset library through the component usage description information and the matching requirement description information.
[0012] Furthermore, according to each of the software definition units, after matching in a pre-built software asset library, the method also includes: when there is no matching program component corresponding to the software definition unit in the software asset library, automatically generating program code through a large language model; encapsulating the program code, determining the program component corresponding to the software definition unit, and storing the program component in the software asset library.
[0013] Furthermore, according to the assembly process instruction set, the multiple program components are assembled in order through a software assembly agent, specifically including: configuring each of the program components according to the assembly process instruction set through a software assembly agent, and determining the assembly instruction sequence through the assembly process instruction set; and assembling the multiple program components in order according to the assembly instruction sequence.
[0014] Furthermore, the multiple software program components in the software asset library are managed through the component usage description information and the matching requirement description information, specifically including: determining the business domain corresponding to each of the software program components through the matching requirement description information; determining the technical dimension corresponding to each of the software program components according to the component usage description information; and setting component indexes of the multiple software program components according to the business domain and the technical dimension corresponding to each of the software program components, so as to manage the multiple software program components in the software asset library.
[0015] One or more embodiments of the present specification provide an agent-based software assembly device, including:
[0016] at least one processor; and,
[0017] a memory communicatively connected to the at least one processor; wherein,
[0018] The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to perform the above method.
[0019] One or more embodiments of the present specification provide a non-volatile computer storage medium storing computer executable instructions, wherein the computer executable instructions are configured to execute the above method.
[0020] At least one of the above technical solutions adopted in the embodiments of this specification can achieve the following beneficial effects: through the above technical solutions, through the large model intelligent agent technology, the software requirement document is parsed, the software definition model and the software assembly instruction set are generated, and the automatic assembly of enterprise application software is realized, which reduces the development workload of enterprise application software and improves the software development efficiency; through automated and standardized processes, the time and labor costs required for software development are significantly reduced; the introduction of software definition models and assembly process instruction sets makes the development process more efficient and orderly; the software definition model is accurately defined based on the software requirement document to ensure the accurate implementation of software requirements; by matching the program components in the pre-built software asset library, the quality and reliability of the components are ensured, and the orderly assembly process reduces errors and conflicts, further improving the overall quality of the software; using the pre-built software asset library, the reuse of software components is realized, the workload of repeated development is reduced, and the reusability of the software definition model and the assembly process instruction set makes the development of similar software faster and more efficient; when the software requirements change, the software definition model and the assembly process instruction set can be quickly updated to quickly adapt to new requirements. BRIEF DESCRIPTION OF THE DRAWINGS
[0021] In order to more clearly illustrate the technical solutions in the embodiments of this specification or the prior art, the following briefly introduces the drawings required for use in the embodiments or the prior art description. Obviously, the drawings described below are only some embodiments recorded in this specification. For ordinary technicians in this field, other drawings can be obtained based on these drawings without creative labor. In the drawings:
[0022] Figure 1 A flowchart of an agent-based software assembly method provided in an embodiment of this specification;
[0023] Figure 2 A schematic diagram of the structure of an agent-based software assembly system provided in an embodiment of this specification;
[0024] Figure 3 A schematic diagram of the structure of an agent-based software assembly device provided in an embodiment of this specification. DETAILED DESCRIPTION
[0025] In order to enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below in conjunction with the drawings in the embodiments of this specification. Obviously, the described embodiments are only part of the embodiments of this specification, not all of the embodiments. Based on the embodiments of this specification, all other embodiments obtained by ordinary technicians in this field without creative work should fall within the scope of protection of this specification.
[0026] In recent years, the market environment has become increasingly complex, and enterprises are facing the challenges of constantly changing and unpredictable market demands and environments. This complexity has led to the development needs of enterprise-level software showing the characteristics of personalization and rapid iteration, which has put forward higher requirements for the software architecture and development model. The traditional hard-coded development model has seriously restricted the innovation and supply capabilities of software providers due to its high cost, low efficiency and quality issues. In order to alleviate this contradiction, low-code development methods came into being. Compared with the manual development model, low-code development has significantly improved software development efficiency and alleviated the contradiction between software supply and demand to a certain extent.
[0027] However, low-code development has not fundamentally solved the contradiction between software supply and demand. It mainly reduces the workload of software coding, but other links in the software development life cycle, such as system design and software testing, still need to be completed manually. This means that the technical threshold for software development is still high, and it is difficult for non-professionals to easily get involved. Although there are large model technologies that can directly convert requirements into small-scale codes, these codes cannot be automatically assembled into software that can be deployed and run.
[0028] In summary, the current software development method cannot automatically generate software, is highly dependent on professional technicians, and cannot meet the needs of personalized and rapidly iterative software development.
[0029] The embodiment of this specification provides a software assembly method based on an intelligent agent. It should be noted that the execution subject in the embodiment of this specification can be a server or any device with data processing capabilities. Figure 1 A flowchart of a software assembly method based on an agent provided in an embodiment of this specification is shown in FIG. Figure 1 As shown, it mainly includes the following steps:
[0030] Step S101, obtaining a software requirement document corresponding to the software requirement, and determining a software definition model based on the software requirement document.
[0031] The software-defined model includes multiple software-defined units and unit relationships between the multiple software-defined units.
[0032] In one embodiment of the present specification, obtaining a software requirement document corresponding to the software requirement is a key step in the software development process, which describes in detail the functions, performance, design constraints and other requirements of the user or system that the system or software product must meet.
[0033] Based on the software requirement document, a software definition model is determined, specifically including: segmenting the software requirement document according to a preset segmentation rule to determine a plurality of document blocks corresponding to the software requirement document; using an embedded model to perform similarity calculations on the plurality of document blocks to determine similarity result data, and selecting a specified number of texts with the highest similarity based on the similarity result data; dynamically generating a software definition model description file through the specified number of texts and a preset large model to determine the software definition model, wherein the software definition model description file includes a business entity object description, a business function description, a business interface presentation description, a business process logic description, and a business collaboration relationship description.
[0034] In one embodiment of the present specification, the software requirement document is divided into multiple document blocks according to preset segmentation rules (such as by chapter, by functional module, by keyword, etc.), ensuring that each document block contains relatively independent and complete information. Each document block is vectorized using an embedded model (such as BERT, Word2Vec, etc.). The similarity between all document blocks is calculated to obtain a similarity matrix or result data set. From the similarity result data, a specified number of texts with the highest similarity (such as Top-N) are selected. Texts with high similarity may represent core or recurring concepts, functions or interface elements in the software requirements. In addition, the document blocks obtained by segmentation can also be input into the Embedding model to realize text similarity calculation and determine the 5 texts with the highest similarity. The 5 texts with the highest similarity are input into the large model, which is understood and summarized by the large model. Use the specified number of selected texts as input, combined with the preset large model (such as GPT, etc.), to generate a description file of the software-defined model. The description file should include key parts such as business entity object description, business function description, business interface display description, business process logic description and business collaboration relationship description, to ensure that the generated description file is comprehensive, accurate and consistent with the original intention of the software requirements document. Compare and verify the generated software-defined model description file with the original software requirements document. Further adjust and improve the model as needed to ensure its accuracy and completeness. Output the final software-defined model description file in an appropriate format (such as JSON, etc.). Apply the model to various stages of the software development process, such as design, coding, testing and deployment.
[0035] By automatically analyzing and processing software requirement documents, the time for manual interpretation and organization of requirements is reduced. The dynamically generated software-defined model description file provides developers with clear and structured requirement information, enabling them to understand and start development work more quickly. Similarity calculation and selection of high-similarity text help identify core and repeated concepts in software requirements, ensuring that these key elements are fully reflected in the software-defined model. By comparing and verifying with the original requirement documents, errors or omissions in the model can be discovered and corrected in a timely manner, thereby improving the accuracy and completeness of the software. The structured software-defined model description file provides team members with a unified basis for understanding requirements, reducing communication costs and conflicts caused by inconsistent understanding of requirements. When software requirements change, document blocks and similarity calculations can be easily updated, and the software-defined model can be dynamically adjusted, which helps to quickly respond to changes in requirements and reduce development delays and cost increases caused by changes.
[0036] Step S102, through the software definition model, matching corresponding multiple program components in the pre-built software asset library, determining the program component set, and generating an assembly process instruction set corresponding to the program component set.
[0037] Through the software definition model, before matching the corresponding multiple program components in the pre-built software asset library, the method also includes: building a software asset library according to the software requirement program components of the specified domain software, wherein the software asset library includes any one or more of software services and middleware, business microservice applications and software program components; obtaining component rules and usage information of each software program component in the software asset library, so as to generate component usage description information for each software program component in the software asset library; obtaining software requirement information corresponding to each of the software program components in the software asset library, so as to generate matching requirement description information for each of the software program components in the software asset library; and managing multiple software program components in the software asset library through the component usage description information and the matching requirement description information.
[0038] In one embodiment of the present specification, software for a specified field is precipitated and managed to build program components required for software, including independently run software services and middleware, business microservice applications, software program components, etc. The rules and usage of software components are described in detail, and unified management is performed according to business and technical dimensions. The corresponding program components can be found according to software demand characteristics and requirements.
[0039] First, identify and collect the various software program components required for the software in the specified field. Classify these components systematically and integrate them into the software asset library. This library should cover key elements such as software services and middleware, business microservice applications, and basic software program components. To ensure the comprehensiveness and practicality of the asset library, it needs to be continuously updated and maintained to adapt to the ever-changing software requirements. Analyze each software program component in the software asset library and determine its component rules and usage methods. Based on this information, determine the usage description information corresponding to each component so that developers or maintenance personnel can quickly understand and correctly apply these components.
[0040] Through the component usage description information and the matching requirement description information, multiple software program components in the software asset library are managed, specifically including: determining the business field corresponding to each software program component through the matching requirement description information; determining the technical dimension corresponding to each software program component according to the component usage description information; setting component indexes of the multiple software program components according to the business field and the technical dimension corresponding to each software program component, so as to manage the multiple software program components in the software asset library.
[0041] In one embodiment of the present specification, the matching requirement description information of each software program component is analyzed. Each component is associated with a specific business domain according to the keywords, business scenarios or application examples in the description. One or more business domain tags are assigned to each component to accurately describe the business scope to which it belongs, such as e-commerce, finance, education, etc., so as to quickly find relevant components according to business needs. The component usage description information of each software program component is analyzed, the technical features, programming languages, frameworks, platforms or any other relevant technical details in the description are identified and extracted, and one or more technical dimension tags are assigned to each component to accurately reflect its technical attributes and requirements. The components are classified according to the technology stack, such as Java, Python, Node.js, etc., so as to find suitable components according to the technology selection. An efficient indexing mechanism is established for the software asset library to quickly search and locate components. Combine the business domain tags and technical dimension tags of each software program component to create a unique component index for it. The component index should be able to clearly reflect the business value and technical characteristics of the component, which is convenient for subsequent management and retrieval. The component index is associated with the actual software program component and stored in the software asset library.
[0042] The component index enables developers or maintenance personnel to quickly and accurately retrieve the required software program components without spending a lot of time browsing the entire asset library. Through the classification of business fields and technical dimensions, similar components are easier to identify and reuse, thereby reducing the workload of repeated development and making it easier to select components that meet business and technical requirements, thereby improving the overall quality of the software. When business needs or technical environment changes, by adjusting the component index, you can quickly adapt to these changes and reduce development delays.
[0043] Through the software definition model, the corresponding multiple program components are matched in the pre-built software asset library, which specifically includes: obtaining multiple software definition units in the software definition model; matching in the pre-built software asset library according to each software definition unit, and determining the matching program component corresponding to each software definition unit, wherein the software asset library includes multiple preset program components.
[0044] In one embodiment of the present specification, multiple software definition units are systematically extracted from the software definition model, and the software definition units cover various key components in the model, such as business entities, functions, interfaces, processes, and collaborative relationships. For each extracted software definition unit, the program components corresponding to each software definition unit and unit relationship are dynamically matched from the software asset library. The matching process should be based on the specific requirements and characteristics of the software definition unit, and the program components in the software asset library are compared one by one. According to the results of the matching operation, the corresponding matching program components are determined for each software definition unit. These matching program components should be able to accurately meet the requirements of the software definition unit and ensure the effectiveness and practicality in the subsequent software development process. The determined matching program components are strictly verified to ensure that they fully meet the requirements of the software definition unit. If any mismatch or non-compliance is found, adjustments should be made in a timely manner to ensure the accuracy and reliability of the match.
[0045] After matching each software definition unit in a pre-built software asset library, the method also includes: when there is no matching program component corresponding to the software definition unit in the software asset library, automatically generating program code through a large language model; encapsulating the program code, determining the program component corresponding to the software definition unit, and storing the program component in the software asset library.
[0046] In one embodiment of the present specification, if there is no program component matching the software definition unit in the software asset library, the code is automatically generated and packaged as a program component through a large language model and deposited into the software asset library.
[0047] Determine a program component set and generate an assembly process instruction set corresponding to the program component set, specifically including: obtaining access rule data corresponding to each program component in the program component set; generating an assembly instruction corresponding to each program component through the access rule of each program component; and arranging multiple assembly instructions according to the software-defined model to determine an ordered assembly process instruction set corresponding to the program component set.
[0048] In one embodiment of the present specification, based on the structure of the software-defined model and the software component rules, an assembly process instruction set is generated in order, and based on the access rules of the program components, assembly instructions are generated for each program component; based on the structure of the software-defined model, the assembly instructions are arranged to form an orderly assembly process instruction set. Generating an assembly process instruction set in an automated manner can significantly reduce the time and errors of manually writing instructions and improve overall development efficiency; when the software-defined model or component rules change, the instruction set can be quickly regenerated to adapt to new requirements or problems; the assembly instructions of each program component are generated based on its access rules, ensuring the correctness and consistency of the components during the assembly process; by arranging assembly instructions in an orderly manner, conflicts and dependency problems between different components during the assembly process can be reduced; a detailed assembly process instruction set makes the software development process more precise and controllable, which helps to improve the overall quality of the software, and each instruction is associated with a specific software-defined model and component rules, which improves the traceability of the development process and facilitates subsequent problem troubleshooting and maintenance.
[0049] Step S103, according to the assembly process instruction set, multiple program components are assembled in order by a software assembly agent to generate application software corresponding to the software requirements.
[0050] According to the assembly process instruction set, the multiple program components are assembled in order through a software assembly agent, specifically including: according to the assembly process instruction set, each of the program components is configured through the software assembly agent, and the assembly instruction sequence is determined through the assembly process instruction set; according to the assembly instruction sequence, the multiple program components are assembled in order.
[0051] In one embodiment of the present specification, the software assembly agent first reads the assembly process instruction set and obtains the configuration information of each program component. According to the configuration information, the agent performs necessary configuration on each program component, including setting parameters, adjusting properties, connecting dependencies, etc. The agent analyzes the assembly process instruction set, identifies the dependencies and sequence between the assembly instructions, and through an algorithm or rule engine, the agent determines an optimal assembly instruction sequence to ensure the smooth progress of the assembly process. According to the determined assembly instruction sequence, the software assembly agent begins to execute the assembly instructions one by one. Each instruction corresponds to a specific program component or assembly action, and the agent is responsible for assembling these components according to the requirements of the instructions. During the assembly process, the agent may need to perform real-time verification and debugging to ensure that each component is assembled correctly. If any problems or conflicts are found, the agent will adjust the assembly strategy or request manual intervention in a timely manner. By executing assembly instructions in an automated manner, the assembly efficiency of software components is significantly improved; by following a strict set of assembly process instructions, it is ensured that each program component is assembled correctly; errors and omissions in the manual assembly process are reduced, and the overall quality of the software is improved. It can handle the assembly of software systems containing a large number of program components and complex dependencies. The orderly assembly process and clear instruction set make it easier to maintain and update the software system.
[0052] Through the above technical solution, the software requirement document is parsed, the software definition model and the software assembly instruction set are generated through the large model intelligent agent technology, and the automatic assembly of enterprise application software is realized, which reduces the development workload of enterprise application software and improves the software development efficiency; through automated and standardized processes, the time and labor costs required for software development are significantly reduced; the introduction of software definition models and assembly process instruction sets makes the development process more efficient and orderly; the software definition model is precisely defined based on the software requirement document to ensure the accurate implementation of software requirements; by matching the program components in the pre-built software asset library, the quality and reliability of the components are ensured, and the orderly assembly process reduces errors and conflicts, further improving the overall quality of the software; using the pre-built software asset library, the reuse of software components is realized, reducing the workload of repeated development, and the reusability of the software definition model and assembly process instruction set makes the development of similar software faster and more efficient; when the software requirements change, the software definition model and assembly process instruction set can be quickly updated to quickly adapt to new requirements.
[0053] The embodiment of this specification also provides a software assembly system based on an agent, Figure 2 A schematic diagram of a software assembly system based on an agent provided in an embodiment of this specification is shown in FIG. Figure 2As shown, the system includes: a software asset library 201, a software assembly agent 202 and a tool set including multiple tools, the tool set includes a software definition model construction tool 203, a software assembly instruction set generation tool 204, and a software assembly instruction set execution tool 205, which are as follows:
[0054] The software asset library 201 is for software in a specified field. It precipitates and manages the program components required to build software, including independently run software services and middleware, business microservice applications, software program components, etc. It describes the rules and usage of software components in detail, manages them uniformly according to business and technical dimensions, and can find corresponding program components according to software demand characteristics and requirements.
[0055] The software assembly agent 202 parses the software requirement document based on the large model, calls the software definition model construction tool to generate a software definition model composed of a series of software definition units and relationships, calls the software assembly instruction set generation tool to retrieve the corresponding program components from the software asset library, and generates the assembly process instruction set in order, and calls the software assembly instruction set execution tool to realize software assembly.
[0056] The software definition model construction tool 203 dynamically generates a software definition model description based on the understanding and analysis of the requirements. The software definition model includes business entity objects, business function descriptions, business interface presentations, business process logic, and business collaboration relationships. The software assembly instruction set generation tool 204 dynamically matches the program components corresponding to each software definition unit and unit relationship from the software asset library, and based on the structure of the software definition model and the software component rules, generates an assembly process instruction set in an orderly manner. The software assembly instruction set execution tool 205 executes the assembly process instruction set to assemble the required program components in an orderly manner to form application software that meets the software requirements.
[0057] The embodiment of this specification also provides a software assembly device based on an intelligent agent, such as Figure 3 As shown, the device includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can execute the above method.
[0058] The embodiments of the present specification also provide a non-volatile computer storage medium storing computer executable instructions, wherein the computer executable instructions are configured to execute the above method.
[0059] Each embodiment in this specification is described in a progressive manner, and the same or similar parts between the embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the device, equipment, and non-volatile computer storage medium embodiments, since they are basically similar to the method embodiments, the description is relatively simple, and the relevant parts can be referred to the partial description of the method embodiment.
[0060] The above is a description of a specific embodiment of the specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recorded in the claims can be performed in an order different from that in the embodiments and still achieve the desired results. In addition, the processes depicted in the drawings do not necessarily require the specific order or continuous order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.
[0061] The devices and media provided in the embodiments of this specification correspond one-to-one to the methods. Therefore, the devices and media also have similar beneficial technical effects as the corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the devices and media will not be repeated here.
[0062] Those skilled in the art will appreciate that the embodiments of this specification may be provided as methods, systems, or computer program products. Therefore, this specification may take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Moreover, this specification may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) that contain computer-usable program code.
[0063] This specification is described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the embodiments of this specification. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of the processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the processes in the flowchart and / or block diagram. Figure 1 A process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.
[0064] These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1 A process or multiple processes and / or boxes Figure 1 A function specified in one or more boxes.
[0065] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing instructions for implementing the process. Figure 1 A process or multiple processes and / or boxes Figure 1 The steps for the functions specified in one or more boxes.
[0066] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.
[0067] The memory may include non-permanent storage in a computer-readable medium, random access memory (RAM) and / or non-volatile memory in the form of read-only memory (ROM) or flash RAM. The memory is an example of a computer-readable medium.
[0068] Computer readable media include permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology to store information. Information can be computer readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disk read-only memory (CD-ROM), digital versatile disk (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined herein, computer readable media does not include temporary computer readable media (transitory media), such as modulated data signals and carrier waves.
[0069] It should also be noted that the terms "include", "comprises" or any other variations thereof are intended to cover non-exclusive inclusion, so that a process, method, commodity or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, commodity or device. In the absence of more restrictions, the elements defined by the sentence "comprises a ..." do not exclude the existence of other identical elements in the process, method, commodity or device including the elements.
[0070] The above description is only one or more embodiments of this specification and is not intended to limit this specification. For those skilled in the art, one or more embodiments of this specification may have various changes and variations. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of one or more embodiments of this specification shall be included in the scope of the claims of this specification.
Claims
1. A software assembly method based on an agent, characterized in that: The method comprises: Obtaining a software requirement document corresponding to the software requirement to determine a software definition model based on the software requirement document, wherein the software definition model includes a plurality of software definition units and unit relationships between the plurality of software definition units; By using the software definition model, a plurality of corresponding program components are matched in a pre-built software asset library, a program component set is determined, and an assembly process instruction set corresponding to the program component set is generated; According to the assembly process instruction set, the multiple program components are assembled in order through a software assembly agent to generate application software corresponding to the software requirements.
2. The agent-based software assembly method according to claim 1, characterized in that: Based on the software requirement document, determine the software definition model, which specifically includes: Segment the software requirement document according to a preset segmentation rule to determine a plurality of document blocks corresponding to the software requirement document; Using the embedded model, similarity calculation is performed on the plurality of document blocks to determine similarity result data, and based on the similarity result data, a specified number of texts with the highest similarity are selected; Through the specified number of texts and the preset large model, a software-defined model description file is dynamically generated to determine the software-defined model, wherein the software-defined model description file includes a business entity object description, a business function description, a business interface presentation description, a business process logic description and a business collaboration relationship description.
3. The agent-based software assembly method according to claim 1, characterized in that: Through the software definition model, a plurality of corresponding program components are matched in a pre-built software asset library, specifically including: Acquire multiple software definition units in the software definition model; According to each of the software definition units, matching is performed in a pre-built software asset library to determine a matching program component corresponding to each of the software definition units, wherein the software asset library includes a plurality of preset program components.
4. The agent-based software assembly method according to claim 1, characterized in that: Determining a program component set and generating an assembly process instruction set corresponding to the program component set specifically includes: Obtaining access rule data corresponding to each program component in the program component set; Generate an assembly instruction corresponding to each of the program components according to the access rule of each of the program components; According to the software definition model, the plurality of assembly instructions are arranged to determine an ordered assembly process instruction set corresponding to the program component set.
5. The agent-based software assembly method according to claim 1, characterized in that: By using the software definition model, before matching the corresponding plurality of program components in the pre-built software asset library, the method further includes: According to the software requirement program components of the specified field software, a software asset library is constructed, wherein the software asset library includes any one or more of software services and middleware, business microservice applications, and software program components; Acquire component rules and usage information of each software program component in the software asset library, so as to generate component usage description information for each software program component in the software asset library; Acquire software requirement information corresponding to each of the software program components in the software asset library, so as to generate matching requirement description information for each of the software program components in the software asset library; The plurality of software program components in the software asset library are managed through the component usage description information and the matching requirement description information.
6. The agent-based software assembly method according to claim 3, characterized in that: After matching each of the software definition units in a pre-built software asset library, the method further includes: When there is no matching program component corresponding to the software definition unit in the software asset library, automatically generating program code through a large language model; The program code is packaged, a program component corresponding to the software definition unit is determined, and the program component is stored in the software asset library.
7. The agent-based software assembly method according to claim 1, characterized in that: According to the assembly process instruction set, the plurality of program components are sequentially assembled by a software assembly agent, specifically comprising: By means of a software assembly agent, each of the program components is configured according to the assembly process instruction set, and an assembly instruction sequence is determined by means of the assembly process instruction set; The multiple program components are assembled in order according to the assembly instruction sequence.
8. The agent-based software assembly method according to claim 5, characterized in that: Managing the plurality of software program components in the software asset library by using the component usage description information and the matching requirement description information specifically includes: Determining the business domain corresponding to each of the software program components through the matching requirement description information; Determining the technical dimension corresponding to each software program component according to the component usage description information; According to the business field and the technical dimension corresponding to each software program component, component indexes of the plurality of software program components are set to manage the plurality of software program components in the software asset library.
9. An agent-based software assembly device, characterized in that: The device comprises: at least one processor; and, a memory communicatively connected to the at least one processor; wherein, The memory stores instructions that can be executed by the at least one processor, and the instructions are executed by the at least one processor so that the at least one processor can perform the method according to any one of claims 1 to 8.
10. A non-volatile computer storage medium storing computer executable instructions, characterized in that: The computer executable instructions are configured to execute the method according to any one of claims 1 to 8.
Citation Information
Cited By
Generative software automatic assembly method and system based on contract framework model
CN120122919A
A generative software automatic assembly method and system based on contract framework model
CN120122919B
