How to generate 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 generally relates 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 Art

[0002] In recent years, in various industries, attempts have been made to improve business efficiency by strategically utilizing data. In applications that utilize data, access to an API is often required for data integration. However, when the required API is not available, it becomes necessary to develop a new API for obtaining the required data. Thus, the absence of a suitable API can sometimes become a bottleneck in the application development process. By leveraging the services provided by generative artificial intelligence (AI) tools incorporating natural language processing, such as advanced chatbots, users can generate the source code used in an API to execute data acquisition tasks. However, improving the accuracy of the generated code still remains an issue. Therefore, there is a need for a system and method that can automatically generate source code for a data acquisition API with high accuracy.

Summary of the Invention

[0003] In some aspects of this disclosure, the generation of API source code for data retrieval tasks is streamlined by utilizing a system and method that combines an API requirement template database and 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 requirement template database stores requirement templates that help create user-defined templates designed for specific data retrieval APIs. The API code generation database stores source code for previously generated APIs and the requirements associated with that source code, 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 the existing template that is closest to the user-defined template and its corresponding existing source code. The source code and user requirements are then provided to an external program or generative AI, and the source code for the data retrieval API is automatically generated.

[0004] Some aspects of this disclosure may include an automated source code generation system which may include a user interface for receiving user requests associated with API types; a template database for storing templates provided to the user for obtaining user-defined requirements; an API code generation database which, in response to receiving user-defined requirements, provides historical source code and historical requirements associated with the user-defined requirements; and a generating AI model which, in response to receiving user-defined requirements and historical source code, generates API source code to be provided to the user next.

[0005] Some aspects of this disclosure may include a system which includes means for retrieving a template from a template database in response to receiving a user request associated with an API type; means for providing a template to a user to retrieve user-defined requirements; means for retrieving historical requirements associated with user-defined requirements and associated with source code from an API code generation database using the user-defined requirements; means for communicating an API endpoint to a user in response to a historical requirement being identical to a user-defined requirement; means for providing a generating AI model with user-defined requirements and source code to request API source code in response to a historical requirement being not identical to a user-defined requirement; and means for communicating an endpoint name to a user in response to receiving API source code and an endpoint name. [Brief explanation of the drawing]

[0006] [Figure 1] A source code generation system according to the example is shown. [Figure 2A] An API requirements template following the example is shown. [Figure 2B] An API requirements template following the example is shown. [Figure 2C] An API requirements template following the example is shown. [Figure 3A] The following shows the records in the API code creation database, following the example. [Figure 3B] The following shows the records in the API code creation database, following the example. [Figure 3C] The following shows the records in the API code creation database, following the example. [Figure 4] This flowchart shows the process for using the API source code creation system according to the example. [Figure 5] This figure shows a table of user-defined requirements for the API, according to the example. [Figure 6]This figure shows the content of the message according to the example. [Figure 7] This figure shows messages generated by the generation AI module according to the example. [Figure 8] This flowchart shows a generalized process for using the API source code generation system according to the example. [Figure 9] This describes a computing environment, including an exemplary computer, that can be used in the embodiment. [Modes for carrying out the invention]

[0007] The following detailed description provides details of the figures and embodiments of the present application. Reference figures between figures and descriptions of redundant elements may be omitted for clarity. Terms used throughout this specification are given as examples and are not intended to limit the scope of the invention. For example, the use of the term “automatic” may include fully automatic or semi-automatic embodiments with user or administrator control over specific aspects of the implementation, depending on a desired embodiment for those skilled in the art practicing embodiments of the present invention. Selection may be performed by a user through a user interface or other input means, or through a desired algorithm. The embodiments described herein may be used individually or in combination, and the functionality of the embodiments may be implemented through any means according to the desired implementation. The terms “template” and “table” are used interchangeably in this specification, and similarly, the terms “existing” and “history” are used interchangeably.

[0008] Figure 1 shows a source code generation system according to one embodiment. In this 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 correlated 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, system 101 generates API source code by interacting with external systems such as user 111 and generation AI 112. System 101 generates source code creation requests based on user input and sends these requests to generation AI 112. Upon receiving the API source code generated by generation AI 112, system 101 deploys this source code and sends the API endpoint to user 111. Furthermore, system 101 registers the requests and API source code received from user 111 in the API code creation database 107.

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

[0011] The requirements template selection unit 104 identifies the corresponding template from the API requirements template database 105, which stores any number of templates for each data type, based on the data type information received from the user input recognition unit 102, and inputs the corresponding template to the message creation unit 103. The message creation unit 103 then transmits the requirements template to the user 111.

[0012] API requirements for data retrieval received by the user are provided to both the correlated API selection unit 106 and the request creation unit 108. The correlated API selection unit 106 uses the API requirements to query the API code creation database 107 and identifies past API requirements similar to the API requirements provided by the user. The API code creation database 107 is updated periodically to store past API requirements and the corresponding API source code generated based on those past API requirements.

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

[0014] The existing source code, along with the API requirements identified by the Correlated API Selection Unit, is input to the Request Creation Unit 108. Based on the API requirements provided by the User Input Recognition Unit 102 and the existing similar API requirements and their generated source codes provided by the Correlated API Selection Unit 106, the Request Creation Unit 108 generates a request for the Generation AI 112 to create the correct API source code. The Request Creation Unit 108 sends the request to the Generation AI 112 and receives a response. The Response Processing Unit 109 stores the API requirements, as well as the corresponding API source code and API endpoint received from the Generation AI 112, in the API Code Creation Database 107. The Response Processing Unit 109 further passes the API source code and API endpoint received from the Generation AI 112 to the API Code Deployment Unit 110 and passes the API endpoint information to the Message Creation Unit 103.

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

[0016] Figures 2A to 2C show examples of API requirement templates according to the 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 example, the API requirement template database 105 in Figure 1, for data acquisition. Figure 2A represents a requirement template for generating an API to acquire video / image data. Figure 2B represents a requirement template for generating an API to acquire temperature data. Figure 2C represents a requirement template for generating an API to acquire vibration data.

[0017] The requirements template in 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 in 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 in 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 data is to be acquired. The Streaming / Snapshot 204 entry indicates whether the data should be streamed or communicated in the form of a snapshot within a time period. The Interval 205 entry indicates the time span (e.g., in seconds) over which data is to 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 an authentication method should be applied to the API. The Additional Data 209 entry indicates information regarding metadata to be added to the target data. The Unit 210 entry specifies the measurement unit associated with the data. The Sampling Rate 211 entry specifies the number of data points acquired per unit time. The Compression 212 entry indicates whether a compression method should be applied to the data.

[0019] Figures 3A to 3C show examples of records in an example of an API code creation database according to an embodiment. In the embodiment, the records stored in each of the API code creation databases of Figures 3A to 3C can represent the requirements for a previously generated data acquisition API for video / image data, together with the corresponding source code stored in each database. The record can include an Item 301 entry, a Value 302 entry, and a 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 entries from Line ID 203 to Additional Data 209, and the Source Code 303, are selected based on the requirements template shown in Figure 2A.

[0020] FIG. 4 is a flowchart showing an example of a process of using an API source code creation system according to an embodiment. In the embodiment, process 400 starts at step 401 where an API source code creation system as shown in FIG. 1 is accessed by a user. At step 402, the system communicates to the user a message asking for 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 selection result from the user. At step 404, based on the user input, the system accesses a database such as the API requirement template database 105 shown in FIG. 1, selects or retrieves an appropriate template from a set of stored requirement templates, and communicates the selected template to the user. The user provides information regarding any number of entries therein, such as by filling in the 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 the API code creation database 107 shown in FIG. 1) to obtain the past requirements most similar to the user-defined requirements and the corresponding source code associated with the past requirements. At step 407, the system determines whether the past requirements are the same as the user-defined requirements. If they are the same, the process, at step 408, communicates to the user the existing API endpoints included in the obtained data, for example, in the form of an endpoint vector. If the past requirements are not the same as the user-defined requirements, process 400 resumes from step 409.

[0021] In step 409, the system creates a message that includes the user-defined requirements and similar past requirements, as well as the corresponding source code retrieved from the API creation database. The system sends this message to the generating AI model, instructing the model to create API source code that satisfies the user-defined requirements. In response, the system receives the requested API source code and endpoint name from the model in step 410. The system can deploy the received source code in step 411 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 illustrates process 400 using an API source code generation system. The API source code is created as a result of interactions between the user and the system, and between the system and the generated AI model.

[0023] First, in step 401, the user accesses the API source code creation system and, in response to being presented with a selection as shown in step 402 of Figure 4, the user can select "A: Video / Image". In step 403, in response to receiving the user selection, the system accesses the requirements template database in step 404 and, according to the user selection, retrieves a video / image template such as the template shown in Figure 2A 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 in Figure 5, according to the embodiment.

[0024] Assume the API code creation database contains three records, as depicted in Figures 3A to 3C, of ​​past requirements categorized as videos / images and their corresponding source code. When the system compares the user-defined requirement in Figure 5 with the past requirement in Figure 3A, it finds that only one entry differs, namely the entry "Interval". In contrast, when comparing the user-defined requirement in Figure 5 with the past requirement in Figure 3B, the system finds that the values ​​of three items differ from each other. Similarly, when comparing the current requirement with the past requirement in Figure 3C, it finds that the values ​​of four items differ from each other. As a result, the system determines that the past requirement in the table in Figure 3A is the most similar to the user-defined requirement, and in step 406, it fetches the table in Figure 3A as the most similar requirement. Since the requirement in the fetched table and the user requirement are not exactly identical, the process proceeds to step 409, and, according to the example, creates a message with content as shown in Figure 6.

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

[0026] Figure 7 shows an example of a message generated by the generation AI module according to an embodiment. In step 410 of Figure 4, the message 700 received by the system from the generation AI includes the API endpoint 702 and the 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 creation database.

[0027] Figure 8 is a flowchart of a generalized process for using an API source code generation system according to one embodiment. In the embodiment, process 800 starts in step 802, when the API source code generation system receives a user request associated with an API type. In response, in step 804, the system retrieves a template from the template database, in step 806, it delivers the template to the user, and in step 808, it retrieves user-defined requirements.

[0028] In step 810, the system retrieves historical requirements associated with user-defined requirements from the API creation database and also 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 source code to the generating AI model to request 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, API source code, or endpoint name in the API code creation database. A person skilled in the art will recognize that (1) certain steps may be performed arbitrarily, (2) the steps are not limited to the specific order specified herein, (3) certain steps may be performed in a different order, and (4) certain steps may be performed simultaneously.

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

[0031] Computer 905 can be communicatively connected 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 may include any physical or virtual devices, components, sensors, or interfaces that can be used to provide input (e.g., buttons, touchscreen interfaces, keyboards, pointer / cursor controls, microphones, cameras, Braille, motion sensors, optical readers, and / or similar). The output device / interface 940 may include displays, televisions, monitors, printers, speakers, Braille, and the like. In some embodiments, the input / user interface 935 and the output device / interface 940 may be embedded in or physically connected to computer 905. In other embodiments, another computer may function as or provide the functions of the input / user interface 935 and the output device / interface 940 of computer 905.

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

[0033] Computer 905 can, for example, communicate with external storage 945 via I / O interface 925, and can also connect to network 950 to communicate with any number of network-connected components, devices, and systems, including one or more computers of the same or different configurations. Computer 905 or any connected computer may provide, function as, or be referred to as, a server, client, thin server, general-purpose machine, special-purpose machine, or a service of another label.

[0034] The 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 protocol, etc.) for communicating information with at least all connected components, devices, and networks within the computing environment 900. The network 950 may be any network or combination of networks (e.g., the Internet, local area network, wide area network, telephone network, cellular network, satellite network, etc.).

[0035] Computer 905 may use and / or use computer-usable media or computer-readable media, including transient media and non-transient media, to communicate. Transient media include transmission media (e.g., metal cables, optical fibers), signals, carrier waves, etc. Non-transient media include magnetic media (disks, tapes, etc.), optical media (CD-ROMs, digital video discs, Blu-ray discs, etc.), solid-state media (RAM, ROMs, flash memory, solid-state storage, etc.), and other non-volatile storage or memory.

[0036] Computer 905 can be used to implement techniques, methods, applications, processes, or computer executable instructions in several exemplary computing environments. Computer executable instructions may be obtained from transient media, stored in non-transient media, and retrieved from non-transient media. Executable instructions may originate from one or more of any programming languages, scripting languages, and machine languages ​​(e.g., C, C++, C#, Java (Java is a registered trademark), Visual Basic, Python, Perl, JavaScript, and others).

[0037] One or more processors 910 can run under any operating system (OS) (not shown) in a native or virtual environment. One or more applications can be deployed, including logical units 960, application programming interface (API) units 965, input units 970, output units 975, and inter-unit communication mechanisms 995 for different units to communicate with each other, the OS, and other applications (not shown). The described units and elements can take various forms in design, function, configuration, or implementation, and are not limited to the description provided. The processor 910 can take 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 execution instructions are received by the API unit 965, they may be communicated to one or more other units (e.g., a logic unit 960, an input unit 970, and an output unit 975). In some embodiments, the logic unit 960 may be configured to control the flow of information between units and to direct the services provided by the API unit 965, the input unit 970, and the output unit 975, as described in some embodiments above. For example, one or more processes or implementation flows may be controlled by the logic unit 960 alone or in conjunction with the API unit 965. The input unit 970 may be configured to obtain input for the calculations described in the embodiments, and the output unit 975 may be configured to provide outputs based on the calculations described in the embodiments.

[0039] The processor 910 may be configured to execute a method or computer instruction that, in response to receiving a user request associated with an API type, as shown in Figures 1, 4, and 8, retrieves a template from a template database, provides the template to the user to retrieve user-defined requirements, uses the user-defined requirements to retrieve historical requirements associated with the user-defined requirements and associated with source code from an API code generation database, communicates the API endpoint to the user in response that the historical requirements are identical to the user-defined requirements, provides the user-defined requirements and source code to a generating AI model to request API source code in response that the historical requirements are not identical to the user-defined requirements, and communicates the endpoint name to the user in response to receiving the API source code and endpoint name.

[0040] Some parts of this specification are presented in terms of symbolic representations of algorithms and computer operations. These algorithmic descriptions and symbolic representations are means used by those skilled in the art of data processing technology to convey the essence of the innovations of that technology. An algorithm is a set of defined steps that lead to a desired final state or result. In the examples, the steps performed require a specific amount of physical operation to achieve the specific result.

[0041] Unless otherwise explicitly stated, it is understood that throughout this specification, discussions using terms such as “processing,” “operation,” “calculation,” “determination,” and “display” may include the operations and processes of a computer system or other information processing device that manipulate and convert data represented as physical (electronic) quantities in the registers and memory of the computer system into other data similarly represented as physical quantities in the memory, registers, or other information storage devices, transmitters, or display devices of the computer system.

[0042] The embodiments may relate to an apparatus for performing the operations described herein. This apparatus may be specifically configured for a particular purpose and may include one or more general-purpose computers that are selectively started or reconfigured by one or more computer programs. Such computer programs may be stored on computer-readable media, such as computer-readable storage media or computer-readable signal media. 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-transient medium suitable for storing electronic information. Computer-readable signal media may include media such as carrier waves. The algorithms and representations presented herein are not inherently related to any particular computer or other apparatus. Computer programs may include pure software containing instructions for performing the operations of a desired implementation.

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

[0044] As is known in the art, the operations described above can be performed by hardware, software, or any combination of software and hardware. Various embodiments of the embodiment can be implemented using circuits and logic devices (hardware), while other embodiments, when performed by a processor, can be implemented using instructions stored on a computer-readable medium (software) that cause the processor to perform the method of this embodiment. Furthermore, some embodiments of this specification can be performed by hardware alone, while others can be performed by software alone. Moreover, the various functions described can be performed by a single unit or distributed across numerous components in any number of ways. When performed by software, the method can be performed 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] Furthermore, other embodiments will be apparent to those skilled in the art from the considerations herein and the practice of the art disclosed herein. Various aspects and / or components of the embodiments described herein can be used individually or in any combination. The description herein and the embodiments are intended to be for illustrative purposes only, and the true scope and spirit of the application are indicated by the claims.

Claims

1. A method for generating source code, The processor, In response to receiving a user request associated with an API type, retrieve a template from the template database. The aforementioned template is provided to the user, and the user-defined requirements entered into the template by the user are obtained. From the API code creation database, which stores historical requirements that are requirements for previously generated data acquisition APIs, source code generated based on the historical requirements, and API endpoints corresponding to the historical requirements, retrieve historical requirements similar to the user-defined requirements and source code generated based on the historical requirements. The aforementioned processor further, In response to the fact that the history requirement is the same as the user-defined requirement, the API endpoint is communicated to the user. In response to the fact that the historical requirements are not identical to the user-defined requirements, the source code generated based on the user-defined requirements and the historical requirements is provided to the generating AI model to request API source code. A method comprising, in response to receiving the API source code and endpoint name, communicating the endpoint name to the user.

2. The method according to claim 1, A method further comprising the processor registering the user-defined requirements, the API source code, or the API endpoint in the API code creation database.

3. The method according to claim 1, A method wherein the API type is a data acquisition API, and the API endpoint is a functional API endpoint.

4. A system for generating source code, A template database that stores templates provided to users to obtain user-defined requirements, and An API code creation database that stores historical requirements, which are requirements for previously generated data acquisition APIs, source code generated based on the historical requirements, and API endpoints corresponding to the historical requirements. Includes a processor, The aforementioned processor, In response to receiving a user request associated with an API type, retrieve a template from the template database. The aforementioned template is provided to the user, and the user-defined requirements entered into the template by the user are obtained. From the API code creation database, retrieve historical requirements similar to the user-defined requirements and source code generated based on those historical requirements. In response to the fact that the history requirement is the same as the user-defined requirement, the API endpoint is communicated to the user. In response to the fact that the historical requirements are not identical to the user-defined requirements, the source code generated based on the user-defined requirements and the historical requirements is provided to the generating AI model to request API source code. A system that, in response to receiving the API source code and endpoint name, communicates the endpoint name to the user.

5. The system according to claim 4, The API code creation database is a system for registering the user-defined requirements, the API source code, or the API endpoint.

6. The system according to claim 4, A system in which the API type is a data acquisition API and the API endpoint is a functional API endpoint.

7. A non-transient computer-readable medium for storing instructions that cause a computer system to perform processing, The aforementioned process is, In response to receiving a user request associated with an API type, retrieve a template from the template database. The aforementioned template is provided to the user, and the user-defined requirements entered into the template by the user are obtained. From the API code creation database, which stores historical requirements that are requirements for previously generated data acquisition APIs, source code generated based on the historical requirements, and API endpoints corresponding to the historical requirements, retrieve historical requirements similar to the user-defined requirements and source code generated based on the historical requirements. In response to the fact that the history requirement is the same as the user-defined requirement, the API endpoint is communicated to the user. In response to the fact that the historical requirements are not identical to the user-defined requirements, the source code generated based on the user-defined requirements and the historical requirements is provided to the generating AI model to request API source code. A computer-readable medium that, in response to receiving the API source code and endpoint name, transmits the endpoint name to the user.

8. A computer-readable medium according to claim 7, The process further includes registering the user-defined requirements, the API source code, or the API endpoint in the API code creation database, in a computer-readable medium.

9. A computer-readable medium according to claim 7, A computer-readable medium in which the API type is a data acquisition API and the API endpoint is a functional API endpoint.

Images