JP2019016352A - Application program interface mash-up generation - Google Patents

Abstract

To provide a method for generating an application program interface (API) mash-up.SOLUTION: A method includes: a step of grouping a plurality of API into a plurality of sub-clusters on the basis of at least one keyword as for each of the plurality of API; a step of specifying a plurality of keyword combinations as for the plurality of sub-clusters on the basis of two or more keywords as for the plurality of sub-clusters and real world data; a step of determining a plurality of possible API mash-ups including two or more API among the plurality of API as for the plurality of keyword combinations; and a step of processing the plurality of possible API mash-ups, and generating at least one priority-given API mash-up associated with at least one keyword combination among the plurality of keyword combinations among the plurality of possible API mash-ups.SELECTED DRAWING: Figure 2

Description

  Embodiments described in this disclosure relate to application program interface (API) mashup generation.

  An application program interface (API) is a set of protocols, commands, definitions, and tools for creating application software. APIs specify how software components should interact and how APIs are used when programming graphical user interface (GUI) components or implementing services or functions be able to. API mashups are multiple APIs that work together to provide new or value-added services.

  The claimed subject matter in this application is not limited to embodiments that solve any disadvantages or that operate only in environments such as those described above. Rather, this background description is provided merely to illustrate one exemplary technology area in which some embodiments described in the present disclosure may be implemented.

  According to an aspect of an embodiment, a method may include grouping a plurality of APIs into a plurality of sub-clusters based on at least one keyword for each API of the plurality of APIs. The method may also include identifying a plurality of keyword combinations for the plurality of sub-clusters based on two or more keywords for the plurality of sub-clusters and real world data. Further, the method may include determining a plurality of possible API mashups that include two or more APIs of the plurality of APIs for the plurality of keyword combinations. The method also processes the plurality of possible API mashups and, among the plurality of possible API mashups, at least one priority associated with at least one keyword combination of the plurality of keyword combinations. Generating a refined API mashup may be included.

  The objects and advantages of the embodiments will be realized and attained by at least the elements, features, and combinations particularly pointed out in the claims.

  Both the foregoing general description and the following detailed description are exemplary and explanatory and are not restrictive of the claimed invention.

Exemplary embodiments will be described and explained with more specificity and detail through the use of the accompanying drawings in which:
1 is a block diagram of an exemplary system that includes an API mashup generator. FIG. 3 is a flow diagram of an example method for generating one or more API mashups. FIG. 3 illustrates an exemplary API tree structure. FIG. 4 illustrates another example API tree structure. FIG. 3 illustrates an example system that includes a named entity extraction tool. FIG. 4 is an example flow diagram that may be used to generate and process one or more API mashups. FIG. 3 illustrates an example API that includes an endpoint, an input description, an output description, and an endpoint description. FIG. 4 is an exemplary flow diagram of a method for processing one or more API mashups. FIG. 4 is an exemplary flow diagram of another method of processing one or more API mashups. FIG. 4 is an exemplary flow diagram of yet another method of processing one or more API mashups. The figure which shows an example learning algorithm. The figure which shows an example learning algorithm. FIG. 3 illustrates an example system that includes a processing tool for generating one or more keyword combinations. 1 is a block diagram of an exemplary computing system.

  Various embodiments disclosed in this application relate to application program interface (API) mashup generation. In some embodiments, API mashups can be automatically identified and / or generated based on real-world data via text mining techniques and / or natural language processing techniques. In accordance with various embodiments, API mashups can include word embedding (eg, character and / or sentence-based word embedding) and / or proper expression extraction (eg, a combination of different data sets for proper expression extraction). ) Based on and / or generated.

  Further, some embodiments further generate scrutinized (eg, prioritized) API mashups (eg, filter, recommend, rank, and / or identify valid API mashups). ) May be related to processing. Further, the scrutinized API mashup can be provided to one or more application developers. More specifically, in some embodiments, the identified (eg, generated) API mashup is, for example, one or more most suitable API mashups recommended (eg, at high priority). As can be done, it can be filtered, tested and / or ranked. Some embodiments facilitate the prediction of whether multiple APIs can be used for reasonable API mashups and / or whether APIs can be introduced to increase performance. Online processing.

  According to some embodiments, API mashups can be ranked based on real world data, so application developers can verify the feasibility and usefulness of identified and / or generated API mashups You may not be required to search for API methods to do this. The embodiments disclosed in this application are not limited to any particular use case and can be used to develop applications for any suitable use case.

  Traditionally, due to the vast number of available APIs, identifying the right API to use in an application can be burdensome and require time-consuming manual searches across a diverse set of websites. there were. Furthermore, the information was mainly limited to a single API. Therefore, in order to develop applications by using multiple APIs, developers understand each API by searching and selecting APIs and reviewing the documents, and these APIs can be combined as an API mashup. It was necessary to verify the input and output to determine whether to obtain.

  Embodiments of the present disclosure will be described with reference to the accompanying drawings.

  FIG. 1 is a block diagram of an exemplary API mashup generation system 100 that includes an API database 102 and an API mashup generator 104. The API database 102 may include a plurality of APIs (eg, API1-API1n), and in some embodiments may include various API data such as API endpoints, parameters, and descriptions thereof. The API database 102 may include any computer-based source for APIs and / or API data. For example, the API database 102 can include servers, client computers, repositories, and the like. The API database 102 can store API and API data in an arbitrary electronic format. Further, the API data may be readable by a machine and / or human readable. The API data can be in any language. For example, the API data can be in any target human language (eg, English, Japanese, German, etc.). The API can be any structured data format. For example, the API data may be the Open API specification, JavaScript (registered trademark) Object Notation (JavaScript (registered trademark) object notation: JSON), Extensible Markup Language (XML), or the like.

  Each API in the API database 102 includes a primary category keyword (eg, medical), a secondary category keyword (eg, healthcare, business, office, etc.), an API description, and other information related to the API (eg, endpoint) , HTTP methods, parameters, and their descriptions). In some embodiments, API category keywords (eg, primary category keywords and secondary category keywords) and / or API descriptions may be defined by a repository (eg, a public repository such as ProgrammableWeb).

  The API mashup generator 104 may be configured to receive APIs and / or API data from the API database 102 and generate one or more API mashups according to one or more embodiments described in this disclosure. Further, according to some embodiments, the API mashup generator 104 can process one or more API mashups to generate one or more scrutinized API mashups.

  FIG. 2 illustrates an example flow diagram of a method 200 for generating one or more API mashups configured in accordance with at least one embodiment described in this disclosure. Although illustrated in separate blocks, the various blocks may be divided into additional blocks, combined into fewer blocks, or removed depending on the desired implementation. is there.

  In some embodiments, method 200 may be performed by one or more devices, such as system 100 of FIG. 1 and / or system 1300 of FIG. For example, the processor 1310 of FIG. 13 may be configured to execute computer instructions stored in the memory 1330 to perform functions and operations represented by one or more of the blocks of the method 200.

  The method 200 may begin at block 202. At block 202, multiple APIs may be grouped. In some embodiments, multiple APIs may be grouped into categories, clusters, and / or sub-clusters. For example, these APIs that may be received from a database (eg, API database 102 of FIG. 1) and / or various sources (eg, websites) are sent by at least one processor (eg, processor 1310 of FIG. 13) to the API. Can be grouped according to a tree structure (eg, categories, clusters, and sub-clusters, or additional layers / levels). More specifically, for example, the category for an API determines the number of occurrences of any keyword in both the API category field and the primary category field, and ranks and selects keywords based on the number of keyword occurrences (eg, , Machine classification), top keywords (eg, M keywords) can be generated by selecting as a category for the API.

  In addition, a cluster for the API in each category can be generated. In some embodiments, secondary category keywords can be analyzed using text mining techniques and / or natural language processing (NLP) techniques. For example, “stop” words and / or general words may be removed, word stemming operations may be performed, keywords may be counted and ranked based on the number of occurrences, top keywords (Eg, N keywords) may be selected as a cluster.

  In addition, a sub-cluster for the API in each cluster may be generated. In some embodiments, text mining tools and / or text mining techniques and / or NLP tools and / or NLP techniques can be used to analyze API descriptions and similarity scores between selected keywords. Can be calculated and the top keywords (eg, K keywords) can be selected as sub-clusters. More specifically, in some embodiments, APIs are classified into API categories and descriptions using, for example, text mining tools and / or text mining techniques, and / or NLP tools and / or NLP techniques. Based on, it can be grouped into different sub-clusters. For example, “stop” words and / or symbols can be removed, keyword types (eg, nouns, verbs, etc.) can be determined, word stemming operations can be performed, and keywords can be counted and ranked based on the number of occurrences. Similarity scores between keywords (eg, using NLP technology) can be calculated, and top keywords (eg, K keywords) can be selected as sub-clusters. The keyword similarity may be evaluated using any appropriate index (for example, Levenshtein distance, Euclidean distance, Hamming distance, Simhash, Minhash, LSH (Locality-sensitive hashing), etc.).

  In some embodiments, if real-world data is available (eg, from one or more corresponding websites for each category), sub-cluster keyword combinations are identified, eg, via named entity extraction. Sub-cluster keyword combinations may be based on sub-cluster keywords and real-world data when real-world data is available from one or more corresponding websites for each category.

  In other embodiments, if real-world data is not obtainable, the sub-cluster keyword combination may identify all possible sub-cluster keyword combinations of the sub-cluster keyword and / or threshold (eg, 5 occurrences). By specifying a sub-cluster keyword combination having a sub-cluster keyword that has a description appearance count exceeding 10 occurrences and 20 occurrences).

  At block 204, a plurality of sub-cluster keywords may be determined and method 200 may proceed to block 206. More specifically, for example, a plurality of APIs are grouped into a plurality of subclusters based on at least one keyword for each API of the plurality of APIs by at least one processor (for example, the processor 1310 in FIG. 13). Can be Although the method 200 is illustrated as proceeding from block 204 to block 206, the operation of block 206 may be independent of the operation of block 204. For example, block 204 may proceed to block 208.

  Referring to the exemplary tree structure 300 shown in FIG. 3, a first level (eg, top level) 302 may include categories and / or primary category keywords, and a second level 304 may include secondary category keywords. The third level 306 may include keywords (eg, determined through an API description). The third level 306 may include multiple subclusters, each subcluster including a keyword and one or more (eg, multiple) APIs.

  Although tree structure 300 is associated with a healthcare area, the present disclosure is not so limited. Instead, the embodiments described in this disclosure are applicable to any area such as science, finance, business, education, electronic commerce, and the like.

  FIG. 4 shows another exemplary tree structure 400. The structure 400 includes a first level (eg, top level) 402, a second level 404, and a third level 406, where the first level 402 includes categories and / or primary category keywords, and the second level 404 includes Including secondary category keywords, the third level 406 may include keywords (eg, determined through an API description). The third level 406 may include multiple subclusters, each subcluster including a keyword and one or more (eg, multiple) APIs. In some embodiments, APIs (eg, authentication APIs) may be grouped into multiple sub-clusters (eg, in different areas) based on API keywords and descriptions.

  Referring back to the method 200 in FIG. 2, at block 206, real world data (eg, real world questions) may be identified, and the method 200 may proceed to block 208. For example, real world data that may include real world questions may be collected (eg, from the Internet via a web crawler) by at least one processor (eg, processor 1310 of FIG. 13). For example, for healthcare specific areas, patient questions may be extracted from websites such as specialized healthcare related websites. In other examples, for other areas, relevant information may be identified (eg, via an associated web blog) and relevant information may be extracted using a web crawler. For example, in the financial area, data (eg, questions) may be collected from one or more financial investment blogs (eg, Vanguard® blogs).

  At block 208, based on the identified data (eg, real world data) and subcluster keywords, subcluster keyword combinations may be determined, and method 200 may proceed to block 210. As an example, at least one processor (eg, processor 1310 of FIG. 13) may be used to determine subcluster keyword combinations. Further, for example, useful sub-cluster combinations can be determined using named entity extraction techniques. For example, as shown in the exemplary system 500 of FIG. 5, a named entity extraction tool 502 receives data 504 (eg, real world data such as real world questions) and subcluster keywords 506, An output 508 may be generated that includes a list of subcluster keyword combinations.

  In some embodiments, the number of keyword combination occurrences can be used to determine an evaluation of sub-cluster keyword combinations. For example, at least one processor (eg, processor 1310 of FIG. 13) can be used to determine the number of keyword combination occurrences. For example, approximately 50,000 clinical questions can be processed, and approximately 10,000 subcluster keyword combinations can be generated based on these clinical questions. In some embodiments, the number of keyword combination occurrences can be incremented when the collected questions match all keywords for a given combination.

  Based on the API and subcluster keyword combination in each subcluster, one or more possible API mashups that include two or more of the plurality of APIs (eg, at least one processor (eg, FIG. 13 Processor 1310)).

  At block 210, an API mashup may be identified and method 200 may proceed to block 212. For example, an API mashup may be specified by at least one processor (eg, processor 1310 of FIG. 13). More specifically, for a given subcluster keyword combination, all possible API mashups can be identified by selecting an API from each subcluster. In addition, a similarity analysis can be performed for each of the identified possible API mashups to identify the API mashups and rank them as needed.

  The description may be known for each API in the API mashup. An API description may include a shortened summary for a given API, such a summary including API title and keywords, input / output parameters, API description, protocol format, endpoint description, input / output description, etc. It can include, but is not limited to these. Each part of the description can be obtained and aggregated from one or more sources (eg, API related websites). Further, in some embodiments, a word vector for each description may be generated and an average value of similarity scores may be calculated. The similarity analysis may be based on a keyword, a sentence, or both. For example, the similarity analysis may be performed by at least one processor (eg, processor 1310 of FIG. 13).

  More specifically, in some embodiments, the similarity analysis / calculation may be based on an API description. More specifically, the description of each API in the API mashup can be separated into sentences, “stop” words and symbols can be removed, word stemming operations can be performed, and each sentence using NLP technology. Can be converted to a word vector. Further, for example, a Hamming distance between word vectors or other similarity measure can be calculated. As an example, the average similarity score may be equal to (total Hamming distance / total number of calculations).

  As an example, the description of one API (“API1”) includes two statements (eg, API1_s1 and API_s2), and the description of another API (“API2”) includes three statements (eg, API2_s1, API2_s2, and AP2_s3) ), The Hamming distance (Ham (API1_sp, API2_sq)) between all two sentences can be calculated, and the similarity score is (Ham (API1_s1, API2_s1) + Ham (API1_s1, API2_s2) + Ham ( API1_s1, API2_s3) + Ham (API1_s2, API2_s1) + Ham (API1_s2, API2_s2) + Ham (API1_s2, API2_s3)) / 6.

  At block 212, the identified API mashup may be reviewed and the method 200 may proceed to block 214. For example, after an API mashup is identified and / or generated based on an API description similarity analysis, the results are filtered (eg, by at least one processor (eg, processor 1310 of FIG. 13)) and Identified API mashups can be reviewed and / or ranked and API mashups can be recommended. For example, results can be reviewed and / or ranked by comparing identified API mashups with one or more public repositories (eg, API Harmony, Github®, ProgrammableWeb, etc.).

  More specifically, given a determined API mashup, for example, a repository may be searched to attempt to identify the determined API mashup. If the repository identifies the API of the determined API mashup as relevant (eg, as used in the project), that API mashup can be recommended (eg, with high priority). For example, Validic API and Fitbit® API are used in some Github® projects, so API mashups including Validic API and Fitbit® API are recommended with high priority. obtain. As another example, for a given API mashup as input, if relevant information in at least one repository is identified that indicates that the API in the given API mashup is relevant, the API mashup is , (Eg, to application developers) can be recommended with high priority.

  At block 214, the API mashup may be published (eg, recommended) to one or more third parties (eg, application developers). For example, after an API mashup has been identified and ranked as needed, the API mashup can be published to at least one third party (eg, an application developer) (eg, recommendations and / or offers) Can be).

  Changes, additions, or omissions may be made to method 200 without departing from the scope of the present disclosure. For example, the operations of method 200 may be performed in a different order. In addition, the steps and operations described are provided as examples only, and some of these steps and operations may be optional without detracting from the nature of the disclosed embodiments. Or may be combined with fewer steps and actions, and may be extended to additional steps and actions.

  In one contemplated exemplary operation, the sub-cluster keyword combination may include “<security, administration>”. This keyword combination can be obtained from collection and analysis of real world data. In this example, the “security” sub-cluster includes “API_1” that is the first API and “API_2” that is the second API. Further, the “administration” sub-cluster includes “API_3” that is the third API and “API_4” that is the fourth API. Continuing with this example, four possible API mashup combinations (eg, <API_1, API_3>, <API_1, API_4>, <API_2, API_3>, and <API_2, API_4>) may be identified. Furthermore, from the API description, a similarity score for each possible API mashup can be calculated (eg, determined via similarity analysis) to identify the API mashup. According to some examples, the higher the similarity score, the more reasonable the API mashup. In some embodiments, identified API mashups can be ranked and recommended to one or more third parties as needed.

  FIG. 6 is a diagram of an example flow 600 that may be used to generate and process one or more API mashups configured in accordance with at least one embodiment described in this disclosure. Flow 600 may be performed by any suitable system, apparatus, or device. For example, system 100 (FIG. 1), system 1300 (FIG. 13), or one or more of these components can perform one or more of the operations associated with flow 200. In these and other embodiments, program instructions stored on a computer readable medium may be executed to perform one or more of the operations of flow 200.

  In some embodiments, one or more operations in one or more blocks and / or components in flow 600 may be performed via online processing. Further, one or more operations on one or more blocks and / or components in flow 600 may be performed via offline processing. For example, in at least one embodiment, the operations in blocks 602, 604, and 606 and model 608 may be performed via offline processing, and the operations in model 610 and blocks 612 and 614 are performed via online processing. Can be executed.

  At block 604, one or more generated API mashups from the API mashup database 602 are processed to produce one or more scrutinized (eg, prioritized) API mashes in the API mashup database 606. Up can be generated. According to various embodiments, the API mashup database 602 can include one or more API mashups generated via one or more embodiments disclosed in the present application. More specifically, API mashups in API mashup database 602 may be made via one or more operations of method 200 (see FIG. 2) and / or via an API mashup generator (see FIG. 1). Can be generated. In some embodiments, the API mashup database 602 is by way of example only and API mashups generated for different domains such as medical, healthcare, business, office, science, e-commerce, etc. (eg, domain specific API mashup).

  For example, one or more API mashups in the API mashup database 602 may be processed, for example, input / output verification, API testing, and / or data format / unit compatibility verification, as described in more detail in this disclosure. Filtering, ranking, prioritization, and / or testing to generate one or more scrutinized API mashups in the API mashup database 606. According to various embodiments, API mashup database 606 may further include subcluster keyword combinations in addition to the scrutinized API mashup for each subcluster keyword combination.

  According to various embodiments, processing operations (eg, at block 604) may be performed alone or in combination to filter and / or rank API mashups. For example, such processing operations can be performed sequentially or in parallel. In some embodiments, API mashups that successfully pass one or more operations (eg, filtering, testing, etc.) are prioritized as high priority API mashups and / or valid API mashups. In at least some embodiments, it may be ranked based on the weight assigned to each action (eg, filtering, testing, etc.). In some embodiments, API mashups may be prioritized as low priority API mashups and / or invalid API mashups. Further, in some embodiments, similarity scores can be considered (eg, to deal with collateral between API mashups).

  FIG. 7 shows an exemplary API 700 in JSON format that includes an endpoint 702, an output description 704, an input description 706, and an endpoint description 708. To parse the description, according to some embodiments, input descriptions and / or output descriptions for different endpoints may be gathered together for each API. In this example, the collected descriptions may be considered API level input descriptions and / or output descriptions. In order to parse the description, according to other embodiments, the input description and / or output description for each API endpoint may be considered separately. In this example, the description may include an API endpoint level input description and / or an output description.

  For example, for input / output matching, for generated API mashups (eg, API_1, API_2), API mashup input / output descriptions can be identified and / or verified, and similarity scores can be calculated. For example, for an API mashup, if the similarity score is relatively high, either between API_1 input and API_2 output or between API_1 output and API_2 input, this API mashup is It can be designated as a high priority API mashup and / or can be recommended (eg, to a developer).

  According to some embodiments, a similarity score between two different APIs (eg, API1 and API2) can be calculated. As an example, API1 (input description) -API2 (output description) can be used to calculate a similarity score. As another example, API1 (output description) -API2 (input description) can be used to calculate a similarity score. In some embodiments, if the input description or output description of an API is “null” (eg, if the description for a given API is not included in the API database block 102), this The description cannot be involved in the calculation.

  Furthermore, in some embodiments, the similarity analysis / calculation may be based on a description of the API. More specifically, the description of each API in the API mashup can be separated into sentences, “stop” words and / or symbols can be removed, word stemming operations can be performed, using NLP techniques, Each sentence can be converted to a word vector. Further, for example, a Hamming distance between word vectors or other similarity measure can be calculated. As an example, the average similarity score may be equal to (total Hamming distance / total number of calculations).

  As an example, the description of one API (“API1”) includes two statements (eg, API1_s1 and API_s2), and the description of another API (“API2”) includes three statements (eg, API2_s1, API2_s2, and AP2_s3) ), The Hamming distance (Ham (API1_sp, API2_sq)) between all two sentences can be calculated, and the similarity score is (Ham (API1_s1, API2_s1) + Ham (API1_s1, API2_s2) + Ham ( API1_s1, API2_s3) + Ham (API1_s2, API2_s1) + Ham (API1_s2, API2_s2) + Ham (API1_s2, API2_s3)) / 6.

  In some embodiments, a similarity score can be calculated between two different API / endpoints (eg, API1 / endpoint_x and API2 / endpoint_y). In one example, API1 / endpoint_x (input description) -API2 / endpoint_y (output description) may be used to calculate a similarity score. In another example, API1 / endpoint_x (output description) -API2 / endpoint_y (input description) may be used to calculate a similarity score. In some embodiments, if the API / endpoint input description or output description is “null” (eg, the API database block 102 does not include a description for the endpoint of a given API). ), This description cannot be involved in the calculation.

  FIG. 8 is an illustration of a method 800 for processing (eg, filtering, ranking, and / or prioritizing) one or more API mashups configured in accordance with at least one embodiment described in this disclosure. A simple flow diagram is shown. Although illustrated in separate blocks, the various blocks may be divided into additional blocks, combined into fewer blocks, or removed depending on the desired implementation. is there. For example, the method 800 may be performed at block 604 of FIG.

  In some embodiments, the method 800 may be performed by one or more devices and / or systems, such as the system 100 of FIG. 1 and / or the system 1300 of FIG. For example, the processor 1310 of FIG. 13 may be configured to execute computer instructions stored in the memory 1330 to perform functions and operations represented by one or more of the blocks of the method 800.

  At block 802, the input description and / or output description for the API combination of the API mashup may be parsed and the method 800 may proceed to block 804. More specifically, for example, for API combinations (for example, API_1, API_2) of API mashup, the input description and output description of API_1 and API_2 can be analyzed. For example, the processor 1310 of FIG. 13 may parse the input description and / or output description for the API mashup API combination.

  At block 804, a similarity score between the output description of the first API of the API mashup and the input description of the second API of the API mashup may be determined, and the method 800 may proceed to block 806. More specifically, for example, the similarity score between the output description of API_1 and the input description of API_2 can be determined. For example, the processor 1310 of FIG. 13 may determine a similarity score between the output description of the first API of the API mashup and the input description of the second API of the API mashup.

  At block 806, it can be determined whether the determined similarity score is greater than a threshold. For example, the processor 1310 of FIG. 13 may compare the determined similarity score with a threshold value to determine whether the determined similarity score is greater than the threshold value. If the determined similarity score is greater than the threshold, method 800 may proceed to block 808. If the determined similarity score is less than or equal to the threshold, the method 800 may proceed to block 810.

  At block 808, the API mashup may be designated as a high priority mashup. For example, an API mashup may be designated (eg, prioritized) by the processor 1310 of FIG. 13 as a high priority mashup.

  At block 810, it may be determined whether each possible API combination for API mashup has been evaluated. For example, for an API mashup that includes API_1 and API_2, it may be determined whether both API_1-> API_2 and API_2-> API_1 have been evaluated. More specifically, whether the similarity score between the output description of API_1 and the input description of API_2 was evaluated, and whether the similarity score between the output description of API_2 and the input description of API_1 was evaluated. Can be determined. If each possible API combination for an API mashup is evaluated, the method 800 may proceed to block 812, where the API mashup may be designated as a low priority mashup (eg, prioritization). Can be). For example, determining whether each possible API combination for an API mashup has been evaluated can be performed by the processor 1310 of FIG. If each of the possible API combinations for the API mashup has not been evaluated, the method 800 may return to block 802, where another API combination may be identified.

  Changes, additions, or omissions may be made to method 800 without departing from the scope of the present disclosure. For example, the operations of method 800 may be performed in a different order. In addition, the steps and operations described are provided as examples only, and some of these steps and operations may be optional without detracting from the nature of the disclosed embodiments. Or may be combined with fewer steps and actions, and may be extended to additional steps and actions.

  FIG. 9 is an illustration of another method 900 for processing (eg, filtering, ranking, and / or prioritizing) one or more API mashups configured in accordance with at least one embodiment described in this disclosure. An exemplary flow diagram is shown. Although illustrated in separate blocks, the various blocks may be divided into additional blocks, combined into fewer blocks, or removed depending on the desired implementation. is there. For example, the method 900 may be performed at block 604 of FIG.

  In some embodiments, method 900 may be performed by one or more devices and / or systems, such as system 100 of FIG. 1 and / or system 1300 of FIG. For example, the processor 1310 of FIG. 13 may be configured to execute computer instructions stored in the memory 1330 to perform functions and operations represented by one or more of the blocks of the method 900.

  With respect to API testing, for a given API mashup (eg, in database 602 of FIG. 6), automatic API testing can be used to prioritize API mashups and / or API mashups are valid It can be verified whether or not. If the API mashup passes automatic API testing, the API mashup can be designated as a high priority mashup and / or recommended to the application developer. If the API mashup does not pass the automatic API test, the API mashup can be designated as a low priority mashup.

  At block 902, inputs and / or outputs for API combinations of the API mashup may be analyzed and the method 900 may proceed to block 904. More specifically, for example, for API combinations (for example, API_1, API_2) of API mashup, the input and output (for example, type, description, etc.) of each API can be analyzed. As an example, for a weather API, the input may include a city name or zip code (zip code) and the output may include temperature. For example, the inputs and / or outputs for the API mashup API combinations may be analyzed by the processor 1310 of FIG.

  At block 904, input for the API combination may be generated and the method 900 may proceed to block 906. More specifically, an input for an API may be generated that may be used for testing based on, for example, the semantic type and / or input type of the API combination. As an example, for a weather API, a city name (eg, Sunnyvale) or a zip code (eg, 94085) can be automatically generated from the knowledge base. For example, the input for the API may be generated by the processor 1310 of FIG.

  At block 906, it can be determined whether the API combination can produce a valid output. For example, a determination of whether an API combination can produce a valid output can be performed by the processor 1310 of FIG. If it is determined that the API combination can produce a valid (eg, correct) output, the method 900 may proceed to block 908 where the API mashup may be designated as a high priority mashup ( For example, it can be prioritized). If it is determined that the API combination cannot produce a valid output, the method 900 may proceed to block 910.

  At block 910, it may be determined whether each possible API combination for API mashup has been evaluated. For example, for an API mashup that includes API_1 and API_2, it may be determined whether both API_1-> API_2 and API_2-> API_1 have been evaluated. If each possible API combination for an API mashup has been evaluated, the method 900 can proceed to block 912 where the API mashup can be designated as a low priority mashup (eg, prioritization). Can be). For example, the determination of whether each possible API combination for API mashup has been evaluated can be performed by the processor 1310 of FIG. If each of the possible API combinations for the API mashup has not been evaluated, the method 900 can return to block 902, where another API combination can be identified.

  Changes, additions, or omissions may be made to method 900 without departing from the scope of the present disclosure. For example, the operations of method 900 may be performed in a different order. In addition, the steps and operations described are provided as examples only, and some of these steps and operations may be optional without detracting from the nature of the disclosed embodiments. Or may be combined with fewer steps and actions, and may be extended to additional steps and actions.

  FIG. 10 is an illustration of yet another method 1000 for processing (eg, filtering, ranking, and / or reviewing) one or more API mashups configured in accordance with at least one embodiment described in this disclosure. Shows a typical flow diagram. Although illustrated in separate blocks, the various blocks may be divided into additional blocks, combined into fewer blocks, or removed depending on the desired implementation. is there. For example, the method 1000 may be performed at block 604 of FIG.

  In some embodiments, method 1000 may be performed by one or more devices and / or systems, such as system 100 of FIG. 1 and / or system 1300 of FIG. For example, the processor 1310 of FIG. 13 may be configured to execute computer instructions stored in the memory 1330 to perform functions and operations represented by one or more of the blocks of the method 1000.

  For a given API mashup (eg, in database 602 of FIG. 6), the input / output data format can be analyzed to verify whether the API mashup is valid. If the API mashup has a matching input / output data format, or in the knowledge graph, link between input parameters and output parameters (eg, data format (eg, convert from XML format to JSON format) An API mashup can be designated as a high priority mashup (eg, priority) if there is a conversion or a relationship involving a data unit conversion (eg, converting a unit of temperature from Celsius to Fahrenheit). And / or recommended to application developers.

  In some embodiments, there may be multiple output parameters and input parameters. According to some embodiments, as long as there is a match between the output data format / unit of one API and the input data format / unit of another API, the API mashup has a compatible data format. In particular, API mashups can be designated as high priority mashups (eg, can be prioritized) and / or recommended to application developers.

  At block 1002, the input and / or output for each API in the API combination of the API mashup may be analyzed and the method 1000 may proceed to block 1004. More specifically, for example, the input and output (eg, type, description, etc.) of API_1 and API_2 can be analyzed for an API combination (eg, API_1, API_2) of the API mashup. For example, the inputs and / or outputs for the API mashup API combinations may be analyzed by the processor 1310 of FIG.

  At block 1004, it may be determined whether the output of one API of the API combination has the same data format and / or unit as the input of another API of the API combination. More specifically, for example, based on the semantic type and / or input / output type of an API in the API combination, the output of one API of the API combination has the same data format and / or the input of another API of the API combination Or it can be determined whether it has units. For example, the determination of whether the output of one API of an API combination has the same data format and / or unit as the input of another API of the API combination may be performed by the processor 1310 of FIG.

  If the output of one API of the API combination has the same data format and / or unit as the input of another API of the API combination, the method 1000 may proceed to block 1006, where the API mashup is high priority. It can be designated as a degree mashup (eg, can be prioritized). If the output of one API of the API combination does not have the same data format and / or unit as the input of another API of the API combination, the method 1000 may proceed to block 1008.

  At block 1008, for data format / unit conversion, it can be determined whether a link exists between the input parameter and the output parameter in the knowledge graph. For example, for data format / unit conversion, determination of whether a link exists between an input parameter and an output parameter in a knowledge graph may be performed by the processor 1310 of FIG. For data format / unit conversion, if it is determined in the knowledge graph that a link exists between the input parameter and the output parameter, the method 1000 may proceed to block 1006 where the API mashup is a high priority. As a mashup (e.g., can be prioritized). For data format / unit conversion, if it is determined in the knowledge graph that there is no link between the input parameter and the output parameter, the method 1000 may proceed to block 1010.

  At block 1010, it may be determined whether each possible API combination for API mashup has been evaluated. For example, for an API mashup that includes API_1 and API_2, it may be determined whether both API_1-> API_2 and API_2-> API_1 have been evaluated. If each of the possible API combinations for an API mashup has been evaluated, the method 1000 can proceed to block 1012 where the API mashup can be designated as an invalid mashup (eg, can be prioritized). ). For example, the determination of whether each possible API combination for API mashup has been evaluated can be performed by the processor 1310 of FIG. If each of the possible API combinations for the API mashup has not been evaluated, the method 1000 can return to block 1002 where another API combination can be identified.

  Changes, additions, or omissions may be made to method 1000 without departing from the scope of the present disclosure. For example, the operations of method 1000 may be performed in a different order. In addition, the steps and operations described are provided as examples only, and some of these steps and operations may be optional without detracting from the nature of the disclosed embodiments. Or may be combined with fewer steps and actions, and may be extended to additional steps and actions.

  Referring back to FIG. 6, the API mashup database 606 (eg, including sub-cluster keyword combinations and API mashups for each combination) has been filtered and / or scrutinized, but in some embodiments, Not all API mashups and / or keyword combinations may be evaluated (eg, via offline processing). Accordingly, various embodiments of the present disclosure use one or more learning models (e.g., machine learning models and / or deep learning models) to allow some APIs to be valid API mashups, Predicting whether they can be combined and used.

  For example, in some embodiments, at least one model can include a training model 608 and at least one other model can include a test module 610. Although model 608 and model 610 are illustrated as two models, model 608 and model 610 may be the same machine learning model or deep learning model. According to some embodiments, one or more models can include information about API mashup features such as title, category, primary category, secondary category, link, description, protocol format, etc. (eg, specification information about each API). ). Further, one or more machine learning algorithms such as, for example, CNN (two layers as an example; see FIG. 11A) and / or LSTM (eight nodes as an example; see FIG. 11B) and / or Or a deep learning algorithm may be used.

  In some embodiments, one or more training data sets that may include data from the API mashup database 606 may be received by the training model 608. Further, feedback from developer 616 (eg, a developer's API mashup selection (eg, preferred or disliked) can be received in model 608 and such feedback can be used to generate training model 608. For different machine learning or deep learning algorithms, model training can be prioritized at block 606, only valid API mashup data sets, or valid API mashup data sets and valid You may need both, but not API mashup datasets.

  At block 612, the request (eg, from a third party such as developer 616) may be processed. For example, as shown in flow 600, request processing can include requests from developers 616 (also referred to as “queries” in this disclosure) (eg, natural language descriptions of service requests) and / or API mashups. Based on one or more inputs such as one or more API mashups and / or subcluster keywords from database 606. Further, an output that can include one or more keyword combinations can be generated in response to the request processing. In the exemplary system 1200 of FIG. 12, a request processing tool 1202 receives one or more inputs (eg, request 1204 and subcluster keywords 1206) and generates an output 1208 that can include one or more keyword combinations. obtain.

  Further, in some embodiments, at block 614 of FIG. 6, the generated keyword combination (eg, at block 612) is compared with the keyword combination of database 606 and generated (eg, from a query). It can be determined whether there is a match between the keyword combination and the keyword combination in the database 606. If there is a match, an associated API mashup from database 606 can be provided to developer 616. If there is no match, for each keyword in the keyword combination, an associated API (eg, from block 606) may be identified and all possible API combinations for the identified API may be identified.

  Further, each of the API combinations can be communicated to the model 610, and the model 610 trained based on the machine learning algorithm or deep learning algorithm and the existing API mashup data set in block 606 can receive the appropriate API. An output such as a label (eg, “1” or “0”) can be generated that can represent whether it can be combined as an API mashup. For example, if the label is 1, the API mashup can be designated as a high priority mashup (eg, can be prioritized) and / or provided to the developer 616 as a valid API mashup. obtain. Further, for example, if the label is 0, the API mashup can be designated as a low priority mashup (eg, can be prioritized).

  Further, according to some embodiments, depending on the recommended API mashup, developer 616 can choose whether developer 616 likes or dislikes this API mashup. This selection may be provided as feedback to the learning model to update and / or refine the learning model (eg, in model 608).

  In some embodiments, the API mashup was originally labeled 1 (eg, via test model 608) (eg, was a valid / high priority API mashup) If multiple developers (eg, a large number of developers) do not like this API mashup, the API mashup can be relabeled with “0”. In some embodiments, the API mashup was originally labeled 0 (eg, it was an invalid / low priority API mashup), but multiple developers (eg, multiple developments) If this person prefers this API mashup, the API mashup can be relabeled with “1”.

  Further, according to some embodiments, an arbitrary data set (eg, a new data set) can be used to retrain the learning model. Further, in some embodiments, the model 608 that can be trained (eg, using information from the database 606 and / or feedback from the developer 616) is an API mashup where the model 610 is valid for the received API. Model 610 can be updated to allow a more accurate prediction of whether they can be combined as

  FIG. 13 is a block diagram of an exemplary computing system 1300 in accordance with at least one embodiment of the present disclosure. For example, system 100 (see FIG. 1), system 500 (see FIG. 5), system 1200 (see FIG. 12), or one or more of these components may be implemented as computing system 1300. The computing system 1300 is a desktop computer, laptop computer, server computer, tablet computer, mobile phone, smartphone, personal digital assistant (PDA), electronic reader device, network switch, network router, network hub, other networking device, or Other suitable computing devices may be included.

  Computing system 1300 can include a processor 1310, a storage device 1320, a memory 1330, and a communication device 1340. Processor 1310, storage device 1320, memory 1330, and / or communication device 1340 can all be communicatively connected such that each of these components can communicate with other components. The computing system 1300 can perform any of the operations described in this disclosure.

  In general, processor 1310 may include any suitable dedicated or general purpose computer, computing entity, or processing device including various computer hardware or software modules, stored in any applicable computer readable storage medium. May be configured to execute the instructions being executed. For example, the processor 1310 may interpret and / or execute a microprocessor, microcontroller, digital signal processor (DSP), application specific integrated circuit (ASIC), field programmable gate array (FPGA), or program instructions and / or Or any other digital or analog circuit configured to process data. Although processor 1310 is shown as one processor in FIG. 13, processor 1310 may be any number of processors configured to perform any number of operations described herein individually or collectively. May be included.

  In some embodiments, processor 1310 interprets and / or executes program instructions stored on storage device 1320, memory 1330, or both storage device 1320 and memory 1330, and / or storage device 1320. , Memory 1330, or data stored in both storage device 1320 and memory 1330. In some embodiments, the processor 1310 can fetch program instructions from the storage device 1320 and load the program instructions into the memory 1320. After the program instructions are loaded into the memory 1330, the processor 1310 can execute the program instructions.

  For example, in some embodiments, one or more of the processing operations of the device and / or system (eg, application program, server, etc.) may be included in the storage device 1320 as a program instruction. The processor 1310 may fetch program instructions for one or more of the processing operations and load program instructions for one or more of the processing operations into the memory 1330. After a program instruction for one or more of the processing operations is loaded into memory 1330, processor 1310 may perform an operation associated with the processing operation as directed by the program instruction. Program instructions for one or more of the processing operations can be executed.

  Storage device 1320 and memory 1330 may include computer-readable storage media that carry or store computer-executable instructions or data structures. Such computer-readable storage media may include any available media that can be accessed by a general purpose or special purpose computer such as processor 1310. By way of example, and not limitation, such computer readable storage media may be RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage device, flash memory device (eg, solid state Memory device) or any other storage medium that can be used to carry or store the desired program code in the form of computer-executable instructions or data structures, which can be accessed by a general purpose or special purpose computer It may include a tangible or non-transitory computer readable storage medium including any other storage medium. Combinations of the above may also be included within the scope of computer-readable storage media. Computer-executable instructions may include, for example, instructions and data configured to cause processor 1310 to perform a predetermined operation or group of operations.

  In some embodiments, storage device 1320 and / or memory 1330 may store data associated with an API mashup generation system (eg, API mashup generation system 100 of FIG. 1). For example, the storage device 1320 and / or the memory 1330 may include APIs, API combinations, API information (eg, keywords, parameter descriptions, endpoint descriptions, categories, clusters, sub-clusters, etc.) and / or API mashup generation systems. Any other relevant data can be stored.

  Communication device 1340 may include any device, system, component, or collection of components configured to enable or facilitate communication between computing system 1300 and another electronic device. For example, the communication device 1340 may be a modem, a network card (wireless or wired), an infrared communication device, an optical communication device, a wireless communication device (such as an antenna), and / or a chipset (Bluetooth® device, 802.6 device (eg, , Metropolitan Area Network (MAN)), Wi-Fi® device, WiMAX® device, cellular communication facility, etc.), and / or the like. . The communication device 1340 may include and / or include remote devices with any network, such as a cellular network, Wi-Fi® network, MAN, optical network, etc., to name just a few. May allow data to be exchanged with any other device described in.

  Changes, additions, or omissions may be made to FIG. 13 without departing from the scope of the present disclosure. For example, in some embodiments, computing system 1300 may include more or fewer elements than those shown and described in this disclosure. For example, the computing system 1300 may include an integrated display device, such as a tablet or mobile phone screen, or may be separated from the computing system 1300 and communicatively connected to the computing system 1300, projector, A television or other suitable display device may be included.

  As used in this disclosure, the term “module” or “component” refers to a particular hardware implementation configured to perform the operation of the module or component, and / or, for example, the API mashup generator 104. May refer to software objects or software routines that may be stored in and / or executed by the API mashup generator 104. In some embodiments, the different components and modules described in this disclosure may be implemented as objects or processes (eg, as separate threads) that execute on a computing system. Although some of the systems and methods described in this disclosure are generally described as being implemented by software (stored in and / or executed by system 1300), certain hardware implementations or Combinations of software and specific hardware implementations are possible and contemplated. In this description, a “computing entity” may include any computing system defined in this disclosure, or any module or combination of modules that operates on a computing device, such as system 1300.

  As used in this disclosure, the term “module” or “component” refers to a particular hardware implementation and / or general purpose hardware of a computing system configured to perform the actions of a module or component ( For example, it may refer to a software object or software routine that may be stored on a computer readable medium and / or executed by general purpose hardware (eg, a processing device, etc.) of a computing system. In some embodiments, the different components, modules, engines, and services described in this disclosure may be implemented as objects or processes that execute on the computing system (eg, as separate threads). Although some of the systems and methods described in this disclosure are generally described as being implemented by software (stored in and / or executed by general-purpose hardware), specific hardware Implementations or combinations of software and specific hardware implementations are possible and contemplated. In this description, a “computing entity” may be any computing system as defined earlier in this disclosure, or any module or combination of modules operating on a computing system.

  Terms used in this disclosure and specifically in the claims (eg, the body portion of a claim) are generally intended to be “open” terms (eg, the term “comprising” includes “ Comprising, but not limited to, the term “having to” should be interpreted as “having at least” and the term “including” Should be interpreted as “including but not limited to”, etc.).

  Further, where a particular number of claim statements to be introduced is intended, such intent is explicitly stated in the claim, and if not, such intent exists. do not do. For example, as an aid to understanding, the claims may include the use of introductory phrases such as “at least one” and “one or more” to introduce claim recitations. However, the use of such an introductory phrase means that the introduction of an indefinite article such as “a” or “an” is an introduction of “one or more” or “at least one” in the same claim. Even if a phrase and an indefinite article such as “a” or “an” are included, a particular claim including the introduced claim statement is limited to an embodiment that includes only one such claim statement. (Eg, “a” and / or “an” should be interpreted as meaning “at least one” or “one or more”) . The same is true for the use of definite articles used to introduce claims.

  Further, even if a specific number of claim statements to be introduced is explicitly set forth, such description should be interpreted as meaning at least the number set forth ( For example, those skilled in the art will recognize that a mere description of “two items” without other modifiers means at least two items or two or more items). Further, when a notation similar to “at least one of A, B, and C, etc.” or “one or more of A, B, and C, etc.” is used, generally such a structure is It is intended to include A only, B only, C only, both A and B, both A and C, both B and C, or all of A, B, and C, etc.

  In addition, any disjunction or disjunctive phrase representing two or more selectable terms, whether in the description, the claims, or the drawings, is one of those terms, It should be understood as a combination or the possibility of including all of these terms. For example, the phrase “A or B” should be understood to include the possibilities of “A” or “B” or “A and B”.

  All examples and conditional language set forth in this disclosure are intended for educational purposes to help the reader understand the concepts contributed by the inventor and to facilitate the art. It should be construed as not limited to such specifically described examples and conditions. Although embodiments of the present disclosure have been described in detail, various modifications, substitutions, and alterations to the embodiments are possible without departing from the spirit and scope of the disclosure.

  Regarding the above embodiment, the following additional notes are disclosed.

(Appendix 1)
A method of generating an application program interface (API) mashup,
Grouping, by at least one processor, a plurality of APIs into a plurality of sub-clusters based on at least one keyword for each API of the plurality of APIs;
Identifying, by the at least one processor, a plurality of keyword combinations for the plurality of subclusters based on two or more keywords for the plurality of subclusters and real world data;
Determining, by the at least one processor, a plurality of possible API mashups including two or more APIs of the plurality of APIs for the plurality of keyword combinations;
Processing the plurality of possible API mashups by the at least one processor to at least one of the plurality of possible API mashups associated with at least one keyword combination of the plurality of keyword combinations. Generating two prioritized API mashups;
Including a method.

(Appendix 2)
Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Comparing the input of the first API of the API combination of the API mashup with the output of the second API of the API combination of the API mashup;
Calculating a similarity score between the input of the first API of the API combination and the output of the second API of the API combination;
If the similarity score exceeds a threshold, designating the API mashup as a high priority API mashup;
The method according to appendix 1, comprising:

(Appendix 3)
Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Generating input for API combinations for API mashups;
Determining whether the API mashup produces valid output based on the generated input;
If the generated output is valid, designating the API mashup as a high priority API mashup;
The method according to appendix 1, comprising:

(Appendix 4)
Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Determining whether the output of the first API of the API combination of the API mashup has a data format that matches the data format of the input of the second API of the API combination of the API mashup;
In the knowledge graph, determining whether there is at least one link between the output parameter of the first API and the input parameter of the second API;
When the output of the first API has a data format that matches the data format of the input of the second API, or in the knowledge graph, the output parameters of the first API and the second API Designating the API mashup as a high-priority API mashup in any of the cases where there is at least one link between the input parameters;
The method according to appendix 1, comprising:

(Appendix 5)
Receiving an API mashup request from a third party;
Processing the API mashup request by the at least one processor to identify one or more keyword combinations for the API mashup request;
Comparing, by the at least one processor, the one or more keyword combinations for the API mashup request with the at least one keyword combination for the at least one prioritized API mashup;
The at least one priority in response to the one or more keyword combinations for the API mashup request matching the at least one keyword combination for the at least one prioritized API mashup. Providing the attached API mashup to the third party;
Responsive to the one or more keyword combinations for the API mashup request not matching the at least one keyword combination for the at least one prioritized API mashup;
Communicating the at least one prioritized API mashup to at least one learning model;
Determining whether the at least one prioritized API mashup is a valid API mashup via the at least one learning model;
Providing the at least one prioritized API mashup to the third party in response to determining that the at least one prioritized API mashup is a valid API mashup; When,
The method according to appendix 1, further comprising:

(Appendix 6)
Receiving feedback from the third party regarding the at least one prioritized API mashup;
Updating the at least one learning model based on the feedback from the third party;
The method according to appendix 5, further comprising:

(Appendix 7)
The method of claim 1, further comprising: providing the at least one prioritized API mashup to a third party.

(Appendix 8)
One or more non-transitory computer readable media containing instructions, the instructions performing a plurality of operations on the one or more processing systems when executed by the one or more processing systems And the plurality of operations are configured as follows:
Grouping a plurality of APIs into a plurality of sub-clusters based on at least one keyword for each API of the plurality of APIs;
Identifying a plurality of keyword combinations for the plurality of sub-clusters based on two or more keywords for the plurality of sub-clusters and real world data;
Determining a plurality of possible API mashups including two or more of the plurality of APIs for the plurality of keyword combinations;
Processing the plurality of possible API mashups and, out of the plurality of possible API mashups, at least one prioritized API associated with at least one keyword combination of the plurality of keyword combinations. Generating mashups,
A computer-readable medium including:

(Appendix 9)
Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Comparing the input of the first API of the API combination of the API mashup with the output of the second API of the API combination of the API mashup;
Calculating a similarity score between the input of the first API of the API combination and the output of the second API of the API combination;
If the similarity score exceeds a threshold, designating the API mashup as a high priority API mashup;
The computer-readable medium according to appendix 8, comprising:

(Appendix 10)
Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Generating input for API combinations for API mashups;
Determining whether the API mashup produces valid output based on the generated input;
If the generated output is valid, designating the API mashup as a high priority API mashup;
The computer-readable medium according to appendix 8, comprising:

(Appendix 11)
Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Determining whether the output of the first API of the API combination of the API mashup has a data format that matches the data format of the input of the second API of the API combination of the API mashup;
In the knowledge graph, determining whether there is at least one link between the output parameter of the first API and the input parameter of the second API;
When the output of the first API has a data format that matches the data format of the input of the second API, or in the knowledge graph, the output parameters of the first API and the second API Designating the API mashup as a high-priority API mashup in any of the cases where there is at least one link between the input parameters;
The computer-readable medium according to appendix 8, comprising:

(Appendix 12)
The plurality of operations are:
Receiving an API mashup request from a third party;
Processing the API mashup request to identify one or more keyword combinations for the API mashup request;
Comparing the one or more keyword combinations for the API mashup request with the at least one keyword combination for the at least one prioritized API mashup;
The at least one priority in response to the one or more keyword combinations for the API mashup request matching the at least one keyword combination for the at least one prioritized API mashup. Providing the attached API mashup to the third party;
Responsive to the one or more keyword combinations for the API mashup request not matching the at least one keyword combination for the at least one prioritized API mashup;
Communicating the at least one prioritized API mashup to at least one learning model;
Determining whether the at least one prioritized API mashup is a valid API mashup via the at least one learning model;
Providing the third party with the at least one prioritized API mashup in response to determining that the at least one prioritized API mashup is a valid API mashup; When,
The computer-readable medium according to claim 8, further comprising:

(Appendix 13)
The plurality of operations are:
Receiving the feedback from the third party regarding the at least one prioritized API mashup;
Updating the at least one learning model based on the feedback from the third party;
The computer-readable medium according to claim 12, further comprising:

(Appendix 14)
The plurality of operations are:
The computer-readable medium of clause 8, further comprising: providing the third party with the at least one prioritized API mashup.

(Appendix 15)
Grouping a plurality of APIs into a plurality of sub-clusters based on at least one keyword for each API of the plurality of APIs;
Identifying a plurality of keyword combinations for the plurality of sub-clusters based on two or more keywords for the plurality of sub-clusters and real world data;
Determining a plurality of possible API mashups including two or more of the plurality of APIs for the plurality of keyword combinations;
Processing the plurality of possible API mashups and, out of the plurality of possible API mashups, at least one prioritized API associated with at least one keyword combination of the plurality of keyword combinations. Generating mashups,
A system having one or more processors configured to execute.

(Appendix 16)
For each API combination of each of the plurality of possible API mashups, the one or more processors are:
Comparing the input of the first API of the API combination of the API mashup with the output of the second API of the API combination of the API mashup;
Calculating a similarity score between the input of the first API of the API combination and the output of the second API of the API combination;
When the similarity score exceeds a threshold, the API mashup is designated as a high priority API mashup;
The system of claim 15, wherein the system is further configured to perform.

(Appendix 17)
For each API combination of each of the plurality of possible API mashups, the one or more processors are:
An action to generate input for API combinations in API mashups;
Determining whether the API mashup generates valid output based on the generated input;
If the generated output is valid, the API mashup is designated as a high priority API mashup;
The system of claim 15, wherein the system is further configured to perform.

(Appendix 18)
For each API combination of each of the plurality of possible API mashups, the one or more processors are:
Determining whether the output of the first API of the API combination of the API mashup has a data format that matches the data format of the input of the second API of the API combination of the API mashup;
In the knowledge graph, an operation of determining whether at least one link exists between the output parameter of the first API and the input parameter of the second API;
When the output of the first API has a data format that matches the data format of the input of the second API, or in the knowledge graph, the output parameters of the first API and the second API Designating the API mashup as a high priority API mashup in any of the cases where there is at least one link between the input parameters;
The system of claim 15, wherein the system is further configured to perform.

(Appendix 19)
The one or more processors are:
Receiving an API mashup request from a third party;
Processing the API mashup request to identify one or more keyword combinations for the API mashup request;
Comparing the one or more keyword combinations for the API mashup request with the at least one keyword combination for the at least one prioritized API mashup;
The at least one priority in response to the one or more keyword combinations for the API mashup request matching the at least one keyword combination for the at least one prioritized API mashup. Providing the attached API mashup to the third party;
Responsive to the one or more keyword combinations for the API mashup request not matching the at least one keyword combination for the at least one prioritized API mashup;
Communicating the at least one prioritized API mashup to at least one learning model;
Determining whether the at least one prioritized API mashup is a valid API mashup via the at least one learning model;
Providing the third party with the at least one prioritized API mashup in response to determining that the at least one prioritized API mashup is a valid API mashup; When,
The system of claim 15, wherein the system is further configured to perform.

(Appendix 20)
The one or more processors are:
Receiving the feedback from the third party regarding the at least one prioritized API mashup;
Updating the at least one learning model based on the feedback from the third party;
The system of claim 19, wherein the system is further configured to perform.

100 API mashup generation system 102 API database 104 API mashup generator 502 Specific expression extraction tool 504 Data 506 Keyword 508 Output 1202 Request processing tool 1204 Request 1206 Subcluster keyword 1208 Output 1300 Computing system 1310 Processor 1320 Storage device 1330 Memory 1340 Communication device

Claims (20)

A method of generating an application program interface (API) mashup,
Grouping, by at least one processor, a plurality of APIs into a plurality of sub-clusters based on at least one keyword for each API of the plurality of APIs;
Identifying, by the at least one processor, a plurality of keyword combinations for the plurality of subclusters based on two or more keywords for the plurality of subclusters and real world data;
Determining, by the at least one processor, a plurality of possible API mashups including two or more APIs of the plurality of APIs for the plurality of keyword combinations;
Processing the plurality of possible API mashups by the at least one processor to at least one of the plurality of possible API mashups associated with at least one keyword combination of the plurality of keyword combinations. Generating two prioritized API mashups;
Including a method. Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Comparing the input of the first API of the API combination of the API mashup with the output of the second API of the API combination of the API mashup;
Calculating a similarity score between the input of the first API of the API combination and the output of the second API of the API combination;
If the similarity score exceeds a threshold, designating the API mashup as a high priority API mashup;
The method of claim 1 comprising: Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Generating input for API combinations for API mashups;
Determining whether the API mashup produces valid output based on the generated input;
If the generated output is valid, designating the API mashup as a high priority API mashup;
The method of claim 1 comprising: Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Determining whether the output of the first API of the API combination of the API mashup has a data format that matches the data format of the input of the second API of the API combination of the API mashup;
In the knowledge graph, determining whether there is at least one link between the output parameter of the first API and the input parameter of the second API;
When the output of the first API has a data format that matches the data format of the input of the second API, or in the knowledge graph, the output parameters of the first API and the second API Designating the API mashup as a high-priority API mashup in any of the cases where there is at least one link between the input parameters;
The method of claim 1 comprising: Receiving an API mashup request from a third party;
Processing the API mashup request by the at least one processor to identify one or more keyword combinations for the API mashup request;
Comparing, by the at least one processor, the one or more keyword combinations for the API mashup request with the at least one keyword combination for the at least one prioritized API mashup;
The at least one priority in response to the one or more keyword combinations for the API mashup request matching the at least one keyword combination for the at least one prioritized API mashup. Providing the attached API mashup to the third party;
Responsive to the one or more keyword combinations for the API mashup request not matching the at least one keyword combination for the at least one prioritized API mashup;
Communicating the at least one prioritized API mashup to at least one learning model;
Determining whether the at least one prioritized API mashup is a valid API mashup via the at least one learning model;
Providing the at least one prioritized API mashup to the third party in response to determining that the at least one prioritized API mashup is a valid API mashup; When,
The method of claim 1, further comprising: Receiving feedback from the third party regarding the at least one prioritized API mashup;
Updating the at least one learning model based on the feedback from the third party;
The method of claim 5, further comprising: The method of claim 1, further comprising: providing the at least one prioritized API mashup to a third party. One or more non-transitory computer readable media containing instructions, the instructions performing a plurality of operations on the one or more processing systems when executed by the one or more processing systems And the plurality of operations are configured as follows:
Grouping a plurality of APIs into a plurality of sub-clusters based on at least one keyword for each API of the plurality of APIs;
Identifying a plurality of keyword combinations for the plurality of sub-clusters based on two or more keywords for the plurality of sub-clusters and real world data;
Determining a plurality of possible API mashups including two or more of the plurality of APIs for the plurality of keyword combinations;
Processing the plurality of possible API mashups and, out of the plurality of possible API mashups, at least one prioritized API associated with at least one keyword combination of the plurality of keyword combinations. Generating mashups,
A computer-readable medium including: Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Comparing the input of the first API of the API combination of the API mashup with the output of the second API of the API combination of the API mashup;
Calculating a similarity score between the input of the first API of the API combination and the output of the second API of the API combination;
If the similarity score exceeds a threshold, designating the API mashup as a high priority API mashup;
The computer-readable medium of claim 8, comprising: Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Generating input for API combinations for API mashups;
Determining whether the API mashup produces valid output based on the generated input;
If the generated output is valid, designating the API mashup as a high priority API mashup;
The computer-readable medium of claim 8, comprising: Processing the plurality of possible API mashups for each API combination of each API mashup of the plurality of possible API mashups,
Determining whether the output of the first API of the API combination of the API mashup has a data format that matches the data format of the input of the second API of the API combination of the API mashup;
In the knowledge graph, determining whether there is at least one link between the output parameter of the first API and the input parameter of the second API;
When the output of the first API has a data format that matches the data format of the input of the second API, or in the knowledge graph, the output parameters of the first API and the second API Designating the API mashup as a high-priority API mashup in any of the cases where there is at least one link between the input parameters;
The computer-readable medium of claim 8, comprising: The plurality of operations are:
Receiving an API mashup request from a third party;
Processing the API mashup request to identify one or more keyword combinations for the API mashup request;
Comparing the one or more keyword combinations for the API mashup request with the at least one keyword combination for the at least one prioritized API mashup;
The at least one priority in response to the one or more keyword combinations for the API mashup request matching the at least one keyword combination for the at least one prioritized API mashup. Providing the attached API mashup to the third party;
Responsive to the one or more keyword combinations for the API mashup request not matching the at least one keyword combination for the at least one prioritized API mashup;
Communicating the at least one prioritized API mashup to at least one learning model;
Determining whether the at least one prioritized API mashup is a valid API mashup via the at least one learning model;
Providing the third party with the at least one prioritized API mashup in response to determining that the at least one prioritized API mashup is a valid API mashup; When,
The computer-readable medium of claim 8, further comprising: The plurality of operations are:
Receiving the feedback from the third party regarding the at least one prioritized API mashup;
Updating the at least one learning model based on the feedback from the third party;
The computer-readable medium of claim 12, further comprising: The plurality of operations are:
The computer-readable medium of claim 8, further comprising: providing the third party with the at least one prioritized API mashup. Grouping a plurality of APIs into a plurality of sub-clusters based on at least one keyword for each API of the plurality of APIs;
Identifying a plurality of keyword combinations for the plurality of sub-clusters based on two or more keywords for the plurality of sub-clusters and real world data;
Determining a plurality of possible API mashups including two or more of the plurality of APIs for the plurality of keyword combinations;
Processing the plurality of possible API mashups and, out of the plurality of possible API mashups, at least one prioritized API associated with at least one keyword combination of the plurality of keyword combinations. Generating mashups,
A system having one or more processors configured to execute. For each API combination of each of the plurality of possible API mashups, the one or more processors are:
Comparing the input of the first API of the API combination of the API mashup with the output of the second API of the API combination of the API mashup;
Calculating a similarity score between the input of the first API of the API combination and the output of the second API of the API combination;
When the similarity score exceeds a threshold, the API mashup is designated as a high priority API mashup;
The system of claim 15, further configured to perform: For each API combination of each of the plurality of possible API mashups, the one or more processors are:
An action to generate input for API combinations in API mashups;
Determining whether the API mashup generates valid output based on the generated input;
If the generated output is valid, the API mashup is designated as a high priority API mashup;
The system of claim 15, further configured to perform: For each API combination of each of the plurality of possible API mashups, the one or more processors are:
Determining whether the output of the first API of the API combination of the API mashup has a data format that matches the data format of the input of the second API of the API combination of the API mashup;
In the knowledge graph, an operation of determining whether at least one link exists between the output parameter of the first API and the input parameter of the second API;
When the output of the first API has a data format that matches the data format of the input of the second API, or in the knowledge graph, the output parameters of the first API and the second API Designating the API mashup as a high priority API mashup in any of the cases where there is at least one link between the input parameters;
The system of claim 15, further configured to perform: The one or more processors are:
Receiving an API mashup request from a third party;
Processing the API mashup request to identify one or more keyword combinations for the API mashup request;
Comparing the one or more keyword combinations for the API mashup request with the at least one keyword combination for the at least one prioritized API mashup;
The at least one priority in response to the one or more keyword combinations for the API mashup request matching the at least one keyword combination for the at least one prioritized API mashup. Providing the attached API mashup to the third party;
Responsive to the one or more keyword combinations for the API mashup request not matching the at least one keyword combination for the at least one prioritized API mashup;
Communicating the at least one prioritized API mashup to at least one learning model;
Determining whether the at least one prioritized API mashup is a valid API mashup via the at least one learning model;
Providing the third party with the at least one prioritized API mashup in response to determining that the at least one prioritized API mashup is a valid API mashup; When,
The system of claim 15, further configured to perform: The one or more processors are:
Receiving the feedback from the third party regarding the at least one prioritized API mashup;
Updating the at least one learning model based on the feedback from the third party;
The system of claim 19, further configured to perform:

Images