Vector generation and indexing system

Abstract

This system provides a vector generation and indexing system. [Solution] A system and method are provided for generating vector embeddings for each set of data from multiple sets of data, storing them in each of multiple tables, and for each table, storing a model type and version corresponding to the model used to generate the vector embeddings stored in each of the multiple tables. The system and method further generates a response to a query by generating vector embeddings for the query using the same model type and version as used to generate vector embeddings for one or more tables using the relevant data for the query.

Description

Technical Field

[0001] This disclosure relates to vector generation and indexing systems.

Background Art

[0002] Many computing systems use or are being updated to use artificial intelligence (AI), such as machine learning models (e.g., LLM), to convert artifacts such as text, images, audio, or video into high-dimensional vectors. This conversion is called vector embedding because these models embed the semantics of the artifacts into a vector space with many dimensions. For example, in a common scenario, an LLM can generate vector embeddings with hundreds to thousands of dimensions.

Summary of the Invention

Means for Solving the Problems

[0003] The various attached drawings show merely exemplary embodiments of the present disclosure and should not be regarded as limiting its scope.

Brief Description of the Drawings

[0004] [Figure 1] It is a block diagram showing a network system according to some examples. [Figure 2] It is a block diagram showing a vector generation and indexing system according to some examples. [Figure 3] It is a diagram showing vector embedding generation and indexing performed by a vector embedding generation and indexing system according to some examples. [Figure 4] It is a diagram showing query reception and query processing performed by a vector embedding generation and indexing system according to some examples. [Figure 5]This is a flowchart illustrating the methods with several examples. [Figure 6] This is a flowchart illustrating the methods using several examples. [Figure 7] This block diagram shows an example of a software architecture that can be installed on a machine, with several examples. [Figure 8] This is a schematic diagram of a machine in the form of a computer system, in which a set of instructions can be executed to cause the machine to carry out one or more of the methodologies discussed herein, as illustrated by several examples. [Modes for carrying out the invention]

[0005] As mentioned above, machine learning models (e.g., LLMs) transform artifacts within a system, such as text, images, audio, or video, into vectors of high dimensionality. These vectors, also called vector embeddings, are used to generate responses to queries by performing similar searches within the system, among other things, within the system's relational database (e.g., an SQL database). These dimensions, or components generated for vector embeddings, are model-specific. Using a very simple example, an embedding for the term "apple" might have dimensional values ​​[-2, 34]. These dimensional values ​​are meaningless on their own and only become useful when compared to other embeddings generated by the same model. Because the generated vectors are model-dependent, these vectors cannot be used with any other model, library, or engine. Furthermore, if the model parameters change, these vectors cannot be used then. These components, or dimensional values ​​of the vectors, are obscured, making it impossible to map them to the original data, and this obscurity prevents them from being transcribed into vectors generated by any other model or engine.

[0006] Therefore, these vectors must be regenerated with every change to the external model, and their semantics are unique to the model used for their generation. This is a major drawback for companies that use vector data for their Generative Artificial Intelligence (Gen AI) search and generation workflows. The effectiveness of their databases becomes dependent on external entities, and these companies not only need to keep track of changes to the external LLM, but also need to regenerate all vector embeddings whenever there is any change to the model. This is impractical for the amount of data in a given system. Furthermore, many systems have tens or hundreds of thousands of tables that store artifacts and vector embeddings. Different models and versions may be used for different tables, leading to further complexity and even inconsistencies.

[0007] The search results for similar data can be returned for client consumption, or they can be used to perform Retrieval Augmented Generation (RAG) using machine learning models such as LLMs. Within the RAG workflow, similar artifacts are retrieved from the database using their vector embeddings, and these artifacts are fed to an external LLM as prompts or context. Since LLMs have no knowledge of enterprise data, without RAG, a modern LLM is not useful in an enterprise environment. Therefore, search results without RAG are of no use to enterprise users in this example.

[0008] The examples described herein address at least these technical issues using a datastore-managed (e.g., database-managed) vector generation and indexing system that is clear to the end user. Implementation details of how vectors are generated and maintained are hidden from the end user and automatically managed by the datastore, such as a database. For example, the vector generation and indexing system, in response to a query, uses LLM or other machine learning modeling techniques to ingest artifacts, regardless of the model type or version number of the model type used for vector embedding, and then retrieves the ingested artifacts in real time using techniques described in more detail below. When the vector generation and indexing system receives a query, it vectorizes the query terms using the same model used to create the vectors for the data to be retrieved. Furthermore, the vector generation and indexing system can retrieve those artifacts even if the ingested artifacts are stored in a datastore, each having vector embeddings generated using different model types and / or different versions of the same model type.

[0009] In some examples, a vector generation and indexing management system generates vector embeddings for multiple sets of data that will be stored in each of the tables of a group of tables, stores the vector embeddings for each set of data within each of the tables of the group of tables, and for each table, stores the model type and version corresponding to the model used to generate the vector embeddings stored within each of the tables of the group of tables. The vector generation and indexing management system further receives a query, determines a subset of tables from a group of tables related to the query, and determines the stored model type and version associated with each table in the subset of tables. In some examples, there are at least two different model types or versions for the subset of tables. Using the stored model types and versions for each of the at least two different model types or versions for the subset of tables, the vector generation and indexing management system generates vector embeddings for the query, and generates sets of similar data based on the vector embeddings for the query and the vector embeddings for the sets of data stored within the subset of tables. Based on the sets of similar data, the vector generation and indexing management system may further generate a response to the query.

[0010] Figure 1 is a block diagram of a network system 100 according to several exemplary embodiments. The system 100 may include one or more client devices, such as client device 110. Client device 110 may include, but is not limited to, a mobile phone, desktop computer, laptop, portable digital assistant (PDA), smartphone, tablet, ultrabook, netbook, laptop, multiprocessor system, microprocessor-based or programmable consumer electronics, game console, set-top box, in-vehicle computer, wearable computing device, or any other computing or communication device that a user can use to access the network system 100. In some embodiments, client device 110 includes a display module (not shown) that displays information (for example, in the form of a user interface). In further embodiments, client device 110 may include one or more of the following: a touchscreen, accelerometer, gyroscope, camera, microphone, global positioning system (GPS) device, etc. The client device 110 may be a user's device used within an application to access and utilize cloud services and to utilize the vector generation and indexing system 124.

[0011] One or more users 106 may be a person, a machine, or other means of interacting with the client device 110. In exemplary embodiments, user 106 may not be a part of system 100 but may interact with system 100 through the client device 110 or other means. For example, user 106 may provide input (e.g., touchscreen input or alphanumeric input) to the client device 110, and the input may be communicated via the network 104 to other entities in system 100 (e.g., third-party server system 130, server system 102). In this example, the other entities in system 100 communicate information to the client device 110 via the network 104 in response to receiving input from user 106, which will then be presented to user 106. In this way, user 106 can use the client device 110 to interact with various entities in system 100.

[0012] System 100 further includes network 104. One or more parts of network 104 may be an ad-hoc network, intranet, extranet, virtual private network (VPN), local area network (LAN), wireless LAN (WLAN), wide area network (WAN), wireless WAN (WWAN), metropolitan area network (MAN), part of the internet, part of a public switched telephone network (PSTN), cellular telephone network, wireless network, Wi-Fi network, WiMAX network, another type of network, or a combination of two or more such networks.

[0013] The client device 110 may access various data and applications provided by other entities within the system 100 via a web client 112 (for example, a browser such as the Internet Explorer® browser developed by Microsoft® Corporation in Redmond, Washington State) or one or more client applications 114. The client device 110 may include, but is not limited to, one or more client applications 114 (also called "apps") such as a web browser, a search engine, a messaging application, an email application, an e-commerce site application, a mapping or location application, an enterprise resource planning (ERP) application, a customer relationship management (CRM) application, an application that facilitates efforts to update code within a project, or an application for accessing and using the vector generation and indexing system 124.

[0014] In some embodiments, one or more client applications 114 are contained within a given client device 110 and configured to locally provide at least some of the user interface and functionality, and the client applications 114 are configured to communicate with other entities in the system 100 (e.g., third-party server system 130, server system 102, etc.) as needed for data and / or processing capabilities that are not locally available (e.g., accessing location information, accessing machine learning models, authenticating users 106, verifying payment methods, accessing vector generation and indexing systems 124, etc.). Conversely, one or more client applications 114 do not have to be contained within the client device 110, in which case the client device 110 can use its web browser to access one or more applications hosted on other entities in the system 100 (e.g., third-party server system 130, server system 102).

[0015] The server system 102 provides server-side functionality to one or more third-party server systems 130 and / or one or more client devices 110 via a network 104 (for example, the Internet or a wide area network (WAN)). The server system 102 may include an application programming interface (API) server 120, a web server 122, and a vector generation and indexing system 124 that can be communicatively coupled with one or more databases 126.

[0016] One or more databases 126 include a storage device that stores data about users of system 100, applications associated with system 100, cloud services, machine learning models, entities / products / services, etc. One or more databases 126 may further store information about a third-party server system 130, a third-party application 132, a third-party database 134, a client device 110, a client application 114, a user 106, etc. In one example, one or more databases 126 are cloud-based storage. In some examples, the database is a relational database, such as a type of Structured Query Language (SQL) database, which can also store and manage vector embeddings along with the main data stored in the database tables, as will be described in more detail below.

[0017] The server system 102 may be a cloud computing environment, according to some exemplary embodiments. The server system 102, and any server associated with the server system 102, may, in one exemplary embodiment, be associated with a cloud-based application.

[0018] The vector generation and indexing system 124 provides backend support for third-party applications 132 and client applications 114, which may include cloud-based applications. The vector generation and indexing system 124 provides vector generation and indexing, among other functions, which are further described below. The vector generation and indexing system 124 may comprise one or more servers or other computing devices or computing systems. In some examples, the vector generation and indexing system 124 is part of a database system.

[0019] System 100 further includes one or more third - party server systems 130. The one or more third - party server systems 130 may include one or more third - party applications. One or more third - party applications 132 running on the third - party server 130 may interact with the server system 102 via the API server 120 through a programming interface provided by the API server 120. For example, one or more of the third - party applications 132 may request and utilize information from the server system 102 via the API server 120 to support one or more features or functions on a third - party - hosted website or a third - party - hosted application.

[0020] The third - party website or application 132 may provide, for example, access to functionality and data supported by the third - party server system 130. In one exemplary embodiment, the third - party website or application 132 provides access to functionality supported by related functionality and data within the third - party server system 130. In another example, the third - party server system 130 is a system related to an entity that accesses cloud services via the server system 102.

[0021] The third - party database 134 may be a storage device that stores data related to users of the third - party server system 130, applications related to the third - party server system 130, cloud services, machine - learning models, parameters, etc. The one or more databases 126 may further store information related to the third - party applications 132, client devices 110, client applications 114, users 106, etc. In one example, the one or more databases 134 are cloud - based storage.

[0022] FIG. 2 is an exemplary block diagram 200 showing further details of the vector generation and indexing system 124. In the exemplary block diagram of FIG. 2, the vector generation and indexing system 124 includes a vector embedding generator 202, an internal embedding model 204, a vector management system 206, and a similarity search system 208. It should be understood that the vector generation and indexing system 124 may include fewer, different, or additional components in the examples described herein, or some components may be combined.

[0023] The vector embedding generator 202 converts an artifact into a vector embedding, such as by using the internal embedding model 204 and / or an external embedding model (not shown). As described above, an artifact may include text, images, audio, and video, or other content. The vector embedding generator 202 further converts a query into a vector embedding, such as by using the internal embedding model 204 and / or an external embedding model (not shown). Some examples of the internal embedding model 204 or the external embedding model include Apache Lucene, ChatGPT, Gemini, etc. The similarity search system 208 compares the query vector embedding with the vector embeddings for the artifacts to generate result artifacts related to the query. The vector management system 206 manages the model type and version for the vector embeddings, as will be described in more detail below.

[0024] FIG. 3 is a diagram 300 showing vector embedding generation and indexing performed by the vector generation and indexing system 124 that can be coupled to or be part of the database 312 shown in FIG. 3 (or other databases). The database 312 is used as an exemplary data store in FIG. 3. It should be understood that other data stores (e.g., JSON) may be used in the examples described herein.

[0025] An end user 106 may create table 304, for example, through data definition (DDL) or data manipulation (DML) statements, as shown in reference number 302. When table 304 is created, a vector index is also automatically created for table 304. A vector index is a hidden vector column that maintains vector data for the desired column. In Figure 3, the vector data 308 is shown within the same tablespace 306 as table 304.

[0026] Artifacts such as text, images, audio, and video are inserted into the database either as a whole or in batches. These artifacts can be used to create vector embeddings. When database 312 receives new data (e.g., artifacts), database 312 generates vector embeddings for this newly created record and maintains references to the newly created data record. Other actions may be performed, such as updating other indexes, which are not discussed here.

[0027] The vector embedding generator 202 may generate vector embeddings for artifacts using either an internal embedding model 204 and / or an external embedding model 310 within the database. The embedding model selection is a configuration that can apply to the entire database, or it can apply to a specific schema, table, or even be overridden at table creation. While any selected model may be used in the examples described herein, the same model used to generate the vector embeddings must be used as the query model, as vector embeddings generated by different models will be inconsistent. Therefore, the model type and model version used to generate the vector embeddings are associated with each artifact, as will be described in more detail below. The vector embeddings are stored as vector data 308.

[0028] Figure 4 is a 400 diagram showing query reception and query processing performed by a vector embedding generation and indexing system 124, which has additional components compared to Figure 3, to illustrate this process. In Figure 4, an end user 106 may submit a query 402 to the database 312. The database 312 receives each query in 404 and converts the query into a vector embedding. The database 312 compares the user's query to existing artifacts in one or more tables by performing a vector similarity search 406. The similarity search is performed by comparing the vector embedding for the query with the vector data 308 to determine similar data. As described above, the database can perform vector similarity indirectly because it creates embeddings for all records (artifacts) inserted into the tables. The database 312 returns all rows, or in some examples, a subset of the similarity search (e.g., the top N rows). As will be explained in more detail below, the response is generated based on similar data (e.g., a row or a subset of rows) and sent to the end user 106 who submitted the query (402).

[0029] Since vector embeddings are performed and maintained by database 312, end users do not need to know about vector generation or the maintenance of vector generation. Furthermore, as will be explained in more detail below, database 312 tracks the embedding model and versions of the embedding model in order to generate vector embeddings within database 312. As described above, the generating AI model is updated frequently, and the vector embeddings produced by each version of the model will be inconsistent with other versions of the same model, so model versioning and management are important. Generally speaking, vector embeddings are obscure, meaning that the semantics of their components are unknown, and therefore these components are not convertible to other formats produced by other models or to other versions of the same model.

[0030] Figure 5 is a flowchart illustrating aspects of Method 500 for vector embedding generation and indexing in several exemplary embodiments. For illustrative purposes, Method 500 is described with respect to the block diagrams of Figures 1 to 4. It should be understood that Method 500 may be implemented in other system configurations in other embodiments.

[0031] In operation 502, a computing system such as the server system 102 or the vector generation and indexing system 124 generates vector embeddings for multiple sets of data that will be stored in each of the tables of the multiple data tables. In some examples, at least two different model types or two different versions of a model type are used to generate the vector embeddings. The examples described herein use data or document collectibles in the form of tables in a database. It should be understood that any data or document collectible may be used in the examples described herein.

[0032] In some examples, the computing system discovers artifacts, also referred to herein as data, that are inserted into the database. Different artifacts may be associated with different data collections, such as tables, so that each artifact is associated with its own table, and sets of artifacts are stored within each table. Thus, for each of the multiple tables, the computing system performs the operations shown in Figure 5.

[0033] As explained above, before or after generating vector embeddings for multiple sets of data that will be stored in each of the tables, the computing system generates vector indexes for each of the tables. The computing system generates vector embeddings for the data sets by transforming each data point in each set of data into a vector space of a given number of dimensions.

[0034] For example, the computing system generates vector embeddings for each artifact via an internal embedding model 204 or an external embedding model 310, such as via a vector embedding generator 202. The computing system stores the vector embeddings for each artifact in its respective table. In this way, in operation 504, each vector embedding for each set of data from multiple sets of data is stored in its respective table from multiple tables.

[0035] As an example, consider the table below, which contains a simple example of data with the terms apple and house. This table has a column containing the data and a column containing vector embeddings (v_data) for the data. For example, for the artifact "apple", the vector embedding is [-2, 34]. As mentioned above, this is merely an example for illustrative purposes. In a typical real-world example, the artifact or data would include text, images, audio, and / or video, and have hundreds to thousands of dimensions. In some examples, v_data could be a data type such as REAL_VECTOR in a HANA database with a wide range of dimensions (e.g., 1 to 65,000).

[0036] As mentioned above, the column v_data is internal and hidden from the end user's view. This type of internal / hidden column is sometimes called a shadow column for vector data. The content of the v_data column is a vector embedding generated by either an internal or external embedding model.

[0037] [Table 1]

[0038] In operation 506, the computing system stores for each table the model type and version corresponding to the model used to generate the vector embeddings stored within each of the multiple tables. For example, the model type and version are stored in another system table in database 312, for example, in the following exemplary table within an internal table for storing tables for embedding model mappings. The table below will be called v_mappings. The v_mappings table will contain mappings between tables containing vector embeddings (e.g., word_table and another_table) and their respective embedding models (e.g., 1 and 2). For example, word_table is mapped to model_id 1.

[0039] [Table 2]

[0040] In some examples, when inserting rows into a table containing vector embeddings, such as the word_table shown above, the computing system first performs a lookup against the v_mappings table / view to obtain the ID of the embedding model to be used to create the vector embedding. Then, using that model, the embedding is generated and inserted into the hidden column v_data.

[0041] The table below, which will be called the v_embeddings table, contains metadata for the embedding models. In this example, the model_id column shown in the v_mappings table above is a foreign key in the v_embeddings model.id column. The v_embeddings table contains fields about the models that generate the vector embeddings, such as the version and the number of vector dimensions they generate. In some examples, the number of dimensions is stored so that it can be used in certain types of search methods that use that number of dimensions to perform similarity searches, such as cosine searches. This table may contain more columns to store other characteristics about the embedding models, such as API endpoint URLs, or in some examples, it may have different column types.

[0042] [Table 3]

[0043] The vector columns shown within word_table may have indexes for faster similarity searches, and other data columns shown within the table may also have indexes for faster similarity searches. The storage and management of these auxiliary indexes are carried out through established database techniques, and details of such indexes are not described here.

[0044] The computing system may revectorize the data columns in word_table and update the v_data column using an internal database API or tool that allows for model changes or model version changes. This action does not change the data columns, but instead modifies the internal v_data column shown in word_table above.

[0045] Figure 6 is a flowchart illustrating embodiments of Method 600 for processing queries using the vector generation and indexing described above with respect to Figure 6, in some exemplary embodiments. For illustrative purposes, Method 600 is described with respect to the block diagrams of Figures 1, 2, and 4. It should be understood that Method 600 may be practiced in other embodiments and in other system configurations.

[0046] In operation 602, a computing system, such as the server system 102 or the vector generation and indexing system 124, receives a query and determines a subset of tables from among several tables related to the query. The computing system generates the relevant data for the response to the query in real time or near real time. For example, the computing system receives a user query from a client device 110. The computing device determines one or more tables, such as a table, that contain data related to the received user query. Using a simple example, the computing system may determine that two different tables contain data related to the query. It should be understood that any number of tables can contain data related to the query.

[0047] In operation 604, the computing system determines the stored model type and version associated with each table in a subset of tables. In some examples, there are at least two different model types or versions for a subset of tables. For example, the computing system performs a lookup on a vector mapping table (such as the exemplary v_mappings table described above) to determine which model types are associated with the first table, which are associated with the second table, and so on. The computing system may further perform a lookup on a vector embedding table (such as the exemplary v_embeddings table described above) to determine the model name, version, and other information associated with each of the model types associated with each table. In other examples, only one table is used to determine both the model type and version for each table.

[0048] In operation 606, the computing system generates vector embeddings for queries using the stored model types and versions associated with each table. In some examples, the computing system generates vector embeddings for queries for each of at least two different model types or versions for a subset of tables. For example, a query is input into a machine learning model (e.g., LLM) corresponding to a first stored model type and version, and the machine learning model outputs vector embeddings for the query; a query is input into a machine learning model (e.g., LLM) corresponding to a second stored model type and version (or the first stored model type and the second version), and the machine learning model outputs vector embeddings for the query, and so on. In this way, the vector embeddings for queries are performed using the same model types and versions as the vector embeddings performed for the sets of data in each table, so that the vector embeddings for queries and the vector embeddings for the sets of data stored in each table are consistent.

[0049] In operation 608, the computing system generates sets of similar data based on the vector embeddings for the query and the vector embeddings for the sets of data stored within the subset of tables. For example, the computing system compares the vector embeddings for the query with the vector embeddings for the sets of data stored within each table using a function that allows comparing two vectors for similarity, such as cosine similarity, Euclidean similarity, L2 distance, Manhattan distance, or other techniques for determining which data in the set of stored data is similar to the query. In some examples, the computing system determines the top N data that are most similar to the query.

[0050] As described above, in some examples, there are at least two different model types or versions for a subset of tables, and therefore, as also described above, at least two different model types and versions are used to generate vector embeddings for queries. The computing system compares the vector embeddings for queries with the vector embeddings in each corresponding table to generate sets of similar data. For example, for each different vector embedding for a query, the computing system compares the vector embedding for the query using the first model type and version with the vector embedding for the table made using the first model type and version, and the computing system compares the vector embedding using the second model type and version (or the first model type and the second version) with the vector embedding for the table made using the second model type and version (or the first model type and the second version), and so on. In this way, the vector embeddings for queries and the vector embeddings for the set of data stored in the second table are consistent for the purpose of comparing similarity.

[0051] A computing system generates a response to a query based on a set of similar data. For example, a computing system provides a set of similar data and the query to a machine learning model (e.g., an LLM) to generate a response to the query. The set of similar data is input into the machine learning model, which analyzes the input data to generate an appropriate response to the query.

[0052] When a new model type or a new version of a model type is used to generate vector embeddings, the computing system automatically regenerates the vector embeddings and updates the table to capture the regenerated (i.e., new) model type and version of the data. For example, vector embeddings for a set of data stored in a first table were generated using a first model type and a first version. When a new version of the first model type is provided, the computing system regenerates the vector embeddings for the set of data stored in the first table using the first model type and a second version (for example, generating new vector embeddings). The computing system stores the regenerated vector embeddings in the first table and updates the first table with the version corresponding to the first model type used to regenerate the vector embeddings for the set of data stored in the first table. Therefore, when the computing system receives a second query corresponding to the first table, the computing system determines the first model type and second version associated with the first table, as described above, generates vector embeddings for the second query using the first model type and second version associated with the first table, determines sets of similar data in the first table based on the vector embeddings for the query and the vector embeddings for the sets of data stored in the first table, and generates a response to the second query based on the sets of similar data.

[0053] In light of the above disclosure, various examples are described below. Note that one or more features of the examples, when used individually or in combination, should be considered to be within the disclosure of this application.

[0054] Example 1 A computer implementation method, The steps include generating vector embeddings for multiple sets of data that will be stored in each of the tables, The steps include storing vector embeddings for each set of data from multiple sets of data within each of the tables in multiple tables, For each table, the steps include storing the model type and version corresponding to the model used to generate the vector embeddings stored within each of the tables in a group of tables, The steps include receiving a query and determining a subset of tables from among several tables related to the query, A step of determining the stored model type and version for each table in a subset of tables related to a query, wherein there are at least two different model types or versions for the subset of tables. A step of generating vector embeddings for a query using stored model types and versions for each of at least two different model types or versions for a subset of tables, The steps include generating a set of similar data based on vector embeddings for queries and vector embeddings for sets of data stored within a subset of tables, The steps include generating a response to a query based on a set of similar data and A computer implementation method, including

[0055] Example 2 After the step of generating vector embeddings for multiple sets of data that will be stored in each of the tables, the computer implementation method Steps to generate vector indexes for each of multiple tables. The computer implementation method described in Example 1, including the method described in Example 1.

[0056] Example 3 A computer implementation according to either Example 1 or 2, wherein the step of generating a set of similar data based on vector embeddings for a query and vector embeddings for a set of data stored in a subset of a table includes the steps of comparing two vectors for similarity and using a function that can utilize a vector index to compare the two vectors.

[0057] Example 4 A computer implementation according to any one of Examples 1 to 3, wherein at least two different model types are used to generate vector embeddings.

[0058] Example 5 A computer implementation as described in any one of Examples 1 to 4, wherein at least two different versions of the model type are used to generate vector embeddings.

[0059] Example 6 A computer implementation according to any one of Examples 1 to 5, wherein the step of generating vector embeddings for multiple sets of data includes the step of transforming each data point in each set of data into a vector space having a given number of dimensions.

[0060] Example 7 A computer implementation according to any one of Examples 1 to 6, wherein a set of similar data is determined based at least on a comparison between a first vector embedding of a query and a vector embedding of a set of data stored in a first table, and a comparison between a second vector embedding of a query and a vector embedding of a set of data stored in a second table.

[0061] Example 8 A computer implementation according to any one of Examples 1 to 7, wherein the comparison is performed using a function that allows for the comparison of two vectors in terms of similarity.

[0062] Example 9 Vector embeddings for the set of data stored in the first table are generated using the first model type and the first version, and the computer implementation is as follows: The steps include: regenerating vector embeddings for the set of data stored in the first table using the first model type and the second version; The steps include storing the regenerated vector embeddings in the first table, For the first table, the step of updating the version corresponding to the first model type used to regenerate vector embeddings for the set of data stored in the first table, and A computer implementation method according to any one example from Examples 1 to 8, further including the above.

[0063] Example 10 The steps include receiving a second query corresponding to the first table, The steps include determining the first model type and second version related to the first table, The steps include generating vector embeddings for a second query using a first model type and a second version associated with the first table, The steps include determining a second set of similar data in the first table based on vector embeddings for the second query and vector embeddings for the set of data stored in the first table, The steps include generating a response to a second query based on a second set of similar data, and A computer implementation method according to any one example from Examples 1 to 9, further including the above.

[0064] Example 11 A computer implementation method according to any one of Examples 1 to 10, wherein the data includes text, images, audio, or video.

[0065] Example 12 It is a system, The memory that stores the instructions, One or more processors configured to operate by instructions and Equipped with, the operation is This involves generating vector embeddings for multiple sets of data that will be stored in each of the tables, Storing vector embeddings for each set of data from multiple sets of data within each of multiple tables, For each table, store the model type and version corresponding to the model used to generate the vector embeddings stored within each of the multiple tables, Receiving queries and Determining the stored model type and version for each table in a subset of tables related to a query, and determining that there are at least two different model types or versions for the subset of tables. Using the stored model types and versions for each of at least two different model types or versions for a subset of the table, generate vector embeddings for the query, Based on vector embeddings for queries and vector embeddings for sets of data stored within a subset of tables, generate sets of similar data. To generate a response to a query based on a set of similar data and A system that includes this.

[0066] Example 13 After generating vector embeddings for multiple sets of data that will be stored in each of the tables, the operation proceeds as follows: Generating a vector index for each of multiple tables. The system according to Example 12, further comprising:

[0067] Example 14 The system according to any one example of Examples 12 and 13, wherein at least two different model types are used to generate vector embeddings, or at least two different versions of a model type are used to generate vector embeddings.

[0068] Example 15 The system according to any one example of Examples 12 to 14, wherein generating vector embeddings for multiple sets of data includes transforming each data point in each set of data into a vector space having a given number of dimensions.

[0069] Example 16 The system according to any one example of Examples 12 to 15, wherein a set of similar data is determined based at least on a comparison between a first vector embedding of the query and a vector embedding for a set of data stored in a first table, and a comparison between a second vector embedding of the query and a vector embedding for a set of data stored in a second table.

[0070] Example 17 The system described in any one of Examples 12 to 16, wherein the comparison is performed using a function that allows for the comparison of two vectors in terms of similarity.

[0071] Example 18 Vector embeddings for the set of data stored in the first table are generated using the first model type and the first version, and the operation is as follows: Using the first model type and the second version, regenerate the vector embeddings for the set of data stored in the first table, The regenerated vector embeddings are stored in the first table, For the first table, update the version corresponding to the first model type used to regenerate the vector embeddings for the set of data stored in the first table. The system described in any one of Examples 12 to 17, further including the system described in Example 12 to 17.

[0072] Example 19 The operation is, Receiving a second query corresponding to the first table, To determine the first model type and second version related to the first table, Using the first model type and second version associated with the first table, generate vector embeddings for the second query, Based on the vector embedding for the second query and the vector embedding for the set of data stored in the first table, determine the second set of similar data in the first table, To generate a response to a second query based on a second set of similar data. The system described in any one of Examples 12 to 18, further including the system described in any one of Examples 12 to 18.

[0073] Example 20 A non-temporary computer-readable medium storing instructions that can be executed by at least one processor, wherein the instructions are transmitted to a computing device. This involves generating vector embeddings for multiple sets of data that will be stored in each of the tables, Storing vector embeddings for each set of data from multiple sets of data within each of multiple tables, For each table, store the model type and version corresponding to the model used to generate the vector embeddings stored within each of the multiple tables, Receiving queries and Determining the stored model type and version for each table in a subset of tables related to a query, and determining that there are at least two different model types or versions for the subset of tables. Using the stored model types and versions for each of at least two different model types or versions for a subset of the table, generate vector embeddings for the query, Based on vector embeddings for queries and vector embeddings for sets of data stored within a subset of tables, generate sets of similar data. To generate a response to a query based on a set of similar data and A non-temporary computer-readable medium that performs actions including [specific actions].

[0074] Figure 7 is a block diagram showing a software architecture 702 that can be installed on one or more of the devices described above. For example, in various embodiments, client device 110, as well as servers and systems 130, 102, 120, 122, and 124, may be implemented using some or all of the elements of the software architecture 702. Figure 7 is only a non-limiting example of a software architecture, and it should be understood that many other architectures may be implemented to facilitate the functionality described herein. In various embodiments, the software architecture 702 is implemented by hardware such as machine 800 in Figure 8, which includes a processor 810, memory 830, and input / output (I / O) components 850. In this example, the software architecture 702 can be conceived as a stack of layers, each layer which may provide specific functionality. For example, the software architecture 702 includes layers such as an operating system 704, a library 706, a framework 708, and an application 710. In operation, application 710, in accordance with several embodiments, invokes an application programming interface (API) call 712 through the software stack and receives a message 714 in response to the API call 712.

[0075] In various embodiments, the operating system 704 manages hardware resources and provides common services. The operating system 704 includes, for example, a kernel 720, services 722, and drivers 724. The kernel 720, in accordance with several embodiments, functions as an abstraction layer between hardware and other software layers. For example, the kernel 720 provides, among other functionalities, memory management, processor management (e.g., scheduling), component management, network connectivity, and security settings. Services 722 may provide other common services to other software layers. The drivers 724, according to several embodiments, play a role in controlling or interacting with the underlying hardware. For example, the drivers 724 may include a display driver, a camera driver, a Bluetooth® or Bluetooth® Low Energy driver, a flash memory driver, a serial communication driver (e.g., a Universal Serial Bus (USB) driver), a Wi-Fi® driver, an audio driver, a power management driver, and the like.

[0076] In some embodiments, library 706 provides a low-level common infrastructure used by application 710. Library 706 may include a system library 730 (for example, the C standard library) that can provide functions such as memory allocation, string manipulation, and arithmetic functions. In addition, Library 706 may include API Library 732, which includes libraries to support the presentation and manipulation of various media formats, such as media libraries (e.g., Moving Picture Experts Group-4 (MPEG4), Advanced Video Coding (H.264 or AVC), Moving Picture Experts Group Layer-3 (MP3), Advanced Audio Coding (AAC), Adaptive Multi-Rate (AMR) audio codecs, Joint Photographic Experts Group (JPEG or JPG), or Portable Network Graphics (PNG)), graphics libraries (e.g., the OpenGL framework used to render two-dimensional (2D) and three-dimensional (3D) graphic content on a display), database libraries (e.g., SQLite for providing various relational database functionalities), and web libraries (e.g., WebKit for providing web browsing functionality). Library 706 may include a wide variety of libraries 734 for providing many other APIs to application 710.

[0077] Framework 708 provides a high-level common infrastructure that can be utilized by applications 710, according to several embodiments. For example, Framework 708 provides various graphical user interface (GUI) functions, high-level resource management, high-level location services, and so on. Framework 708 can also provide a broad spectrum of other APIs that can be utilized by applications 710, some of which may be specific to particular operating systems 704 or platforms.

[0078] In one exemplary embodiment, application 710 includes a wide variety of other applications, such as a home application 750, a contacts application 752, a browser application 754, a book reader application 756, a location application 758, a media application 760, a messaging application 762, a game application 764, and third-party applications 766 and 767. According to some embodiments, application 710 is a program that performs functions defined within the program. Various programming languages ​​may be employed to create one or more of applications 710, which may be structured in various ways, such as object-oriented programming languages ​​(e.g., Objective-C, Java, or C++) or procedural programming languages ​​(e.g., C or assembly language). In certain examples, a third-party application 766 (e.g., an application developed by an entity other than the vendor of a particular platform using the Android® or iOS® Software Development Kit (SDK)) may be mobile software that runs on a mobile operating system, such as iOS®, Android®, Windows® Phone, or another mobile operating system. In this example, the third-party application 766 can invoke an API call 712 provided by the operating system 704 to facilitate the functionality described herein.

[0079] Figure 8 is a block diagram showing components of a machine 800, in several embodiments, that can read instructions from a machine-readable medium (e.g., a machine-readable storage medium) and implement one or more of the methodologies discussed herein. Specifically, Figure 8 shows a schematic diagram of a machine 800 in an exemplary form of a computer system, in which instructions 816 (e.g., software, programs, applications 710, applets, apps, or other executable code) can be executed, causing the machine 800 to implement one or more of the methodologies discussed herein. In alternative embodiments, the machine 800 may operate as a standalone device or be coupled to other machines (e.g., network-connected). In a network-connected deployment, the machine 800 may operate as a server machine or server system 130, 102, 120, 122, 124, etc., or as a client device 110 in a server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. Machine 800 may include, but is not limited to, a server computer, a client computer, a personal computer (PC), a tablet computer, a laptop computer, a netbook, a personal digital assistant (PDA), an entertainment media system, a cellular phone, a smartphone, a mobile device, a wearable device (e.g., a smartwatch), a smart home device (e.g., a smart appliance), another smart device, a web appliance, a network router, a network switch, a network bridge, or any machine capable of sequentially executing instruction 816, or in some cases specifying the actions that machine 800 should take. Furthermore, although only a single machine 800 is shown, the term “machine” should also be understood to include collections of machines 800 that individually or collectively execute instruction 816 to implement one or more of the methodologies discussed herein.

[0080] In various embodiments, the machine 800 comprises a processor 810, memory 830, and I / O components 850, which may be configured to communicate with each other via a bus 802. In one exemplary embodiment, the processor 810 (for example, a central processing unit (CPU), a reduced instruction set computing (RISC) processor, a complex instruction set computing (CISC) processor, a graphics processing unit (GPU), a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a radio-frequency integrated circuit (RFIC), another processor, or a suitable combination thereof) includes, for example, processors 812 and 814 capable of executing instruction 816. The term “processor” is intended to include a multicore processor 810 which may include two or more independent processors 812, 814 (also called “cores”) capable of executing instruction 816 simultaneously. Figure 8 shows multiple processors 810, but machine 800 may include a single processor 810 with a single core, a single processor 810 with multiple cores (for example, a multi-core processor 810), multiple processors 812, 814 with a single core, multiple processors 812, 814 with multiple cores, or any combination thereof.

[0081] Memory 830, according to some embodiments, includes main memory 832, static memory 834, and a storage unit 836, all accessible to the processor 810 via bus 802. The storage unit 836 may include a machine-readable medium 838 storing instructions 816 thereon, which perform one or more of the methodologies or functions described herein. The instructions 816 may reside, fully or at least partially, in the main memory 832, in the static memory 834, in at least one of the processors 810 (for example, in the processor's cache memory), or in any preferred combination thereof, while being executed by the machine 800. Thus, in various embodiments, the main memory 832, static memory 834, and processor 810 are considered to be the machine-readable medium 838.

[0082] As used herein, the term “memory” refers to, but may be understood to include, random-access memory (RAM), read-only memory (ROM), buffer memory, flash memory, and cache memory, a machine-readable medium 838 capable of temporarily or permanently storing data. Although the machine-readable medium 838 is shown as a single medium in some exemplary embodiments, the term “machine-readable medium” should be understood to include a single or multiple mediums (e.g., a centralized or distributed database, or associated caches and servers) capable of storing the instruction 816. The term “machine-readable medium” should also be understood to include any medium, or a combination of multiple mediums, capable of storing an instruction (e.g., instruction 816) for execution by a machine (e.g., machine 800) such that the instruction 816, when executed by one or more processors of machine 800 (e.g., processor 810), causes machine 800 to implement one or more of the methodologies described herein. Therefore, “machine-readable media” refers to a single storage device or storage apparatus, as well as a “cloud-based” storage system or storage network comprising multiple storage devices or storage apparatuses. The term “machine-readable media” should therefore be understood to include, but not limited to, one or more data repositories in the form of solid memory (e.g., flash memory), optical media, magnetic media, other non-volatile memory (e.g., erasable programmable read-only memory (EPROM)), or a preferred combination thereof. The term “machine-readable media” specifically excludes non-statutory signals themselves.

[0083] The I / O components 850 include a wide variety of components for receiving inputs, providing outputs, generating outputs, transmitting information, exchanging information, and capturing measurements. Generally, it should be understood that the I / O components 850 may include many other components not shown in Figure 8. The I / O components 850 are grouped according to their functionality simply to simplify the following discussion, and the grouping is by no means limiting. In various exemplary embodiments, the I / O components 850 include output components 852 and input components 854. Output components 852 include visual components (e.g., displays such as plasma display panels (PDPs), light-emitting diode (LED) displays, liquid crystal displays (LCDs), projectors, or cathode ray tubes (CRTs)), acoustic components (e.g., speakers), haptic components (e.g., vibration motors), and other signal generators. The input components 854 include alphanumeric input components (e.g., keyboards, touchscreens configured to receive alphanumeric input, photo-optical keyboards, or other alphanumeric input components), point-based input components (e.g., mice, touchpads, trackballs, joysticks, motion sensors, or other pointing means), tactile input components (e.g., physical buttons, touchscreens that provide location and force for touch or touch gestures, or other tactile input components), audio input components (e.g., microphones), and the like.

[0084] In some further exemplary embodiments, the I / O components 850 include, among a wide range of components, biometric components 856, motion components 858, environmental components 860, or positional components 862. For example, the biometric components 856 include components for detecting facial expressions (e.g., hand expressions, facial expressions, voice expressions, gestures, or eye tracking), measuring biosignals (e.g., blood pressure, heart rate, body temperature, sweating, or electroencephalography), or identifying a person (e.g., voice recognition, retinal recognition, facial recognition, fingerprint recognition, or electroencephalography-based recognition). The motion components 858 include acceleration sensor components (e.g., accelerometers), gravity sensor components, rotation sensor components (e.g., gyroscopes), and the like. The environmental components 860 include, for example, illuminance sensor components (e.g., photometers), temperature sensor components (e.g., one or more thermometers for detecting ambient temperature), humidity sensor components, pressure sensor components (e.g., barometers), acoustic sensor components (e.g., one or more microphones for detecting background noise), proximity sensor components (e.g., infrared sensors for detecting nearby objects), gas sensor components (e.g., mechanical olfactory detection sensors, gas detection sensors for detecting concentrations of toxic gases for safety or for measuring airborne pollutants), or other components that can provide displays, measurements, or signals corresponding to the surrounding physical environment. The positional components 862 include, for example, location sensor components (e.g., Global Positioning System (GPS) receiver components), altitude sensor components (e.g., altimeters or barometers for detecting air pressure from which altitude can be derived), direction sensor components (e.g., magnetometers), and the like.

[0085] Communication can be implemented using a wide variety of technologies. Each I / O component 850 may include a communication component 864 that can operate to couple machine 800 to network 880 or device 870 via couplings 882 and 872, respectively. For example, communication component 864 includes a network interface component, or another suitable device for interface with network 880. In further examples, communication component 864 may include wired communication components, wireless communication components, cellular communication components, near-field communication (NFC) components, Bluetooth® components (e.g., Bluetooth® Low Energy), Wi-Fi® components, and other communication components for providing communication via other modalities. Device 870 may be another machine 800 or a wide variety of peripheral devices (e.g., peripheral devices coupled via a Universal Serial Bus (USB)).

[0086] Furthermore, in some embodiments, the communication component 864 includes components that detect or are operable to detect identification information. For example, the communication component 864 includes a radio frequency identification (RFID) tag reader component, an NFC smart tag detection component, an optical reader component (e.g., an optical sensor for detecting one-dimensional barcodes such as Universal Product Code (UPC) barcodes, multi-dimensional barcodes such as Quick Response (QR) codes, Aztec Code, Data Matrix, Dataglyph, MaxiCode, PDF417, Ultra Code, Uniform Commercial Code Reduced Space Symbology (UCC RSS) 2D barcodes, and other optical codes), an acoustic detection component (e.g., a microphone for identifying tagged audio signals), or a preferred combination thereof. In addition, various information can be derived via communication components 864, such as location via Internet Protocol (IP) geographical location, location via Wi-Fi® signal triangulation, and location via detection of Bluetooth® or NFC beacon signals that may indicate a specific location.

[0087] In various exemplary embodiments, one or more parts of network 880 may be an ad-hoc network, an intranet, an extranet, a virtual private network (VPN), a local area network (LAN), a wireless LAN (WLAN), a wide area network (WAN), a wireless WAN (WWAN), a metropolitan area network (MAN), the Internet, a part of the Internet, a part of a public telephone switched network (PSTN), a plain old telephone service (POTS) network, a cellular telephone network, a wireless network, a Wi-Fi® network, another type of network, or a combination of two or more such networks. For example, network 880 or a part of network 880 may include a wireless network or a cellular network, and coupling 882 may be a Code Division Multiple Access (CDMA) connection, a Global System for Mobile communications (GSM) connection, or another type of cellular or wireless coupling.In this example, the combined 882 may implement any of the following types of data transfer technologies: Single Carrier Radio Transmission Technology (1xRTT), Evolution-Data Optimized (EVDO) technology, General Packet Radio Service (GPRS) technology, Enhanced Data rates for GSM Evolution (EDGE) technology, the third-generation partnership project (3GPP®), including 3G, fourth-generation wireless (4G) networks, Universal Mobile Telecommunications System (UMTS), High Speed ​​Packet Access (HSPA), Worldwide Interoperability for Microwave Access (WiMAX), Long Term Evolution (LTE) standards, other standards defined by various standards-setting organizations, other long-range protocols, or other data transfer technologies.

[0088] In exemplary embodiments, instruction 816 is transmitted or received on network 880 using a transmission medium via a network interface device (e.g., a network interface component contained within communication component 864) and utilizing one of several well-known transfer protocols (e.g., Hypertext Transfer Protocol (HTTP)). Similarly, in other exemplary embodiments, instruction 816 is transmitted or received using a transmission medium via a coupling 872 to device 870 (e.g., a peer-to-peer coupling). The term “transmission medium” should be understood to include any intangible medium capable of storing, encoding, or carrying instruction 816 for execution by machine 800, and including digital or analog communication signals or other intangible medium for facilitating communication of such software.

[0089] Furthermore, the machine-readable medium 838 is non-temporary in that it does not carry a propagating signal (in other words, it does not have any temporary signals). However, labeling the machine-readable medium 838 as "non-temporary" should not be interpreted as meaning that the medium is immobile; rather, the machine-readable medium 838 should be considered movable from one physical location to another. In addition, since the machine-readable medium 838 is tangible, it can be considered a machine-readable device.

[0090] Throughout this specification, multiple examples may implement components, operations, or structures described as a single example. While individual operations of one or more methods are presented and described as separate operations, one or more of these operations may be performed simultaneously, and there is no requirement that they be performed in the order in which they are presented. Structures and functionalities presented as separate components in exemplary configurations may be implemented as combined structures or components. Similarly, configurations and functionalities presented as single components may be implemented as separate components. These and other modifications, alterations, additions, and improvements are included within the scope of the subject matter of this specification.

[0091] While the subject matter of the present invention has been described with reference to certain exemplary embodiments, various modifications and changes can be made to these embodiments without departing from the broader scope of the embodiments of the present disclosure.

[0092] The embodiments described herein are described in sufficient detail to enable those skilled in the art to practice the disclosed teachings. Other embodiments may be used, and other embodiments may be derived from those embodiments, so that structural and logical substitutions and modifications can be made without departing from the scope of this disclosure. Accordingly, the embodiments for carrying out the invention should not be understood in a restrictive sense, and the scope of the various embodiments, along with the full scope of the equivalents to which the appended claims are entitled, is defined only by such claims.

[0093] As used herein, the term “or” may be interpreted either comprehensively or exclusively. Furthermore, multiple examples may be provided for a resource, operation, or structure described herein as a single example. In addition, the boundaries between various resources, operations, modules, engines, and datastores are somewhat arbitrary, and certain operations are shown in the context of specific exemplary configurations. Other allocations of functionality are conceivable and may be included within the scope of various embodiments of this disclosure. Generally, structures and functionalities presented as separate resources in exemplary configurations may be implemented as combined structures or resources. Similarly, structures and functionalities presented as single resources may be implemented as separate resources. These and other modifications, alterations, additions, and improvements are included within the scope of the embodiments of this disclosure represented by the appended claims. Accordingly, the specification and drawings should be considered illustrative, not restrictive. [Explanation of Symbols]

[0094] 100 Network Systems 102 Server systems, servers, server machines 104 Network 106 users 110 Client Devices 112 Web Clients 114 Client Applications 120 Application Programming Interface (API) Servers 122 Web Server 124 Vector Generation and Indexing Systems 126 Databases 130 Third-party server systems 132 Third-party applications, third-party websites 134 Third-Party Databases 200 Block Diagram 202 Vector Embedding Generator 204 Internally Embedded Model 206 Vector Management Systems 208 Similarity Search System Figure 300 304 table 306 Tablespace 308 vector data 310 External Embedded Model 312 Databases Figure 400 402 query 406 Vector Similarity Search 500 ways 600 ways 702 Software Architecture 704 Operating Systems 706 Library 708 Framework 710 Applications 712 Application Programming Interface (API) Invocation 714 Message 720 kernel 722 Services 724 Drivers 730 System Library 732 API Libraries 734 Library 750 Home Applications 752 Contacts Application 754 Browser applications 756 Book Reader Applications 758 Location Applications 760 Media Applications 762 Messaging applications 764 Game Applications 766 Third-party applications 767 Third-party applications 800 machines 802 Bus 810 processor, multi-core processor 812 Processors 814 Processors 816 command 830 memory 832 Main Memory 834 Static Memory 836 Storage Units 838 Machine-readable media 850 Input / Output (I / O) Components 852 Output Components 854 Input Components 856 Biometric Authentication Components 858 Motion Components 860 Environment Components 862 Position component 864 Communication Components 870 devices 872 Combine 880 Network 882 Combine

Claims

1. A computer implementation method, The steps include generating vector embeddings for multiple sets of data that will be stored in each of the tables, The steps include storing the vector embeddings for each set of data in the respective tables of the plurality of tables, For each table, the steps include storing the model type and version corresponding to the model used to generate the vector embeddings stored within each of the plurality of tables, The steps include receiving a query and determining a subset of tables from among the multiple tables related to the query, A step of determining the stored model type and version for each table in the subset of tables related to the query, wherein there are at least two different model types or versions for the subset of tables; The steps of generating vector embeddings for the query using the stored model types and versions for each of the at least two different model types or versions for the subset of the table, A step of generating a set of similar data based on the vector embedding for the query and the vector embedding for the set of data stored in the subset of the table, A step of generating a response to the query based on the set of similar data. A computer implementation method, including

2. After the step of generating vector embeddings for multiple sets of data that will be stored in each of the tables of the multiple tables, the computer implementation method The step of generating a vector index for each of the multiple tables. The computer implementation method according to claim 1, including the method described in claim 1.

3. The step of generating a set of similar data based on the vector embedding for the query and the vector embedding for the set of data stored in the subset of the table, The steps include comparing two vectors for similarity and using a function that can utilize the vector index to compare the two vectors. The computer implementation method according to claim 2, including the method described in claim 2.

4. The computer implementation method according to claim 1, wherein at least two different model types are used to generate vector embeddings.

5. The computer implementation method according to claim 1, wherein at least two different versions of the model type are used to generate vector embeddings.

6. The step of generating vector embeddings for multiple sets of data, Steps to transform each data point in each set of data into a vector space with a given number of dimensions. The computer implementation method according to claim 1, including the method described in claim 1.

7. The aforementioned set of similar data includes at least, Comparison of the first vector embedding of the query with the vector embedding for the set of data stored in the first table, and Comparison of the second vector embedding of the aforementioned query with the vector embedding of the set of data stored in the second table. A computer implementation method according to claim 1, determined based on the above.

8. The computer implementation method according to claim 7, wherein the comparison is performed using a function that allows for the comparison of two vectors in terms of similarity.

9. The vector embedding for the set of data stored in the first table is generated using the first model type and the first version, and the computer implementation is The steps include: regenerating vector embeddings for the set of data stored in the first table using the first model type and the second version; The steps include storing the regenerated vector embeddings in the first table, The steps include updating the version of the first table that corresponds to the first model type used to regenerate the vector embeddings for the set of data stored in the first table, and The computer implementation method according to claim 1, further comprising:

10. The steps include receiving a second query corresponding to the first table, A step of determining the first model type and the second version related to the first table, A step of generating a vector embedding for the second query using the first model type and the second version associated with the first table, A step of determining a second set of similar data in the first table based on the vector embedding for the second query and the vector embedding for the set of data stored in the first table, The steps include generating a response to the second query based on the second set of similar data, and The computer implementation method according to claim 9, further comprising:

11. The computer implementation method according to claim 1, wherein the data includes text, images, audio, or video.

12. It is a system, The memory that stores the instructions, One or more processors configured to perform operations according to the aforementioned instructions The above operation is provided, This involves generating vector embeddings for multiple sets of data that will be stored in each of the tables, The vector embeddings for each set of data in the plurality of tables are stored in each of the tables. For each table, the model type and version corresponding to the model used to generate the vector embeddings stored within each of the multiple tables are stored. Receiving queries and Determining the stored model type and version for each table in a subset of tables related to the aforementioned query, and determining that there are at least two different model types or versions for the subset of tables. Using the stored model types and versions for each of the at least two different model types or versions for the subset of the table, generate vector embeddings for the query, Based on the vector embedding for the query and the vector embedding for the set of data stored in the subset of the table, a set of similar data is generated. To generate a response to the query based on the aforementioned set of similar data. A system that includes this.

13. After generating vector embeddings for multiple sets of data that will be stored in each of the tables, the operation proceeds as follows: To generate a vector index for each of the aforementioned tables. The system according to claim 12, further comprising:

14. At least two different model types are used to generate the vector embedding, or At least two different versions of the model type are used to generate the vector embeddings. The system according to claim 12.

15. Generating vector embeddings for multiple sets of data is possible. Transforming each data point in each set of data into a vector space with a given number of dimensions. The system according to claim 12, including the system described in claim 12.

16. The aforementioned set of similar data includes at least, A comparison of the first vector embedding of the query with the vector embedding for the set of data stored in the first table, and Comparison of the second vector embedding of the aforementioned query with the vector embedding of the set of data stored in the second table. The system according to claim 12, determined based on the above.

17. The system according to claim 16, wherein the comparison is performed using a function that allows for the comparison of two vectors in terms of similarity.

18. The vector embedding for the set of data stored in the first table is generated using the first model type and the first version, and the operation is as follows: Using the first model type and the second version, regenerate the vector embeddings for the set of data stored in the first table, The regenerated vector embeddings are stored in the first table, To update the version of the first table that corresponds to the first model type used to regenerate the vector embeddings for the set of data stored in the first table, The system according to claim 12, further comprising:

19. The aforementioned operation, Receiving a second query corresponding to the first table, To determine the first model type and the second version related to the first table, Using the first model type and the second version associated with the first table, generate vector embeddings for the second query, Based on the vector embedding for the second query and the vector embedding for the set of data stored in the first table, a second set of similar data in the first table is determined. To generate a response to the second query based on the second set of similar data. The system according to claim 18, further comprising:

20. A non-temporary computer-readable medium storing instructions that can be executed by at least one processor, wherein the instructions are transmitted to a computing device. This involves generating vector embeddings for multiple sets of data that will be stored in each of the tables, The vector embeddings for each set of data in the plurality of tables are stored in each of the tables. For each table, the model type and version corresponding to the model used to generate the vector embeddings stored within each of the multiple tables are stored. Receiving queries and Determining the stored model type and version for each table in a subset of tables related to the aforementioned query, and determining that there are at least two different model types or versions for the subset of tables. Using the stored model types and versions for each of the at least two different model types or versions for the subset of the table, generate vector embeddings for the query, Based on the vector embedding for the query and the vector embedding for the set of data stored in the subset of the table, a set of similar data is generated. To generate a response to the query based on the aforementioned set of similar data. A non-temporary computer-readable medium that performs actions including [specific actions].

Images