Method for generating source code

Abstract

To provide a system and a method for automatically generating a source code for data acquisition application programming interfaces (APIs) and similar tasks.SOLUTION: Methods can involve: responsive to receiving a user request associated with an API type, retrieving a template from a template database; providing the template to a user to obtain a user-defined requirement; using the user-defined requirement to obtain from an API code creation database a historic requirement that is associated with the user-defined requirement and is associated with a source code; in response to the historic requirement being identical to the user-defined requirement, communicating an API endpoint to the user; in response to the historic requirement not being identical to the user-defined requirement, providing the user-defined requirement and the source code to a generative AI model to request an API source code; and in response to receiving the API source code and an endpoint name, communicating the endpoint name to the user.SELECTED DRAWING: Figure 4

Description

[Technical Field]

[0001] The present disclosure relates generally to source code generation tools, and more particularly to systems and methods for automatically generating source code for data acquisition application programming interfaces (APIs) and similar tasks. [Background technology]

[0002] In recent years, various industries have attempted to improve business efficiency by strategically utilizing data. Applications that utilize data often require access to APIs for data integration. However, if the required API is not available, a new API must be developed to acquire the required data. This lack of an appropriate API can sometimes become a bottleneck in the application development process. By utilizing services provided by generative artificial intelligence (AI) tools incorporating natural language processing, such as advanced chatbots, users can generate source code to be used with APIs and perform data acquisition tasks. However, improving the accuracy of the generated code remains a challenge. Therefore, a system and method capable of automatically generating source code for data acquisition APIs with high accuracy is desired. Summary of the Invention

[0003] In some aspects of the present disclosure, the generation of API source code for data acquisition tasks is streamlined by utilizing a system and method that combines an API requirements template database with a code generation database to match user requirements to existing templates. Based on this matching, new API source code can be generated from scratch using a generative AI. The API requirements template database stores requirement templates that aid in the creation of user-defined templates designed for specific data acquisition APIs. The API code generation database also stores previously generated API source code and associated requirements, structured in the same format as the templates. The contents of the user-defined template are compared with existing requirements stored in the API code generation database to find an existing template that most closely matches the existing source code corresponding to the user-defined template. The source code and user requirements are then provided to an external program or generative AI to automatically generate source code for the data acquisition API.

[0004] Some aspects of the present disclosure may include an automated source code generation system that may include a user interface that receives user requests associated with an API type; a template database that stores templates that are provided to a user to obtain user-defined requirements; an API code generation database that, in response to receiving the user-defined requirements, provides historical source code and historical requirements associated with the user-defined requirements; and a generative AI model that, in response to receiving the user-defined requirements and the historical source code, generates API source code that is then provided to the user.

[0005] Some aspects of the present disclosure may include a system that may include: in response to receiving a user request associated with an API type, means for retrieving a template from a template database; means for providing the template to a user to retrieve user-defined requirements; means for using the user-defined requirements to retrieve historical requirements associated with the user-defined requirements and associated with source code from an API code creation database; means for communicating an API endpoint to the user in response to the historical requirements being identical to the user-defined requirements; means for providing the user-defined requirements and the source code to a generative AI model to request API source code in response to the historical requirements not being identical to the user-defined requirements; and means for communicating the endpoint name to the user in response to receiving the API source code and the endpoint name. [Brief explanation of the drawings]

[0006] [Figure 1] 1 illustrates a source code generation system according to an embodiment. [Figure 2A] 1 illustrates an API requirements template according to an example embodiment. [Figure 2B] 1 illustrates an API requirements template according to an example embodiment. [Figure 2C] 1 illustrates an API requirements template according to an example embodiment. [Figure 3A] 1 illustrates records in an API code generation database according to an embodiment. [Figure 3B] 1 illustrates records in an API code generation database according to an embodiment. [Figure 3C] 1 illustrates records in an API code generation database according to an embodiment. [Figure 4] 1 is a flowchart illustrating a process for using an API source code creation system according to an embodiment. [Figure 5] FIG. 10 illustrates a table of user-defined requirements for an API, according to an embodiment. [Figure 6]FIG. 10 illustrates the contents of a message according to an embodiment. [Figure 7] FIG. 10 illustrates a message generated by a generation AI module, according to an embodiment. [Figure 8] 1 is a flowchart illustrating a generalized process for using an API source code creation system according to an embodiment. [Figure 9] 1 illustrates a computing environment including an exemplary computer that can be used in the embodiments. DETAILED DESCRIPTION OF THE INVENTION

[0007] The following detailed description provides details of the figures and examples of the present application. Reference numerals and redundant element descriptions between figures may be omitted for clarity. Terms used throughout this specification are given by way of example and are not intended to be limiting. For example, the use of the term "automatic" can include fully automatic or semi-automatic implementations with user or administrator control over certain aspects of the implementation, depending on the desired implementation of one skilled in the art practicing embodiments of the present invention. Selection can be performed by a user through a user interface or other input means, or can be performed through a desired algorithm. The examples described herein can utilize either singular or combinations, and the functionality of the examples can be implemented through any means according to the desired implementation. The terms "template" and "table" are used interchangeably herein, as are the terms "existing" and "history."

[0008] 1 illustrates a source code generation system according to one embodiment. In the embodiment, the source code generation system 101 includes a message creation unit 103, a requirements template selection unit 104, an API requirements template database 105, a correlation API selection unit 106, an API code creation database 107, a request creation unit 108, a response processing unit 109, and an API code deployment unit 110.

[0009] In operation, the system 101 generates API source code by interacting with external systems such as a user 111 and a generation AI 112. The system 101 generates requests for source code generation based on user input and sends these requests to the generation AI 112. Upon receiving the API source code generated by the generation AI 112, the system 101 deploys the source code and sends an API endpoint to the user 111. Additionally, the system 101 registers the requests and API source code received from the user 111 in the API code generation database 107.

[0010] Specifically, in response to receiving input from the user 111, the system 101 uses the message creation unit 103 to inquire about the type of data retrieval (data retrieval) API that the user 111 wishes to generate or through which to retrieve data (data retrieval). For example, this can be achieved by generating and communicating an appropriate message to the user 111 when the user 111 successfully accesses the user input recognition unit 102 after a user verification process. Information regarding the type of data that the user wishes to retrieve through API generation is input to the requirement template selection unit 104.

[0011] Based on the data type information received from the user input recognition unit 102, the requirement template selection unit 104 identifies a corresponding template from an API requirement template database 105 that stores any number of templates for each data type, and inputs the corresponding template to the message creation unit 103. The message creation unit 103 communicates the requirement template to the user 111.

[0012] The API requirements for data retrieval received by the user are provided to both the correlation API selector 106 and the request creator 108. The correlation API selector 106 uses the API requirements to query the API code creation database 107 to identify past API requirements that are similar to the API requirements provided by the user. The API code creation database 107 is periodically updated to store past API requirements and the corresponding API source code that was generated based on the past API requirements.

[0013] Similarity can be ascertained using any method known in the art, for example, by establishing highly correlated relationships using weights and other statistical tools, and any number of criteria can be given priority to modify the correlation results, for example, based on user input.

[0014] The existing source code, together with the API requirements identified by the correlation API selector, is input to the request creator 108. The request creator 108 generates a request for the generation AI 112 to generate accurate API source code based on the API requirements provided by the user input recognizer 102 and the existing similar API requirements and their generated source codes provided by the correlation API selector 106. The request creator 108 sends the request to the generation AI 112 and receives a response. The response processor 109 stores the API requirements, as well as the corresponding API source code and API endpoints received from the generation AI 112, in the API code generation database 107. The response processor 109 further passes the API source code and API endpoints received from the generation AI 112 to the API code deployer 110 and passes the API endpoint information to the message creator 103.

[0015] The API code deployment unit 110 deploys the API endpoint and API source code provided by the response processing unit 109. Finally, in response to receiving the API endpoint from the response processing unit 109, the message creation unit 103 transmits the API endpoint and / or the API source code to the user 111.

[0016] 2A-2C illustrate example API requirement templates according to an embodiment. Each template includes an item field 201 and a user input example field 202. In one embodiment, such API requirement templates are stored in a database for data acquisition, such as API requirement template database 105 of FIG. 1. FIG. 2A illustrates a requirement template for creating an API for acquiring video / image data. FIG. 2B illustrates a requirement template for creating an API for acquiring temperature data. FIG. 2C illustrates a requirement template for creating an API for acquiring vibration data.

[0017] The requirements template of Figure 2A includes entries for line ID 203, streaming / snapshot 204, interval 205, format 206, API type 207, authentication 208, and additional data 209. The requirements template of Figure 2B includes entries for line ID 203, streaming / snapshot 204, interval 205, format 206, unit 210, API type 207, authentication 208, and additional data 209. The requirements template of Figure 2C includes entries for line ID 203, streaming / snapshot 204, interval 205, sampling rate 211, compression 212, API type 207, authentication 208, and additional data 209.

[0018] The Line ID 203 entry identifies the production line from which the data is acquired. The Streaming / Snapshot 204 entry indicates whether the data should be streamed or communicated in the form of a snapshot in time. The Interval 205 entry indicates the time span (e.g., in seconds) over which the data will be acquired. The Format 206 entry indicates the data or file format, such as JPEG. The API Type 207 entry indicates the type of API. The Authentication 208 entry indicates whether authentication methods should be applied to the API. The Additional Data 209 entry indicates information about metadata that will be added to the target data. The Units 210 entry specifies the units of measurement associated with the data. The Sampling Rate 211 entry specifies the number of data points to be acquired per unit of time. The Compression 212 entry indicates whether a compression method should be applied to the data.

[0019] 3A-3C illustrate example records in an example API code generation database, according to one embodiment. In an embodiment, the records stored in each API code generation database of FIGS. 3A-3C may represent requirements for a previously generated data acquisition API for video / image data, along with the corresponding source code stored in each database. A record may include an item 301 entry, a value 302 entry, and source code 303. Each API endpoint 304 entry specifies a functional endpoint for accessing the stored API. As will be apparent to those skilled in the art, the line ID 203 through additional data 209 entries and source code 303 are selected based on the requirements template shown in FIG. 2A.

[0020] FIG. 4 is a flowchart illustrating an example process for using an API source code creation system, according to one embodiment. In the embodiment, process 400 begins at step 401, when an API source code creation system, such as that shown in FIG. 1, is accessed by a user. At step 402, the system communicates a message to the user inquiring about the type of data acquisition API the user requests. The user can select a type from a list of types. At step 403, the system receives the user's selection. At step 404, based on the user's input, the system accesses a database, such as API requirements template database 105 shown in FIG. 1, to select or retrieve an appropriate template from a set of stored requirement templates and communicates the selected template to the user. The user provides information about any number of entries therein, such as by filling in entries within the selected template. At step 405, the system receives the user-defined requirements within the template and, at step 406, provides them to an API creation database (such as API code creation database 107 shown in FIG. 1) to retrieve the most similar past requirements to the user-defined requirements and the corresponding source code associated with the past requirements. In step 407, the system determines whether the previous requirement is identical to the user-defined requirement. If so, the process communicates the existing API endpoints contained in the retrieved data to the user, for example, in the form of an endpoint vector, in step 408. If the previous requirement is not identical to the user-defined requirement, process 400 resumes at step 409.

[0021] In step 409, the system creates a message that includes the user-defined requirements and similar past requirements, and also includes the corresponding source code retrieved from the API creation database. The system sends this message to the generative AI model, instructing the model to create API source code that satisfies the user-defined requirements. In response, in step 410, the system receives the requested API source code and endpoint name from the model. In step 411, the system can deploy the received source code and communicate the endpoint name to the user in step 412. Finally, in step 413, the system registers the user-defined requirements, the API source code retrieved from the model, and the endpoint name in the API code creation database.

[0022] The following example describes a process 400 for using the API source code creation system. The API source code is created as a result of interactions between a user and the system, and between the system and a generative AI model.

[0023] First, in step 401, a user accesses the API source code creation system, and in response to being presented with a selection as shown in step 402 of FIG. 4, the user can select "A: Video / Image." In response to receiving the user selection in step 403, the system accesses a requirements template database in step 404, obtains a video / image template such as the template shown in FIG. 2A according to the user selection, and sends it to the user. In step 405, the system receives user-defined requirements from the user. The received user-defined requirements are in the form of user-filled entries as shown in the template of FIG. 5 according to an embodiment.

[0024] Assume that the API code creation database contains three records of past requirements categorized as video / image and corresponding source code, as depicted in FIGS. 3A to 3C. When the system compares the user-defined requirements of FIG. 5 with the past requirements of FIG. 3A, the system finds that only one entry, namely the entry "Interval," is different. In contrast, when comparing the user-defined requirements of FIG. 5 with the past requirements of FIG. 3B, the system finds that the values ​​of three items are different from each other. Similarly, when comparing the current requirement with the past requirements of FIG. 3C, the system finds that the values ​​of four items are different from each other. As a result, the system determines that the past requirements in the table of FIG. 3A are most similar to the user-defined requirements, and in step 406, the system fetches the table of FIG. 3A as the most similar requirements. Because the requirements in the fetched table and the user-defined requirements are not completely identical, the process proceeds to step 409, where a message with the content shown in FIG. 6 is created according to the embodiment.

[0025] The message sent from the system to the generation AI can be seen as a query containing a request 601, a requirements table 602 for generating API source code, and a similar requirements table 603 with that source code, and a request to generate the appropriate API source code.

[0026] Figure 7 shows an example message generated by the generation AI module, according to an embodiment. In step 410 of Figure 4, a message 700 received by the system from the generation AI includes an API endpoint 702 and API source code 704. In step 411, the system deploys the received source code. In step 412, the system sends the API endpoint name (https: / / lineB / image / jpeg / 5sec in Figure 7) to the user. Finally, in step 413, the system registers the user-defined requirements, API source code, and endpoint name in the API code generation database.

[0027] 8 is a flowchart illustrating a generalized process for using an API source code creation system, according to one embodiment. In one embodiment, process 800 begins at step 802, where the API source code creation system receives a user request associated with an API type. In response, at step 804, the system retrieves a template from a template database, communicates the template to the user at step 806, and retrieves user-defined requirements at step 808.

[0028] In step 810, the system retrieves the historical requirements associated with the user-defined requirements from the API production database and further receives the corresponding source code associated with the historical requirements. In step 812, if the historical requirements are identical to the user-defined requirements, process 800 communicates the API endpoint to the user. If the historical requirements are not identical to the user-defined requirements, in step 814, the system provides the user-defined requirements and the source code to the generative AI model and requests the API source code.

[0029] In response to receiving the requested API source code and endpoint name from the model, the system communicates the received source code and endpoint name to the user in step 816. In step 818, the system registers at least one of the user-defined requirements, the API source code, or the endpoint name in an API code creation database. One skilled in the art will recognize that (1) certain steps may be performed arbitrarily, (2) steps may not be limited to the particular order set forth herein, (3) certain steps may be performed in a different order, and (4) certain steps may be performed simultaneously.

[0030] 9 illustrates a computing environment including an exemplary computer that can be used in embodiments herein. The computer 905 of the computing environment 900 can include one or more processing units, cores, or processors 910, memory 915 (e.g., RAM, ROM, and / or the like), internal storage 920 (e.g., magnetic, optical, solid-state storage, and / or organic storage), and / or an I / O interface 925, any of which can be connected to a communication mechanism or bus 930 for communicating information or embedded in the computer 905. The I / O interface 925 can be configured to receive images from a camera or send images to a projector or display, depending on the desired implementation.

[0031] The computer 905 can be communicatively coupled to an input / user interface 935 and an output device / interface 940. Either or both of the input / user interface 935 and the output device / interface 940 can be wired or wireless interfaces and can be detachable. The input / user interface 935 can include any device, component, sensor, or interface, physical or virtual, that can be used to provide input (e.g., buttons, touchscreen interfaces, keyboards, pointer / cursor control, microphones, cameras, Braille, motion sensors, optical readers, and / or the like). The output device / interface 940 can include displays, televisions, monitors, printers, speakers, Braille, etc. In some embodiments, the input / user interface 935 and the output device / interface 940 can be embedded in or physically connected to the computer 905. In other embodiments, other computers can function as or provide the functionality of the input / user interface 935 and the output device / interface 940 of the computer 905.

[0032] Examples of computing devices 905 may include highly mobile devices (e.g., smartphones, devices mounted on vehicles and other machines, devices carried by humans and animals, etc.), mobile devices (e.g., tablets, notebooks, laptops, personal computers, portable televisions, radios, etc.), and devices not designed for mobility (e.g., desktop computers, other computers, information kiosks, televisions, radios, etc. that include one or more processors embedded therein and / or connected thereto).

[0033] The computing device 905 may be communicatively connected to external storage 945, for example, via an I / O interface 925, and may also be connected to a network 950 to communicate with any number of networked components, devices, and systems, including one or more computing devices of the same or different configurations. The computing device 905 or any connected computing device may provide, function as, or be referred to as a server, client, thin server, general machine, special purpose machine, or other labeled service.

[0034] I / O interface 925 may include wired and / or wireless interfaces using any communication, I / O protocol or standard (e.g., Ethernet, 802.11x, Universal System Bus, WiMax, modem, cellular network protocols, etc.) for communicating information to and from at least all connected components, devices, and networks in computing environment 900. Network 950 may be any network or combination of networks (e.g., the Internet, a local area network, a wide area network, a telephone network, a cellular network, a satellite network, etc.).

[0035] The computer 905 uses and / or can communicate using computer-usable or computer-readable media, including transient and non-transitory media. Transitory storage media include transmission media (e.g., metallic cables, optical fibers), signals, carrier waves, etc. Non-transitory media include magnetic media (disks, tapes, etc.), optical media (CD ROM, digital video disks, Blu-ray disks, etc.), solid-state media (RAM, ROM, flash memory, solid-state storage, etc.), and other non-volatile storage or memory.

[0036] The computer 905 can be used to implement techniques, methods, applications, processes, or computer-executable instructions in some exemplary computing environments. The computer-executable instructions can be retrieved from a transitory medium, stored on a non-transitory medium, or retrieved from a non-transitory medium. The executable instructions can be from one or more of any programming, scripting, and machine language (e.g., C, C++, C#, Java, Visual Basic, Python, Perl, JavaScript, and others).

[0037] The processor(s) 910 may run under any operating system (OS) (not shown) in a native or virtual environment. One or more applications may be deployed, including a logic unit 960, an application programming interface (API) unit 965, an input unit 970, an output unit 975, and an inter-unit communication mechanism 995 through which different units communicate with each other, the OS, and other applications (not shown). The described units and elements may vary in design, function, configuration, or implementation and are not limited to the provided description. The processor 910 may be in the form of a hardware processor, such as a central processing unit (CPU), or a combination of hardware and software units.

[0038] In some embodiments, when information or instructions to execute are received by API unit 965, it may be communicated to one or more other units (e.g., logic unit 960, input unit 970, output unit 975). In some embodiments, logic unit 960 may be configured to control the flow of information between units and direct the services provided by API unit 965, input unit 970, and output unit 975 in some of the embodiments described above. For example, the flow of one or more processes or implementations may be controlled by logic unit 960 alone or in cooperation with API unit 965. Input unit 970 may be configured to obtain inputs for calculations described in embodiments, and output unit 975 may be configured to provide outputs based on the calculations described in embodiments.

[0039] The processor 910 may be configured to execute a method or computer instructions including, for example, as shown in FIGS. 1, 4, and 8, in response to receiving a user request associated with an API type, retrieving a template from a template database and providing the template to a user to retrieve user-defined requirements; using the user-defined requirements, retrieving historical requirements associated with the user-defined requirements and associated with source code from an API code creation database; communicating an API endpoint to the user in response to the historical requirements being identical to the user-defined requirements; providing the user-defined requirements and the source code to a generative AI model to request API source code in response to the historical requirements not being identical to the user-defined requirements; and communicating the endpoint name to the user in response to receiving the API source code and the endpoint name.

[0040] Some portions of this specification are presented in terms of algorithms and symbolic representations of operations within a computer. These algorithmic descriptions and symbolic representations are the means used by those skilled in the data processing arts to convey the essence of their innovations to others skilled in the art. An algorithm is a series of defined steps leading to a desired end state or result. In some embodiments, the steps performed require specific quantities of physical manipulations to achieve a specific result.

[0041] Unless expressly stated otherwise, it is understood that throughout this specification, discussions utilizing terms such as "processing," "operating," "calculating," "determining," "displaying," and the like may include operations and processes of a computing system or other information processing device that manipulate and transform data represented as physical (electronic) quantities in the computing system's registers and memory into other data also represented as physical quantities in the computing system's memory, registers, or other information storage, transmission, or display devices.

[0042] Examples may relate to an apparatus for performing the operations herein. This apparatus may be specially constructed for the required purposes, or it may include one or more general-purpose computers selectively activated or reconfigured by one or more computer programs. Such computer programs may be stored on a computer-readable medium, such as a computer-readable storage medium or a computer-readable signal medium. Computer-readable storage media may include tangible media such as optical disks, magnetic disks, read-only memory, random-access memory, solid-state devices, drives, or any other type of tangible or non-transitory medium suitable for storing electronic information. Computer-readable signal media may include media such as carrier waves. The algorithms and displays presented herein are not inherently related to any particular computer or other apparatus. A computer program may include pure software containing instructions for performing the operations of a desired implementation.

[0043] Various general-purpose systems may be used with programs and modules according to the embodiments herein, or more specialized apparatus may be constructed to perform the desired method steps. Moreover, the embodiments are not described with reference to a particular programming language. It will be understood that various programming languages ​​can be used to implement the techniques of the embodiments described herein. Instructions in the programming language may be executed by one or more processing devices, such as a central processing unit (CPU), processor, or controller.

[0044] As is known in the art, the operations described above can be performed by hardware, software, or some combination of software and hardware. Various aspects of the embodiments can be implemented using circuits and logic devices (hardware), while other aspects can be implemented using instructions stored on a computer-readable medium (software) that, when executed by a processor, cause the processor to perform the methods of the embodiments. Furthermore, some embodiments herein can be performed exclusively in hardware, while other embodiments can be performed exclusively in software. Furthermore, the various functions described can be performed in a single unit or distributed across multiple components in any number of ways. When performed by software, the methods can be executed by a processor, such as a general-purpose computer, based on instructions stored on a computer-readable medium. If desired, the instructions can be stored on the storage medium in a compressed and / or encrypted format.

[0045] Additionally, other embodiments will be apparent to those skilled in the art from consideration of this specification and practice of the techniques disclosed herein. Various aspects and / or components of the described embodiments may be used alone or in any combination. It is intended that the specification and description of the embodiments be considered exemplary only, with the true scope and spirit of the present application being indicated by the following claims.

Claims

1. 1. A method for generating source code, comprising: retrieving a template from a template database in response to receiving a user request associated with the API type; providing said template to a user to obtain user-defined requirements; using the user-defined requirements to retrieve, from an API code generation database, historical requirements associated with the user-defined requirements and associated with source code; In response to the historical requirements being identical to the user-defined requirements, communicating an API endpoint to the user; In response to the historical requirements not being identical to the user-defined requirements, providing the user-defined requirements and the source code to a generative AI model to request API source code; In response to receiving the API source code and an endpoint name, communicating the endpoint name to the user.

2. 10. The method of claim 1, The method further comprising registering at least one of the user-defined requirements, the API source code, or the API endpoints in the API code creation database.

3. 10. The method of claim 1, The method, wherein the API type is a data acquisition API and the API endpoint is a function API endpoint.

4. 10. The method of claim 1, The method, wherein the historical requirements are selected based on at least one of a similarity or a priority associated with the user-defined requirements.

5. 10. The method of claim 1, The method further comprising updating the template based on the user-defined requirements.

6. 10. The method of claim 1, The method further includes updating at least one of the API code generation database or the generative AI model with requirements-source code pairs.

7. 10. The method of claim 1, The method further includes analyzing the source code to determine whether the user-defined requirements are associated with the source code.

8. 1. A system for generating source code, comprising: a user interface that receives a user request associated with an API type; A template database that stores templates provided to users to obtain user-defined requirements; an API code creation database that, in response to receiving the user-defined requirements, provides historical requirements associated with historical source code and provides the user-defined requirements; a generative AI model that, in response to receiving the user-defined requirements and the historical source code, generates API source code that the system provides to the user.

9. 9. The system of claim 8, The system further includes a message creator that communicates a query to the user interface to obtain a query result.

10. 10. The system of claim 9, In response to receiving the API source code and the endpoint name, the message creation unit communicates the endpoint name to the user.

11. 10. The system of claim 9, The system further includes a response processor that transmits the API source code to the message generator.

12. 10. The system of claim 9, The system further includes a template selector that uses the query results to select the template from the template database.

13. 9. The system of claim 8, In response to the historical requirement being identical to the user-defined requirement, the system communicates an API endpoint to the user interface.

14. 9. The system of claim 8, The generative AI model receives the user-defined requirements and the historical source code in response to the historical requirements not being identical to the user-defined requirements.

15. 14. The system of claim 13, The API code creation database registers at least one of the user-defined requirements, the API source code, or the API endpoints.

16. 14. The system of claim 13, The system, wherein the API type is a data acquisition API and the API endpoint is a function API endpoint.

17. 9. The system of claim 8, The system, wherein the historical requirements are selected based on at least one of a similarity or a priority associated with the user-defined requirements.

18. 9. The system of claim 8, The template is updated based on the user-defined requirements.

19. 1. A non-transitory computer-readable medium storing instructions for causing a computer system to perform a process, the process comprising: retrieving a template from a template database in response to receiving a user request associated with the API type; providing said template to a user to obtain user-defined requirements; using the user-defined requirements to retrieve, from an API code generation database, historical requirements associated with the user-defined requirements and associated with source code; In response to the historical requirements being identical to the user-defined requirements, communicating an API endpoint to the user; In response to the historical requirements not being identical to the user-defined requirements, providing the user-defined requirements and the source code to a generative AI model to request API source code; A computer-readable medium that, in response to receiving the API source code and the endpoint name, communicates the endpoint name to the user.

20. 20. The computer readable medium of claim 19, The process registers at least one of the user-defined requirements, the API source code, or the API endpoints in the API code creation database.

Images