Automating the efficient deployment of artificial intelligence models.

Abstract

To provide a solution that facilitates the process of automatically deploying artificial intelligence (AI) models. [Solution] The system processes input data and deploys a first artificial intelligence (AI) model for use in a production environment for corresponding output generation. It receives a first request for the use of the first AI model for use by an entity. A first model deployment location for the first model is selected based on the model deployment engine. The system generates a script to deploy the first AI model to the selected location, monitors the operational parameters associated with the deployment of the first AI model, and based on its values, updates the model deployment engine. In response to a second request for deploying a second AI model, the system uses the updated model deployment engine to select a second model deployment location for the second model.

Description

Technical Field

[0001] Cross - reference to Related Applications This application claims priority to U.S. Patent Application No. 18 / 390,916, filed on December 20, 2023, entitled "GENERATING A UNIFIED METADATA GRAPH VIA A RETRIEVAL - AUGMENTED GENERATION (RAG) FRAMEWORK SYSTEMS AND METHODS", which is a continuation - in - part of U.S. Patent Application No. 18 / 627,332, filed on April 4, 2024, entitled "AUTOMATING EFFICIENT DEPLOYMENT OF ARTIFICIAL INTELLIGENCE MODELS". This application also claims priority to U.S. Patent Application No. 18 / 617,305, filed on March 26, 2024, entitled "ACCESSING SILOED DATA ACROSS DISPARATE LOCATIONS VIA A UNIFIED METADATA GRAPH SYSTEMS AND METHODS", and to U.S. Patent Application No. 18 / 888,088, filed on September 17, 2024, entitled "ARTIFICIAL INTELLIGENCE SANDBOX FOR AUTOMATING DEVELOPMENT OF AI MODELS". The contents of the aforementioned applications are hereby incorporated by reference in their entirety into this specification.

Background Art

[0002] As computing systems become increasingly complex, the data they use often requires its own data silos (databases, data warehouses, or data lakes) for efficient data processing. However, each computing system having its own data silos means that copies of the data can exist across different silos for each computing system. Consequently, reading and maintaining a single, true version of the data residing in different data silos distributed across one or more computer systems requires enormous computational power. Furthermore, data in one data silo may be similar to data in others. For example, variable names and technical implementations may differ from data silo to data silo, as each computing system may require its own unique variable names, sequencing keys, and integrity constraints, but the underlying data is the same. New applications are built using the latest technologies and techniques, but these quickly become obsolete with the emergence of newer and better implementing systems. These new and emerging silos compromise time and complexity in business processes, and building a coordinated and streamlined silo capable of replacing all existing silos requires enormous effort to build and validate. If left unchecked, this results in similar data residing in multiple data silos that could otherwise be used to store new information, leading to a significant waste of computing resources. [Brief explanation of the drawing]

[0003] [Figure 1] This diagram illustrates a graphical user interface (GUI) used in some implementations of this technology to reduce the use of computational resources when accessing siloed storage data across heterogeneous locations via an integrated metadata graph. [Figure 2]This block diagram shows some of the components typically incorporated into at least some computer systems and other devices in which the disclosed system operates, based on some implementations of this technology. [Figure 3] This is a system diagram illustrating an example of a computing environment in which the disclosed system operates in some implementation forms of this technology. [Figure 4] This flowchart illustrates a process that reduces the use of computing resources when accessing silo storage data across heterogeneous locations via an integrated metadata graph, using one implementation of this technology. [Figure 5] This is a diagram illustrating an illustrative representation of a metadata graph based on one of the implementations of this technology. [Figure 6] This is an enlarged view of the metadata graph based on one of the implementations of this technology. [Figure 7] This is a diagram of an artificial intelligence model based on one of the implementations of this technology. [Figure 8] This flowchart illustrates the process of generating an integrated metadata graph via a retrieval-augmented generation (RAG) framework using one of the implementations of this technology. [Figure 9A] This is an illustrative diagram of a Large Language Model (LLM) prompt, based on one implementation of this technology. [Figure 9B] This is an illustrative diagram of a Large Language Model (LLM) prompt, based on one implementation of this technology. [Figure 10A] This subsystem diagram illustrates an example of a RAG framework environment for generating an integrated metadata graph, based on one of the implementations of this technology. [Figure 10B] This subsystem diagram illustrates an example of a RAG framework environment for generating an integrated metadata graph, based on one of the implementations of this technology. [Figure 10C]This subsystem diagram illustrates an example of a RAG framework environment for generating an integrated metadata graph, based on one of the implementations of this technology. [Figure 10D] This subsystem diagram illustrates an example of a RAG framework environment for generating an integrated metadata graph, based on one of the implementations of this technology. [Figure 11] This is an illustrative representation of the generated metadata graph, based on one implementation of this technology. [Figure 12] This is a block diagram illustrating the components within the AI ​​Sandbox 1200 in some implementation configurations. [Figure 13] This is a block diagram illustrating the components within a data processor in some implementation configurations. [Figure 14] This is a block diagram illustrating the components within a model generator in some implementation configurations. [Figure 15] This block diagram illustrates the functionality of a model governor in various implementation configurations. [Figure 16A] This flowchart illustrates a process for automatically generating artificial intelligence (AI) models using certain implementation methods. [Figure 16B] This flowchart illustrates a process for automatically generating data pipelines for AI models, based on certain implementation configurations. [Figure 17A] This is a diagram of an example chat interface. [Figure 17B] This is a diagram of an example chat interface. [Figure 17C] This is a diagram of an example chat interface. [Figure 17D] This is a diagram of an example chat interface. [Figure 18] This is a schematic diagram illustrating the operation of a model automaton in some implementation configurations. [Figure 19] This flowchart illustrates a process for automating the deployment of AI models using certain implementation methods. [Modes for carrying out the invention]

[0004] In the drawings, for the purpose of discussing some implementations of this technology, some components and / or operations may be separated into different blocks or combined into a single block. Furthermore, while this technology is compatible with various modifications and alternative forms, certain implementations are shown as examples in the drawings and described in detail below. Nevertheless, the intention is not to limit this technology to the specific implementations described. On the contrary, this technology is intended to cover all modifications, equivalents, and alternative forms that fall within the scope of this technology as defined by the attached claims.

[0005] To maintain data integrity between computing systems, modern computing systems may have data silos created to store data for a given computing system or software application. For example, each data silo may consist of unique variable names, access protocols (e.g., SQL, AMQP, etc.), data formats (e.g., relational, non-relational, etc.), or other unique characteristics. Having data silos specifically configured for a given computing system or software application allows the computing system / software application to not only communicate with the given data silo, but also maintain data integrity of the data within that data silo so that only the data within that silo can be modified, thereby protecting data stored in other data silos.

[0006] While data silos offer these benefits, they also result in numerous drawbacks. For example, one such drawback is that a data silo prevents a computing system / software application not configured to communicate with that data silo from retrieving or receiving data from it. Since each data silo can be configured for a specific software application or computing system, data scientists must reconfigure the data silos or software applications / computing systems when new software applications are built or computing systems are scaled down. Another drawback is that data silos can store the same or similar information as other data silos. For example, the configuration of such data silos (e.g., variable names, access protocols, data formats, or other characteristics) could allow one data silo to store information associated with a first variable name, and another data silo to store the same information associated with a second variable name, where the first and second variable names are different. The variable names may differ, but the underlying data can be the same (or similar). This results in a significant waste of computing memory across computing systems because various copies of the data exist in different data silos. Another drawback is that searching for data that may be stored within a data silo is often difficult due to its configuration. For example, because each data silo is isolated from others, there is no common interface for searching all available data silos at once, forcing users to manually search each and every data silo iteratively until they find the data they need. This is not only a waste of time, but such iterative searches consume a significant amount of wasted computing resources, as each and every data silo requires hundreds, if not thousands, of queries. Data retrieval from distributed silos becomes even more complex when it is not known where the data is stored.

[0007] Existing systems have previously attempted to address these shortcomings by utilizing computers and data scientists to create new data silos that (i) can remove copies of the data and (ii) have the ability to communicate with all computing systems / software applications that utilize such data. Nevertheless, the manual creation of new data silos is practically impossible to implement. For example, the sheer scale of modern computing systems means there may be hundreds, if not thousands, of data silos and corresponding computing systems / software applications that would need to be modified to communicate and utilize such data. Since these computing systems / software applications rely on the massive amounts of data stored within these data silos, which will be processed in real time (or near real time), reconfiguring such systems, applications, or data silos would result in significant computing system downtime, thereby impacting the user experience.

[0008] Furthermore, even when computer and data scientists manually create new data silos, there is a threat that this will impact the data integrity of the data stored in the data silos. For example, when creating a new data silo, computer / data scientists may not only have to remove copies of the data but also reformatting the data so that the intended computing system / software application can communicate effectively with the data in the data silo. Such modifications to the data can corrupt it and render such valuable data unusable. Even when data scientists create copies of the data silo if the data stored in a given data silo becomes corrupted, this further exacerbates the problem of wasted computer memory, as even more copies of the data must be created.

[0009] Moreover, creating new data silos or restructuring existing computing systems / software applications creates further problems of wasting the computing resources (e.g., computer processing and computer memory resources) of a given system. For example, when each data silo, computing system, or software application has to be restructured / created, computing resources are wasted because each new data silo or new computing system / software application occupies a large amount of memory. Therefore, creating these new data silos, computing systems, or software applications further exacerbates these problems.

[0010] For these and other reasons, there is a need to stop copying data and simplify data access patterns when accessing siloed storage data spanning different locations via an integrated metadata graph. There is a further need to enable user access to such siloed storage data without creating new data silos, databases, or restructuring existing computer systems and / or software applications. There is a further need to maintain data integrity of the data stored within data silos without requiring multiple copies of the data to be stored within the data silos.

[0011] For example, as described above, existing systems lack a mechanism for accessing siloed storage data that spans different locations without creating new computational components. Since existing systems rely on creating new data silos, databases, computing systems, software applications, and the like to access siloed storage data, such new computational components require a large amount of resources to effectively access the data. Further, since these existing systems rely on creating new data silos, the time and energy expended can lead to long-term computing system downtime. Moreover, since existing systems are prone to corrupting data during the creation process of such computational components, existing systems rely on creating various copies of the data silos themselves, which can further exacerbate the problem of wasting valuable computer memory resources.

[0012] To overcome these and other shortcomings of existing systems, the inventors have developed systems and methods for reducing the use of computational resources when accessing siloed data across heterogeneous locations via an integrated metadata graph. For example, the system can receive user-defined queries in a graphical user interface (GUI) that instruct a request to access a set of data objects, where each data object in the set is stored in its respective data silo within a set of data silos in heterogeneous locations. For example, the system can receive user queries to access data stored across various data silos. The system can then perform natural language processing on the user-defined query to determine the set of clauses corresponding to the user-defined query. For example, to enable a non-technically savvy user to access the data they desire, the system can determine a contextually accurate set of clauses (based on the user query) to provide the data the non-technically savvy user is trying to access.

[0013] The system then accesses the metadata graph to determine the node corresponding to the set of clauses. The metadata graph may comprise a set of nodes, each having (i) metadata indicating an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges indicating the data lineage between sets of nodes. For example, by using a metadata graph, the system can traverse a metadata graph that indicates where data (e.g., data objects) is stored and which data in different data silos is available. In this way, data scientists can reduce the use of computing resources by not having to create new data silos and / or reconfigure existing computing systems / software applications, as the metadata graph can provide an abstraction layer about which data is stored where. Furthermore, because the metadata graph includes the data lineage between sets of nodes (e.g., representations of data stored within the data silos themselves), the system can provide even more information about where copies of data intended for user access may reside, which the system can leverage to efficiently find where copied data is hosted. The system then determines the data silo containing at least one data object from the set of data objects, using the location identifier corresponding to the determined node, in order to retrieve at least one data object from the set of data objects via the data silo. The system then generates a visual representation of at least one data object for display on a GUI. For example, the system can then provide data intended for access by a non-technically savvy user.Therefore, by leveraging the capabilities of metadata graphs to access siloed data, systems can reduce the utilization of computing resources caused by generating new data silos, computing systems, or software applications to access data stored across different data silos in heterogeneous locations.

[0014] Metadata graphs reduce data retrieval times when accessing silo-stored data across heterogeneous locations (e.g., data silos hosted in various locations), but there is a further need to optimize the generation of such metadata graphs. For example, traditional approaches to locating data may involve manually generating tables containing metadata for silo-stored data, but generating these tables is inefficient and wastes significant computing resources (e.g., computer memory and processing power), as computer scientists must first find the metadata, normalize the data (e.g., based on mere opinion), and then create the tables. Not only is creating such tables inefficient, but these tables are also prone to errors, given the enormous amount of data to consider and the various copies of the data inherent in many copies of the data stored in different data silos. To reduce errors and overcome the inherent inefficiencies of traditional approaches, inventors have developed optimized data structures (e.g., metadata graphs) that reduce data retrieval times compared to parsing error-prone metadata tables. The inventors have further developed optimized methods for generating error-free metadata by leveraging large-scale language models, the metadata itself, and domain-specific languages ​​to reduce the time required to generate such data structures while increasing metadata normalization and accuracy to ensure correct metadata labeling.

[0015] For example, the system can select a first LLM prompt from a set of Large Language Model (LLM) prompts that corresponds to a first metadata identifier from a set of metadata identifiers. The LLM prompt may correspond to a first metadata identifier based on the data profile of the metadata identifier (e.g., data schema, data format, etc.). The system can then extend the first LLM prompt with a first metadata identifier that will be provided to the LLM, which is configured to produce a first intermediate output that points to a second set of metadata identifiers corresponding to the first metadata identifier. For example, the system can provide a first metadata identifier to the first LLM prompt to cause the LLM to generate a set of semantically similar metadata identifiers. A set of semantically similar metadata identifiers can represent variations of the first metadata identifier (e.g., to "ask" the LLM what it thinks the first metadata identifier represents).

[0016] The system can then extend the first LLM prompt with a first intermediate output (e.g., a second set of metadata identifiers) that will be provided to the LLM, which is configured to generate a second intermediate output that points to filtered domain-specific metadata identifiers by accessing a set of domain-specific ontologs. For example, by providing the extended LLM prompt to an LLM (e.g., one that is communicatively concatenated to a set of domain-specific ontologs), the LLM can leverage the contextual knowledge provided by the domain-specific ontologs to generate normalized domain-specific metadata identifiers. The domain-specific ontologs contain relationships between phrases, words, or descriptions of data that exist within the entity's computing system, thereby providing the entity with a level of contextual knowledge. The LLM can leverage this contextual knowledge to generate filtered domain-specific metadata identifiers. Furthermore, by using an LLM communicatively concatenated to a domain-specific ontolog, the system can reduce the amount of computational resources required to generate the metadata graph by reducing the dataset of metadata identifiers to consider (e.g., via access to the domain-specific ontologs).

[0017] The system can then generate a domain-specific integrated metadata graph via LLM using (i) a first metadata identifier and (ii) a second intermediate output indicating a filtered domain-specific identifier. For example, the filtered domain-specific metadata identifier may be a traversable identifier, and the first metadata identifier may be a non-traversable identifier in the domain-specific integrated metadata graph. By generating a domain-specific integrated metadata graph with traversable and non-traversable identifiers, the system reduces data retrieval time by reducing the amount of information that would need to be traversed when identifying where data is located (e.g., within data silos via the metadata graph), while maintaining the verifiability and accuracy of the metadata graph (e.g., by associating an unfiltered, non-domain-specific first metadata identifier with the filtered domain-specific metadata identifier). In this way, the system maintains data integrity of metadata across heterogeneous data silos by transforming metadata into a verifiable metadata graph in order to efficiently find and determine available underlying data stored across data silos. Finally, to ensure data retrieval time efficiency, the system determines performance metrics for the generated domain-specific integrated metadata graph against previous performance metrics for other versions of the domain-specific integrated metadata graph. If the performance metrics for the generated domain-specific integrated metadata graph do not meet the performance metrics for previous versions of the domain-specific integrated metadata graph, the system performs an update process for the domain-specific integrated metadata graph. In this way, the system can ensure that data retrieval time is minimized and that the generation, update, or modification of the domain-specific integrated metadata graph is accurate when it occurs.

[0018] In various implementations, the methods and systems described herein can reduce the use of computational resources when accessing siloed data across heterogeneous locations via an integrated metadata graph. For example, the system can receive queries (e.g., via a GUI) that instruct requests to access a set of data objects, each data object in the set of data objects being stored in a data silo in a set of data silos in heterogeneous locations. The system can perform natural language processing on the query to determine the corresponding set of clauses. The system can then access the metadata graph to determine the nodes corresponding to the set of clauses, the metadata graph comprising a set of nodes each having (i) (a) metadata indicating an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges indicating the data lineage of the set of nodes, the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers. The system can then determine the data silo storing at least one data object in the set of data objects using the location identifier corresponding to the determined node, in order to retrieve at least one data object in the set of data objects via the data silo. The system can then generate a visual representation of at least one data object for display on the GUI.

[0019] In various implementations, the methods and systems described herein can reduce data retrieval time when accessing siloed storage data across heterogeneous locations by generating an integrated metadata graph via a Search Expansion Generation (RAG) framework. For example, the system selects a first LLM prompt from a set of LLM prompts that corresponds to a first metadata identifier from a set of metadata identifiers. The system then extends the first LLM prompt with a first metadata identifier that will be provided to the LLM, and the LLM is configured to generate a first intermediate output that points to a second set of metadata identifiers corresponding to the first metadata identifier. The system then extends the first LLM prompt with a second set of metadata identifiers that will be provided to the LLM, and the LLM is configured to generate a second intermediate output that points to filtered domain-specific metadata identifiers by accessing a set of domain-specific ontologs. The system can then use (i) the first metadata identifiers and (ii) the second intermediate output pointing to filtered domain-specific metadata identifiers to generate a domain-specific integrated metadata graph via the LLM. Filtered domain-specific metadata identifiers can be traversable identifiers, and the first metadata identifier can be a non-traversable identifier within the domain-specific integrated metadata graph. In response to determining that the first performance metric of the domain-specific integrated metadata graph cannot meet the performance measure of the second performance metric of another version of the domain-specific integrated metadata graph, the system performs an update process for the domain-specific integrated metadata graph.

[0020] This domain-specific, integrated metadata graph also enables the system to automatically build or apply artificial intelligence (AI) models. The AI ​​sandbox, as implemented herein, provides a low-code or no-code environment in which data from heterogeneous locations, as represented by the metadata graph, is used to automatically generate AI models for data analysis or to automatically apply existing AI models to the data.

[0021] In some implementations, the computer system generates a dataset for training or applying to an AI model. The computer system may receive a first natural language input from the user, which includes a set of phrases and instructions for analyzing the data associated with the set of phrases using an artificial intelligence (AI) model. In response to the first natural language input, the computer system accesses a metadata graph to determine the nodes corresponding to the set of phrases, which includes a set of nodes containing (i) (a) metadata pointing to internal data objects stored in data silos, and (b) location identifiers for the data silos, and (ii) edges pointing to the data lineage of the set of nodes. The system processes the internal data objects pointed to by the determined nodes to generate a first set of application data, and applies the AI ​​model to the first set of application data to generate one or more first outputs. For example, the first output may include a classification of data items in the first set of application data, or a prediction made based on the first application data. One or more representations of the outputs are sent for display to the user. Subsequently, a second natural language input can be received from the user, which includes instructions for modifying the first set of application data. Based on the second natural language input, the computer system generates a second set of application data. The AI ​​model can then be applied to this second set of application data.

[0022] In some implementations, the computer system automates the deployment of AI models. The computer system can receive a first request for a first artificial intelligence (AI) model to be used by an entity, to deploy the first AI model and make it available for use in a production environment to process input data and generate corresponding outputs. Based on the model deployment engine, the computer system selects a first model deployment location for the first AI model, which can be selected from one or more cloud provider environments or an on-premises environment operated by the entity. The computer system generates a script to deploy the first AI model to the first model deployment location and, after the model is deployed, monitors the operational parameters associated with the deployment of the first AI model at the selected model deployment location as the first AI model processes input data and generates corresponding outputs. Based on the monitored operational parameters, the computer system can update the model deployment engine and, in response to a second request to deploy a second AI model, select a second model deployment location for the second AI model based on the updated model deployment engine.

[0023] The following description includes numerous specific details to provide a complete understanding of the porting of this technology. Nevertheless, it will be apparent to those skilled in the art that implementations of this technology are possible even without some of these specific details.

[0024] The phrases "in some implementations," "in several implementations," "by some implementations," "in the indicated implementations," "in other implementations," and similar phrases generally mean that the particular feature, structure, or characteristic following the phrase is present in at least one implementation of the Art and may be present in one or more implementations. In addition, such phrases do not necessarily refer to the same or different implementations.

[0025] System Overview Figure 1 illustrates a graphical user interface (GUI) representation for reducing the use of computing resources when accessing siloed data across heterogeneous locations via an integrated metadata graph, based on one implementation of the technology. For example, the user interface 100 may include a user-specified query input 102, a result output 104, a visual representation of at least one data object 106, and data lineage information 108 (e.g., 108a-108b) for at least one data object. For example, the user-specified query input 102 may be a data field configured to accept a user-specified query as input. The user can provide a query to the user-specified query input 102 for accessing data that may be stored across heterogeneous data silos of the computing system. The result output 104 may include one or more visual representations of at least one data object 106, and data lineage information 108 corresponding to at least one data object 106. For example, in a context where a non-technically savvy user attempts to find, or otherwise access, data that may be stored between a set of data silos relating to one or more computing systems, the user interface 100 provides a mechanism to enable such a user to find the data they want or need.

[0026] Often, users are unaware of which data silos (e.g., databases) host the data they intend to retrieve, nor do they know exactly what data they might need for a given purpose. For example, a non-technically savvy user, such as a business user, might want a list of all the initial names of users who were active last month. Therefore, the user could provide a user-specified query input 102 stating, "I want all the initial names of users who were active last month," and the system could generate result output 104. As will be discussed later, the system can perform natural language processing on the user-specified query to obtain a set of phrases (e.g., keywords, semantically similar phrases, etc.) for searching the metadata graph. The metadata graph may also be a graph indicating where data is stored and what data is available. For example, when the user-specified query can be in question format, the system can determine a set of phrases for accessing the metadata graph by removing irrelevant terms from the user-specified query. This set of phrases could not only be a "cleaned-up" version of the user-specified query, but could also serve to target what data the user intends to retrieve. By leveraging access to the metadata graph, the system can display a result output 104 which may include a visual representation of at least one data object 106 (e.g., the data the user is trying to access, the location of the data the user is trying to access, the format of how the data the user is trying to access is stored, etc.) and may also include a visual representation of data lineage information 108 (e.g., where copies of the data or similar data may be stored, the format of how the data is stored, etc.).Thus, for users who are not technically savvy, an integrated, user-friendly interface can be provided that offers a central access point for accessing data stored between different data silos in different locations, while improving the user experience.

[0027] In some implementations, the visual representation of at least one data object 106 may be interactive. For example, the visual representation of at least one data object 106 may be a bidirectional link (e.g., a hyperlink) that, when the user selects the visual representation of at least one data object 106, allows the user to access the data associated with that data object (e.g., by generating a visual representation of a table containing at least one data object, or by generating a window showing at least one data object). In this way, the user is able to quickly and efficiently browse the data they intend to access.

[0028] Appropriate computing environment Figure 2 is a block diagram showing some of the components typically incorporated into at least some computer systems and other devices in which the disclosed system operates. In various implementations, these computer systems and other devices 200 may include server computer systems, desktop computer systems, laptop computer systems, netbooks, mobile phones, personal digital assistants, televisions, cameras, automotive computers, electronic media players, web services, mobile devices, watches, wearables, eyeglasses, smartphones, tablets, smart displays, virtual reality devices, augmented reality devices, and the like.In various implementations, the computer system and device include an input component 204, including a keyboard, microphone, image sensor, touchscreen, buttons, trackpad, mouse, CD drive, DVD drive, 3.5mm input jack, HDMI® input connection, VGA input connection, USB input connection, or other computing input components; an output component 206, including a display screen (e.g., LCD, OLED, CRT, etc.), speaker, 3.5mm output jack, light, LED, tactile motor, or other output-related components; a processor 208, including a central processing unit (CPU) for executing computer programs, a graphical processing unit (GPU) for executing computer graphics programs and handling computing graphical elements; and data during the program's use, including the program (e.g., applications 212a-212N, models 214a-214N, and other programs), as well as the equipment and associated data. The system includes zero or more of the following: storage 210, which includes at least one computer memory for storing data, an operating system including a kernel, and device drivers; network connection components 216, which allow a computer system to communicate with other computer systems and send and / or receive data via the Internet or another network, and its networking hardware such as switches, routers, repeaters, electrical cables and optical fibers, light emitters and optical receivers, wireless transmitters and receivers, and the like; persistent storage devices 218, such as hard drives or flash drives, for permanently storing programs and data; and computer-readable media drives 220 (e.g., at least one non-temporary computer-readable medium), which are tangible storage means that do not include temporary propagation signals, such as floppy disks, CD-ROMs, or DVD drives, for reading programs and data stored on computer-readable media.While the computer system configured as described above is typically used to support the operation of the equipment, those skilled in the art will understand that the equipment can be realized using devices of various types and configurations, as well as having various components.

[0029] Figure 3 is a system diagram illustrating an example of a computing environment in which the disclosed system operates in some implementations. In some implementations, the environment 300 includes one or more client computing devices 302a-d, which may host a metadata graph 500 (Figure 5) (or other system components). For example, computing devices 302a-d may each comprise distributed entities a-d. Client computing devices 302 operate in a networked environment using logical connections via a network 304 to one or more remote computers, such as server computing devices. In some implementations, client computing device 302 may correspond to device 200 (Figure 2).

[0030] In some implementations, server computing device 306 is an edge server that receives client requests and coordinates the execution of these requests through other servers such as servers 310a-c. In some implementations, server computing devices 306 and 310 comprise a computing system. Although each server computing device 306 and 310 is logically represented as a single server, each server computing device can be a distributed computing environment encompassing numerous computing devices located in the same or geographically heterogeneous physical locations. In some implementations, each server computing device 310 corresponds to a group of servers. In some implementations, server computing devices 306 and 310 host large-scale language models, sets of domain-specific ontologs, artificial intelligence models, user interfaces, web servers, or other computing components.

[0031] The client computing device 302 and the server computing devices 306 and 310 can each function as a server or client to other servers or client devices. In some implementations, the server computing devices (306, 310a-c) connect to the corresponding databases (308, 312a-c). As described above, each server computing device 310 can correspond to a group of servers, each of which can share a database or have its own database (e.g., a data silo). Databases 308 and 312 store (e.g., contain) information such as predefined ranges, predefined thresholds, error thresholds, graphical representations, machine learning models, artificial intelligence models, natural language processing models, LLMs, LLM prompts, keywords, metadata graphs, location identifiers, lineage information, semantically similar phrases, file-level metadata identifiers, container-level metadata identifiers, system-level metadata identifiers, governance policies, usage metrics, machine learning model training data, artificial intelligence model training data, performance metrics, data schemas, data profiles, or other information. In some implementations, databases 308 and 312 may be data silos.

[0032] Although databases 308 and 312 are logically presented as a single unit, they can each be a distributed computing environment encompassing numerous computing devices, reside on their respective servers, or be located in the same or geographically different physical locations.

[0033] Network 304 can be a local area network (LAN) or a wide area network (WAN), but it can also be another wired or wireless network. In some implementations, network 304 is the internet or some other public or private network. Client computing devices 302 are connected to network 304 through a network interface, such as by wired or wireless communication. Although the connection between server computing devices 306 and 310 is shown as a separate connection, these connections can be any type of network, including network 304, or another public or private network, including local, wide area, wired, or wireless networks.

[0034] Accessing silo storage data across different locations Figure 4 is a flowchart illustrating a process 400, one of the implementations of this technology, which reduces the use of computing resources when accessing silo storage data across heterogeneous locations via an integrated metadata graph.

[0035] In Act 402, Process 400 receives a user-defined query that directs a request to access a set of data objects. For example, the system receives a user-defined query in the GUI that directs a request to access a set of data objects, and each data object in the set of data objects is stored in its respective data silo in a set of data silos in heterogeneous locations. A data object can be any object that can be stored in a data silo, a single piece of data, or a piece of information, such as a file, information contained within a file (e.g., first name, last name, email address, home address, business address, financial information, account identifier, account number, value, percentage, ratio, alphanumeric string, statement, etc.), a table, a data structure, or other data object.

[0036] Data objects (for example, those a user is trying to access) can be stored across various data silos (e.g., databases) within a computing environment (e.g., Environment 300 (Figure 3)). For example, a user might want to access account-related data for one or more user accounts. However, this account-related data could still be stored in one or more data silos within the computing environment. For example, one data silo might indicate how many accounts are currently open / active (e.g., the first data object), and another data silo might indicate the names of the users who opened the accounts (e.g., the second data object). A user might not be aware of where such data resides, if available. Therefore, a user can provide a user-defined query that directs a request to access a set of data objects, and the system can return the data (e.g., the set of data objects) to the user, as will be explained later. In this way, the system improves the user experience because the user can access such data without needing any prior knowledge of where the data may or may not reside.

[0037] In Act 404, Process 400 may perform natural language processing to determine a set of clauses. For example, the system may perform natural language processing on a user-defined query to determine a set of clauses corresponding to the user-defined query. Since data stored between data silos may contain the same data (e.g., copies of data) or similar data, the system may determine a set of clauses corresponding to a user-defined query for efficiently searching the data stored between data silos. For example, one data silo storing user account information, such as a user's last name, may store the user's last name as a variable called "last_name". Yet another data silo storing user account information may store the user's last name as a variable called "given_name". The data stored is the same (e.g., each silo stores the user's last name), but the variable names may be different. Therefore, when searching the data, the system can determine a set of clauses corresponding to a user-provided query for accessing the data.

[0038] In some implementations, the system determines a set of semantically similar phrases corresponding to a user-specified query. For example, the system parses the user-specified query for a set of keywords. This set of keywords may correspond to a set of data objects stored in a data silo. For example, a user provides a query (e.g., "I want the first names of all users who were active last month"). The system parses the user-specified query for a set of keywords (e.g., first name, active, etc.). For each keyword, the system can determine a set of semantically similar phrases.

[0039] For example, data may be stored in different silos for each computer application across an entity's computing systems, so the same or similar data may be stored in various formats. For instance, a database storing a table of user account information might store the user's first name as a variable such as "name_first", "account_ID", "first_name", "name", or something else. In this way, the system determines a set of semantically similar phrases corresponding to each keyword in a set of keywords used to search the metadata graph to retrieve the data the user intends to receive.

[0040] The system can then use a set of semantically similar phrases corresponding to each keyword in a set of keywords to determine the set of phrases corresponding to the user-specified query. For example, continuing the above example, if the user-specified query is "I want the first names of all users who were active last month," the system can determine the first set of semantically similar phrases for "first name" (e.g., "name_first", "account_ID", "first_name", "name") which will be used when accessing the metadata graph to determine nodes (e.g., metadata for data objects stored in silos, and lineage data for such data objects). In this way, the system can more efficiently determine the location of the data needed based on a set of semantically similar phrases (e.g., when traversing the metadata graph) as opposed to being limited to a single phrase, keyword, or variable name, so the system can use the metadata graph to reduce the computational resource usage for accessing silo storage data.

[0041] In some implementations, the system can determine semantically similar phrases by accessing a database. For example, the database can dictate a mapping between a set of first keywords and a set of second keywords. In some implementations, the database can store a pre-determined set of keywords generated by a Subject Matter Expert (SME). In this way, the SME can create such a database to accurately determine which keywords are semantically similar to others, thereby improving the accuracy of determining semantically similar phrases.

[0042] In some implementations, the database can be based on an artificial intelligence model. For example, given a large number of user-specified queries, a large amount of semantically similar phrases, and unique data that can be searched within a data silo, the system can use an AI model to determine sets of semantically similar phrases, or generate a database to determine semantically similar phrases. The AI ​​model may be a machine learning model configured to take keywords (e.g., phrases) as input and output sets of semantically similar keywords (e.g., semantically similar phrases). Due to the nature of machine learning models (or other AI models) that have the ability to learn associations between training data (e.g., labeled instances of keywords and semantically similar phrases), the model is not limited to a predefined set of keywords and phrases. For example, a machine learning model can generate new, undiscovered instances of semantically similar phrases corresponding to a given keyword that may not be plausible to the human mind. Thus, by using a machine learning model, the system can determine a set of semantically similar phrases corresponding to each respective keyword. In this way, since the machine learning model is not limited to a given set of keywords, the system can determine more robust semantically similar phrases, thereby expanding the range of possible semantically similar phrases that can be generated.

[0043] In response to accessing the database, the system can determine a set of semantically similar phrases corresponding to each keyword by using each keyword. For example, the system can parse the database using each keyword to determine a match between (i) each keyword and (ii) the keyword in the database. When identifying a match, the system can obtain a set of semantically similar phrases corresponding to the keyword. In this way, the system can reduce the computational resources used when determining semantically similar phrases by using matches, as opposed to performing natural language processing on each keyword to determine a set of semantically similar phrases.

[0044] In Act 406, Process 400 can access the metadata graph to determine the node corresponding to a set of clauses. For example, the system can access the metadata graph to determine the node corresponding to a set of clauses. The metadata graph may include (i) a set of nodes and (ii) edges indicating the data lineage of the set of nodes. The set of nodes may include (a) metadata indicating internal data objects stored in data silos and (b) location identifiers of the data silos. For example, the metadata graph may be a graph data structure indicating metadata for information stored in a set of data silos in Environment 300 (Figure 3).

[0045] As described above, when accessing data that may be stored in data silos in different locations, each data silo may be associated with its own configuration for accessing the data stored within it. When designing computing systems / software applications, data scientists and computer scientists may carefully design data silos, computing systems, and software applications to communicate effectively with each other via one or more communication protocols. Nevertheless, this creates a scalability problem when scaling computing systems, as the data required for a given computing system / software application may become inaccessible due to the configuration of either the computing system / software application or the data silo itself. Furthermore, searching for the required data can be difficult because information stored in one data silo may be the same underlying data as in another data silo, even if it has different variable names (e.g., variable identifiers, metadata identifiers, etc.). When searching for such required data for a given computing system / software application, existing systems can parse each and every data silo available for a given match between the data stored within the data silos and the data intended to be accessed (e.g., the required data). Nevertheless, parsing each and every data silo in the environment wastes valuable computer processing and memory resources, as it involves determining whether a match exists between each and every data silo and the information stored within it.

[0046] To address these technical shortcomings, accessing the metadata graph to determine the node corresponding to a set of clauses (e.g., clauses, keywords, and alphanumeric strings corresponding to user-specified queries) can be used to quickly and efficiently identify and access data, thereby reducing the use of computing resources.

[0047] Referring to Figure 5, which illustrates an illustrative representation of a metadata graph, the metadata graph 500 may include a set of nodes 502a-502m and edges 504a-504q. Each node 502 may be linked to or connected to one or more other nodes via one or more edges 504. Each node 502 may indicate metadata for one or more data silos, such as metadata for internal data objects stored within a given data silo (e.g., file-level metadata), metadata for the data silo itself (e.g., container-level metadata), and location identifiers for a given data silo (e.g., where the data silo is located, such as compute component node identifiers or server identifiers). Each edge 504 may indicate the data lineage of a set of nodes. For example, each edge may represent a lineage relationship between a first node and a second node. That is, each edge may indicate whether a node is a data source of another node or a derivative of another node.

[0048] For example, Figure 6 shows an enlarged view of the metadata graph. In some implementations, the enlarged view 600 of the metadata graph may correspond to a portion of the metadata graph 500 in some implementations of this technology. For example, the first node 602a may indicate the metadata of one or more data objects stored in a data silo. For example, the first node 602a may include a file-level metadata identifier 606a, a container-level metadata identifier 608a, and a data silo location identifier 610a. The file-level metadata identifier 606a may be a variable name, file name, or other identifier that indicates a single piece of data stored in a given silo. For example, the file-level metadata identifier may be any identifier that describes data stored in a file stored in a data silo (e.g., a variable identifier, file format, file size, access timestamp, or other file-level metadata). The container-level metadata identifier 608a may also be an identifier that identifies the format in which the data stored in a given data silo can take (e.g., table format, tabular format, graphical format, dictionary, etc.), one or more configurations of the data silo (e.g., communication protocol, accessibility parameters, etc.), or other container-level metadata associated with a given data silo. The location identifier 610a may also be an identifier that indicates the location of a given data silo. For example, the location identifier may indicate the location of the computer node to which the data silo is associated (e.g., stored, hosted, connected, etc.), the computer system to which the data silo is associated, the server to which the data silo is hosted or otherwise associated, or other location identifiers.

[0049] Each node in the set of nodes (e.g., nodes 602a-602d) may have its own file-level metadata identifier 606, container-level metadata identifier 608, or location identifier 610. Each node in the set of nodes can represent an abstract diagram of how data is derived from one another, where the data resides, and which data is available, so that the system can leverage the metadata graph to efficiently find where the data resides, along with the lineage information of the data itself. In other words, a node can represent an abstract diagram of how data is stored across data silos, the relationships between data stored in data silos, and where data is stored between data silos. For example, the first node 602a may be linked to the second node 602b via the first edge 604a. In some implementations, the first edge 604a may indicate the lineage information of the nodes, such as the second node 602b being the data source for the first node 602a. Nevertheless, in other implementations, the first edge 604a can indicate lineage information, such as when the first node 602a is the data source for the second node 602b, as in some implementations of this technology. Each node 602 may be linked to other nodes via the edge 604, and it should be apparent to those skilled in the art that each edge indicates lineage information between one or more nodes in a set of nodes.By representing data objects through a metadata graph that indicates (i) where the data object (e.g., data stored in a data silo) is located, (ii) metadata of the data object itself, (iii) metadata of the data silo that stored the data object, and (iv) the location of such data silo, the system can more efficiently traverse the metadata graph to access data stored in data silos in heterogeneous locations, in contrast to existing systems that rely on manually parsing each and every data silo for a match between the data the user is trying to access and the data stored within the silo itself, thereby reducing the use of computational resources when accessing silo-stored data across heterogeneous locations.

[0050] In some implementations, the system can determine the node corresponding to a set of clauses by traversing the metadata graph. For example, the system can traverse each node in the set of nodes in the metadata graph. The system can compare the metadata identifier of a given node with each clause in the set of clauses. For example, the metadata identifier may be a file-level, container-level, or other identifier indicating that a given data silo contains data related to the clause. For example, the metadata identifier may be "first_name" (e.g., a file-level metadata identifier) ​​indicating that the data silo contains the user's first name. In response to determining that the metadata identifier matches at least one clause in the set of clauses, the system can determine the node corresponding to the set of clauses.

[0051] For example, in contrast to traversing a metadata graph using a single phrase, the system traverses the metadata graph and compares each phrase in a set of phrases with the metadata identifier of a given node. In other words, in contrast to existing techniques that traverse a graph (e.g., a metadata graph or other graphs) using a given keyword, the system traverses the graph using a set of phrases. In this way, the system can more efficiently determine the node corresponding to the set of phrases because the system does not have to perform numerous traverses of the graph using a different phrase each time, thereby reducing the use of computational resources.

[0052] In some implementations, the system can determine another data silo that stores a second data object. For example, the system can traverse each node in a set of nodes (e.g., a metadata graph) to identify a metadata identifier that matches at least one clause in a set of clauses. In response to determining that the metadata identifier matches at least one clause in the set of clauses, the system determines the first node corresponding to the set of clauses. It is still possible that the system has determined the first node corresponding to the set of clauses (e.g., by determining the data silo that stores the data object associated with the set of clauses), but the system can still continue traversing the metadata graph to determine other locations (e.g., data silos) that host a given data object.

[0053] For example, if a user-defined query states "I want all locations where the user's first name resides," the system can continue traversing a set of nodes using edges connected to a given node. For example, in response to determining that a first node corresponds to a set of clauses, the system can perform a second traverse of nodes in the set to determine a second node using an edge that points to the first data lineage of the first node. The first data lineage of the first node can point to a second node containing information that is the source of the information associated with the first node. For example, each edge in a metadata graph can point to a lineage of data objects. Since each node in the set of nodes points to metadata (e.g., data of data), edges between nodes can point to one node being the source (or alternatively, a derived data source of another node) of another node.

[0054] To illustrate, referring to Figure 6, the system can determine a first node corresponding to a set of clauses, such as the first node 602a. The system can traverse to the second node 602b using the first edge 604a, to the third node 602c using the second edge 604b, or to the fourth node 602d using the third edge 604c. In some implementations, after performing the first traverse (e.g., from the first node 602a to the second node 602b), the system can perform a second traverse (e.g., from the first node 602a to the third node 602c). The system can iterate through such traverses until each node has been traversed, or until there are no more nodes remaining that correspond to a set of clauses after a traverse has been performed. In this way, the system can access silo-stored data more efficiently by traversing the metadata graph, as opposed to parsing each and every data silo in the computing environment for matches.

[0055] Therefore, the system can determine which second data silo contains the second data object (e.g., the same data object, or a similar data object related to at least one data object) by using the location identifier corresponding to the second node to retrieve the second data object from the set of data objects via the second data silo. In other words, the system can determine alternative locations (e.g., data silos) where a given data object may be stored by traversing the metadata graph using edges connected to the determined node. In this way, the system can determine all locations where the same or similar data may be stored. In some implementations, the system can then generate a visual representation of the second data object on a GUI. In this way, the user may be provided with additional data of interest to them.

[0056] In some implementations, in response to determining which data silo contains a given data object, the system can perform one or more data aggregation techniques. For example, the system can remove unnecessary instances of the data itself. For instance, since a metadata graph is an abstraction that indicates where data is located and what data a given silo may contain, the system can remove all but one instance of data (e.g., a data object) to reduce the amount of computer memory used.

[0057] In some implementations, process 400 can generate a metadata graph using the generated metadata data structure. For example, the system can extract (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers from each data silo in a given environment (e.g., environment 300). Each file-level metadata identifier in the set of file-level metadata identifiers points to the metadata of a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers points to the metadata of each data silo in a set of data silos in a given environment. The system can generate sets of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier. For example, the system can perform natural language processing on file-level and container-level metadata identifiers to determine sets of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier. For example, for the file-level metadata identifier "first_name", the system can generate sets of semantically similar metadata identifiers such as "name_first", "account_ID", "user_id", "name", or others.

[0058] The system can then generate a metadata data structure for mapping each semantically similar metadata identifier from a set of semantically similar metadata identifiers to a normalized file-level metadata identifier and a normalized container-level metadata identifier. For example, to enable the system to efficiently search data across a metadata graph, the system can generate a normalized metadata identifier corresponding to each semantically similar phrase (e.g., by using natural language processing, machine learning models, artificial intelligence models, etc.). For example, the normalized metadata identifier for the semantically similar set of metadata identifiers "name_first", "account_ID", "user_id", and "name" could be "first_name_ID", and the metadata data structure maps "first_name_ID" to each of the semantically similar metadata identifiers. In some implementations, the system can generate a metadata graph using the generated metadata data structure (e.g., normalized metadata identifiers, sets of semantically similar metadata identifiers, etc.). As an addition or alternative, the system can generate a metadata graph based on an artificial intelligence model. In this way, the system can optimize the metadata graph by using normalized container-level and file-level metadata identifiers associated with the nodes in the metadata graph, enabling more efficient data searching.

[0059] Referring again to Figure 4, in Act 408, process 400 can determine a data silo that stores at least one data object. For example, the system can determine a data silo among a set of data silos that stores at least one data object among a set of data objects, using a location identifier corresponding to a determined node (e.g., Act 406) in order to retrieve at least one data object from a set of data objects via a data silo. Since each node in the set of nodes in the metadata graph contains a location identifier corresponding to a data silo (e.g., indicating which data silo stores a given data object), the system can access a data silo using the location identifier to retrieve a data object. For example, the system can use the location identifier of a determined node to determine which data silo hosts at least one data object from a set of data objects. In some implementations, the system can determine each data silo that stores each data object from a set of data objects, using location identifiers corresponding to other determined nodes, in order to retrieve a set of data objects. Using the location identifier, the system can determine the communication protocol associated with the determined data silo in order to retrieve at least one data object. For example, since each data silo may be associated with its own communication protocol, the system can identify which communication protocol a determined data silo is associated with, select this communication protocol (e.g., query language, access protocol, configuration, etc.) to communicate with the data silo, and provide queries to the data silo. Thus, the system can retrieve at least one data object through the query. In this way, the system can reduce the amount of computational resources wasted when accessing silo storage data across heterogeneous locations via a metadata graph.

[0060] In Act 410, Process 400 can generate a visual representation of at least one data object for display. For example, the system can generate a visual representation of at least one data object for display on a GUI. In some implementations, the visual representation of at least one data object includes lineage information of at least one data object. For example, referring to Figure 1, a visual representation of at least one data object 106 may be presented for display within the user interface 100, together with lineage information 108 corresponding to at least one data object. It should be recognized by those skilled in the art that, in one or more implementations of the technology, the user interface 100 may include one or more visual representations (e.g., data objects and / or lineage information) that may correspond to a set of data objects.

[0061] In some implementations, the system can use an artificial intelligence model to generate a desired outcome. For example, the system may receive a second user-specified query via a second GUI that directs a request to generate the desired outcome. For instance, a user could provide a query that directs a request to use an artificial intelligence model to generate a desired outcome (e.g., a prediction). The desired outcome can be any user-specified prediction that the user would like to receive. In the context of a user who is not technically savvy, such a user may be ignorant of which artificial intelligence / machine learning model to choose to generate a given prediction, what data to use to train a given artificial intelligence / machine learning model, or what other components / data to use to generate a given prediction. Nevertheless, the user may know what they want to discover (e.g., how many accounts will be opened in the next three months, in which week the company is most likely to experience an influx of opened accounts, what the expected cost of monitoring fraudulent activity against a set of accounts over a given period is, how many users / accounts are active, how many users / accounts are inactive, etc.). To enable such technically inexperienced users to obtain the intended results, the system can provide a GUI (which may be the same GUI or similar to the GUI shown in Figure 1) that allows the user to provide queries to generate the intended results, and can provide recommendations on which artificial intelligence / machine learning model should be used to generate the intended results, and what training data should be used to train the artificial intelligence / machine learning model to generate the intended results.

[0062] The system can provide a second user-specified query to an artificial intelligence model to generate a recommendation, which includes (i) a second artificial intelligence model to be used to produce the intended result, and (ii) a second set of data objects to be used when training the second artificial intelligence model. For example, the system can provide a user-specified query to an artificial intelligence model trained to generate recommendations (e.g., a machine learning model, Model 702 (Figure 7)). The artificial intelligence model can generate a recommendation that instructs which artificial intelligence model should be used to produce the intended result, and with which training data the given artificial intelligence model should be trained to produce the intended result. For example, the recommended artificial intelligence model can be an artificial intelligence model or machine learning model that can be configured to produce the intended result. Such a recommended artificial intelligence model / machine learning model may be a deep learning model, a neural network, a convolutional neural network, a recurrent neural network, a support vector machine, a natural language processing model, a KNN model, a linear regression model, a logistic regression model, a random forest model, a Bayesian model, or any other artificial intelligence / machine learning mode. In this way, the system provides recommendations on which artificial intelligence model to use to produce the intended results and which training data to use to train the AI ​​model, thereby reducing the use of computational resources that would otherwise be wasted by technically inexperienced users performing numerous incorrect iterations to train a machine learning model to produce the intended results.

[0063] In response to receiving a user selection instructing the acceptance of a recommendation, the system may, in some implementations of this technology, (i) access a database to retrieve a second artificial intelligence model, and (ii) use a metadata graph to retrieve a second set of data objects. For example, the system may generate a message (e.g., a notification, a user-selectable object) to enable the user to accept the recommendation (e.g., via a button, text-based command, checkbox, etc.). In some implementations, the system may automatically accept the recommendation even without a user selection to accept it. In this way, the system can automatically select a recommended artificial intelligence model and training data to produce the intended results, thereby improving the user experience. The system may then access a database (e.g., an artificial intelligence model database) containing untrained or pre-trained artificial intelligence / machine learning models and retrieve a recommended artificial intelligence model (e.g., via an artificial intelligence model identifier, machine learning model identifier, etc.). The system may also access a metadata graph to retrieve a second set of data objects (e.g., which will be used as training data for the recommended artificial intelligence / machine learning model). For example, the second set of data objects may be training data stored in one or more data silos in environment 300, which will be used as training data for an artificial intelligence model. In response to obtaining the recommended artificial intelligence model and the second set of data objects, the system can use the second set of data objects (e.g., training data) to train the recommended artificial intelligence model and apply the recommended artificial intelligence model (e.g., on input data) to produce the desired results. For example, the system may provide new input data (e.g., new data obtained via a metadata graph) as input to the recommended artificial intelligence model to produce the desired results (e.g., at least in part based on a user-specified query).In this way, users who are not technically proficient can be enabled to use artificial intelligence models to generate one or more intended results, thereby improving the user experience.

[0064] In some implementations, the system can determine whether the output of an artificial intelligence model is authorized to be provided to one or more computing systems. For example, since artificial intelligence and machine learning models are used in various domains relating to entities (e.g., companies, businesses, etc.), the use of such artificial intelligence / machine learning models may be required to conform to one or more governance standards when using such models for one or more functions. Since non-technically savvy users can use such models to generate predictions, discover new relationships between existing data, or for other functions, the system can ensure that the use of such models, the data provided to the models, and the output generated by the models conform to one or more industry, government, or internal standards. In this way, the system can reduce the likelihood of data breaches and thereby improve data security.

[0065] For example, the system can access a governance database to retrieve a set of policies that specify usage metrics corresponding to a set of data objects. The governance database can store policies (e.g., governance policies, industry standards, internal company policies, etc.) that specify usage metrics (e.g., definitions or other metrics regarding how data may be used, generated, provided to other computing systems, provided to external computing environments, or made public). The system can access the governance database to retrieve a set of policies that specify usage metrics for a second set of data objects (e.g., data used to train a recommended artificial intelligence model), and can determine whether it is approved to use the second set of data objects to train a recommended artificial intelligence model using the set of policies. For example, in some implementations, the system can provide (i) a second set of data objects and (ii) a retrieved set of policies (e.g., corresponding to a second set of data objects) to another artificial intelligence / machine learning model (e.g., Model 702 (Figure 7)) configured to generate predictions about whether it is approved to use the second set of data objects to train a second artificial intelligence model. The system can also determine whether it is authorized that the output of a second artificial intelligence model (e.g., a recommended artificial intelligence model) be provided to one or more computing systems using a second set of policies that specify usage metrics corresponding to the artificial intelligence model predictions. For example, the second set of policies may include information on which types of artificial intelligence model predictions may be sent, provided, published, or transmitted to internal or external computing systems.In response to (i) approval that a second set of data objects will be used to train a second artificial intelligence model, and (ii) approval that the output of the second artificial intelligence model will be provided to one or more computing systems, the system can apply the second artificial intelligence model (e.g., the recommended artificial intelligence model) to produce the intended result. In this way, the system can examine the training data and the output that may be produced by the artificial intelligence model before producing the intended result, thereby reducing the likelihood of a data breach caused by providing such output to one or more computing systems.

[0066] Referring to Figure 7, which shows Figure 700 of an artificial intelligence model in one of the implementations of the technology, Model 702 can take input 704 and provide output 706. The input can include multiple datasets, such as a training dataset and a test dataset. Each of the multiple datasets (e.g., input 704) can include a subset of data related to user data, predicted predictions and / or errors, and / or actual predictions and / or errors. In some embodiments, output 706 may be fed back to Model 702 as input for training Model 702 (e.g., alone or with user instructions about the accuracy of output 706, labels associated with the input, or other reference feedback information). For example, the system may receive a first labeled feature input, the first labeled feature input being labeled with known predictions about the first labeled feature input. The system can then train a first machine learning model to classify the first labeled feature input (e.g., responses to user-provided queries) with the known predictions.

[0067] In various implementations, Model 702 can update its configuration (e.g., weights, bias, or other parameters) based on evaluation of its predictions (e.g., output 706) and reference feedback information (e.g., user instructions on accuracy, reference labels, or other information). In various implementations, if Model 702 is a neural network, the connection weights can be adjusted to harmonize the difference between the neural network's predictions and the reference feedback. In further use cases, one or more neurons (or nodes) of the neural network may require their respective errors to be propagated backward through the neural network (e.g., error backpropagation) to facilitate the update process. Updates to the connection weights may reflect, for example, the magnitude of errors propagated backward after the forward pass is complete. Thus, for example, Model 702 can be trained to produce better predictions.

[0068] In some implementations, Model 702 may include an artificial neural network. In such implementations, Model 702 may include an input layer and one or more hidden layers. Each neural unit of Model 702 may be connected to many other neural units of Model 702. Such connections may have a coercive or inhibitory effect on the activation state of the connected neural units. In some implementations, each individual neural unit may have a summary function that combines all the values ​​of its input. In some implementations, each connection (or the neural unit itself) may have a threshold function that must be overcome before a signal propagates to other neural units. Model 702 may be self-learning and trainable rather than explicitly programmed, and may perform considerably better than traditional computer programs in certain areas of problem-solving. During training, the output layer of Model 702 may correspond to a classification of Model 702, and inputs known to correspond to this classification may be input to the input layer of Model 702 during training. During testing, inputs without known classifications may be input to the input layer, and a determined classification may be output.

[0069] In some implementations, Model 702 may include multiple layers (e.g., signal pathways traversing from the front layer to the back layer). In some implementations, backpropagation techniques may be utilized by Model 702, with forward stimuli being used to reset the load on the “front” neural units. In some implementations, stimuli and inhibitors for Model 702 may be more fluid, with connections interacting in a more disordered and complex manner. During testing, the output layer of Model 702 may indicate whether a given input corresponds to a classification of Model 702 (e.g., a response to a user-provided query).

[0070] In some implementations, the model (e.g., Model 702) may automatically perform actions based on Output 706. In some implementations, the model (e.g., Model 702) may not perform any actions. The output of the model (e.g., Model 702) may be used to instruct, or otherwise perform, generating a metadata graph, determining a set of phrases, determining semantically similar phrases, providing recommendations for artificial intelligence / machine learning models, determining whether it is acceptable for data objects to be used to train an artificial intelligence / machine learning model, determining whether it is acceptable for the artificial intelligence / machine learning model output to be provided to one or more computing systems, generating a response, or generating other information, according to one or more implementations of the Technology.

[0071] In some implementations, a model (e.g., Model 702) can be trained based on training information stored in database 308 or database 312 to generate recommendations. For example, recommendations may be recommendations for a given artificial intelligence / machine learning model to produce an intended outcome, and recommendations on which training data should be used when training a given artificial intelligence / machine learning model. Model 702 can take a first set of training information as input 704 and generate outputs (e.g., one recommendation, multiple recommendations) as output 706. The first set of training information may include user-specified queries that instruct requests to produce an intended outcome (e.g., predictions), artificial intelligence / machine learning model identifiers used to produce the intended outcome, training data used to train the artificial intelligence / machine learning model used to produce the intended outcome, or other information. For example, Model 702 can learn associations between the first set of training information to generate recommendations as output 706. Output 706 may also be a recommendation on which artificial intelligence model should be selected to produce the intended result, and which training data should be used to train the artificial intelligence model to produce the intended result. In some embodiments, Output 706 may be fed back to Model 702 to evaluate Model 702's prediction (e.g., Output 706) and to update one or more configurations (e.g., loads, bias, or other parameters) based on reference feedback information (e.g., user instructions on accuracy, reference labels, ground truth information, known recommendations, etc.). The first set of training information may also be historical training information that has been used to train previous artificial intelligence / machine learning models to produce a given intended result.Thus, Model 702 is trained to generate one or more recommendations on which artificial intelligence / machine learning models are capable of producing the intended results, as well as the training data necessary to train such artificial intelligence / machine learning models, thereby enabling non-technically savvy users to utilize artificial intelligence / machine learning models.

[0072] In some implementations, a model (e.g., Model 702) can be trained based on training information stored in database 308 or database 312 to determine approval. For example, Model 702 can be trained to determine whether training data for a given artificial intelligence / machine learning model is approved for use in training the artificial intelligence / machine learning model, and whether the output of the artificial intelligence / machine learning model is approved to be exposed, transmitted, or provided to one or more computing systems. For example, as mentioned above, with the increasing use of artificial intelligence and machine learning models in business contexts, such models are being scrutinized and must be examined before being applied to sensitive user data. To examine such a model, Model 702 can take a second set of training information as input 704 and generate outputs (e.g., one approval, multiple approvals) as output 706. The second set of training information may include predictions generated by an artificial intelligence / machine learning model, an artificial intelligence / machine learning model identifier used to generate the predictions, training data used to train the artificial intelligence / machine learning model used to generate the predictions, a set of policies indicating usage metrics corresponding to data objects (e.g., training data) used to train the artificial intelligence / machine learning model used to generate the predictions, a second set of policies indicating usage metrics corresponding to the artificial intelligence model predictions, or other information. For example, model 702 may learn associations between the second set of training information to generate approval as output 706. Output 706 may also be approval indicating whether the second set of data objects (e.g., training data) is approved for use in training an artificial intelligence / machine learning model, and whether the output of the artificial intelligence / machine learning model (e.g., predictions) is approved to be provided to one or more computing systems.In some embodiments, output 706 may be fed back to model 702 to evaluate model 702's prediction (e.g., output 706) and to update one or more configurations (e.g., loads, bias, or other parameters) based on reference feedback information (e.g., user instructions on accuracy, reference labels, ground truth information, known recommendations, etc.). A second set of training information may be historical information that has been used to provide recommendations for different data objects (e.g., training data) and machine learning models. Thus, model 702 may be trained to scrutinize artificial intelligence / machine learning models, their input data, their training data, and their output data before use, according to one or more implementations of the art.

[0073] To generate an integrated metadata graph Figure 8 illustrates the process of generating an integrated metadata graph via a Search and Augmented Generator (RAG) framework, using one implementation of this technology.

[0074] In Act 802, Process 800 selects a first LLM prompt. For example, the system selects a first LLM prompt from a set of LLM prompts that corresponds to a first metadata identifier in a set of metadata identifiers. Each LLM prompt in the set of LLM prompts may be associated with a data schema, data format, data type, or other characteristic of the metadata identifier. For example, an LLM prompt associated with a data type of a metadata identifier may refer to a file-level metadata identifier, a container-level metadata identifier, a system-level metadata identifier, or another metadata identifier. For example, the type of metadata identifier may indicate the structure of the LLM prompt that will be selected for use.

[0075] LLM prompts can be structured with respect to the data type of metadata identifiers. For example, a structured LLM prompt might refer to an input configured to be interpreted by an LLM in a structured format. A structured LLM prompt is a prompt for a text-to-text language model (e.g., an LLM) that is structured so that the text contained within the structured LLM prompt is interpreted and understood by the LLM. Each LLM prompt can be structured for the data schema, data format, data type, data profile, or other characteristics of a metadata identifier, so that an LLM prompt can provide additional information to the LLM when generating output. For example, a structured LLM prompt structured for the data type of a metadata identifier might include one or more attributes, tags, labels, or other information indicating that the metadata identifier contained within the LLM prompt is of a particular type. In this way, the LLM can generate a more precise first intermediate output that indicates the set of metadata identifiers corresponding to a first metadata identifier.

[0076] For example, referring to Figures 9A-9B, which illustrate LLM prompts in some implementations of this technology, the illustrative LLM prompt 900 may include prompts 1 902, 2 910, 3 914, 4 916, and 5 922. Additionally, LLM 906 is shown for illustrative purposes. Prompt 1 902 may include level 903, a first metadata identifier 904, and a first prompt text 905. For example, level 903 may refer to the data schema, data format, data type, or other characteristics of the first metadata identifier 904 to provide LLM 906 with additional information about which types or kinds of metadata identifiers LLM should consider. The first prompt text 905 may be structured text associated with level 903. For example, the first prompt text 905 may be unique to level 903. For example, the first prompt text 905 is indicated to indicate “provide a set of similar identifiers for” and may also be text corresponding to level 903, where level 903 indicates a file-level metadata identifier type, and the first metadata identifier 904 indicates a file-level metadata identifier. In some implementations, the first prompt text 905 may differ based on the metadata identifier of the first metadata identifier 904. For example, if the first metadata identifier 904 is a container-level metadata identifier, the first prompt text 905 could alternatively enumerate “provide a set of similar container-level identifiers for” and level 903 indicates the first prompt text 905. In other words, once the type of metadata identifier of the first metadata identifier 904 is determined, prompt 1 902 may be selected, where prompt 1 902 is associated with level 903 indicating a metadata identifier type, and the first metadata identifier 904 further includes the correct first prompt text 905.Thus, LLM prompts can be structured based on the data schema, data format, data type, or other characteristics of a first metadata identifier, in order to obtain more accurate results from LLM, in contrast to general LLM prompts in existing systems that do not depend on the generated LLM prompt.

[0077] To generate metadata graphs, systems can leverage the RAG framework. For example, the RAG framework, or RAG as an alternative, may refer to a framework that allows artificial intelligence models (e.g., large language models) to access data sources that may contain information that can be updated without requiring the entire LLM to be retrained. Traditionally, LLMs are trained on large corpora of data to provide outputs based on input prompts. Nevertheless, LLMs are often limited to the training data on which they are trained, and the training process for LLMs is exceptionally computationally intensive. To overcome these shortcomings of LLMs, the RAG method can be employed to ensure that LLMs are provided with up-to-date data without requiring the complete retraining of the LLM.

[0078] Furthermore, using RAG, the LLM can query for additional information that it has not previously been trained on. For example, the LLM can often produce an output that appears to be factually correct on the surface, but the LLM has no mechanism to decipher what is true and what is not. Rather, the LLM dictates that the output it interprets is the most correct output for the input (e.g., the prompt). In order to provide a mechanism that enables the LLM not only to access information that it has not previously been trained on, but also to provide a source of truth (e.g., verifiable information on which the LLM can generate an output), the LLM can be communicate-connected to one or more data sources. For example, in the context of generating a metadata graph via the RAG framework, the LLM can be communicate-connected to a set of domain-specific ontologs, such as a raw data component 1010 (for "extracting" metadata identifiers) and an entity's domain ontology component 1008 (for returning filtered domain-specific metadata identifiers generated (based on an extended LLM prompt containing the extracted metadata identifiers)).

[0079] For example, referring to Figure 10A, Figure 10A shows subsystem Figure 1000 illustrating an example of a RAG framework environment for generating an integrated metadata graph. Subsystem Figure 1000 can provide an example of a RAG framework environment in some implementation forms of the technology, and the RAG framework environment may include a user interface 1002, a metadata graph 1004, an LLM 1006, a domain ontology component 1008, a raw data component 1010, a feedback component 1012, and communication links 1014a-1014p. For example, user interface 1002 is a user interface for receiving user-specified queries that instruct requests to access a set of data objects (for example, as described in Act 402 of Figure 4). Metadata graph 1004 can be a metadata graph (for example, as described in Act 406 of Figure 4). LLM1006 can be any LLM (e.g., BERT, Claude, Cohere, Ernie, Falcon40B, Galactica, etc.) configured to provide output in response to input. For example, LLM1006 may be configured to receive an LLM prompt and provide a response (e.g., text, graphical, etc.) in response to the LLM prompt.

[0080] Communication links 1014a to 1014p can enable communication between the user interface 1002, the metadata graph 1004, the LLM 1006, the domain ontology component 1008, the raw data component 1010, the feedback component 1012, or other components (shown or not shown). For example, communication links 1014a to 1014p may include the Internet, a mobile phone network, a mobile voice or data network (e.g., a 5G or LTE network), a cable network, a public switched telephone network, or other types of communication networks, or combinations of communication networks. Communication links 1014a to 1014p may include one or more communication paths, separately or together, such as a satellite path, a fiber optic path, a cable path, a path supporting Internet communications (e.g., IPTV), a free-space connection (e.g., for broadcast or other wireless signals), or any other suitable wired or wireless communication path, or combinations of such paths.

[0081] The domain ontology component 1008 may be a database, server, or other computational component configured to store a set of domain ontologs relating to an entity. For example, the domain ontology component 1008 may store domain ontologs that point to a set of concepts and categories in a given subject area (e.g., a domain) that provide information about the nature of concepts / categories and the relationships between concepts / categories. According to one or more implementations of the technology, the domain ontology component 1008 may store a set of domain ontologs specific to the entities of the system. For example, if the entity is a company, the domain ontologs may reflect domain-specific knowledge about the terminology used in the entity's domain (e.g., terminology systems, taxonomy, word-for-word systems). For example, if the entity is a bank, the domain ontology component 1008 may include ontologs that relate financial terms to other financial terms in order to infer the context in which a given financial term is used.

[0082] Such domain-specific (e.g., entity-specific) contextual knowledge is advantageous to leverage in generating metadata graphs because it can be used to generate normalized, filtered domain-specific metadata identifiers that conform to the terminology used by entities in their daily operations. By connecting the LLM to a set of entity-specific domain ontologs, the system can generate normalized, filtered domain-specific metadata identifiers that will be used when generating the metadata graph. In doing so, the system can extract, identify, and find the data that its users intend to find in the metadata graph based on a common terminology, context, or domain. Furthermore, by leveraging the domain ontologs associated with entities, the system reduces errors when generating normalized, filtered domain-specific metadata identifiers because the entity's terminology and contextual knowledge are maintained. For example, different entities may have different meanings for a given term. By leveraging domain-specific ontologs, the system can reduce errors when generating normalized filtered domain-specific metadata identifiers that will be used in the metadata graph, because the LLM can "reference" a set of domain-specific ontologs to verify the LLM's output (e.g., normalized filtered domain-specific metadata identifiers). In addition to verifying the LLM's output (which may include, for example, the metadata graph 1004 itself), the feedback component 1012 can be used to update, verify, or validate the metadata graph 1004 (e.g., an addition to ) during the metadata graph generation process. For example, the feedback component 1012 may include one or more user or automated inputs to validate the accuracy of the metadata graph 1004 (which will be described in more detail later).

[0083] The raw data component 1010 can be a data source that provides raw data to the LLM. For example, when generating the metadata graph 1004, the raw data component 1010 provides metadata identifiers, data profiles (e.g., metadata identifiers, data silos, data objects, systems), or other raw data to the LLM 1006. For example, the raw data component 1010 can retrieve raw data from the system's data silos. For example, the system can receive raw data from a set of data silos, comprising a set of metadata identifiers that point to (i) file-level metadata identifiers, (ii) container-level metadata identifiers, or (iii) system-level metadata identifiers. A file-level metadata identifier can point to the metadata of a data object stored in one of the data silos in the set of data silos, a container-level metadata identifier can point to the metadata of one of the data silos in the set of data silos, and a system-level metadata identifier can point to the metadata of the computing system hosting one of the data silos in the set of data silos. For example, a file-level metadata identifier can indicate the label of a data object stored within a data silo, a container-level metadata identifier can indicate the label of the data format in which the data silo stores the data, and a system-level metadata identifier can indicate the label of the operating system or the system identifier hosting the data silo.

[0084] In some implementations, the system can perform a crawling process across a set of data silos. For example, to retrieve raw metadata, the system can perform a crawling process across a set of data silos associated with an entity (e.g., a company, merchant, legal entity, business, computing environment, etc.) to retrieve raw data containing a set of metadata identifiers. For example, referring to Figure 10B, which shows a subsystem diagram of raw data component 1010, the crawling process may be performed by a crawler 1016, which can be any database crawling service configured to extract metadata from data silo 1015. Data silo 1015 may be the same or similar data silo described in acts 402-410 of process 400 (Figure 4). For example, crawler 1016 can generate a set of crawl queries to retrieve file-level, container-level, or system-level metadata (e.g., metadata values, metadata identifiers, etc.). Parser 1018 can parse the set of crawl queries to extract file-level, container-level, or system-level metadata identifiers. Thus, the system can retrieve all available metadata from data silos for use in generating a more robust and accurate metadata graph, in contrast to existing methods that rely on manual labeling techniques. In some implementations, metadata is retrieved via a combination of crawler 1016 and parser 1018, and via manually labeled data entities.

[0085] In some implementations, the system can generate a data profile for each data silo within a set of data silos. When generating a domain-specific integrated metadata graph, the data silos themselves can store various data of different schemas, types, and formats, and can also have different contexts. Profiling such data silos is advantageous because these data profiles can point to valuable contextual information that can impact a given structure of an LLM prompt, thereby impacting the ultimate result received by the LLM. For example, each LLM prompt can be a key to achieving an intended result (e.g., to obtain a normalized metadata identifier with a specific context or domain), so when providing a prompt to the LLM, the structure of the prompt can include various data elements to achieve a more efficient and accurate result. As an example, an LLM prompt extended with a metadata identifier and the data type corresponding to this metadata identifier may result in a more accurate result than an LLM prompt that only includes a metadata identifier (e.g., because additional contextual information may be lacking). Therefore, the system can generate a data profile for each data silo in a set of data silos for extending or selecting structured LLM prompts for processing.

[0086] For example, parser 1018 can extract a first value from each data silo in a set of data silos. Since each data silo can store a unique set of data, the system only needs to extract at least one value from each of the data silos in the set. However, in other implementations, the system can extract one or more values ​​from each data silo in a set of data silos. Profiler 1020 can then determine the data type corresponding to each first value extracted from each of the data silos in the set. For example, profiler 1020 may be a logical construct that can determine the data type corresponding to the first value. The data type may relate to the data schema of the first value, the format of the first value, or whether the first value is an integer, character, floating-point, double-precision floating-point, or some other data type. Using the data type of the first value, profiler 1020 can generate a data profile for each of the data silos in the set of data silos, indicating the data type of the values ​​stored in the data silos. For example, the system can generate data profiles (e.g., files, text files, tags, etc.) associated with each data silo (e.g., containers) within the entity's computing system, specifying the data types of values ​​stored in each data silo. Such data profiles may be stored in a database for later retrieval and may be associated with each data silo. In this way, the system can index the data types associated with each data silo to accurately select structured LLM prompts with contextual information (e.g., data profiles).

[0087] In some implementations, the system can filter the set of LLM prompts to select a first LLM prompt from that set. For example, as mentioned above, the data profile of each data silo (e.g., data type) can add contextual information that is advantageous to use when selecting structured LLM prompts to generate a domain-specific integrated metadata graph. For example, by extending LLM prompts specifically designed with metadata identifiers derived from the contextual information (e.g., the data profile of the data silo), the system can achieve more accurate results, in contrast to existing systems that cannot add such contextual information and instead rely on the learned knowledge of the LLM itself.

[0088] Therefore, the system can determine the data silo that stores the data corresponding to the first metadata identifier. For example, the system can compare the first metadata identifier with each metadata identifier stored in each data silo for matching. In other implementations, the system can still refer to a database that stores the mapping between metadata identifiers and the data silos that store the data associated with those metadata identifiers. The system can then retrieve the data profile corresponding to the data silo that stores the data corresponding to the first metadata identifier. For example, as described above, the system can retrieve the generated data profile for the data silo.

[0089] The system can then use the retrieved data profile to filter the set of structured LLM prompts to generate a filtered set of LLM prompts. For example, each LLM prompt in the set of LLM prompts may be tagged with one or more tags indicating (i) a metadata identifier, (ii) a data profile (e.g., data type), (iii) the architecture of the LLM prompt, and / or (iv) other tags (e.g., data schema, data format, or other characteristics). The system can filter the set of structured LLM prompts into a subset of LLM prompts (e.g., a filtered set of LLM prompts) to reduce the amount of computational resources used when comparing LLM prompts. Filtering not only reduces the use of computational resources (e.g., computer memory and processing power) but can also provide a reduced set of LLM prompts to select based on the data profile of the data silo associated with the metadata identifier, thereby improving the accuracy of LLM prompt selection. The system can then select a first structured LLM prompt corresponding to a first metadata identifier in the set of metadata identifiers from the filtered set of LLM prompts. For example, the system selects a first structured LLM prompt based on a match between the LLM prompt tag, which specifies the data format of the LLM prompt, and the data format of the metadata identifier.

[0090] Referring again to Figure 8, in Act 804, Process 800 extends the first LLM prompt with a first metadata identifier. For example, the system extends the first LLM prompt (e.g., a Structured LLM prompt) with a first metadata identifier that will be provided to the LLM. The LLM may be configured to produce a first intermediate output that points to a second set of metadata identifiers corresponding to the first metadata identifier. For example, the LLM may be communicatively connected to (i) raw data components and (ii) domain ontology components, and the LLM may be configured to produce a first intermediate output that points to a second set of metadata identifiers corresponding to the first metadata identifier without accessing the domain ontology components.

[0091] For example, referring to Figure 10A, LLM 1006 is communicated to both the raw data component 1010 and the domain ontology component 1008. Although LLM is communicated to each of the raw data component 1010 and the domain ontology component 1008, LLM can communicate with the raw data component 1010 to generate a first intermediate output. For example, the first intermediate output may be an intermediate output such that the first intermediate output is not the final output of LLM. For example, in accordance with the RAG framework, the system can extend the first LLM prompt with a first metadata identifier which will be provided to LLM 1006 to generate a second set of metadata identifiers corresponding to a first metadata identifier.

[0092] Referring again to Figure 9, for example, prompt 1 902 may reflect a first LLM prompt. The system can extend prompt 1 902 with a first metadata identifier (e.g., first metadata identifier 904) (e.g., add, update, place, etc.). The extended version of prompt 1 902 can then be provided by the system as input to LLM906 for generating a first intermediate output 908. For example, LLM906 may be the same as or similar to LLM1006 (Figure 10A) in some implementations of this technology. LLM906 processes prompt 1 902 to generate a first intermediate output 908. The first intermediate output 908 can be a set of metadata identifiers corresponding to the first metadata identifier 904. For example, in order to determine what a metadata identifier (e.g., a first metadata identifier 904) means, could mean, or resembles, the system can provide the first metadata identifier to the LLM, which will receive a generated set of metadata identifiers, descriptions, texts, or other information that correspond to or are otherwise associated with the first metadata identifier. In some implementations, the first intermediate output may be the same as or similar to semantically similar phrases, as described in Act 404 of Process 400 (Figure 4). By doing so, the system can generate a set of semantically similar phrases corresponding to the first metadata identifier, thereby extending the scope of contextual information that will later be considered by the LLM to generate a more accurate normalized domain-specific metadata identifier that serves as a key to the unique entity.

[0093] Referring again to Figure 8, in act 806, process 800 extends the first LLM prompt with a set of metadata identifiers corresponding to a first metadata identifier. For example, the system extends the first LLM prompt with a second set of metadata identifiers corresponding to a first metadata identifier that will be provided to the LLM. The LLM can be configured to generate a second intermediate output that points to filtered domain-specific metadata identifiers by accessing a set of domain-specific ontologs. For example, referring to Figure 9A, the system extends prompt 2 910 with a first intermediate output 908 corresponding to a first metadata identifier 904 that will be provided as input to LLM 906. In some implementations, prompt 2 910 may be the same as or similar to prompt 1 902, but in other embodiments, prompt 2 910 may be different from that of prompt 1 902. For example, prompt 3 914 may represent a single prompt that combines the information from prompts 1 902 and 2 910 into a single updatable prompt. In other words, in contrast to having two separate prompts to achieve a given goal, the system can extend the prompt multiple times with respect to receiving the respective outputs from the LLM906.

[0094] For example, referring again to prompt 2 910, prompt 2 910 may include a second prompt text 907 and a first intermediate output 908. The second prompt text 907 may also be structured text associated with level 903 or the first intermediate output 908. For example, the second prompt text 907 may be unique to level 903. For example, the second prompt text 907, shown to instruct "return a domain-specific identifier for", may also be text corresponding to level 903, where level 903 indicates a file-level metadata identifier type and the first metadata identifier 904 indicates a file-level metadata identifier. In some implementations, the second prompt text 907 may differ based on the metadata identifier of the first metadata identifier 904. For example, if the first metadata identifier 904 is a container-level metadata identifier, the second prompt text 907 could alternatively enumerate "return domain-specific for the container-level identifier of", with level 903 indicating the second prompt text 907. That is, once the type of metadata identifier for the first metadata identifier 904 is determined, prompt 2 910 may be selected, with prompt 2 910 associated with level 903 indicating the type of metadata identifier, and the first metadata identifier 904 further containing the correct second prompt text 907. Thus, LLM prompts can be structured based on the data schema, data format, data type, or other characteristics of the first metadata identifier to obtain more accurate results from LLM, in contrast to the general LLM prompts of existing systems that do not particularly depend on the generated LLM prompt.

[0095] As an addition or alternative, a second prompt text 907 may be associated with a first intermediate output 908. For example, the second prompt text 907 may be extended to prompt 2 910 when the system receives the first intermediate output 908. For example, the system may modify, update, extend, or otherwise change prompt 1 902 to reflect prompt 2 910 (including, for example, the second prompt text 907 and the first intermediate output 908). To provide an illustrative example, prompt 3 914 is shown. Prompt 3 914 can be a combined prompt (for example, prompts 1 902 and 2 910). In some implementations, prompt 3 914 may also be a resulting prompt. For example, if the system originally selected prompt 1 902 which will be provided to the LLM to generate the first intermediate output 908, the system can only provide the LLM with information about prompt 1 902 to generate the first intermediate output 908. When the system receives a first intermediate output from the LLM, it can extend the original prompt (e.g., prompt 1 902) to generate prompt 3 914, which includes a second prompt text 907 and the first intermediate output 908. In some implementations, the system can provide prompt 3 914 as a whole to the LLM 906 to generate a second intermediate output 912 that points to a filtered domain-specific metadata identifier by accessing a set of domain-specific ontologities. In yet another implementation, the system can provide the LLM 906 with only the new information from prompt 3 914 to generate the second intermediate output 912. For example, the system can provide the LLM 906 with only the second prompt text 907 and the first intermediate output 908 to generate the second intermediate output 912, thereby reducing the amount of computational resources required by the LLM to process the input data (e.g., prompt information).

[0096] The second intermediate output 912 may be a filtered domain-specific metadata identifier. For example, to reduce data retrieval time when accessing data stored in various heterogeneous data silos through a non-technically savvy user, it is necessary to maintain domain-specific information in the context of the entity's system, enabling users to quickly find the data they need without the burden of knowing the correct terminology of the data. For example, a non-technically savvy user might try to find an account name. However, because computer engineers, data scientists, and other more technically savvy users are the ones who set up, create, or otherwise maintain the data silos, values, identifiers, phrases, or other data markers may differ from what a non-technically savvy user is familiar with. A non-technically savvy user may have a business mindset and understand the domain-specific language that the entity officially operates in, which computer engineers and data scientists often do not, leading them to label data without considering the business's (e.g., the entity's) domain-specific context. To overcome this, the system can provide prompt 2 910 (or, alternatively, prompt 3 914) to the LLM, which is communicated to the domain ontology component 1008, in order to generate a second intermediate output 912 (e.g., a filtered domain-specific metadata identifier).

[0097] For example, referring to Figure 10, LLM1006 may be provided with an extended LLM prompt as input that points to a second set of metadata identifiers (e.g., the first intermediate output) in order to generate a second intermediate output that points to filtered domain-specific metadata identifiers by accessing the domain ontology component 1008. LLM1006 can extract one or more domain ontologs, each containing a set of domain ontologs specific to an entity in the system. For example, as mentioned above, if the entity is a company, the domain ontology may reflect domain-specific knowledge about the terminology used in the entity's domain (e.g., terminology, taxonomy, word-for-word). For example, if the entity is a bank, the domain ontology component 1008 may include ontologs that relate financial terms to other financial terms in order to infer the context in which a given financial term is used. LLM1006 can use one or more domain-specific ontologs contained in the domain ontology component 1008 to verify the first intermediate output (e.g., the second set of metadata identifiers corresponding to the first metadata identifier). For example, LLM1006 can compare each metadata identifier in the second set of metadata identifiers with a keyword, phrase, string, or other domain-specific value in a domain-specific ontology to determine (i) the meaning of each metadata identifier in the second set of metadata identifiers, or (ii) filtered domain-specific metadata identifiers.

[0098] Since LLM1006 can be an unsupervised artificial intelligence model, it can be trained to determine the meaning of each metadata identifier in a second set of metadata identifiers by accessing a domain-specific ontology. The domain-specific ontology may be a predefined ontology generated by one or more experts in a particular field of a given entity. By accessing the domain-specific ontology, LLM1006 can determine filtered domain-specific metadata identifiers. For example, during a comparison process (e.g., LLM compares or processes a first intermediate output), LLM1006 can determine that the first intermediate output (e.g., a second set of metadata identifiers corresponding to the first metadata identifier) ​​corresponds to a common filtered domain-specific metadata identifier present in the domain-specific ontology (e.g., associated, matched). The domain-specific metadata identifier is considered "filtered" because it is filtered to a single representative domain-specific metadata identifier corresponding to a potential match to the first intermediate output, such as one generated via LLM1006. In this way, the system can reduce the amount of computational resources involved in generating the metadata graph because filtered domain-specific metadata identifiers are used to generate the metadata graph.

[0099] Referring to Figure 10C, which shows a subsystem diagram of Domain Ontology Component 1008, Domain Ontology Component 1008 can be communicated to Domain Thesaurus 1024 and Concepts 1022. For example, Domain Ontology Component 1008 may host a set of domain-specific ontologs generated at least partially based on experts in a particular field, while Domain Thesaurus 1024 and Concepts 1022 may contribute to the generation of Domain Ontology Component 1008 of the domain-specific ontologs. Concepts 1022 may include a set of entity-specific terms, phrases, or other concepts used commonly throughout a system of entities (e.g., Figure 3). Thesaurus 1024 may include a data structure that maps a set of entity-specific terms, phrases, or concepts to other terms, phrases, or other concepts used throughout a system of entities. For example, Thesaurus 1024 may represent a digital thesaurus of terms, phrases, or concepts. In some implementations, the ontology component 1008 can aggregate information stored in the thesaurus 1024 and concepts 1022 to automatically generate one or more domain-specific ontologs (for example, through one or more ontology creation models). Alternatively, the ontology component 1008 can leverage SMEs to create a set of domain-specific ontologs. In this way, the system can maintain accuracy of the domain-specific context on which metadata identifiers depend when generating the metadata graph, thereby preserving the system's domain-specific language for entities.

[0100] In Act 808, Process 800 generates a metadata graph. For example, the system can generate a domain-specific integrated metadata graph via the LLM using (i) a first metadata identifier and (ii) a second intermediate output indicating filtered domain-specific metadata identifiers. The LLM may be configured to generate graphs (e.g., undirected graphs, directed graphs, directed acyclic graphs, etc.) using the first metadata identifier and the filtered domain-specific metadata identifiers. In some implementations, the LLM may be provided with a prompt instructing it to generate a graph (e.g., a metadata graph), the prompt including the first metadata identifier, the filtered domain-specific metadata identifiers, and prompt text instructing it to generate a metadata graph. In some implementations, Acts 802-808 may be repeated iteratively until all metadata in data silo 1015 (Figure 10B) has been processed by the system.

[0101] Referring to Figure 9B, prompt 4 916 may include a third prompt text 918 instructing the generation of graph 920, a first metadata identifier 904, and a second intermediate output 912. The third prompt text 918 may also be structured text associated with level 903 or the second intermediate output 912. For example, the third prompt text 918 may be unique to level 903, the first metadata identifier 904, and the second intermediate output 912, and LLM 906 is for generating a domain-specific integrated metadata graph based on level 903, the first metadata identifier 904, or the second intermediate output 912. LLM can generate metadata graph 920 using at least a portion of the information contained in prompt 4 916. For example, LLM can be trained to generate a graph data structure containing a first metadata identifier, filtered domain-specific metadata identifiers, and other information (e.g., file-level metadata identifiers, container-level metadata identifiers, system-level metadata identifiers, location identifiers, data lineage, etc.), as described in Act 406 of Process 400 (Figure 4) and in Figures 5-6.

[0102] In some implementations, the LLM may be provided with prompt 5 922, which can represent a single prompt that combines the information from prompts 1 902, 2 910, and 4 916 into a single updatable prompt. In other words, in contrast to having three separate prompts to achieve a given goal, the system can extend the prompt multiple times with respect to receiving their respective outputs from the LLM 906. When a prompt (e.g., prompt 4 916 or prompt 5 922) is provided to the LLM 906 as input, the LLM 906 can generate a metadata graph 920.

[0103] Referring to Figure 11, which shows an illustrative representation of the generated metadata graph, LLM906 can generate metadata graph 1100. Metadata graph 1100 may be the same as or similar to metadata graph 920 (Figure 9B), metadata graph 1004 (Figure 10A), metadata graph 500 (Figure 5), or metadata graph 600 (Figure 6). Metadata graph 1100 can represent a domain-specific integrated metadata graph in some implementations of this technology. Metadata graph 1100 may include nodes 1102a to 1102d, such as a fifth node 1102a, a sixth node 1102b, a seventh node 1102c, and an eighth node 1102d. Each node 1102a to 1102d can point to the metadata of one or more data objects stored in a given data silo. For example, the fifth node 1102a may include a file-level metadata identifier 1106a, a container-level metadata identifier 1108a, a location identifier 1110a, and a domain-specific metadata identifier 1112a. Additionally or alternatively, the fifth node 1102a may include a system-level metadata identifier or other information, although not illustrated. The domain-specific metadata identifier 1112a may be the same as or similar to the second intermediate output 912 that indicates the filtered domain-specific metadata identifier.

[0104] Each of nodes 1102a to 1102d may be linked to one or more other nodes. For example, the fifth node 1102a may be linked to the sixth node 1102b via the second edge 1104a. In some implementations, the second edge 1104a can indicate node lineage information, such as the sixth node 1102b being the data source for the fifth node 1102a. Nevertheless, in other implementations, the second edge 1104a can indicate lineage information, such as the fifth node 1102a being the data source for the sixth node 1102b, as in some implementations of this technology. Each node 1102 may also be linked to other nodes via the edge 1104, and it should be apparent to those skilled in the art that each edge indicates lineage information between one or more nodes in a set of nodes.

[0105] In some implementations, one or more identifiers contained within nodes 1102a-1102d are traversable. To efficiently traverse the metadata graph 1100, the system can traverse the metadata graph based on a single traversable identifier, ignoring other identifiers contained within the nodes. For example, the traversable identifier could be a filtered domain-specific metadata identifier 1112a. As referred to herein, traversable identifiers are identifiers that the system looks for when a user provides a query to find data, while non-traversable identifiers are identifiers that the system stores associated with node 1102a and does not look for when traversing the metadata graph 1100. Thus, the system reduces the amount of computational resources traditionally used when strings search large tables, because the metadata graph is (i) a graph that provides direction (e.g., a directed graph) and (ii) uses entity-specific, domain-specific, context-accurate metadata identifiers to find the same instance of data objects stored throughout the entity system. For example, when the system traverses the metadata graph, it can compare a set of clauses (such as those described in Act 406 of Process 400 (Figure 4)) with traversable metadata identifiers in the metadata graph 1100. The system can traverse the metadata graph 1100 based on filtered domain-specific metadata identifiers, but the metadata graph 1100 can still store other metadata identifiers (which could be, for example, file-level metadata identifiers 1106a, container-level metadata identifiers 1108a, or system-level metadata identifiers) associated with nodes 1102a-1102d to maintain information for future use.For example, when a metadata graph finds a given data object using filtered domain-specific metadata identifiers 1112a, the system can then retrieve file-level, container-level, or system-level location information, or other information about the given data object.

[0106] Referring again to Figure 8, in some implementations, the system can perform a verification process on the generated metadata graph 1100 (Figure 11). For example, in some implementations, the system calculates query-versus-result performance metrics and accuracy performance metrics. For example, the verification process may include providing automatically generated or user-provided test queries to the domain-specific integrated metadata graph to measure its performance.

[0107] For example, referring to Figure 10D, which shows a subsystem diagram of the feedback component 1012, the feedback component 1012 may include a versioning component 1026, a generator 1028, a result 1030, and an update component 1034. The versioning component 1026 can store previous versions of the metadata graph 1100 (Figure 11). For example, the versioning component can store the most recent version of the metadata graph 1100 before generating an updated version of the metadata graph 1100 (Figure 11). The generator 1028 can generate a test query to provide the metadata graph 1100. For example, the test query may be the same as or similar to a user-specified query, as discussed in Act 402 of Process 400 (Figure 4). Additionally or alternatively, the test query may be a historical user-specified query, as discussed in Act 402 of Process 400 (Figure 4). The test query may be used to generate one or more results. For example, result 1030 can determine (e.g., generate) one or more performance metrics based on a test query, such as one generated by generator 1028. For example, result 1030 can store historical performance metrics for other versions of metadata graph 1100, and performance metrics for the current version of metadata graph 1100 (Figure 11). The performance metrics may be query-versus-result performance metrics, accuracy metrics, or other performance metrics.

[0108] Once performance metrics for the metadata graph 1100 are generated, a decision may be made to update the metadata graph 1100 (Figure 11). The update component 1034 can automatically trigger the update process to the metadata graph 1100 (Figure 11). In some implementations, the update component 1034 can still be used in conjunction with a third-party input 1032 to trigger the update process to the metadata graph 1100. For example, the third-party input 1032 may be a third-party source of information (e.g., a website, computing device, etc.). As another example, the third-party input 1032 may be input from a subject area expert. By leveraging subject area expert input in this way, humans can verify the accuracy of the LLM-generated metadata graph before publishing such a metadata graph for use across systems. Adding subject area expert input to the metadata graph 1100 generation process can enhance the accuracy of the generated metadata graph to avoid any unintended LLM-related errors.

[0109] To perform the verification process, the system may provide a first query (e.g., a test query) to each of (i) the domain-specific integrated metadata graph and (ii) other versions of the domain-specific integrated metadata graph requesting the location of a first data item. For example, the system may test the most recent iteration of the domain-specific integrated metadata graph to find the location of a given data item (e.g., stored in a data silo). Still, to ensure that the most recent modification to the domain-specific integrated metadata graph is a better metadata graph, the system compares the performance metrics of the domain-specific metadata graph to previous versions (or other versions) of the metadata graph. For example, the system may calculate a query-versus-result performance metric that indicates the period between the time a query is provided to each metadata graph and the time a result is received from each metadata graph. The period may be epoch time, seconds, milliseconds, decision time, UNIX® time measured in microseconds, etc. Such query-versus-result performance metrics may be generated for each of the domain-specific integrated metadata graph and other versions of the domain-specific integrated metadata graph (e.g., previous versions of the integrated metadata graph).

[0110] In some implementations, the system can calculate accuracy metrics (e.g., performance metrics) for the domain-specific integrated metadata graph and other versions of the domain-specific integrated metadata graph. For example, the accuracy metric may be the degree of accuracy of the results generated from the domain-specific integrated metadata graph and other versions of the domain-specific metadata graph (e.g., percentage, decimal value, ratio, integer, binary value, numeric, alphanumeric, etc.). The accuracy metric may be generated based on human evaluation of the results (e.g., results returned from providing queries to each metadata graph). For example, a subject matter expert (e.g., data scientist, software developer, computer engineer) can verify the accuracy of the results for each of the domain-specific metadata graph and other versions of the domain-specific metadata graph. Since each metadata graph integrates the system's "domain," "context," and "terminology" for a given entity, a subject matter expert can verify the accuracy of the generated results returned by each metadata graph when finding the location of a given data item. In this way, experts can verify the accuracy of the results, thereby enabling the more accurate generation of domain-specific, integrated metadata graphs. Nevertheless, in other implementations, accuracy metrics may be automatically generated without human intervention. For example, accuracy metrics may be based on a comparison of results generated from each metadata graph by one or more implementations of this technology with historical results.

[0111] The system can calculate accuracy metrics by sampling and examining one or more parts of the results, or all of the results. For example, the system can select a sample set of results to determine the accuracy metric and can resize the sample set until a desired accuracy metric threshold is met.

[0112] In some implementations, the system can determine whether an update process should be performed on the metadata graph. For example, the system can determine whether the performance metrics of a metadata graph (e.g., metadata graph 1100) meet the performance metrics of a second performance metric of another version of the metadata graph (e.g., a previous version). In some implementations, determining whether the performance metrics of a metadata graph meet the performance metrics can be based on whether (i) the query-to-result performance metric of the metadata graph does not exceed the query-to-result performance metric of another version of the metadata graph, or (ii) the result accuracy metric of the metadata graph meets or exceeds the result accuracy metric of another version of the metadata graph. Thus, if the performance metrics fail to be met, the system can perform an update process on the metadata graph. In short, if a metadata graph (i) returns results faster than a previous version of the metadata graph, and (ii) returns results more accurately than a previous version of the metadata graph, the metadata graph should not be updated. Nevertheless, if the metadata graph (i) returns results slower than the previous version of the metadata graph, or (ii) returns results less accurate than the previous version of the metadata graph, the metadata graph will be updated.

[0113] Referring again to Figure 8, in Act 810, Process 800 performs an update process on the metadata graph. For example, in response to determining that the first performance metric of a domain-specific integrated metadata graph cannot meet the performance measure of the second performance metric of another version of the domain-specific integrated metadata graph, the system may perform an update process on the domain-specific integrated metadata graph (e.g., metadata graph 1100 (Figure 11)). As described above, the metadata graph will be updated if (i) it returns results slower than the previous version of the metadata graph, or (ii) it returns results that are less accurate than the previous version of the metadata graph.

[0114] In some implementations, the update process can be performed by updating the nodes and edges of the metadata graph to the nodes and edges of a previous version of the metadata graph. For example, the system can determine a set of inconsistencies between a domain-specific integrated metadata graph and other versions of the domain-specific integrated metadata graph. The set of inconsistencies may reflect (i) inconsistencies between nodes in the domain-specific integrated metadata graph and other versions of the domain-specific integrated metadata graph, and (ii) in inconsistencies between edges connected to at least one node in the domain-specific integrated metadata graph and other versions of the domain-specific integrated metadata graph. For example, the system can traverse each graph to determine newly added nodes, edges, metadata identifiers, or other information. For example, the system can first traverse the current version of the domain-specific integrated metadata graph and store a tabular representation of the current version of the domain-specific integrated metadata graph in the database. The system can then retrieve tabular representations of other versions of the domain-specific integrated metadata graph (e.g., previous versions), if available. In some implementations, the system can traverse other versions of the domain-specific integrated metadata graph and store tabular representations of those versions in the database. The system can then compare the two tabular versions of the metadata graph with each other to identify discrepancies between the two versions. For example, the system can identify one newly added node (e.g., and the metadata identifier or location identifier the node contains), as well as two newly added edges connecting this node to other nodes in the current version of the metadata graph (when compared to the previous version of the metadata graph). The system can then update the domain-specific integrated metadata graph with the updated nodes and edges in the other version of the domain-specific integrated metadata graph corresponding to the set of discrepancies.In this way, the system can revert to a previous version of the integrated metadata graph if it fails to meet the performance metrics.

[0115] In some implementations, the system can trigger an update process based on the detection of the addition of a data silo. For example, in some implementations, the system can perform an update process on a domain-specific integrated metadata graph when a data silo is added to the computing environment associated with an entity. The system can monitor the computing environment associated with an entity (e.g., Figure 3) using one or more network discovery tools, such as SNMP, LLDP, CDP, or others, to identify when a new device is added to the entity's computing environment. The system can then communicate with the new device to determine the type of the new device using the IP address determined via the network discovery tool to verify the addition of the new device (e.g., using the "ping" command). The system can further compare the determined IP address of the new device with a database that stores device information for the computing environment. For example, a table may store the IP address and device type of a device for the entity's computing system. The system can use the table to determine whether the newly added device is a data silo (e.g., a data source, database, etc.). In response to the detection of the addition of a data silo, the system can trigger an update process on the domain-specific integrated metadata graph. For example, the system can extract metadata from newly added data silos in order to update or regenerate the domain-specific integrated metadata graph 1100 (Figure 11). For example, the system can repeatedly perform one or more of the above processes until all metadata from the data silos (and newly added data silos) has been processed by the system, thereby generating a system-wide domain-specific integrated metadata graph.

[0116] Artificial Intelligence Sandbox The domain-specific, integrated metadata graph described above enables computer systems to efficiently retrieve siloed data across heterogeneous locations. The artificial intelligence (AI) sandbox allows the use of data from these heterogeneous locations to generate AI models for data analysis or to automatically apply existing AI models. The sandbox provides a low-code or no-code environment, enabling users to build and apply models to extract insights or predictions from data, even when they lack the expertise or time to build AI models and data pipelines for the data to be processed through the models, or when they are unaware that the models should help solve problems. As described herein, the AI ​​sandbox includes automated tools for deploying and managing models, ensuring that the models function efficiently without requiring human intervention. The AI ​​sandbox can be used to automate any or all steps in the model lifecycle, such as training new models, fine-tuning or improving existing models, deploying models, or generating data pipelines suitable for analysis by the models once deployed. By integrating these functions, the sandbox provides a practical solution for transforming user interactions with data and AI models, enhancing accessibility and usability while maintaining operational efficiency.

[0117] Figure 12 is a block diagram illustrating the components within the AI ​​sandbox 1200 in one implementation. As shown in Figure 12, the AI ​​sandbox 1200 may include a model review assistant 1210, a data processor 1220, a model generator 1230, a model governor 1240, and a model automatator 1250. Other implementations of the AI ​​sandbox 1200 may include additional, fewer, or different components, or the functionality may be separated between the components.

[0118] The Model Review Assistant 1210 interacts with the user and orchestrates other components of the AI ​​Sandbox 1200 to generate and apply AI models. Leveraging a Large-Scale Language Model (LLM), the Model Review Assistant 1210 can both interact with the user and perform tasks related to generating, applying, or improving AI models as the user interacts with the Assistant 1210. In some implementations, the Model Review Assistant 1210 generates a chat-style interface where user input is received and information is output to the user.

[0119] The data processor 1220 identifies relevant data objects applicable to a model that the user requests to train or apply. The data processor 1220 processes the data to ensure cleanliness and integrity, making it suitable for analysis by the AI ​​model. The data can be prepared for various stages of AI development, including generating, training, and testing datasets for training, fine-tuning, or evaluating the model. Furthermore, the data processor 1220 can provide archiving capabilities to securely store clean data and generated training samples. Using this archived data, the data processor 1220 can generate documentation that facilitates inspection of the model and its applications, ensuring transparency and compliance with regulatory standards. The data processor 1220 is further described with respect to Figure 13.

[0120] The model generator 1230 constructs an AI model based on user input and data output from the data processor 1220. The model generator 1230 is configured to train a machine learning model using the cleaned and processed dataset from the data processor 1220. The model generator 1230 can analyze the dataset output by the processor 1220, for example, by creating a set of features from the dataset and identifying the target variables of the model. The model generator 1230 can also recommend the type of machine learning model to build from a list of available models or based on model performance metrics. Using the processed dataset and the selected model type, the model generator 1230 constructs a model, which may include training a new model, fine-tuning an existing model, or preparing a model for deployment. The model generator 1230 is further described with respect to Figure 14.

[0121] Model Governor 1240 performs higher-level analysis and governance assessment tasks to ensure that the model conforms to a set of governance measures. These governance measures can relate to policies or procedures within the organization in which Model Review Assistant 1210 operates, or to policies from external organizations that the organization must follow (such as policies or regulations implemented by a government or standards-setting body, or social pledges signed by the organization). If the model does not conform to the governance measures, Model Governor 1240 can cause the model to be modified until it conforms. Model Governor 1240 can further generate documentation for the model that can be archived and stored for subsequent analysis and inspection. Model Governor 1240 is further described with respect to Figure 15.

[0122] The Model Automator 1250 manages the deployment of AI models. Models can have different requirements for their deployment. For example, some models require a large and significant amount of computing resources. Some models are used for applications where results are needed quickly. Entities using AI models may have access to various different locations for deploying the models, such as one or more cloud providers or on-premises machines or scalable resources. The Model Automator 1250 can orchestrate the deployment of models across these various different locations. The Model Automator 1250 can provide a central system that has access to any applicable APIs for deploying and calling models, access to the data used to train these models, and access to the application data processed by the models. Thus, the Model Automator 1250 can determine how to efficiently deploy the models so that they can perform and manage computing resources well. The Model Automator is further described with respect to Figure 18.

[0123] Figure 13 is a block diagram illustrating the components within the data processor 1220 in some implementation configurations. The data processor 1220 can generally prepare data for various purposes associated with an AI model, including generating training data for training or fine-tuning the model, generating test data for testing the model, or preparing data for application to the model.

[0124] When a data request is received (for example, to train, fine-tune, or test a model, or to apply it to a model), the data processor 1220 accesses the dataset 1310 to which it has been authorized for the entity requesting access. The dataset 1310 can be accessed using any of the techniques described above, including using a metadata graph to identify data objects within data silos in the data repository.

[0125] The data processor 1220 may include a data preprocessor 1320 that performs various operations on the accessed dataset 1310 to prepare the data for desired use. The data preprocessor may perform operations to generate training or test datasets for training, fine-tuning, and / or testing a model. Such operations may include, for example, normalizing the data, converting the data from one type to another, transforming the data into an appropriate format or structure, or aggregating or reducing the data. In some implementations, the data preprocessor 1320 may apply anonymization operations to remove, encrypt, or obscure personally identifiable or private information within the accessed dataset 1310. Some implementations of the data preprocessor 1320 also apply operations to make the data compliant with policies or regulations. For example, the data preprocessor 1320 may remove data that has been determined to be inaccurate from the dataset 1310. An example process for detecting and removing noise from a dataset is described in U.S. Patent Application No. 18 / 736,407, filed on June 6, 2024, and is incorporated herein by reference in its entirety.

[0126] The processed data output by the data preprocessor 1320 can be passed to other elements of the data processor 1220 to generate a set of data for training or testing an AI model. The data preprocessor 1320 can also generate a set of application data 1322 for application to an existing AI model, either as an addition or replacement. To generate the application data, the data preprocessor 1320 can perform cleanup, normalization, conversion, or other processing operations on the accessed dataset 1310. These operations may include anonymizing the data as described above, or, in another example, applying a preprocessing model to the dataset 1310 to counteract the distortions in the model to which the application dataset 1322 will be applied. The preprocessing model may include one or more data modification operators that modify the raw dataset 1310, for example, by adding features, removing features, or changing values ​​within the dataset 1310, in order to create a set of modified data. When applied to an AI model, the modified data items from the set of modified data cause the model to produce an output that does not exhibit distortions in the model. An example process for detecting and canceling model distortion via a pre-processed model is described in U.S. Patent Application No. 18 / 783,409, filed July 25, 2024, and is incorporated herein by reference in its entirety.

[0127] The data analyzer 1330 analyzes the data to understand the data types and how the data is used, and generates a usable set of data (e.g., training data, test data, or inference dataset). The data analyzer 1330 receives the raw data and / or the pre-processed dataset output by the preprocessor 1320 and evaluates its properties, such as data types, data range, linkages or dependencies between data, or other information that helps the system understand what the data is, how the data is used, and how the data can be used in a model. Based on its analysis of the data properties, the data analyzer 1330 can generate further synthetic data to supplement the existing data. In some implementations, the data analyzer 1330 includes a data profile generator 1340 and / or a sampler 1350, which are described below.

[0128] The data profile generator 1340 generates a data profile 1342 of the dataset output by the data preprocessor 1320. The data profile generator 1340 can analyze the structure of the dataset and the relationships between the data within the set to ensure that the dataset is suitable for the intended artificial intelligence application. Such analysis may include, for example, calculating the statistics of the dataset (e.g., mean or standard deviation), checking the data types in the dataset and correcting them as necessary, checking for data anomalies (e.g., missing values, duplicates, or outliers), detecting patterns or correlations between data items in the dataset, or detecting asymmetry or imbalance in the data distribution within the dataset that may affect model performance. The data profile 1342 output by the data profile generator 1340 may further include metadata describing the dataset, which can be used to generate model documentation or to perform inspection and compliance checks.

[0129] In some implementations, the data processor 1220 generates a set of training data that can be used to train a machine learning model. Therefore, the data processor 1220 may further include a sampler 1350 that samples the dataset output by the data preprocessor 1320 and data analyzer 1330 to generate training samples 1352 or test samples 1354. For example, the sampler 1350 can generate representative random samples of data items from the processed dataset for the training and test datasets, respectively. The training samples 1352 can then be further input into a synthetic fabricator to generate additional training or test cases.

[0130] Figure 14 is a block diagram illustrating the components within the model generator 1230 in some implementation configurations. As described above, the model generator 1230 trains a machine learning model using the cleaned and / or processed dataset output by the data processor 1220. The model training procedure can be performed in part on input 1405 received from the user (e.g., via the model review assistant 1210).

[0131] As shown in Figure 14, the model generator 1230 may include a feature set generator 1410 that collects the data profile 1342 and training samples 1352 generated by the data processor 1220. The feature set generator 1410 creates a set of features from the dataset that can be used to train a machine learning model. When creating features, the feature set generator 1410 may convert the data (e.g., in the training samples 1352) into an appropriate machine-readable format by, for example, converting non-numeric to numeric, converting numeric formats to the same type, vectorizing the data, or doing something similar.

[0132] The features output by the feature set generator 1410 can be defined in part based on user input. For example, when a user is creating a model using the AI ​​sandbox 1200, the user can directly specify the features of interest to the model, or they can provide information that the feature set generator 1410 uses to identify features in the dataset.

[0133] In some implementations, the feature set generator 1410 further uses feedback to learn over time how to select relevant features for a given application. For example, when a user interacts with the AI ​​sandbox 1200 to generate a model, the feature set generator 1410 can evaluate features used in each model, such as the data types input to the model, the model's target variables, or the model's performance, in order to build a robust mapping between model features and attributes. The feature set generator 1410 can then use this mapping to recommend features from other models or train a feature selection model based on the mapping. In another example, the feature set generator 1410 uses model performance feedback to recommend or select features from a given model. The feature set generator 1410 may, for example, select a first set of features and receive feedback indicating the performance (e.g., accuracy) of a model trained using that first set of features. The generator 1410 can then select a second set of features, receive feedback indicating the performance of the model trained using the second set of features, and compare the performance measurements to determine which of the first and second sets of features yielded better results.

[0134] The target selector 1420 selects target variables for a machine learning model based on features output by the feature set generator 1410 and / or user instructions received via the model review assistant 1210. Target variables specify the outputs that the machine learning model will predict or classify. To identify target variables, the target selector 1420 can receive variable identifications from the model review assistant 1210, which are generated based on user input 1405. For example, the model review assistant 1210 uses LLM to identify user-specified target variables in natural language user input. The target selector 1420 can compare the variables identified in the user input with features output by the feature set generator 1410 to determine whether the user-specified variable exists in the set of features or can be derived from the set of features. In some cases, the target selector 1420 can use LLM to evaluate the set of features and identify the closest match to the user-specified target variable. Additionally or alternatively, the target selector 1420 can use patterns of user behavior to identify target variables. For example, if a user has recently used AI Sandbox 1200 to generate a model based on a specific target variable in a corresponding dataset, the target selector 1420 can determine that the user may be interested in generating a model based on the same target variable in a different dataset. Similarly, the target selector 1420 detects similarities between the user's actions within the enterprise (such as other models the user has built, models the user has used, or data the user has created or accessed) and the actions of other users who have used AI Sandbox 1200 to build models. Based on these similarities, the target selector 1420 can determine that, since other users have built models for the same specified target variable, the user is likely to build a model for the specified target variable.

[0135] The target selector 1420 may, as an addition or alternative, use user or other system feedback when selecting target variables. This feedback can be used in place of the process for selecting target variables from the user's natural language input or based on the user's past activities as described above, or it can be used to improve the selector 1420's ability to identify the correct target variables based on natural language input or user activity. In one example, after a model has been initially trained for one target variable, feedback from the user or an external system may be used to determine that the model should be trained for a different target variable (for example, because the user provides direct input indicating that the trained model is not producing the desired output, or because another system identifies an error in the output of the trained model). In other cases, the target selector 1420 generates a mapping between target variables used in other models and attributes of the model (such as features input to other models, data types used in other models, the user who created other models, or the performance of other models) to predict target variables that are likely to be relevant to the developed model.

[0136] The model selector 1430 evaluates whether a model should be generated or deployed, and if so, recommends the type of machine learning model that the model generator 1230 should build. The model type can be one of a set of different model architectures, such as neural networks, random forests, or support vector machines. The model type can be selected from a set of commercially available or existing models that can be used as is, or fine-tuned for a specific purpose, as an addition or replacement. Similarly, the model selector 1430 can select from pre-trained models that can be models previously developed within the organization in which the model review assistant 1210 operates, or received from external sources. Depending on the application, the model selector 1430 can recommend individual models or a set of many models to achieve the user's desired objective. For example, the model selector 1430 can recommend generating a set of models that can be used together in an ensemble method. When recommending multiple models, the model selector 1430 can recommend generating all new models using a selected set of pre-trained or fine-tuned models, or combining new models with pre-trained or fine-tuned models. The model selector 1430 can also recommend specific ensemble learning techniques that enable these models to be used together. For example, the model selector 1430 might recommend generating a set of three models in a voting ensemble, where the predictions for each model are combined by majority vote or averaging. In another example, the model selector 1430 might recommend a stacking ensemble, where the outputs of several base models are used as input to a metalarana model that makes the final prediction, or a boosting ensemble, where models are trained sequentially, each focusing on correcting the errors of its predecessors to improve overall performance.

[0137] When selecting a model, the model selector 1430 can receive an explicit model selection from the user. For example, the model review assistant 1210 can provide the user with a list of available model types, from which the user can select a model. Alternatively, the model selector 1430 can recommend a model type for a given application. To recommend a model, the model selector 1430 can apply a set of input data to each of several model types and calculate metrics for each model type. These metrics may include, for example, a criterion for how quickly the model generates output for a set of input data (e.g., latency, model output speed, or model response time variance), a criterion for how accurate the model output is, a measure of the amount of memory used by the model, or a measure of the cost of using the model. Based on the metrics, the model selector 1430 can recommend one or more model types that achieve a specific goal, such as the fastest execution or the most accurate results. In other cases, instead of applying input data to numerous models and calculating metrics used for model selection, the model selector 1430 can recommend a model type based on historical model performance. For example, the model selector 1430 can evaluate historical data to enable it to recommend model types based on whether speed or accuracy is more important for a given application, for instance, indicating that one type of model is typically faster but less accurate than another type of model. Some implementations of the model selector 1430 output a recommended model identifier to the model builder 1440 to enable the recommended model to be built. In other implementations, the model selector 1430 outputs recommended model types to the user, who can then choose between the recommended model types or select a different type of model.

[0138] The model builder 1440 constructs the model 1445, which may include training a new model, fine-tuning an existing model, or packaging or refining a model for deployment even if no further training is needed. The model builder 1440 receives a model type selected from the model selector 1430 and can determine, based on the selected model, whether to train, fine-tune, package, or perform other tasks. When training a new model or fine-tuning an existing model, the model builder 1440 trains the model type selected by the user or the model selector 1430 based on the target variables identified by the target selector 1420 and the set of training samples 1352 generated by the data processor 1220. The model builder 1440 then tests the model using the test samples 1354 generated by the data processor 1220 and may retrain as needed until the model converges to or reaches a specified accuracy threshold for the test dataset, for example.

[0139] Figure 15 is a block diagram illustrating the functionality of the model governor 1240 in some implementations. As shown in Figure 15, the model governor 1240 can leverage the model review assistant 1210 to evaluate the model 1445, including using the model review assistant 1210 to interface with the Large Language Model (LLM) 1510 and evaluate the model 1445 for higher-level analysis and governance tasks. In some implementations, the LLM 1510 uses the RAG-based process 1520 to retrieve policies, procedures, know-how, or other applicable governance information from data repositories such as the industry knowledge repository 1522 or the enterprise knowledge repository 1524. The industry knowledge repository 1522 may store, for example, scientific models, national regulations, or data standards. The enterprise knowledge repository 1524 may store information such as organizational policies, organization-specific classifications, or the organization's business mission. The Model Review Assistant 1210 can generate queries to LLM1510 that cause LLM1510 to evaluate Model 1445 against applicable governance information.

[0140] Based on the evaluation, Model Governor 1240 may update Model 1445, create additional models or data to make Model 1445 conform to governance metrics, or generate documentation describing how well the model conforms to or does not conform to governance information. For example, an organization may be subject to regulations requiring that certain types of models (e.g., a model for approving loan applications) produce unbiased output based on specific backgrounds (e.g., race, gender, age, sexual orientation, or geographic location or loan applicant). If Model Governor 1240 detects that such a loan approval model is unfairly biasing its conclusions based on one or more of these backgrounds, Model Governor 1240 may have the model retrained or fine-tuned to reduce the biased conclusions. Alternatively, Model Governor 1240 may have a second model generated, which is configured to pre-process application data before it is input into Model 1445 to correct the model's bias. In another example, if Model Governor 1240 determines that a model conforms to each of a set of governance measures, Model Governor 1240 can optionally generate a document (using LLM1510) describing the governance measures that Model 1445 evaluated and how it was determined that the model conforms to each of the measures.

[0141] The model governor 1240 can further generate an explainability layer 1530 for model 1445. The explainability layer 1530 includes data associated with model 1445 that explains what the model does, how the model makes decisions, what data was used to train the model, what data is input or output from the model, any modifications applied to the input data before it is processed through the model, or any other characteristics specified by the firm, regulations, or other standards for the organization from which the model was generated. The model governor 1240 can generate an explainability layer using LLM 1510 by analyzing model 1445 itself and / or governance documents retrieved from repositories such as the industry knowledge repository 1522 or the firm knowledge repository 1524.

[0142] Automated generation of AI models Figure 16A is a flowchart illustrating a process 1600 for automatically generating an artificial intelligence (AI) model in some implementation forms. Process 1600 can be executed by a computer system, such as one or more systems that implement components of the artificial intelligence sandbox 1200.

[0143] As shown in Figure 16A, the computer system receives natural language input from the user in 1602. The natural language input can include explicit instructions for the computer system to train an AI model, or general queries that the computer system can process as instructions for generating a model. The input can include a set of phrases that implicitly or explicitly indicate desired properties of the model, such as the data to be processed by the model and / or the intended output from the model. In one example, the user might provide the input "I need help analyzing my investment portfolio." The computer system processes this input to determine whether the model can help answer the query, or whether the query can be answered without the model. For example, the computer system might determine that the model should help analyze the investment portfolio, while more direct queries (e.g., "Do I own any shares of XYZ Corp?") should not be requested, or should be made more complex by the model. When natural language input is provided, the user does not need to be aware that a model is supposed to be helpful, much less the type of model that should produce the best results, the data that should be used to train or input into the model, or how to go about training and deploying the model.

[0144] Input can be received, for example, via a model review assistant 1210 that provides a chat-style interface where input can be received from the user and information can be output to the user. User input to the chat interface can be received as natural language input and / or as other types of input, such as the selection of an item from a list. Similarly, the model review assistant 1210 can output information to the user in natural language format (e.g., using LLM to generate output), in a graphical format such as a data plot, or in other formats. An example of a chat interface 1700 that can receive user input is depicted in Figure 17A. In the example, the user provided natural language input 1705, "I need help analyzing my investment portfolio." Other users can provide natural language input that more directly instructs the computer system to generate a model (e.g., "Create a model to analyze my investment portfolio"). The phrase "my investment portfolio" can be processed by the computer system as indicating the data that will be processed by the model.

[0145] In 1604, the computer system accesses a metadata graph based on user input. The metadata graph may comprise a set of nodes, each having (i) metadata indicating an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges indicating the data lineage between sets of nodes. As described above, the computer system can traverse the metadata graph indicating where data is stored, which data in different data silos is available, and the data lineage between nodes in the graph, thereby enabling the computer system to efficiently find data within a set of data silos. By traversing the metadata graph, the system can determine the node corresponding to a set of phrases in the natural language input received from the user. In the example interface illustrated in Figure 17A, the computer system selects four candidate data sources associated with one or more nodes in the metadata graph identified based on the phrase "My investment portfolio," each data source containing one or more data items. For example, a data source for the execution of investment A may include a set of measurements of the value of investment A at different points in time. In some implementations, such as the example shown in Figure 17A, the user can provide additional input to select from the candidate data sources shown in Figure 17B. Alternatively, the computer system can proceed to train a new model with data objects identified based on the user's natural language input.

[0146] In 1606, the computer system processes the extracted data objects using a metadata graph to generate a training dataset. The computer system can pre-process the data objects by removing biased, incorrect, or irrelevant values ​​from the dataset. Once the data objects are cleaned, the system can sample a training dataset from the data objects and / or input the data objects into a synthetic data generator to generate synthetic training data. Similarly, once the model is trained, the computer system can generate a set of test data to test the model.

[0147] In step 1608, the computer system selects the model type of the model to be trained. The model type can be selected from different model architectures and / or from commercially available packages or existing models, using model metrics associated with each available model type. In some cases, the model type can be output to the user via a chat interface, allowing the user to select the type of model to be trained. The computer system then, in step 1610, trains the selected type of model using the generated set of training data.

[0148] After the model is trained, the computer system can also interact with the user and automatically generate a pipeline of application data that will be processed through the model, whether by the process in Figure 16A or another process. Figure 16B is a flowchart illustrating process 1620 for automatically generating a data pipeline for an AI model, in some implementation forms. Process 1620 can be performed at least partially by the same computing system that performs process 1600 in Figure 16A, or by one or more different computing systems.

[0149] As shown in Figure 16B, the computer system 1612 receives a first natural language input from the user, which may include a set of phrases and commands, for analyzing data associated with a set of phrases using an AI model. Inputs for deploying the model, like inputs for training the model, can be received via a chat interface generated by the model review assistant 1210. For example, Figure 17C illustrates that user input 1710, commanding the computer system to "look at last year's investment mix," is received via the chat interface. The phrase "last year's investment mix" can be used to identify the set of data to which the model will be applied, while "look at" is interpreted in the context of the chat session as a command to deploy the model generated during the chat session.

[0150] In 1624, the computer system uses natural language input to access a metadata graph that points to internal data objects stored in data silos. The metadata graph can be the same graph used to identify data objects for generating the training dataset described with respect to Figure 16A. Using the metadata graph, the system can determine the nodes corresponding to the set of phrases in the first natural language input.

[0151] In 1626, the computer system processes internal data objects indicated by the determined node to generate a first set of data. For example, the computer system may remove personally identifiable or private information from the internal data objects. In another example, the system applies a set of data correction operators to the internal data objects to generate a corrected set of data based on the internal data objects, and the data correction operators are configured to remove bias from the internal data objects or to remove or compensate for inaccurate or irrelevant data within the objects.

[0152] In 1628, the computer system applies an AI model to a first set of application data to generate one or more outputs based on the application data. For example, the computer system uses the model to classify data items in the first set of application data or to make predictions based on one or more of the application data items.

[0153] In 1630, the computer system sends the user one or more representations of the output for display. For example, Figure 17D illustrates that the computer system generates plot 1715 to illustrate the results produced when a model is applied to a set of data specified by the user (e.g., "last year's investment mix").

[0154] Based on the displayed output, the user can determine whether corrections to the model or the data processed by the model are necessary to obtain the desired result. For example, the displayed output may indicate that the data input to the model was incomplete or incorrect. Therefore, the user can iteratively interact with the model review assistant 1210 to correct the model's inputs until the expected output is received. These iterative interactions may include further natural language input from the user via the chat interface provided by the model review assistant 1210.

[0155] For example, in 1612, the computer system receives a second natural language input containing instructions for modifying a first set of application data (e.g., by adding data to the first set, removing data from the first set, or modifying values ​​within the first set). Figure 17D further illustrates an example input 1720 in which the user instructs the computer system to “add data source 4.” The computer system then generates a second set of application data based on the second natural language input in 1614. Generating a second set of application data in response to instructions in the second input may involve using a metadata graph to retrieve additional data objects, processing the data objects to obtain application data, modifying data values ​​within the first set of application data (e.g., by modifying the way the data objects were processed to produce the first set of application data), or removing data from the first set of application data. The AI ​​model can then be applied to the second set of application data in 1616, and the output produced from the application of the model can be displayed to the user. This iterative process can be repeated until the user is satisfied with the output of the model.

[0156] Deploying AI models Once an AI model is trained and determined to comply with its governance parameters, it can be deployed to make predictions based on the application data input to the model. The Model Automator 1250 determines how the model should be deployed for use in a production environment and orchestrates the deployment.

[0157] Figure 18 is a schematic diagram illustrating the operation of the model autometer 1250 in some implementation configurations. As shown in Figure 18, the model autometer 1250 may include a model unfolding engine 1810, a model unfolding engine updater 1812, an orchestrator 1814, and a data handler 1816.

[0158] The model automatometer 1250 uses the model deployment engine 1810 to select a model deployment location for the AI ​​model, and the model deployment location can be selected from several available computing environments. For example, as illustrated in Figure 18, the model automatometer 1250 can access numerous public cloud environments (e.g., from a first public cloud provider 1820A and a second public cloud provider 1820B), as well as one or more on-premises environments (such as an on-premises machine 1830A or an on-premises stretchable resource 1830B).

[0159] Various deployment environments for AI models can present different advantages and disadvantages, particularly in terms of cost efficiency, computing capacity, and privacy. On-premises environments are often limited in capabilities because they are restricted by the hardware available within the enterprise. Nevertheless, on-premises environments can offer the benefit of privacy that is not available in some cloud environments. Cloud environments, on the other hand, offer scalable resources, but costs can vary significantly depending on the cloud provider and the amount of computing power used. For example, cloud providers typically charge based on usage, and sometimes use tiered pricing systems where the price of the margin amount of computing resources fluctuates depending on the total amount of resources used in a given time frame. Cloud and on-premises environments can also differ in the ease of integration with existing systems, the flexibility of resource allocation, and their potential for downtime or service interruptions.

[0160] The Model Autometer 1250 can monitor operational parameters associated with the deployment environments available to the Autometer. These operational parameters may include relatively dynamic data such as the amount of computing capacity available for use by a given model, the computing resources used while the model is running in the environment, the response time from the deployed model, or the accuracy of the results produced by the model when deployed in the environment. Other examples of operational parameters may include data that is static or changes over longer periods, such as the privacy policy of the deployment environment operator, the average amount of downtime in the environment, or the number of service interrupts to the environment. The Model Autometer 1250 can measure some of the operational parameters as the Autometer deploys the model to various available environments. Alternatively, the Model Autometer 1250 can obtain operational parameters from other sources, such as the environment operator or other systems performing computing tasks within the environment.

[0161] Additionally, the Model Automator 1250 can facilitate the publication of models for use by other users. Within some organizations, it may be desirable for a model generated by one user to be available to other users. For example, many users within an organization may perform similar tasks and should benefit from a model created by another user to assist with these tasks. Once a model is published, the Model Automator 1250 can manage access rights or credentials to the model. For example, the Model Automator 1250 can link the model to access rights, specifying that only users within a specific department of the organization can use the model, or that only users with permissions to access specific data (e.g., the data on which the model was trained) can use the model.

[0162] The model deployment engine 1810 includes rules, models, or other logic tools that enable the model automator 1250 to select a model deployment location. For example, the model deployment engine 1810 may include one or more trained decision models such as decision trees or random forests, knowledge graphs, or rule engines. Once a deployment location for a given model is determined, the model deployment engine 1810 can be input with information such as parameters of the model itself (e.g., the size of the model, privacy considerations associated with the model, or information indicating whether the model will be used in real time or in a batch processing flow), parameters of the data that will be processed through the model when deployed (e.g., the amount of data processed per iteration of the model, the location of the data, or privacy considerations associated with the data), or behavioral parameters associated with the available deployment locations. Based on one or more of these inputs, the model deployment engine 1810 selects a model deployment location for the model. In some implementations, the model deployment engine 1810 includes an explainability layer that enables the engine to output an explanation for the selected model deployment location. For example, if a user is using a chat interface from the model review assistant 1210 to create and deploy a model, the model deployment engine 1810 can generate an explanation of that decision, which can then be output to the user via the model review assistant 1210.

[0163] In one example, the model deployment engine 1810 evaluates the cost-effectiveness of available environments and deploys the model to environments where the cost-effectiveness is greater than a specified threshold. Cost-effectiveness can be measured based on the amount of computing resources the model is expected to use and the expected cost of using those resources for each available environment. The model deployment engine 1810 can determine cost-effectiveness as a standalone metric associated with each available model deployment environment, or as a differential metric comparing the cost of deploying the model to one environment with the cost of deploying it to another. In other cases, the model deployment engine 1810 selects the deployment location based at least partially on the privacy policy associated with the model, the input data that the model will process, or the output produced when the model processes the input. For example, a model will be deployed to an on-premises environment if it has a privacy policy that limits its use to on-premises systems, but will be deployed to a cloud environment if it does not have such a restriction. In yet another case, the model deployment engine 1810 may select the model deployment location based at least partially on whether the model will be used to process data in real time or in a batch process. For example, if the model is used in a real-time processing flow, engine 1810 may choose a cloud environment to deploy the model based on the determination that the cloud environment allows for easier scaling of resources than an on-premises environment to ensure the model's availability. On the other hand, if the model is used in a batch processing flow, engine 1810 may choose to deploy the model to an on-premises environment based on the determination that the execution of the batch process may be delayed until computing resources become available, if necessary.

[0164] The Model Deployment Engine Updater 1812 can update the Model Deployment Engine 1810 based on its continued observations of operating parameters. For example, if the Model Deployment Engine 1810 contains a trained decision model, the Model Deployment Engine Updater 1812 can retrain the decision model based on the updated operating parameters. If the Model Deployment Engine 1810 contains explicit rules, the Model Deployment Engine Updater 1812 can update the rules by instructing the Large Language Model (LLM) to modify existing rules or create new rules based on observed operating parameters. For example, if a cloud service provider updates its privacy policy, the Model Deployment Engine Updater 1812 can prompt the LLM to evaluate the updated privacy policy to determine whether it conforms to the privacy policy of the organization operating the Model Automator 1250. Based on the assessment, the LLM may then update the rules regarding acceptable deployment locations for a particular type of AI model, for example, if the first cloud service provider modifies its privacy policy so that the privacy policy is no longer compliant with the privacy policy associated with a particular AI model or the data that a particular AI model processes.

[0165] The model automatator 1250 can use the model deployment engine 1810 to both select a model deployment location for a new model or a new instance of a model, and move a model from one deployment location to another. For example, since the engine 1810 is updated in response to observed operating parameters, the model automatator 1250 can periodically use the engine 1810 to re-evaluate whether a model should be deployed to a location that meets the engine's criteria (e.g., whether the environment's cost-effectiveness is still greater than the corresponding threshold, or whether the environment still complies with the privacy policy associated with the data). In another example, the model automatator 1250 may determine that a new instance of a model should be deployed to a second environment when the original instance of the model is using computing resources in the first environment that exceed a given threshold (e.g., a specified pricing tier from the cloud computing provider operating the first environment).

[0166] The orchestrator 1814 facilitates the deployment of AI models to locations selected by the model automatator 1250 based on the model deployment engine 1810, making the models available for use in production environments. When deploying a model, the orchestrator 1814 can configure the model for deployment to the selected infrastructure (including transporting the model to the selected infrastructure) and configure the infrastructure for the model (for example, by spinning up the resources required by the model). The orchestrator 1814 is configured to automatically and seamlessly deploy the model in any of the available environments using platform-specific APIs. The orchestrator 1814 can also leverage containerization technologies such as Docker and orchestration frameworks such as Kubernetes to package the model with all necessary dependencies and scale and manage the containerized application.

[0167] Orchestrator 1814 can determine deployment attributes required for the deployment of each model, or to improve the performance of deployed models. These deployment attributes can include, for example, the model's language (such as Python or R), the model's infrastructure needs (such as available memory, processing speed, available parallelization, or hardware type), or configuration parameters for Dockerfile or Kubernetes deployments. In some implementations, Orchestrator 1814 maintains a set of patterns or templates that specify the corresponding types of deployment attributes for each model. Some of these patterns or templates can be initially provided by the user. Other patterns or templates can be automatically generated by Orchestrator 1814, for example, by identifying similar types of deployment attributes for models. Orchestrator 1814 can automatically update patterns or templates over time as it deploys models using the attributes in the patterns or templates.

[0168] After deploying the model, orchestrator 1814 can monitor the deployed model to verify that the deployment was successful. Success can be measured, for example, by an indicator specifying whether the model is producing results, by a measurement of model operating parameters (e.g., latency, memory utilization, or CPU or GPU utilization), by a measurement of model performance (e.g., accuracy or precision), or by a combination of factors. Orchestrator 1814 can determine that the model was not deployed successfully if, for example, the model is not producing results, the model operating parameters fall outside a specified range, or the model performance differs from the expected model performance by at least a threshold amount. When orchestrator 1814 determines that the model was not deployed successfully, it can decide to roll back the configuration to a previous configuration, deploy the model on a different infrastructure, completely stop the model deployment until the error is corrected, or take other corrective actions to improve the model deployment. Orchestrator 1814 can also update deployment templates based on successful or unsuccessful deployments. For example, if it is determined that configuration parameters in a Dockerfile include model behavior parameters for a particular type of model outside the expected range, Orchestrator 1814 will update the deployment template for that model type to ensure that the correct configuration parameters are used in future Dockerfiles for the same type of model.

[0169] The data handler 1816 makes data available to the deployed AI model at the location where the AI ​​model is deployed. In some implementations, the data handler 1816 identifies a pipeline of application data for the deployed model, which is processed by the data processor 1220 described above. Using APIs associated with the environment in which the model is deployed, the data handler 1816 can generate scripts that make the application data available to the environment for processing by the model. The data handler 1816 can also handle data privacy policies, check whether the data complies with ethical or fairness standards, and / or obtain or generate approval for the data that can be used in a given context.

[0170] Figure 19 is a flowchart illustrating process 1900 for automating the deployment of an AI model in some implementation configurations. Process 1900 can be implemented by a computing system, such as a system that implements an embodiment of the model automatator 1250.

[0171] As shown in Figure 19, the computer system receives a first request at 1902 to deploy the first AI model in order to make the first AI model available for use in a production environment. In some implementations, the request may be received as natural language input to a chat interface, similar to the inputs described with respect to Figures 17A–17D.

[0172] In 1904, the computer system selects a first model deployment location for the first AI model based on the model deployment engine. The deployment location can be selected from a cloud provider environment or an environment at least partially operated by the entity controlling the first AI model ("on-premises environment"). For example, an entity may contract with multiple cloud providers to use computing environments maintained by cloud providers, but may also maintain some of its own computing infrastructure. The computer system can choose whether to deploy the first model to on-premises infrastructure or to a cloud environment, and / or to select a specific location within the on-premises infrastructure or a specific cloud environment where the model will be deployed. In selecting a model deployment location, the model deployment engine may take into account the nature of the first AI model itself, the nature of the deployment location, or the governance of the model, or the entity-specific policies of the entity controlling the first AI model. The model deployment engine may include one or more trained models such as decision trees or random forests, one or more knowledge graphs or rule-based systems such as rule engines, or a combination of logic or tools that enable the computer system to make a determination about the model deployment location.

[0173] In 1906, the computer system generates a script for deploying the first AI model to a first model deployment location. For example, the computer system can generate a script that calls platform-specific APIs for the selected model deployment location, leverage cloud technologies (such as containerization or orchestration) for cloud deployment locations, or file system or server management technologies for on-premises deployment locations, and ensure that the deployed model has access to the data pipeline with the data it is configured to process.

[0174] After deploying the first AI model, the computer system can monitor the operational parameters associated with the model deployment in 1908. These operational parameters may include, for example, the computational cost used by the first AI model, the response time from the first AI model when deployed at a selected location, the privacy policy of the environment including the model deployment location, or measurements of downtime or service interrupts in the environment including the deployment location.

[0175] Based on the operating parameters, in 1910, the computer system can update the model deployment engine, for example, by retraining the trained model within the engine or by updating the rules within the engine. For example, the computer system can update the model when the cloud provider modifies its privacy policy, or when the actual operating parameters monitored by the computer system differ from the operating parameters used to train the model deployment engine.

[0176] The updated model deployment engine can then be used in 1912 to deploy a second AI model or to redeploy the first AI model to a different location. In some cases, the second AI model can be deployed in the same environment as the first AI model, or in a different environment, based on the operating parameters observed from the deployment of the first model. For example, if the first model is deployed on an on-premises system and the on-premises system is approaching its computing capacity, the second model can be deployed in a cloud environment. In other cases, the second AI model is a second instance of the first model deployed in a different location. For example, if an entity deploys the first AI model in a first cloud environment where the entity is approaching a certain computing cost threshold, a second instance of the first model can be automatically deployed in the second cloud environment to reduce the computing cost in the first environment. In yet another case, the computer system may determine that the first AI model should be moved from one deployment location to another. For example, if the privacy policy of the first cloud provider changes after the first model has been deployed to the environment of the first provider, the computer system can move the first model from the environment of the first provider to the environment of another cloud provider.

[0177] Process 1900 can be iterated when additional models are deployed by the computer system. The computer system can therefore iteratively improve its knowledge of how well the models perform in different environments, the cost of deploying the models in those environments, and how well the environments comply with governance or policy considerations. Leveraging this iteratively improved knowledge, the computer system can improve its ability to automatically and efficiently deploy AI models.

[0178] section Section 1. A system for reducing the use of computing resources when accessing siloed data across heterogeneous locations via an integrated metadata graph, comprising: at least one hardware processor; receiving a user-specified query in a graphical user interface (GUI) that, when executed by at least one hardware processor, instructs a request to access a set of data objects, wherein each data object in the set of data objects is stored in the respective data silo of a set of data silos in heterogeneous locations; parsing the user-specified query for a set of keywords, wherein each keyword in the set of keywords is associated with the set of data objects; performing natural language processing on the set of keywords to determine a set of semantically similar phrases corresponding to each keyword in the set of keywords; and accessing the metadata graph to determine the node corresponding to the set of semantically similar phrases. A system wherein the metadata graph comprises a set of nodes that point to (i) (a) metadata of internal data objects stored in data silos, and (b) location identifiers of data silos, and (ii) edges that point to data lineages between a first node and a second node of the set of nodes, wherein the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers, and includes at least one non-temporary memory that stores instructions causing the system to generate a visualization of at least one data object for display on a GUI, wherein the visualization of at least one data object comprises lineage information of at least one data object.

[0179] Section 2. The system of Section 1, wherein the metadata graph is generated by retrieving (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers from a second set of data silos, wherein each file-level metadata identifier in the set of file-level metadata identifiers refers to the metadata of a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers refers to the metadata of each data silo in the second set of data silos; generating sets of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier; generating metadata data structures for mapping each semantically similar metadata identifier in the sets of semantically similar metadata identifiers to normalized file-level metadata identifiers and normalized container-level metadata identifiers; and generating a metadata graph using the generated metadata data structures.

[0180] Section 3. The system of Section 1, comprising: receiving a second user-specified query via a second GUI that directs a request to produce an intended result; and providing the second user-specified query to an artificial intelligence model to generate a recommendation, wherein the recommendation comprises (i) a second artificial intelligence model to be used to produce the intended result; and (ii) a second set of data objects to be used when training the second artificial intelligence model; and in response to receiving a user selection directing acceptance of the recommendation, further comprising instructions to (i) access a database to retrieve the second artificial intelligence model; and (ii) retrieve the second set of data objects using a metadata graph; train the second artificial intelligence model using the set of data objects; and apply the second artificial intelligence model to produce the intended result.

[0181] Section 4. The system of Section 3, further comprising instructions for accessing a governance database to obtain a set of policies indicating usage metrics corresponding to a second set of data objects; using the set of policies indicating usage metrics corresponding to a second set of data objects to determine whether the second set of data objects is authorized to be used to train a second artificial intelligence model; using the second set of policies indicating usage metrics corresponding to artificial intelligence model predictions to determine whether the output of the second artificial intelligence model is authorized to be provided to one or more computing systems; and in response to (i) the second set of data objects being authorized to be used to train a second artificial intelligence model, and (ii) the output of the second artificial intelligence model being authorized to be provided to one or more computing systems, applying the second artificial intelligence model to produce intended results.

[0182] Section 5. A method for reducing the use of computing resources when accessing siloed data across heterogeneous locations via an integrated metadata graph, the method comprising: receiving a user-defined query in a graphical user interface (GUI) that instructs a request to access a set of data objects, wherein each data object in the set of data objects is stored in a data silo in a set of data silos in heterogeneous locations; performing natural language processing on the user-defined query to determine a set of clauses corresponding to the user-defined query; and accessing the metadata graph to determine a node corresponding to the set of clauses, wherein the metadata graph is (i)(a) data A method comprising: a set of nodes each having metadata that points to internal data objects stored in a data silo, and (b) a location identifier for the data silo; and (ii) edges that point to the data lineage of the set of nodes, wherein a metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers; accessing and retrieving at least one data object from a set of data objects via a data silo by determining the data silo that stores at least one data object from a set of data objects using the location identifier corresponding to a determined node; and generating a visual representation of at least one data object for display on a GUI.

[0183] Section 6. The method of Section 5, wherein the metadata graph is generated by retrieving (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers from a second set of data silos, wherein each file-level metadata identifier in the set of file-level metadata identifiers refers to the metadata of a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers refers to the metadata of each data silo in the second set of data silos; generating sets of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier; generating a metadata data structure for mapping each semantically similar metadata identifier in the sets of semantically similar metadata identifiers to normalized file-level metadata identifiers and normalized container-level metadata identifiers; and generating a metadata graph using the generated metadata data structure.

[0184] Section 7. The method of Section 5, further comprising: receiving a second user-specified query via a second GUI that directs a request to produce an intended result; providing the second user-specified query to an artificial intelligence model to produce a recommendation, wherein the recommendation comprises (i) a second artificial intelligence model to be used to produce the intended result; and (ii) a second set of data objects to be used when training the second artificial intelligence model; and, in response to receiving a user selection directing acceptance of the recommendation, (i) accessing a database to retrieve the second artificial intelligence model; and (ii) using a metadata graph to retrieve the second set of data objects; training the second artificial intelligence model using the set of data objects; and applying the second artificial intelligence model to produce the intended result.

[0185] Section 8. The method of Section 7, further comprising: accessing a governance database to obtain a set of policies indicating usage metrics corresponding to a second set of data objects; using the set of policies indicating usage metrics corresponding to a second set of data objects to determine whether the second set of data objects is authorized to be used to train a second artificial intelligence model; using the second set of policies indicating usage metrics corresponding to artificial intelligence model predictions to determine whether the output of the second artificial intelligence model is authorized to be provided to one or more computing systems; and in response to (i) the second set of data objects being authorized to be used to train a second artificial intelligence model, and (ii) the output of the second artificial intelligence model being authorized to be provided to one or more computing systems, applying the second artificial intelligence model to produce intended results.

[0186] Section 9. The method of Section 5, wherein determining the set of clauses corresponding to a user-specified query is a parsing of a user-specified query with respect to a set of keywords, wherein each keyword in the set of keywords is associated with a set of data objects; for each keyword in the set of keywords associated with the set of data objects, determining a set of semantically similar clauses corresponding to each keyword in the set of keywords; and using the set of semantically similar clauses corresponding to each keyword in the set of keywords, determining the set of clauses corresponding to the user-specified query.

[0187] Section 10. The method of Section 9, further comprising determining semantically similar phrases corresponding to each keyword in a set of keywords by accessing a database that indicates a mapping between a first set of keywords and a second set of keywords, and, in response to accessing the database, using each keyword to determine a set of semantically similar phrases corresponding to each keyword.

[0188] Section 11. The method of Section 5, wherein accessing the metadata graph further includes traversing each node of a set of nodes to identify a metadata identifier that matches at least one clause of a set of clauses, and determining the node corresponding to the set of clauses in response to determining that the metadata identifier matches at least one clause of the set of clauses.

[0189] Section 12. The method of Section 5, wherein accessing the metadata graph further comprises: traversing each node of a set of nodes to identify a metadata identifier that matches at least one clause of a set of clauses; determining a first node corresponding to the set of clauses in response to determining that the metadata identifier matches at least one clause of the set of clauses; performing a second traverse of the nodes of the set of nodes using an edge that points to a first data lineage of the first node in response to determining that the first node corresponds to a set of clauses, wherein the first data lineage of the first node points to a second node containing information that is the source of information associated with the first node; determining a second data silo that stores a second data object of a set of data objects using a location identifier that points to a second node in order to retrieve a second data object of a set of data objects via the second data silo; and generating a second visual representation of the second data object for display on a GUI.

[0190] Section 13. The method of Section 5, wherein the visual representation of at least one data object comprises genealogical information of at least one data object.

[0191] Section 14. Receiving a user-specified query in a graphical user interface (GUI) that, when executed by one or more processors, instructs a request to access a set of data objects, wherein each data object in the set of data objects is stored in its respective data silo among a set of data silos in heterogeneous locations; performing natural language processing on the user-specified query to determine a set of clauses corresponding to the user-specified query; and accessing a metadata graph to determine a node corresponding to the set of clauses, wherein the metadata graph comprises (i) (a) metadata pointing to internal data objects stored in data silos, and (b) data (ii) a set of nodes having a silo location identifier, and (ii) edges indicating the data lineage of the set of nodes, wherein the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers, and one or more non-temporary computer-readable media store instructions causing the metadata graph to perform actions including accessing and retrieving at least one data object from a set of data objects via a data silo, by using the location identifier corresponding to a determined node to determine the data silo containing at least one data object from a set of data objects, and generating a visual representation of at least one data object for display on a GUI.

[0192] Section 15. The medium of Section 14, wherein the metadata graph is generated by retrieving from a second set of data silos (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers, where each file-level metadata identifier in the set of file-level metadata identifiers refers to the metadata of a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers refers to the metadata of each data silo in the second set of data silos; generating sets of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier; generating metadata data structures for mapping each semantically similar metadata identifier in the sets of semantically similar metadata identifiers to normalized file-level metadata identifiers and normalized container-level metadata identifiers; and generating a metadata graph using the generated metadata data structures.

[0193] Section 16. The medium of Section 14, wherein when an instruction is executed by one or more processors, it receives a second user-specified query via a second GUI that directs a request to produce an intended result, and provides the second user-specified query to an artificial intelligence model to produce a recommendation, the recommendation comprising (i) a second artificial intelligence model to be used to produce the intended result, and (ii) a second set of data objects to be used when training the second artificial intelligence model, and in response to receiving a user selection directing acceptance of the recommendation, the medium further performs actions including (i) accessing a database to retrieve the second artificial intelligence model, and (ii) retrieving the second set of data objects using a metadata graph, training the second artificial intelligence model using the set of data objects, and applying the second artificial intelligence model to produce the intended result.

[0194] Section 17. The medium of Section 16, which, when executed by one or more processors, causes the instruction to perform operations including: accessing a governance database to obtain a set of policies indicating usage metrics corresponding to a second set of data objects; using the set of policies indicating usage metrics corresponding to a second set of data objects to determine whether the second set of data objects is authorized to be used to train a second artificial intelligence model; using the second set of policies indicating usage metrics corresponding to artificial intelligence model predictions to determine whether the output of the second artificial intelligence model is authorized to be provided to one or more computing systems; and in response to (i) the second set of data objects being authorized to be used to train a second artificial intelligence model, and (ii) the output of the second artificial intelligence model being authorized to be provided to one or more computing systems, applying the second artificial intelligence model to produce intended results.

[0195] Section 18. The medium of Section 14, wherein determining the set of clauses corresponding to a user-specified query further comprises parsing the user-specified query with respect to a set of keywords, such that each keyword in the set of keywords is associated with a set of data objects; determining, for each keyword in the set of keywords associated with the set of data objects, a set of semantically similar clauses corresponding to each keyword in the set of keywords; and using the set of semantically similar clauses corresponding to each keyword in the set of keywords, determining the set of clauses corresponding to the user-specified query.

[0196] Section 19. The medium of Section 18, wherein determining semantically similar phrases corresponding to each keyword in a set of keywords further includes accessing a database that indicates a mapping between a first set of keywords and a second set of keywords, and, in response to accessing the database, using each keyword to determine a set of semantically similar phrases corresponding to each keyword.

[0197] Section 20. Accessing the metadata graph further includes traversing each node in a set of nodes to identify a metadata identifier that matches at least one clause in a set of clauses, and determining the node corresponding to the set of clauses in response to determining that the metadata identifier matches at least one clause in the set of clauses. US01 permission granted

[0198] Section 21. A system for reducing data retrieval time when accessing siloed data across heterogeneous locations by generating an integrated metadata graph via a Search Extension Generation (RAG) framework, comprising: at least one hardware processor; receiving raw data from a set of data silos, comprising a set of metadata identifiers that, when executed by at least one hardware processor, point to (i) file-level metadata identifiers, (ii) container-level metadata identifiers, and (iii) system-level metadata identifiers; selecting a first structured LLM prompt from a set of structured large-scale language model (LLM) prompts corresponding to a first metadata identifier from the set of metadata identifiers; extending the first structured LLM prompt with a first metadata identifier that will be provided to an LLM connected to a set of domain-specific ontologs, wherein the LLM provides a first intermediate output that points to a second set of metadata identifiers corresponding to the first metadata identifier without accessing the set of domain-specific ontologs. Extending a first structured LLM prompt with a second set of metadata identifiers corresponding to a first metadata identifier to be provided to the LLM, configured to generate forces, extending to generate a second intermediate output pointing to filtered domain-specific metadata identifiers by accessing a set of domain-specific ontologs, generating a domain-specific integrated metadata graph via the LLM using (i) the first metadata identifiers and (ii) the second intermediate output pointing to filtered domain-specific metadata identifiers, wherein the filtered domain-specific metadata identifiers are traversable identifiers and the first metadata identifiers are non-traversable identifiers in the domain-specific integrated metadata graph, performing a verification process on the domain-specific integrated metadata graph by comparing a first performance metric of the domain-specific integrated metadata graph with a second performance metric of another version of the domain-specific integrated metadata graph, and the first performance metric isA system comprising at least one non-temporary memory containing instructions that cause the system to perform an update process on a domain-specific integrated metadata graph in response to a determination that the system cannot meet or exceed a second performance criterion for other versions of the domain-specific integrated metadata graph.

[0199] Section 22. The system of Section 21, in which a set of raw data is received by performing a crawling process across a set of data silos associated with entities to obtain raw data that includes a set of metadata identifiers.

[0200] Section 23. The system of Section 21, wherein when an instruction is executed by at least one hardware processor, the system further causes the system to extract a first value from each of a set of data silos, determine the data type corresponding to each first value extracted from each of the set of data silos, and generate a data profile for each of the data silos in the set of data silos, indicating the data type of the values ​​stored in the data silos.

[0201] Section 24. The system of Section 23, further comprising: selecting a first structured LLM prompt from a set of structured LLM prompts that corresponds to a first metadata identifier from a set of metadata identifiers; determining a data silo that stores data corresponding to the first metadata identifier; retrieving a first data profile that corresponds to the data silo that stores data corresponding to the first metadata identifier; filtering a set of structured LLM prompts using the first data profile to generate a set of filtered LLM prompts; and selecting a first structured LLM prompt from a set of filtered LLM prompts that corresponds to a first metadata identifier from a set of metadata identifiers.

[0202] Section 25. The verification process provides a first query requesting the location of a first data item to (i) the domain-specific integrated metadata graph and (ii) other versions of the domain-specific integrated metadata graph, wherein the provision of the first query causes the generation of a first result indicating the location of the first data item from the domain-specific integrated metadata graph and a second result indicating the location of the first data item for other versions of the domain-specific integrated metadata graph, and provides a first sub-performance metric for the domain-specific integrated metadata graph and other versions of the domain-specific integrated metadata graph. The system of Section 21, further comprising: calculating a second sub-metric, wherein the first and second sub-metrics are query-versus-results performance metrics; calculating a third sub-metric for a domain-specific integrated metadata graph and a fourth sub-metric for other versions of the domain-specific integrated metadata graph, wherein the third and fourth sub-metrics are result accuracy metrics, the first performance metric comprises the first and third sub-metrics, and the second performance metric comprises the second and fourth sub-metrics.

[0203] Section 26. A system of Section 25 in which the determination that the first performance criterion cannot satisfy or exceed the second performance criterion is based on the determination that (i) the first sub-performance criterion satisfies or exceeds the second sub-performance criterion, or (ii) the third sub-performance criterion cannot satisfy or exceed the fourth sub-performance criterion.

[0204] Section 27. The system of Section 21, wherein performing an update process on a domain-specific integrated metadata graph involves determining a set of inconsistencies between the domain-specific integrated metadata graph and other versions of the domain-specific integrated metadata graph, the set of inconsistencies reflecting (i) inconsistencies between nodes of the domain-specific integrated metadata graph and other versions of the domain-specific integrated metadata graph, and (ii) in inconsistencies between edges connected to at least one node of the domain-specific integrated metadata graph and other versions of the domain-specific integrated metadata graph, and updating the domain-specific integrated metadata graph with updated nodes and edges of the other versions of the domain-specific integrated metadata graph corresponding to the set of inconsistencies.

[0205] Section 28. The system of Section 21, which, when an instruction is executed by at least one hardware processor, further causes the system to detect the addition of a data silo to the computing environment associated with a first entity, and, in response to the detection of the addition of the data silo, causes a second update process to be performed on a domain-specific integrated metadata graph.

[0206] Section 29. The system of Section 21, wherein a file-level metadata identifier indicates the metadata of a given data object stored within each data silo in a set of data silos, a container-level metadata identifier indicates the metadata of each data silo in a set of data silos, and a system-level metadata identifier indicates the metadata of the computing system hosting each data silo in a set of data silos.

[0207] Section 30. The system of Section 21, wherein the domain-specific integrated metadata graph comprises a first node that points to (i) (a) filtered metadata identifiers, (b) a first metadata identifier, and (c) a location identifier for a data silo associated with the first metadata identifier, and (ii) at least one edge that points to a data lineage between the first node and the second node.

[0208] Section 31. A method for reducing data retrieval time when accessing siloed data across heterogeneous locations by generating an integrated metadata graph via a Search Expansion Generation (RAG) framework, comprising: selecting a first LLM prompt from a set of Large Language Model (LLM) prompts corresponding to a first metadata identifier from a set of metadata identifiers; extending the first LLM prompt with a first metadata identifier to be provided to the LLM, configured such that the LLM generates a first intermediate output pointing to a second set of metadata identifiers corresponding to the first metadata identifier; and extending the first LLM prompt with a second set of metadata identifiers corresponding to the first metadata identifier to be provided to the LLM, thereby enabling the LLM to access a set of domain-specific ontologs. A method comprising: extending, configured to generate a second intermediate output indicating filtered domain-specific metadata identifiers; generating a domain-specific integrated metadata graph via LLM using (i) a first metadata identifier and (ii) a second intermediate output indicating filtered domain-specific metadata identifiers, wherein the filtered domain-specific metadata identifiers are traversable identifiers and the first metadata identifiers are non-traversable identifiers in the domain-specific integrated metadata graph; and performing an update process on the domain-specific integrated metadata graph in response to determining that the first performance metric of the domain-specific integrated metadata graph fails to meet the performance measure of a second performance metric for another version of the domain-specific integrated metadata graph.

[0209] Section 32. The method of Section 31, further comprising extracting a first value from each of a set of data silos, determining the data type corresponding to each first value extracted from each of the set of data silos, and generating a data profile for each of the data silos in the set of data silos, indicating the data type of the values ​​stored in the data silos.

[0210] Section 33. The method of Section 32, further comprising: selecting a first LLM prompt from a set of LLM prompts that corresponds to a first metadata identifier from a set of metadata identifiers; determining a data silo that stores data corresponding to the first metadata identifier; retrieving a first data profile that corresponds to the data silo that stores data corresponding to the first metadata identifier; filtering a set of LLM prompts using the first data profile to generate a filtered set of LLM prompts; and selecting a first LLM prompt from a filtered set of LLM prompts that corresponds to a first metadata identifier from a set of metadata identifiers.

[0211] Section 34. Performing a verification process on a domain-specific integrated metadata graph, wherein the verification process provides a first query requesting the location of a first data item to (i) the domain-specific integrated metadata graph and (ii) other versions of the domain-specific integrated metadata graph, wherein the provision of the first query causes the generation of a first result indicating the location of the first data item from the domain-specific integrated metadata graph and a second result indicating the location of the first data item for other versions of the domain-specific integrated metadata graph, providing a first sub-performance metric for the domain-specific integrated metadata graph, and domain-specific integrated metadata The method of Section 31, further comprising calculating a second sub-metric for other versions of the graph, wherein the first sub-metric and the second sub-metric are query-versus-results performance metrics, and further comprising calculating a third sub-metric for a domain-specific integrated metadata graph and a fourth sub-metric for other versions of the domain-specific integrated metadata graph, wherein the third sub-metric and the fourth sub-metric are result accuracy metrics, and the first performance metric comprises the first sub-metric and the third sub-metric, and the second performance metric comprises the second sub-metric and the fourth sub-metric.

[0212] Section 35. The method of Section 34, in which determining whether the first performance criterion satisfies the performance scale relating to the second performance criterion is based on the determination that (i) the first sub-performance criterion satisfies or exceeds the second sub-performance criterion, or (ii) the third sub-performance criterion neither satisfies nor exceeds the fourth sub-performance criterion.

[0213] Section 36. When executed by one or more processors, the process involves selecting a first LLM prompt corresponding to a first metadata identifier from a set of metadata identifiers from a set of Large Language Model (LLM) prompts, extending the first LLM prompt with a first metadata identifier to be provided to the LLM, wherein the LLM is configured to produce a first intermediate output pointing to a second set of metadata identifiers corresponding to the first metadata identifier, and extending the first LLM prompt with a second set of metadata identifiers corresponding to the first metadata identifier to be provided to the LLM, wherein the LLM is configured to produce a second intermediate output pointing to filtered domain-specific metadata identifiers by accessing a set of domain-specific ontologs. One or more non-temporary computer-readable media containing instructions for causing an operation to be performed, which includes extending and generating a domain-specific integrated metadata graph via LLM using (i) a first metadata identifier and (ii) a second intermediate output indicating a filtered domain-specific metadata identifier, wherein the filtered domain-specific metadata identifier is a traversable identifier and the first metadata identifier is a non-traversable identifier in the domain-specific integrated metadata graph, and performing an update process on the domain-specific integrated metadata graph in response to the determination that the first performance metric of the domain-specific integrated metadata graph fails to meet the performance measure of a second performance metric for another version of the domain-specific integrated metadata graph.

[0214] Section 37. A medium of Section 36, which, when executed by one or more processors, causes the processor to perform an operation that includes extracting a first value from each of a set of data silos, determining the data type corresponding to each first value extracted from each of the set of data silos, and generating a data profile for each of the data silos in the set of data silos, indicating the data type of the values ​​stored in the data silos.

[0215] Section 38. The medium of Section 37, further comprising: selecting a first LLM prompt from a set of LLM prompts that corresponds to a first metadata identifier from a set of metadata identifiers; determining a data silo that stores data corresponding to the first metadata identifier; retrieving a first data profile that corresponds to the data silo that stores data corresponding to the first metadata identifier; filtering a set of LLM prompts using the first data profile to generate a filtered set of LLM prompts; and selecting a first LLM prompt from a filtered set of LLM prompts that corresponds to a first metadata identifier from a set of metadata identifiers.

[0216] Section 39. When an instruction is executed by one or more processors, a confirmation process is performed on a domain-specific integrated metadata graph, wherein the confirmation process provides a first query requesting the location of a first data item to (i) the domain-specific integrated metadata graph and (ii) other versions of the domain-specific integrated metadata graph, wherein the provision of the first query causes the generation of a first result indicating the location of the first data item from the domain-specific integrated metadata graph and a second result indicating the location of the first data item for other versions of the domain-specific integrated metadata graph, providing a first sub-performance metric for the domain-specific integrated metadata graph, and domain The medium of Section 36 further includes performing operations that include calculating a second sub-metric for other versions of the domain-specific integrated metadata graph, wherein the first and second sub-metrics are query-versus-results performance metrics, and calculating a third sub-metric for the domain-specific integrated metadata graph and a fourth sub-metric for other versions of the domain-specific integrated metadata graph, wherein the third and fourth sub-metrics are result accuracy metrics, and the first performance metric comprises the first and third sub-metrics, and the second performance metric comprises the second and fourth sub-metrics.

[0217] Section 40. The medium of Section 39, where the determination that the first performance criterion fails to meet the performance measure relating to the second performance criterion is based on the determination that (i) the first sub-performance criterion meets or exceeds the second sub-performance criterion, or (ii) the third sub-performance criterion fails to meet or exceed the fourth sub-performance criterion. US02 authorized.

[0218] Section 41. A computer system receiving a first natural language input from a user, including a set of phrases, and instructions to analyze data associated with the set of phrases using an artificial intelligence (AI) model; accessing a metadata graph in response to the first natural language input to determine a node corresponding to the set of phrases, wherein the metadata graph comprises a set of nodes having (i) (a) metadata pointing to an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges pointing to the data lineage of the set of nodes; processing one or more internal data objects pointed to by the determined node to generate a first set of application data; and generating one or more first outputs. A computer execution method comprising: applying an AI model to a first set of application data, wherein one or more first outputs comprise a classification of data items in the first set of application data, or one or more predictions made based on the first set of application data; transmitting a representation of one or more first outputs for display to a user; receiving a second natural language input from a user, wherein the second natural language input comprises instructions for modifying the first set of application data; generating a second set of application data by the computer system based on the received second natural language input; and applying the AI ​​model to the second set of application data to generate one or more second outputs.

[0219] Section 42. The method of Section 41, which involves processing an internal data object to generate a first set of application data, including removing personally identifiable or private information from the internal data object.

[0220] Section 43. The method of Section 41, which includes processing an internal data object to generate a first set of application data, and applying a set of data modification operators to the internal data object to generate a set of modified data based on the internal data object, wherein the first set of application data includes one or more modified data items from the set of modified data.

[0221] Section 44. The method of Section 41, which involves processing an internal data object to generate a first set of application data, including removing inaccurate data items from the internal data object.

[0222] Section 45. The method of Section 41, further comprising receiving a third natural language input containing instructions for generating an AI model before receiving a first natural language input; accessing a metadata graph to determine a node corresponding to the third natural language input; processing internal data objects associated with the node corresponding to the third natural language input to generate a set of training data; and training the AI ​​model using the set of training data to generate a trained AI model, wherein applying the AI ​​model to a first set of application data includes applying the trained AI model to a first set of application data.

[0223] Section 46. The method of Section 45, wherein training an AI model includes accessing values ​​of one or more model metrics associated with each of several model types, having a computer system select a model type for a trained AI model from among the several model types based on the accessed values ​​of one or more model metrics, and training the selected model type.

[0224] Section 47. The method of Section 45, wherein training an AI model includes receiving a user selection about the model type of the AI ​​model and training the selected model type.

[0225] Section 48. The method of Section 41, further comprising generating a chat interface for display to a user by a computer system, wherein a first natural language input is received via the chat interface, and sending a representation of one or more outputs for display to a user includes displaying one or more outputs via the chat interface.

[0226] Section 49. The method of Section 41, wherein generating a second set of application data based on a second natural language input includes adding data items to a first set of application data, removing data items from a first set of application data, or applying data modification operators to values ​​to modify the values ​​of data items in the first set of application data.

[0227] Section 50.1 or more processors and one or more non-temporary computer-readable storage media storing executable instructions, the instructions, when executed by one or more processors, receive a first natural language input from a user including a set of phrases, and instructions for analyzing data associated with the set of phrases using an artificial intelligence (AI) model, access a metadata graph in response to the first natural language input to determine a node corresponding to the set of phrases, wherein the metadata graph comprises a set of nodes having (i) (a) metadata pointing to an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges pointing to the data lineage of the set of nodes, access the first application data A system comprising one or more non-temporary computer-readable storage media, which causes the system to process one or more internal data objects instructed by a determined node in order to generate a set; apply an AI model to a first set of application data in order to generate one or more first outputs; transmit a representation of one or more first outputs for display to a user; receive a second natural language input from a user, the second natural language input comprising instructions for modifying the first set of application data; generate a second set of application data based on the received second natural language input; and apply an AI model to the second set of application data in order to generate one or more second outputs.

[0228] Section 51. The system of Section 50, which processes internal data objects to generate a first set of application data, including removing personally identifiable or private information from the internal data objects.

[0229] Section 52. The system of Section 50, which includes processing internal data objects to generate a first set of application data, and applying a set of data modification operators to internal data objects to generate a set of modified data based on the internal data objects, wherein the first set of application data includes one or more modified data items from the set of modified data.

[0230] Section 53. The system of Section 50, which processes internal data objects to generate a first set of application data, including removing inaccurate data items from the internal data objects.

[0231] Section 54. The system of Section 50, wherein when an instruction is executed by one or more processors, the system causes the system to further perform the following actions: receive a third natural language input containing instructions for generating an AI model before receiving a first natural language input; access a metadata graph to determine a node corresponding to the third natural language input; process internal data objects associated with the node corresponding to the third natural language input to generate a set of training data; and train the AI ​​model using the set of training data to generate a trained AI model, wherein applying the AI ​​model to a first set of application data includes applying the trained AI model to a first set of application data.

[0232] Section 55. The system of Section 50, wherein when an instruction is executed by one or more processors, the system further causes the system to generate a chat interface for display to a user, and a first natural language input is received via the chat interface, and a representation of one or more outputs for display to a user is sent, which includes displaying one or more outputs via the chat interface.

[0233] Section 56. The system of Section 50, wherein generating a second set of application data based on a second natural language input includes adding data items to the first set of application data, removing data items from the first set of application data, or applying data modification operators to values ​​to modify the values ​​of data items in the first set of application data.

[0234] Section 57. A non-temporary computer-readable storage medium storing executable instructions, wherein when an instruction is executed by one or more processors of the system, it receives a first natural language input from a user including a set of phrases, and an instruction to analyze data associated with the set of phrases using an artificial intelligence (AI) model, and in response to the first natural language input, it accesses a metadata graph to determine a node corresponding to the set of phrases, wherein the metadata graph comprises a set of nodes having (i) (a) metadata pointing to an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges pointing to the data lineage of the set of nodes, and the first application data A non-temporary computer-readable storage medium that causes the system to process one or more internal data objects instructed by a determined node in order to generate a set; apply an AI model to a first set of application data in order to generate one or more first outputs; transmit a representation of one or more first outputs for display to a user; and receive a second natural language input from a user, the second natural language input including instructions for modifying the first set of application data; generate a second set of application data based on the received second natural language input; and apply an AI model to the second set of application data in order to generate one or more second outputs.

[0235] Section 58. A non-temporary computer-readable storage medium of Section 57, which includes processing an internal data object to generate a first set of application data, and applying a set of data modification operators to the internal data object to generate a set of modified data based on the internal data object, wherein the first set of application data includes one or more modified data items from the set of modified data.

[0236] Section 59. A non-temporary computer-readable storage medium of Section 57, which, when an instruction is executed by one or more processors, causes the system to further perform the following actions: receiving a third natural language input containing instructions for generating an AI model before receiving a first natural language input; accessing a metadata graph to determine a node corresponding to the third natural language input; processing internal data objects associated with the node corresponding to the third natural language input to generate a set of training data; and training the AI ​​model using the set of training data to generate a trained AI model, wherein applying the AI ​​model to a first set of application data includes applying the trained AI model to a first set of application data.

[0237] Section 60. A non-temporary computer-readable storage medium of Section 57, in which, when an instruction is executed by one or more processors, the system further causes the system to generate a chat interface for display to a user, a first natural language input is received via the chat interface, and a representation of one or more outputs for display to a user is sent, including displaying one or more outputs via the chat interface. US03 Undecided

[0238] Section 61. A computer execution method comprising: receiving a first request for a first artificial intelligence (AI) model to be used by an entity to deploy and make available a first artificial intelligence (AI) model for use in a production environment for processing input data and generating corresponding outputs; selecting a first model deployment location for the first AI model based on a model deployment engine, wherein the model deployment engine is configured to select the first model deployment location from one or more cloud provider environments or on-premises environments operated by the entity; generating a script for deploying the first AI model to the first model deployment location; monitoring operational parameters associated with the deployment of the first AI model at the selected model deployment location as the first AI model processes input data and generates corresponding outputs; updating the model deployment engine based on the values ​​of the monitored operational parameters; and selecting a second model deployment location for the second AI model based on the updated model deployment engine in response to a second request to deploy a second AI model.

[0239] Section 62. A computer execution method of Section 61, wherein the model deployment engine comprises a decision tree, a knowledge graph, or a rule engine, and the selection of a first model deployment location based on the model deployment engine includes selecting a first model deployment location based on one or more of the following: the computational cost of deploying a first AI model at the selected model deployment location, the computational capacity of the selected model deployment location, the response time from the selected model deployment location, or a measure of the accuracy of the first AI model when deployed at the selected model deployment location.

[0240] Section 63. A computer execution method of Section 61, wherein selecting a first model deployment location based on a model deployment engine includes selecting a first model deployment location based on a privacy policy associated with at least one of a first AI model, input data, or corresponding output.

[0241] Section 64. A computer execution method of Section 61, wherein the operating parameters include one or more of the following: the computational cost used by the first AI model at the first model deployment location; the response time from the first AI model when deployed at the first model deployment location; the computing capacity available in the environment including the first model deployment location; the privacy policy of the environment including the first model deployment location; or a measure of downtime or service interrupts in the environment including the first model deployment location.

[0242] Section 65. A computer execution method of Section 61, wherein the model deployment engine has a trained decision model, and updating the model deployment engine includes retraining the trained decision model based on the difference between the values ​​of monitored operating parameters and the values ​​of the set of operating parameters on which the model deployment engine was trained.

[0243] Section 66. The computer execution method of Section 61, wherein the second AI model is a second instance of the first AI model, and the second model deployment location for the second AI model is a different location from the first model deployment location for the first AI model.

[0244] Section 67. A computer execution method of Section 61, further comprising selecting a third model deployment location for a first AI model, different from a first model deployment location, based on an updated model deployment engine, and generating a script for deploying the first AI model to the third model deployment location.

[0245] Section 68. A computer execution method of Section 61, further comprising selecting a third model deployment location for a first AI model, different from a first model deployment location, based on a model deployment engine and operating parameters, and generating a script for deploying the first AI model to the third model deployment location.

[0246] Section 69. A computer execution method of Section 68, comprising deciding to move the first AI model to a third model deployment location when the operation parameter includes the computational cost associated with deploying the first AI model at a first model deployment location, and the computational cost associated with selecting a third model deployment location for deploying the first AI model at the first model deployment location is greater than the predicted computational cost associated with deploying the first AI model at the third model deployment location.

[0247] Section 70. One or more processors and one or more non-temporary computer-readable storage media storing executable instructions, wherein when the instructions are executed by one or more processors, a first request is received for a first artificial intelligence (AI) model to be deployed and made available for use in a production environment for processing input data and generating corresponding output, for a first AI model to be used by an entity, and based on a model deployment engine, a first model deployment location for the first AI model is selected, the model deployment engine selects from one or more cloud provider environments or on-premises environments operated by the entity A system comprising one or more non-temporary computer-readable storage media configured to select a model deployment location, to select a model deployment location, to generate a script for deploying a first AI model to a first model deployment location, to monitor operating parameters associated with the deployment of the first AI model at the selected model deployment location as the first AI model processes input data and produces corresponding outputs, to update the model deployment engine based on the values ​​of the monitored operating parameters, and to cause the system to select a second model deployment location for the second AI model based on the updated model deployment engine in response to a second request for deploying a second AI model.

[0248] Section 71. The system of Section 70, wherein the model deployment engine comprises a decision tree, a knowledge graph, or a rule engine, and the selection of a first model deployment location based on the model deployment engine includes selecting a first model deployment location based on one or more of the following: the computational cost of deploying a first AI model at the selected model deployment location, the computational capacity of the selected model deployment location, the response time from the selected model deployment location, or a measure of the accuracy of the first AI model when deployed at the selected model deployment location.

[0249] Section 72. The system of Section 70, wherein selecting a first model deployment location based on a model deployment engine includes selecting a first model deployment location based on a privacy policy associated with at least one of a first AI model, input data, or corresponding output.

[0250] Section 73. The system of Section 70, wherein the operating parameters include one or more of the following: the computational cost used by the first AI model at the first model deployment location, the response time from the first AI model when deployed at the first model deployment location, the computational capacity available in the environment including the first model deployment location, the privacy policy of the environment including the first model deployment location, or a measure of downtime or service interrupts in the environment including the first model deployment location.

[0251] Section 74. The system of Section 70, wherein the model deployment engine has a trained decision model, and updating the model deployment engine includes retraining the trained decision model based on the difference between the values ​​of monitored operating parameters and the values ​​of the set of operating parameters on which the model deployment engine was trained.

[0252] Section 75. The system of Section 70, wherein the second AI model is a second instance of the first AI model, and the second model deployment location for the second AI model is a different location from the first model deployment location for the first AI model.

[0253] Section 76. The system of Section 70, wherein, when an instruction is executed by one or more processors, the system further causes itself to select a third model deployment location for a first AI model, different from a first model deployment location, based on an updated model deployment engine, and to generate a script for deploying the first AI model to the third model deployment location.

[0254] Section 77. The system of Section 70, wherein when an instruction is executed by one or more processors, the system further causes the system to select a third model deployment location for a first AI model, different from a first model deployment location, based on a model deployment engine and operating parameters, and to generate a script for deploying the first AI model to the third model deployment location.

[0255] Section 78. The system of Section 77, wherein the operating parameters include the computational cost associated with deploying the first AI model at a first model deployment location, and the system determines to move the first AI model to a third model deployment location when selecting a third model deployment location is greater than the predicted computational cost associated with deploying the first AI model at the first model deployment location.

[0256] Section 79. A non-temporary computer-readable storage medium storing executable instructions, which, when the instructions are executed by one or more processors of the system, receives a first request for a first artificial intelligence (AI) model to be deployed and made available for use in a production environment for processing input data and generating corresponding output, for a first AI model to be used by an entity, and selects a first model deployment location for the first AI model based on a model deployment engine, wherein the model deployment engine selects the first model from a set of one or more cloud provider environments or an on-premises environment operated by the entity. A non-temporary, computer-readable storage medium configured to select a Dell deployment location, generate a script for deploying a first AI model to a first model deployment location, monitor operating parameters associated with the deployment of the first AI model at the selected model deployment location as the first AI model processes input data and produces corresponding outputs, update the model deployment engine based on the values ​​of the monitored operating parameters, and, in response to a second request to deploy a second AI model, select a second model deployment location for the second AI model based on the updated model deployment engine.

[0257] Section 80. A non-temporary computer-readable storage medium of Section 79, wherein the model deployment engine comprises a decision tree, a knowledge graph, or a rule engine, and the selection of a first model deployment location based on the model deployment engine includes selecting a first model deployment location based on one or more of the following: the computational cost to deploy a first AI model at the selected model deployment location, the computational capacity of the selected model deployment location, the response time from the selected model deployment location, or a measure of the accuracy of the first AI model when deployed at the selected model deployment location. US04 Pending Claims

[0258] Section 81. A system for reducing the use of computing resources when accessing silo storage data across heterogeneous locations via an integrated metadata graph, comprising at least one hardware processor, and, when executed by at least one hardware processor, identifying a set of keywords associated with a request to access a set of data objects, performing natural language processing on the set of keywords to determine a set of semantically similar phrases corresponding to each keyword in the set of keywords, and accessing the metadata graph to determine a node corresponding to a set of semantically similar phrases, wherein the metadata graph is a set of nodes that point to (i) (a) metadata of internal data objects stored in data silos, and (b) location identifiers of data silos, and (ii) among the set of nodes A system comprising: an edge indicating a data lineage between a first node and a second node, wherein the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers; accessing; determining a data silo containing at least one data object from a set of data objects using a location identifier corresponding to a determined node in order to retrieve at least one data object from a set of data objects via a data silo; and generating a visual representation of at least one data object for display on a graphical user interface (GUI), wherein the visual representation of at least one data object comprises lineage information of at least one data object, and having at least one non-temporary memory storing instructions for the system to generate.

[0259] Section 82. The system of Section 81, wherein the metadata graph is generated by retrieving (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers from a second set of data silos, wherein each file-level metadata identifier in the set of file-level metadata identifiers refers to the metadata of a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers refers to the metadata of each data silo in the second set of data silos; generating sets of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier; generating metadata data structures for mapping each semantically similar metadata identifier in the sets of semantically similar metadata identifiers to normalized file-level metadata identifiers and normalized container-level metadata identifiers; and generating a metadata graph using the generated metadata data structures.

[0260] Section 83. The system of Section 81, comprising: receiving a second user-specified query via a second GUI that directs a request to produce an intended result; and providing the second user-specified query to an artificial intelligence model to produce a recommendation, wherein the recommendation comprises (i) a second artificial intelligence model to be used to produce the intended result; and (ii) a second set of data objects to be used when training the second artificial intelligence model; and in response to receiving a user selection directing acceptance of the recommendation, further comprising instructions to (i) access a database to retrieve the second artificial intelligence model; and (ii) retrieve the second set of data objects using a metadata graph; train the second artificial intelligence model using the set of data objects; and apply the second artificial intelligence model to produce the intended result.

[0261] Section 84. The system of Section 83, further comprising instructions for accessing a governance database to obtain a set of policies indicating usage metrics corresponding to a second set of data objects; using the set of policies indicating usage metrics corresponding to a second set of data objects to determine whether the second set of data objects is authorized to be used to train a second artificial intelligence model; using the second set of policies indicating usage metrics corresponding to artificial intelligence model predictions to determine whether the output of the second artificial intelligence model is authorized to be provided to one or more computing systems; and in response to (i) the second set of data objects being authorized to be used to train a second artificial intelligence model, and (ii) the output of the second artificial intelligence model being authorized to be provided to one or more computing systems, applying the second artificial intelligence model to produce intended results.

[0262] Section 85. A method for reducing the use of computational resources when accessing siloed data across heterogeneous locations via an integrated metadata graph, the method comprising: identifying a set of keywords associated with a user-specified query for accessing a set of data objects; performing natural language processing on a user-specified query to determine a set of clauses corresponding to the user-specified query; and accessing the metadata graph to determine nodes corresponding to the set of clauses, wherein the metadata graph comprises a set of nodes each having (i)(a) metadata pointing to an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges pointing to the data lineage of the set of nodes, and the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers; and determining a data silo storing at least one data object from a set of data objects using a location identifier corresponding to a determined node, in order to retrieve at least one data object from a set of data objects via the data silo; and generating a representation of at least one data object.

[0263] Section 86. The method of Section 85, wherein the metadata graph is generated by retrieving (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers from a second set of data silos, wherein each file-level metadata identifier in the set of file-level metadata identifiers refers to the metadata of a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers refers to the metadata of each data silo in the second set of data silos; generating sets of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier; generating a metadata data structure for mapping each semantically similar metadata identifier in the sets of semantically similar metadata identifiers to normalized file-level metadata identifiers and normalized container-level metadata identifiers; and generating a metadata graph using the generated metadata data structure.

[0264] Section 87. The method of Section 85, further comprising receiving a second user-specified query via a second GUI that directs a request to produce an intended result, and providing the second user-specified query to an artificial intelligence model to produce a recommendation, wherein the recommendation comprises (i) a second artificial intelligence model to be used to produce the intended result, and (ii) a second set of data objects to be used when training the second artificial intelligence model, and in response to receiving a user selection directing acceptance of the recommendation, (i) accessing a database to retrieve the second artificial intelligence model, and (ii) using a metadata graph to retrieve the second set of data objects, training the second artificial intelligence model using the set of data objects, and applying the second artificial intelligence model to produce the intended result.

[0265] Section 88. The method of Section 87, further comprising: accessing a governance database to obtain a set of policies indicating usage metrics corresponding to a second set of data objects; using the set of policies indicating usage metrics corresponding to a second set of data objects to determine whether the second set of data objects is authorized to be used to train a second artificial intelligence model; using the second set of policies indicating usage metrics corresponding to artificial intelligence model predictions to determine whether the output of the second artificial intelligence model is authorized to be provided to one or more computing systems; and in response to (i) the second set of data objects being authorized to be used to train a second artificial intelligence model, and (ii) the output of the second artificial intelligence model being authorized to be provided to one or more computing systems, applying the second artificial intelligence model to produce intended results.

[0266] Section 89. The method of Section 85, wherein determining the set of clauses corresponding to a user-specified query is a parsing of a user-specified query with respect to a set of keywords, wherein each keyword in the set of keywords is associated with a set of data objects; for each keyword in the set of keywords associated with the set of data objects, determining a set of semantically similar clauses corresponding to each keyword in the set of keywords; and using the set of semantically similar clauses corresponding to each keyword in the set of keywords, determining the set of clauses corresponding to the user-specified query.

[0267] Section 90. The method of Section 89, further comprising determining semantically similar phrases corresponding to each keyword in a set of keywords by accessing a database that indicates a mapping between a first set of keywords and a second set of keywords, and, in response to accessing the database, using each keyword to determine a set of semantically similar phrases corresponding to each keyword.

[0268] Section 91. The method of Section 85, wherein accessing the metadata graph further includes traversing each node of a set of nodes to identify a metadata identifier that matches at least one clause of a set of clauses, and determining the node corresponding to the set of clauses in response to determining that the metadata identifier matches at least one clause of the set of clauses.

[0269] Section 92. The method of Section 85, wherein accessing a metadata graph involves traversing each node in a set of nodes to identify a metadata identifier that matches at least one clause in a set of clauses; determining a first node corresponding to the set of clauses in response to determining that the metadata identifier matches at least one clause in the set of clauses; and performing a second traverse of nodes in a set of nodes using an edge that points to a first data lineage of the first node in response to determining that the first node corresponds to a set of clauses, wherein the first data lineage of the first node points to a second node containing information that is the source of information associated with the first node; and determining a second data silo that stores a second data object in a set of data objects using a location identifier that points to a second node in order to retrieve a second data object in a set of data objects via a second data silo; and generating a second representation of the second data object.

[0270] Section 93. The method of Section 85, wherein the representation of at least one data object comprises lineage information of at least one data object.

[0271] Section 94. One or more non-temporary computer-readable media containing instructions causing the metadata graph to perform an operation that, when executed by one or more processors, includes: performing natural language processing on a user-specified query to determine a set of clauses corresponding to a user-specified query; accessing a metadata graph to determine a node corresponding to a set of clauses, wherein the metadata graph comprises a set of nodes each having (i)(a) metadata pointing to an internal data object stored in a data silo, and (b) a location identifier for the data silo; and (ii) edges pointing to the data lineage of the set of nodes, and the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers, the operation of accessing and retrieving at least one data object from a set of data objects via a data silo, by using a location identifier corresponding to a determined node to determine a data silo storing at least one data object from a set of data objects; and generating a representation of at least one data object.

[0272] Section 95. The medium of Section 94, wherein the metadata graph is generated by retrieving from a second set of data silos (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers, each of which file-level metadata identifiers in the set of file-level metadata identifiers refers to the metadata of a given data object stored in its respective data silo, and each of which container-level metadata identifiers in the set of container-level metadata identifiers refers to the metadata of each of which data silos in the second set of data silos; generating sets of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier; generating metadata data structures for mapping each semantically similar metadata identifier in the sets of semantically similar metadata identifiers to normalized file-level metadata identifiers and normalized container-level metadata identifiers; and generating a metadata graph using the generated metadata data structures.

[0273] Section 96. The medium of Section 94, wherein when an instruction is executed by one or more processors, it receives a second user-specified query via a second GUI that directs a request to produce an intended result, and provides the second user-specified query to an artificial intelligence model to produce a recommendation, the recommendation comprising (i) a second artificial intelligence model to be used to produce the intended result, and (ii) a second set of data objects to be used when training the second artificial intelligence model, and in response to receiving a user selection directing acceptance of the recommendation, the medium further performs actions including (i) accessing a database to retrieve the second artificial intelligence model, and (ii) retrieving the second set of data objects using a metadata graph, training the second artificial intelligence model using the set of data objects, and applying the second artificial intelligence model to produce the intended result.

[0274] Section 97. The medium of Section 96, which, when executed by one or more processors, causes the instruction to perform operations including: accessing a governance database to obtain a set of policies indicating usage metrics corresponding to a second set of data objects; using the set of policies indicating usage metrics corresponding to a second set of data objects to determine whether the second set of data objects is authorized to be used to train a second artificial intelligence model; using the second set of policies indicating usage metrics corresponding to artificial intelligence model predictions to determine whether the output of the second artificial intelligence model is authorized to be provided to one or more computing systems; and in response to (i) the second set of data objects being authorized to be used to train a second artificial intelligence model, and (ii) the output of the second artificial intelligence model being authorized to be provided to one or more computing systems, applying the second artificial intelligence model to produce intended results.

[0275] The medium of Section 94, wherein determining the set of clauses corresponding to a user-specified query further comprises: parsing a user-specified query with respect to a set of keywords such that each keyword in the set of keywords is associated with a set of data objects; determining, for each keyword in the set of keywords associated with the set of data objects, a set of semantically similar clauses corresponding to each keyword in the set of keywords; and using the set of semantically similar clauses corresponding to each keyword in the set of keywords, determining the set of clauses corresponding to the user-specified query.

[0276] Determining semantically similar sentences corresponding to each keyword in a set of keywords further includes accessing a database that indicates a mapping between a first set of keywords and a second set of keywords, and in response to accessing the database, using each keyword to determine a set of semantically similar sentences corresponding to each keyword, for the medium of section 98.

[0277] Accessing a metadata graph further includes traversing each node in a set of nodes to identify a metadata identifier that matches at least one sentence in a set of sentences, and in response to determining that the metadata identifier matches at least one sentence in the set of sentences, determining a node corresponding to the set of sentences, for the medium of section 94.

[0278] Conclusion Unless the context clearly requires otherwise, throughout this description and the claims, the words "comprise," "comprising," and the like are to be construed in an inclusive sense as opposed to an exclusive or exhaustive sense; that is, in the sense of "including, but not limited to." As used herein, the terms "connected," "coupled," or any variation thereof mean any direct or indirect connection or coupling between two or more elements, and the connection or coupling between elements can be physical, logical, or a combination thereof. Additionally, the words "herein," "above," "below," and words of similar import refer to the application as a whole when used in this application and do not refer to any particular part of this application. Where the context permits, the words in the above detailed description using the singular or plural number may also include the plural or singular number, respectively. The word "or" covers all interpretations of the word, meaning any one of the items in a list, all of the items in a list, and any combination of the items in a list, with respect to a list of two or more items.

[0279] The above detailed description of examples of the Art is not intended to be exhaustive or to limit the Art to the precise forms disclosed above. Specific examples of the Art are given above for illustrative purposes, but various equivalent modifications are possible within the scope of the Art, as will be apparent to those skilled in the art. For example, while processes or blocks are presented in a given order, alternative implementations may employ routines having steps or systems having blocks in a different order, and some processes or blocks may be removed, moved, added, subdivided, combined, and / or modified to provide alternative or subordinate combinations. Each of these processes or blocks may be implemented in various different ways. Also, while processes or blocks may be shown as being implemented sequentially, these processes or blocks may instead be implemented or executed in parallel or at different times. Furthermore, any specific numbers mentioned herein are merely examples, and alternative implementations may employ different values ​​or ranges.

[0280] The teachings of the Technology provided herein can be applied to systems other than those described above. The elements and actions of the various examples described above can be combined to provide further implementations of the Technology. Some alternative implementations of the Technology may include fewer elements than those mentioned above, as well as additional elements.

[0281] These and other modifications can be made to the Art in terms of the detailed description above. While the above description illustrates specific examples of the Art and describes the best-case scenario, the Art can be practiced in many ways, no matter how detailed it may appear in the text. The details of the system can vary considerably in their specific implementation, while they are still encompassed by the Art disclosed herein. As stated above, any specific terminology used when describing a particular feature or aspect of the Art should not be taken in a way that suggests the terminology is redefined herein to be limited to any particular characteristic, feature, or aspect of the Art to which the term is associated. In general, the terms used in the following claims should not be interpreted as limiting the Art to the specific examples disclosed herein unless such terms are explicitly defined in the detailed description section above. Thus, the actual scope of the Art includes not only the examples disclosed but also all equivalent ways of practicing or implementing the Art in the claims.

[0282] To reduce the number of claims, certain aspects of the Technology are presented below in the form of certain claims, but the applicant envisions various aspects of the Technology in the form of any number of claims. For example, only one aspect of the Technology is enumerated as a computer-readable media claim, but other aspects may be likewise embodied as computer-readable media claims or in other forms such as means-plus-function claims. Any claim intended to be treated under § 112(f) of the U.S. Patent Act will begin with the word “means for,” but the use of the term “for” in any other context is not intended to exercise the treatment under § 112(f). Accordingly, the applicant reserves the right to pursue additional claims after filing this application to pursue such additional claim forms in either this application or a continuation application. [Explanation of Symbols]

[0283] 100 User Interfaces 102 User-specified query input 104 Result Output 106 At least one data object 108 Data System Information 200 Computer systems and other devices 204 Input Components 206 Output Components 208 processors 210 storage 212a Application 212N Application 214a Model 214N Model 216 Network Connection Components 218 Persistent Storage Devices 220 Computer-readable media drives 300 Environment 302 Client Computing Devices 302a Client computing device, computing device 302b Client computing device, computing device 302c Client computing device, computing device 302d Client computing device, computing device 304 Network 306 Server Computing Devices 310 Server Computing Devices 310a Server 310b Server 310c Server 308 Databases 312 Databases 312a Database 312b Database 312c Database 400 processes 500 Metadata Graphs 502 nodes 502a Node 502b Node 502c Node 502d Node 502e Node 502f Node 502g Node 502h Node 502i Node 502j Node 502k Node 502l Node 502m Node 504 Edge 504a Edge 504b Edge 504c Edge 504d Edge 504e Edge 504f Edge 504g Edge 504h Edge 504i Edge 504j Edge 504k Edge 504l Edge 504m Edge 504n Edge 504o Edge 504p Edge 504q Edge Expanded view of the 600 metadata graph 602 Node 602a First node, Node 602b Second node, Node 602c Third node, Node 602d Fourth node, Node 604 Edge 604a First edge 604b Second edge 604c Third edge 606 File-level metadata identifier 606a File-level metadata identifier 608 Container-level metadata identifier 608a Container-level metadata identifier 610 Location Identifier 610a Location identifier 700 diagrams of artificial intelligence models 702 Model 704 Input 706 Output 800 processes 900 LLM prompt 902 Prompt 1 Level 903 904 Primary metadata identifier 905 First prompt text 906 LLM 907 Second prompt text 908 First intermediate output 910 Prompt 2 912 Second intermediate output 914 Prompt 3 916 Prompt 4 918 Third prompt text 920 Metadata Graph 922 Prompt 5 1000 Subsystem Diagram 1002 User Interface 1004 Metadata Graph 1006 LLM 1008 Domain Ontology Components 1010 Raw data components 1012 Feedback Components 1014a Communication Link 1014b Communication Link 1014c Communication Link 1014d Communication Link 1014e Communication Link 1014f Communication Link 1014g communication link 1014h Communication Link 1014i Communication Link 1014j communication link 1014k communication link 1014l Communication Link 1014m communication link 1014n communication link 1014o Communication Link 1014p Communication Link 1015 Data Silo 1016 Crawler 1018 Parsa 1020 Profiler 1022 Concept 1024 Domain Thesaurus 1026 Versioning Components 1028 Generator 1030 results 1032 Third-party input 1034 Update Components 1100 Metadata Graph 1102 nodes 1102a The fifth node, node 1102b The sixth node, node 1102c The 7th node, node 1102d 8th node, node 1104a Second edge 1106a File-level metadata identifier 1108a Container-level metadata identifier 1110a Location identifier 1112a Domain-specific metadata identifier 1200 AI Sandbox 1210 Model Review Assistant 1220 data processors 1230 Model Generator 1240 Model Governor Auto Meter 1250 Model 1310 datasets, raw datasets 1320 Data Preprocessor 1322 Application data, application dataset 1330 Data Analyst 1340 Data Profile Generator 1350 Sanpla 1342 Data Profile 1352 training samples 1354 Test Samples 1405 User Input 1410 Feature Set Generator 1420 Target selector, selector 1430 Model Selector 1440 Model Builder 1445 Model 1510 Large-Scale Language Models (LLMs) 1520 RAG-based processes 1522 Industry Knowledge Repository 1524 Enterprise Knowledge Repository 1530 Explainability Layer 1600 processes 1620 processes 1700 Chat Interface 1705 Natural Language Input 1710 User Input 1715 Plot 1720 inputs 1810 Model Development Engine, Engine 1812 Model Deployment Engine Updater 1814 Orchestrator 1816 Data Handler 1820A First public cloud provider 1820B Second public cloud provider 1830A On-Premise Machine 1830B On-Premise Scalable Resources 1900 processes

Claims

1. A system for reducing the use of computing resources when accessing silo storage data across heterogeneous locations via an integrated metadata graph, At least one hardware processor, When executed by at least one hardware processor, Receiving a user-specified query in a graphical user interface (GUI) that instructs a request to access a set of data objects, wherein each data object in the set of data objects is stored in its respective data silo within a set of data silos in heterogeneous locations. Parsing a user-specified query with respect to a set of keywords, wherein each keyword in the set of keywords is associated with the set of data objects. In order to determine a set of semantically similar phrases corresponding to each keyword in the aforementioned set of keywords, natural language processing is performed on the aforementioned set of keywords. Accessing a metadata graph to determine a node corresponding to a set of semantically similar phrases, wherein the metadata graph comprises a set of nodes indicating (i) (a) metadata of internal data objects stored in a data silo, and (b) a location identifier of the data silo, and (ii) edges indicating a data lineage between a first node and a second node of the set of nodes, wherein the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers. In order to obtain at least one data object from the set of data objects via the data silo, the location identifier corresponding to the determined node is used to determine the data silo that stores the at least one data object from the set of data objects, and The process involves generating a visual representation of the at least one data object for display on the GUI, wherein the generated visual representation of the at least one data object includes systematic information of the at least one data object. At least one non-temporary memory storing instructions to cause the system to perform the above action A system that includes these features.

2. The aforementioned metadata graph, Retrieving from a second set of data silos (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers, wherein each file-level metadata identifier in the set of file-level metadata identifiers points to the metadata of a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers points to the metadata of its respective data silo in the second set of data silos; To generate a set of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier, To generate a metadata data structure for mapping each semantically similar metadata identifier from the set of semantically similar metadata identifiers to a normalized file-level metadata identifier and a normalized container-level metadata identifier, The metadata graph is generated using the generated metadata data structure. The system according to claim 1, which is generated by...

3. Receiving a second user-specified query via a second GUI that instructs the request to produce the intended result, Providing the second user-specified query to an artificial intelligence model to generate a recommendation, wherein the recommendation comprises (i) a second artificial intelligence model which will be used to generate the intended result, and (ii) a second set of data objects which will be used when training the second artificial intelligence model. In response to receiving a user selection indicating acceptance of the aforementioned recommendation, (i) access the database to obtain the second artificial intelligence model, and (ii) use the metadata graph to obtain the second set of data objects, Training the second artificial intelligence model using the aforementioned set of data objects, Applying the second artificial intelligence model to produce the intended result The system according to claim 1, further comprising the instructions for performing the above.

4. To obtain a set of policies that specify usage metrics corresponding to the second set of data objects, access the governance database and, Using the set of policies that specify usage metrics corresponding to the second set of data objects, determine whether the second set of data objects is approved for use in training the second artificial intelligence model. Using a second set of policies that specify usage metrics corresponding to predictions made by the artificial intelligence model, determine whether it is approved for the output of the second artificial intelligence model to be provided to one or more computing systems. (i) Approval is given that the second set of data objects will be used to train the second artificial intelligence model, and (ii) Approval is given that the output of the second artificial intelligence model will be provided to the one or more computing systems, and the second artificial intelligence model will be applied to produce the intended result. The system according to claim 3, further comprising instructions for performing the following actions.

5. A method for reducing the use of computing resources when accessing silo storage data across heterogeneous locations via an integrated metadata graph, A step of receiving a user-specified query in a graphical user interface (GUI) that instructs a request to access a set of data objects, wherein each data object in the set of data objects is stored in its respective data silo of a set of data silos in heterogeneous locations. The steps include: performing natural language processing on the user-specified query in order to determine the set of clauses corresponding to the user-specified query; A step of accessing a metadata graph to determine the node corresponding to the set of clauses, wherein the metadata graph comprises a set of nodes each having (i) (a) metadata indicating an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges indicating the data lineage of the set of nodes, and the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers. In order to obtain at least one data object from the set of data objects via the data silo, the steps include: determining the data silo storing the at least one data object from the set of data objects using the location identifier corresponding to the determined node; The steps include generating a visual representation of the at least one data object for display on the GUI, and Methods that include...

6. The aforementioned metadata graph, Steps of retrieving from a second set of data silos (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers, wherein each file-level metadata identifier in the set of file-level metadata identifiers indicates metadata for a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers indicates metadata for its respective data silo in the second set of data silos. The steps include generating sets of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier, The steps of generating a metadata data structure for mapping each semantically similar metadata identifier from the set of semantically similar metadata identifiers to a normalized file-level metadata identifier and a normalized container-level metadata identifier, A step of generating the metadata graph using the generated metadata data structure. The method according to claim 5, which is produced by

7. The steps include receiving a second user-specified query via a second GUI that instructs the request to produce the intended result, A step of providing the second user-specified query to an artificial intelligence model to generate a recommendation, wherein the recommendation comprises (i) a second artificial intelligence model which will be used to generate the intended result, and (ii) a second set of data objects which will be used when training the second artificial intelligence model. In response to receiving a user selection indicating acceptance of the aforementioned recommendation, the steps include (i) accessing a database to obtain the second artificial intelligence model, and (ii) obtaining the second set of data objects using the metadata graph, A step of training the second artificial intelligence model using the set of data objects, The steps include applying the second artificial intelligence model to produce the intended result, and The method according to claim 5, further comprising:

8. The steps include accessing a governance database to obtain a set of policies that specify usage metrics corresponding to the second set of data objects, The steps include determining whether the second set of data objects is approved to be used to train the second artificial intelligence model, using the set of policies that specify usage metrics corresponding to the second set of data objects, The steps include determining whether it is approved for the output of the second artificial intelligence model to be provided to one or more computing systems, using a second set of policies that specify usage metrics corresponding to predictions of the artificial intelligence model, (i) in response to approval that the second set of data objects be used to train the second artificial intelligence model, and (ii) in response to approval that the output of the second artificial intelligence model be provided to the one or more computing systems, the step of applying the second artificial intelligence model to produce the intended result; The method according to claim 7, further comprising:

9. The step of determining the set of clauses corresponding to the user-specified query is: A step of parsing a user-specified query with respect to a set of keywords, wherein each keyword in the set of keywords is associated with the set of data objects; For each keyword in the set of keywords associated with the set of data objects, the step of determining a set of semantically similar phrases corresponding to each keyword in the set of keywords: The steps include determining the set of clauses corresponding to the user-specified query using the set of semantically similar clauses corresponding to each keyword in the set of keywords, and The method according to claim 5, further comprising:

10. The step of determining semantically similar phrases corresponding to each of the aforementioned keywords in the aforementioned set of keywords is: The steps include accessing a database that specifies the mapping between a first keyword and a second keyword set, The steps include: determining the set of semantically similar phrases corresponding to each keyword using the respective keywords in response to accessing the database; The method according to claim 9, further comprising:

11. The step of accessing the metadata graph is, The steps of traversing each node in the set of nodes in order to identify a metadata identifier that matches at least one of the phrases in the set of phrases, In response to determining that the metadata identifier matches at least one of the set of phrases, the steps include determining the node corresponding to the set of phrases. The method according to claim 5, further comprising:

12. The step of accessing the metadata graph is, The steps of traversing each node in the set of nodes in order to identify a metadata identifier that matches at least one of the phrases in the set of phrases, In response to determining that the metadata identifier matches at least one of the set of phrases, the steps include determining a first node corresponding to the set of phrases, In response to determining that the first node corresponds to the set of clauses, a step of performing a second traverse of the nodes in the set of nodes using an edge that points to a first data system of the first node, wherein the first data system of the first node points to a second node that contains information which is the source of information associated with the first node. In order to obtain a second data object from the set of data objects via a second data silo, the steps include determining the second data silo that stores the second data object from the set of data objects, using the location identifier corresponding to the second node, The steps include generating a second visual representation of the second data object for display on the GUI, and The method according to claim 5, further comprising:

13. The method according to claim 5, wherein the visual representation of the at least one data object comprises systematic information of the at least one data object.

14. When executed by one or more processors, The graphical user interface (GUI) receives a user-specified query that instructs a request to access a set of data objects, wherein each data object in the set of data objects is stored in its respective data silo within a set of data silos in heterogeneous locations. In order to determine the set of clauses corresponding to the user-specified query, natural language processing is performed on the user-specified query, Accessing a metadata graph to determine the node corresponding to the set of clauses, wherein the metadata graph comprises a set of nodes each having (i) (a) metadata pointing to an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges pointing to the data lineage of the set of nodes, and the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers. In order to obtain at least one data object from the set of data objects via the data silo, the location identifier corresponding to the determined node is used to determine the data silo that stores the at least one data object from the set of data objects, To generate a visual representation of the at least one data object for display on the GUI. One or more non-temporary computer-readable media containing instructions for performing an action including the above.

15. The aforementioned metadata graph, Retrieving from a second set of data silos (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers, wherein each file-level metadata identifier in the set of file-level metadata identifiers points to the metadata of a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers points to the metadata of its respective data silo in the second set of data silos; To generate a set of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier, To generate a metadata data structure for mapping each semantically similar metadata identifier from the set of semantically similar metadata identifiers to a normalized file-level metadata identifier and a normalized container-level metadata identifier, The metadata graph is generated using the generated metadata data structure. The medium according to claim 14, which is produced by

16. When the instruction is executed by one or more processors, Receiving a second user-specified query via a second GUI that instructs the request to produce the intended result, Providing the second user-specified query to an artificial intelligence model to generate a recommendation, wherein the recommendation comprises (i) a second artificial intelligence model which will be used to generate the intended result, and (ii) a second set of data objects which will be used when training the second artificial intelligence model. In response to receiving a user selection indicating acceptance of the aforementioned recommendation, (i) access the database to obtain the second artificial intelligence model, and (ii) use the metadata graph to obtain the second set of data objects, Training the second artificial intelligence model using the aforementioned set of data objects, Applying the second artificial intelligence model to produce the intended result The medium according to claim 14, which further causes the medium to perform an operation including the operation described above.

17. When the instruction is executed by one or more processors, To obtain a set of policies that specify usage metrics corresponding to the second set of data objects, access the governance database and, Using the set of policies that specify usage metrics corresponding to the second set of data objects, determine whether the second set of data objects is approved for use in training the second artificial intelligence model. Using a second set of policies that specify usage metrics corresponding to predictions made by the artificial intelligence model, determine whether it is approved for the output of the second artificial intelligence model to be provided to one or more computing systems. (i) Approval is given that the second set of data objects will be used to train the second artificial intelligence model, and (ii) Approval is given that the output of the second artificial intelligence model will be provided to the one or more computing systems, and the second artificial intelligence model will be applied to produce the intended result. The medium according to claim 16, which further causes the medium to perform an operation including the operation described above.

18. Determining the set of clauses corresponding to the user-specified query is: Parsing a user-specified query with respect to a set of keywords, wherein each keyword in the set of keywords is associated with the set of data objects; For each keyword in the set of keywords associated with the set of data objects, determine the set of semantically similar phrases corresponding to each keyword in the set of keywords. The set of semantically similar phrases corresponding to each keyword in the set of keywords is used to determine the set of phrases corresponding to the user-specified query. The medium according to claim 14, further comprising:

19. Determining semantically similar phrases corresponding to each of the aforementioned keywords in the aforementioned set of keywords is Accessing a database that specifies the mapping between the first keyword and the second keyword set, In response to accessing the database, the set of semantically similar phrases corresponding to each of the keywords is determined using each of the keywords. The medium according to claim 18, further comprising:

20. Accessing the aforementioned metadata graph To identify a metadata identifier that matches at least one of the phrases in the aforementioned set of phrases, traverse each node in the aforementioned set of nodes, In response to determining that the metadata identifier matches at least one of the phrases in the set of phrases, the node corresponding to the set of phrases is determined. The medium according to claim 14, further comprising:

21. A system for reducing data retrieval time when accessing siloed storage data across heterogeneous locations by generating an integrated metadata graph via a Search Enhancement Generator (RAG) framework, At least one hardware processor, When executed by at least one hardware processor, (i) receiving raw data from a set of data silos, which includes a set of metadata identifiers that point to a file-level metadata identifier, (ii) a container-level metadata identifier, and (iii) a system-level metadata identifier. Selecting a first structured LLM prompt corresponding to a first metadata identifier from the set of metadata identifiers from a set of structured large-scale language model (LLM) prompts, Extending the first structured LLM prompt with the first metadata identifier which will be provided to the LLM which is communicate-connected to a set of domain-specific ontologs, the extension being configured such that the LLM generates a first intermediate output which points to a second set of metadata identifiers corresponding to the first metadata identifier without accessing the set of domain-specific ontologs. Extending the first structured LLM prompt with a second set of metadata identifiers corresponding to the first metadata identifier to be provided to the LLM, wherein the LLM is configured to generate a second intermediate output indicating filtered domain-specific metadata identifiers by accessing the set of domain-specific ontologs. (i) generating a domain-specific integrated metadata graph via the LLM using the first metadata identifier and (ii) the second intermediate output indicating the filtered domain-specific metadata identifier, wherein the filtered domain-specific metadata identifier is a traversable identifier and the first metadata identifier is a non-traversable identifier in the domain-specific integrated metadata graph. The verification process for the domain-specific integrated metadata graph is performed by comparing the first performance metric of the domain-specific integrated metadata graph with the second performance metric of another version of the domain-specific integrated metadata graph, and An update process is performed on the domain-specific integrated metadata graph in response to the determination that the first performance criterion cannot satisfy or exceed the second performance criterion of the other version of the domain-specific integrated metadata graph. At least one non-temporary memory storing instructions to cause the system to perform the above action A system that includes these features.

22. The aforementioned set of raw data is Performing a crawling process across the set of data silos associated with an entity in order to obtain the raw data comprising the set of metadata identifiers. The system according to claim 21, which is received by

23. When the instruction is executed by the at least one hardware processor, Extracting a first value from each of the aforementioned sets of data silos, Determining the data type corresponding to each first value extracted from each of the aforementioned sets of data silos, To generate a data profile for each of the data silos in the set of data silos, which indicates the data type of the values ​​stored in the data silos. The system according to claim 21, wherein the system further performs the above.

24. Selecting the first structured LLM prompt corresponding to the first metadata identifier from the set of metadata identifiers from the set of structured LLM prompts is: To determine the data silo that stores the data corresponding to the first metadata identifier, Retrieving a first data profile corresponding to the data silo storing the data corresponding to the first metadata identifier, Using the first data profile, the set of structured LLM prompts is filtered to generate a filtered set of LLM prompts, Select the first structured LLM prompt corresponding to the first metadata identifier from the set of metadata identifiers from the set of filtered LLM prompts. The system according to claim 23, further comprising:

25. The aforementioned verification process, Providing a first query requesting the location of a first data item to (i) the domain-specific integrated metadata graph and (ii) the other versions of the domain-specific integrated metadata graph, wherein the provision of the first query causes the generation of a first result indicating the location of the first data item from the domain-specific integrated metadata graph and a second result indicating the location of the first data item for the other versions of the domain-specific integrated metadata graph. Calculating a first sub-performance metric for the domain-specific integrated metadata graph and a second sub-performance metric for other versions of the domain-specific integrated metadata graph, wherein the first sub-performance metric and the second sub-performance metric are query-versus-result performance metrics. Calculating a third sub-performance metric for the domain-specific integrated metadata graph and a fourth sub-performance metric for other versions of the domain-specific integrated metadata graph, wherein the third and fourth sub-performance metrics are result accuracy metrics, the first performance metric comprises the first sub-performance metric and the third sub-performance metric, and the second performance metric comprises the second sub-performance metric and the fourth sub-performance metric. The system according to claim 21, further comprising:

26. The system according to claim 25, wherein determining whether the first performance criterion can satisfy or exceed the second performance criterion is based on (i) determining whether the first sub-performance criterion satisfies or exceeds the second sub-performance criterion, or (ii) determining whether the third sub-performance criterion can neither satisfy nor exceed the fourth sub-performance criterion.

27. Performing the update process on the domain-specific integrated metadata graph is Determining a set of inconsistencies between the domain-specific integrated metadata graph and the other versions of the domain-specific integrated metadata graph, wherein the set of inconsistencies reflects (i) inconsistencies between nodes of the domain-specific integrated metadata graph and the other versions of the domain-specific integrated metadata graph, and (ii) inconsistencies between edges connected to at least one node of the domain-specific integrated metadata graph and the other versions of the domain-specific integrated metadata graph. Updating the domain-specific integrated metadata graph with updated nodes and edges of the other versions of the domain-specific integrated metadata graph corresponding to the mismatched set. The system according to claim 21, including the above.

28. When the instruction is executed by the at least one hardware processor, To detect the addition of a data silo to the computing environment associated with the first entity, In response to detecting the addition to the data silo, the second update process is performed on the domain-specific integrated metadata graph. The system according to claim 21, wherein the system further performs the above.

29. The system according to claim 21, wherein the file-level metadata identifier indicates the metadata of a given data object stored in each of the data silos in the set of data silos, the container-level metadata identifier indicates the metadata of each of the data silos in the set of data silos, and the system-level metadata identifier indicates the metadata of the computing system hosting each of the data silos in the set of data silos.

30. The system according to claim 21, wherein the domain-specific integrated metadata graph comprises (i) a first node that points to (a) the filtered metadata identifier, (b) the first metadata identifier, and (c) the location identifier of the data silo associated with the first metadata identifier, and (ii) at least one edge that points to a data line between the first node and the second node.

31. A method for reducing data retrieval time when accessing siloed storage data across heterogeneous locations by generating an integrated metadata graph via a Search Enhancement Generator (RAG) framework, The steps include selecting a first LLM prompt corresponding to a first metadata identifier from a set of metadata identifiers from a set of Large Language Model (LLM) prompts, A step of extending the first LLM prompt with the first metadata identifier to be provided to the LLM, wherein the LLM is configured to generate a first intermediate output indicating a second set of metadata identifiers corresponding to the first metadata identifier, A step of extending the first LLM prompt with a second set of metadata identifiers corresponding to the first metadata identifier to be provided to the LLM, wherein the LLM is configured to generate a second intermediate output indicating filtered domain-specific metadata identifiers by accessing a set of domain-specific ontologs, (i) generating a domain-specific integrated metadata graph via the LLM using the first metadata identifier and (ii) the second intermediate output indicating the filtered domain-specific metadata identifier, wherein the filtered domain-specific metadata identifier is a traversable identifier and the first metadata identifier is a non-traversable identifier in the domain-specific integrated metadata graph, In response to determining that the first performance metric of the domain-specific integrated metadata graph cannot satisfy the performance measure relating to the second performance metric of another version of the domain-specific integrated metadata graph, the step of performing an update process on the domain-specific integrated metadata graph. Methods that include...

32. The steps include extracting a first value from each of the set of data silos, The steps include determining the data type corresponding to each first value extracted from each of the aforementioned sets of data silos, A step of generating a data profile for each of the data silos in the set of data silos, which indicates the data type of the values ​​stored in the data silo. The method according to claim 31, further comprising:

33. The step of selecting the first LLM prompt corresponding to the first metadata identifier from the set of metadata identifiers from the set of LLM prompts is: The steps include determining the data silo that stores the data corresponding to the first metadata identifier, A step of retrieving a first data profile corresponding to the data silo storing the data corresponding to the first metadata identifier, The steps include filtering the set of LLM prompts to generate a filtered set of LLM prompts using the first data profile, The steps include selecting the first LLM prompt corresponding to the first metadata identifier from the set of metadata identifiers from the set of filtered LLM prompts. The method according to claim 32, further comprising:

34. A step of performing a verification process on the domain-specific integrated metadata graph, wherein the verification process is performed A step of providing a first query requesting the location of a first data item to (i) the domain-specific integrated metadata graph and (ii) the other versions of the domain-specific integrated metadata graph, wherein the provision of the first query causes the generation of a first result indicating the location of the first data item from the domain-specific integrated metadata graph and a second result indicating the location of the first data item for the other versions of the domain-specific integrated metadata graph. A step of calculating a first sub-performance metric for the domain-specific integrated metadata graph and a second sub-performance metric for other versions of the domain-specific integrated metadata graph, wherein the first sub-performance metric and the second sub-performance metric are query-versus-results performance metrics, and A step of calculating a third sub-performance metric for the domain-specific integrated metadata graph and a fourth sub-performance metric for other versions of the domain-specific integrated metadata graph, wherein the third sub-performance metric and the fourth sub-performance metric are result accuracy metrics, the first performance metric comprises the first sub-performance metric and the third sub-performance metric, and the second performance metric comprises the second sub-performance metric and the fourth sub-performance metric. The method according to claim 31, further comprising the step of a step of comprising comprising comprising comprising comprising comprising comprising comprising a step of comprising comprising comprising comprising comprising comprising comprising comprising comprising a step of comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising a step of comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising comprising

35. The method according to claim 34, wherein determining that the first performance criterion satisfies the performance scale relating to the second performance criterion is based on determining that (i) the first sub-performance criterion satisfies or exceeds the second sub-performance criterion, or (ii) the third sub-performance criterion neither satisfies nor exceeds the fourth sub-performance criterion.

36. When executed by one or more processors, Selecting a first LLM prompt corresponding to a first metadata identifier from a set of metadata identifiers from a set of Large Language Model (LLM) prompts, Extending the first LLM prompt with the first metadata identifier to be provided to the LLM, wherein the LLM is configured to generate a first intermediate output indicating a second set of metadata identifiers corresponding to the first metadata identifier, Extending the first LLM prompt with a second set of metadata identifiers corresponding to the first metadata identifier to be provided to the LLM, wherein the LLM is configured to generate a second intermediate output indicating filtered domain-specific metadata identifiers by accessing a set of domain-specific ontologs. (i) generating a domain-specific integrated metadata graph via the LLM using the first metadata identifier and (ii) the second intermediate output indicating the filtered domain-specific metadata identifier, wherein the filtered domain-specific metadata identifier is a traversable identifier and the first metadata identifier is a non-traversable identifier in the domain-specific integrated metadata graph. In response to determining that the first performance metric of the domain-specific integrated metadata graph cannot satisfy the performance measure relating to the second performance metric of another version of the domain-specific integrated metadata graph, an update process is performed on the domain-specific integrated metadata graph. One or more non-temporary computer-readable media containing instructions for performing an action including the above.

37. When the instruction is executed by one or more processors, Extracting the first value from each set of data silos, Determining the data type corresponding to each first value extracted from each of the aforementioned sets of data silos, To generate a data profile for each of the data silos in the set of data silos, which indicates the data type of the values ​​stored in the data silos. The medium according to claim 36, which further causes the medium to perform an operation including the operation described above.

38. Selecting the first LLM prompt corresponding to the first metadata identifier from the set of metadata identifiers from the set of LLM prompts is: To determine the data silo that stores the data corresponding to the first metadata identifier, Retrieving a first data profile corresponding to the data silo storing the data corresponding to the first metadata identifier, Using the first data profile, the set of LLM prompts is filtered to generate a filtered set of LLM prompts, Select the first LLM prompt corresponding to the first metadata identifier from the set of metadata identifiers from the set of filtered LLM prompts. The medium according to claim 37, further comprising:

39. When the instruction is executed by one or more processors, The verification process is performed on the domain-specific integrated metadata graph, wherein the verification process is performed on the domain-specific integrated metadata graph. Providing a first query requesting the location of a first data item to (i) the domain-specific integrated metadata graph and (ii) the other versions of the domain-specific integrated metadata graph, wherein the provision of the first query causes the generation of a first result indicating the location of the first data item from the domain-specific integrated metadata graph and a second result indicating the location of the first data item for the other versions of the domain-specific integrated metadata graph. Calculating a first sub-performance metric for the domain-specific integrated metadata graph and a second sub-performance metric for other versions of the domain-specific integrated metadata graph, wherein the first sub-performance metric and the second sub-performance metric are query-versus-result performance metrics, and Calculating a third sub-performance metric for the domain-specific integrated metadata graph and a fourth sub-performance metric for other versions of the domain-specific integrated metadata graph, wherein the third and fourth sub-performance metrics are result accuracy metrics, the first performance metric comprises the first sub-performance metric and the third sub-performance metric, and the second performance metric comprises the second sub-performance metric and the fourth sub-performance metric. To further include, to implement The medium according to claim 36, which further causes the medium to perform an operation including the operation described above.

40. The medium according to claim 39, wherein the determination that the first performance criterion cannot satisfy the performance scale relating to the second performance criterion is based on the determination that (i) the first sub-performance criterion satisfies or exceeds the second sub-performance criterion, or (ii) the third sub-performance criterion cannot satisfy or exceed the fourth sub-performance criterion.

41. The steps include: receiving a first natural language input from a user, which includes a set of phrases, and instructions for using an artificial intelligence (AI) model to analyze the data associated with the set of phrases; A step of accessing a metadata graph in order to determine a node corresponding to the set of phrases in response to the first natural language input, The metadata graph comprises (i) a set of nodes each having (a) metadata indicating an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges of the nodes indicating the data lineage of the set. Steps and To generate a first set of application data, the steps include processing one or more internal data objects indicated by the determined node, A step of applying the AI ​​model to the first set of application data in order to generate one or more first outputs, The one or more first outputs comprise a classification of data items in the first set of application data, or one or more predictions made based on the first set of application data. Steps and The steps include transmitting one or more representations of the first output for display to the user, A step of receiving a second natural language input from the user, wherein the second natural language input includes instructions for modifying the first set of application data, The steps include generating a second set of application data by the computer system based on the second natural language input received, The steps include applying the AI ​​model to the second set of application data in order to generate one or more second outputs, and A computer execution method, including...

42. The method according to claim 41, wherein the step of processing the internal data object to generate the first set of application data includes the step of removing personally identifiable or private information from the internal data object.

43. The step of processing the internal data objects in order to generate the first set of application data is, A step of applying a set of data modification operators to the internal data object in order to generate a set of modified data based on the internal data object, The first set of application data includes one or more modified data items from the set of modified data. Step The method according to claim 41, including the method described in claim 41.

44. The step of processing the internal data objects in order to generate the first set of application data is, Step of removing inaccurate data items from the internal data object. The method according to claim 41, including the method described in claim 41.

45. Before receiving the first natural language input, The steps include receiving a third natural language input that includes instructions for generating the aforementioned AI model, The steps include: accessing the metadata graph to determine the node corresponding to the third natural language input; To generate a set of training data, the process involves processing internal data objects associated with the node corresponding to the third natural language input, A step of training the AI ​​model using the set of training data in order to generate a trained AI model, The step of applying the AI ​​model to the first set of application data includes the step of applying the trained AI model to the first set of application data. Steps and The method according to claim 41, further comprising:

46. The step of training the aforementioned AI model is The steps include: accessing the values ​​of one or more model metrics associated with each of multiple model types; The steps include: selecting the model type of the trained AI model from among the plurality of model types based on the accessed values ​​of the one or more model metrics, The steps include training the selected model type and The method according to claim 45, including the method described in claim 45.

47. The method according to claim 45, wherein the step of training the AI ​​model includes the steps of receiving a user selection for the model type of the AI ​​model and training the selected model type.

48. The step of generating a chat interface for display to the user using the computer system. It further includes, The first natural language input is received via the chat interface, The method according to claim 41, wherein the step of sending the representation of the one or more outputs for display to the user includes the step of displaying the one or more outputs via the chat interface.

49. The step of generating the second set of application data based on the second natural language input is: A step of adding data items to the first set of application data, A step of removing data items from the first set of application data, or Steps to apply a data correction operator to a value in order to correct the value of a data item in the first set of application data. The method according to claim 41, including the method described in claim 41.

50. One or more processors, One or more non-temporary computer-readable storage media storing executable instructions, wherein when the instructions are executed by the one or more processors, Receiving a first natural language input from a user, which includes a set of phrases, and instructions to use an artificial intelligence (AI) model to analyze the data associated with the set of phrases. In response to the first natural language input, accessing the metadata graph to determine the node corresponding to the set of phrases, The metadata graph comprises (i) a set of nodes each having (a) metadata indicating an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges of the nodes indicating the data lineage of the set. Access To generate a first set of application data, process one or more internal data objects indicated by the determined node. Applying the AI ​​model to the first set of application data in order to generate one or more first outputs, To transmit the representation of one or more first outputs for display to the user, Receiving a second natural language input from the user, wherein the second natural language input includes instructions for modifying the first set of application data. To generate a second set of application data based on the second natural language input received, and Applying the AI ​​model to the second set of application data in order to generate one or more second outputs. One or more non-temporary computer-readable storage media to cause the system to perform this task. A system that includes these features.

51. The system according to claim 50, wherein processing the internal data object to generate the first set of application data includes removing personally identifiable or private information from the internal data object.

52. Processing the internal data object in order to generate the first set of application data, To generate a set of corrected data based on the internal data object, a set of data correction operators is applied to the internal data object, The first set of application data includes one or more modified data items from the set of modified data. Apply The system according to claim 50, including the system described in claim 50.

53. Processing the internal data object in order to generate the first set of application data, Remove inaccurate data items from the internal data object. The system according to claim 50, including the system described in claim 50.

54. When the instruction is executed by one or more processors, before receiving the first natural language input, The system receives a third natural language input which includes instructions for generating the aforementioned AI model, Accessing the metadata graph in order to determine the node corresponding to the third natural language input, To generate a set of training data, the internal data objects associated with the node corresponding to the third natural language input are processed, To generate a trained AI model, the AI ​​model is trained using the set of training data, Applying the AI ​​model to the first set of application data includes applying the trained AI model to the first set of application data. Training and The system according to claim 50, wherein the system further performs the above.

55. When the instruction is executed by one or more processors, To generate a chat interface for display to the aforementioned user. The system is then made to perform the following: The first natural language input is received via the chat interface, The system according to claim 50, wherein sending the representation of the one or more outputs for display to the user includes displaying the one or more outputs via the chat interface.

56. To generate the second set of application data based on the second natural language input, Adding data items to the above-described set 1 of application data, Removing data items from the first set of application data, or To modify the value of a data item in the first set of application data, a data modification operator is applied to the value. The system according to claim 50, including the system described in claim 50.

57. A non-temporary computer-readable storage medium storing executable instructions, wherein when the instructions are executed by one or more processors of the system, Receiving a first natural language input from a user, which includes a set of phrases, and instructions to use an artificial intelligence (AI) model to analyze the data associated with the set of phrases, In response to the first natural language input, accessing the metadata graph to determine the node corresponding to the set of phrases, The metadata graph comprises (i) a set of nodes each having (a) metadata indicating an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges of the nodes indicating the data lineage of the set. Accessing and To generate a first set of application data, process one or more internal data objects indicated by the determined node, Applying the AI ​​model to the first set of application data in order to generate one or more first outputs, Transmitting the representation of one or more first outputs for display to the user, Receiving a second natural language input from the user, wherein the second natural language input includes instructions for modifying the first set of application data, Based on the second natural language input received, a second set of application data is generated, To generate one or more second outputs, the AI ​​model is applied to the second set of application data. A non-temporary computer-readable storage medium that causes the aforementioned system to perform the above-mentioned function.

58. Processing the internal data object in order to generate the first set of application data, To generate a set of corrected data based on the internal data object, a set of data correction operators is applied to the internal data object, The first set of application data includes one or more modified data items from the set of modified data. Apply A non-temporary computer-readable storage medium according to claim 57, including the following:

59. When the instruction is executed by one or more processors, before receiving the first natural language input, The system receives a third natural language input which includes instructions for generating the aforementioned AI model, Accessing the metadata graph in order to determine the node corresponding to the third natural language input, To generate a set of training data, the internal data objects associated with the node corresponding to the third natural language input are processed, To generate a trained AI model, the AI ​​model is trained using the set of training data, Applying the AI ​​model to the first set of application data includes applying the trained AI model to the first set of application data. Training and A non-temporary computer-readable storage medium according to claim 57, further comprising the system performing the above.

60. When the instruction is executed by one or more processors, To generate a chat interface for display to the aforementioned user. The system is then made to perform the following: The first natural language input is received via the chat interface, A non-temporary computer-readable storage medium according to claim 57, wherein sending the representation of the one or more outputs for display to the user includes displaying the one or more outputs via the chat interface. US03 Undecided

61. The steps include receiving a first request for the first artificial intelligence (AI) model to be used by an entity, to deploy the first artificial intelligence (AI) model for use in a production environment for processing input data and generating corresponding output, and to make the first AI model available. A step of selecting a first model deployment location for the first AI model based on the model deployment engine, The model deployment engine is configured to select the first model deployment location from one or more cloud provider environments or an on-premises environment operated by the entity. Steps and The steps include generating a script for deploying the first AI model to the first model deployment location, The steps include monitoring the operational parameters associated with the deployment of the first AI model at the selected model deployment location when the first AI model processes the input data and generates the corresponding output, The steps include updating the model deployment engine based on the values ​​of the monitored operating parameters, The steps include: selecting a second model deployment location for the second AI model based on the updated model deployment engine in response to a second request to deploy a second AI model; A computer execution method, including...

62. The model deployment engine comprises a decision tree, a knowledge graph, or a rule engine, and the step of selecting the first model deployment location based on the model deployment engine is: The computational cost for deploying the first AI model at the selected model deployment location, Computational capacity of the selected model deployment location, The response time from the selected model deployment location, or Measurement of the accuracy of the first AI model when deployed at the selected model deployment location. The computer execution method according to claim 61, comprising the step of selecting the first model deployment location based on one or more of the following.

63. The computer execution method according to claim 61, wherein the step of selecting the first model deployment location based on the model deployment engine includes the step of selecting the first model deployment location based on a privacy policy associated with at least one of the first AI model, the input data, or the corresponding output.

64. The aforementioned operating parameters are The computational cost used by the first AI model in the first model deployment location, The response time from the first AI model when deployed at the first model deployment location, Computational capacity available in the environment including the first model deployment location, Privacy policy of the environment including the first model deployment location, or Measurement values ​​for downtime or service interrupts in the environment, including the first model deployment location. The computer execution method according to claim 61, comprising one or more of the above.

65. The computer execution method according to claim 61, wherein the model deployment engine comprises a trained decision model, and the step of updating the model deployment engine includes the step of retraining the trained decision model based on the difference between the value of the monitored operating parameter and the value of the set of operating parameters on which the model deployment engine was trained.

66. The computer execution method according to claim 61, wherein the second AI model is a second instance of the first AI model, and the second model deployment location for the second AI model is a different location from the first model deployment location for the first AI model.

67. The steps include selecting a third model deployment location for the first AI model, which is different from the first model deployment location, based on the updated model deployment engine, The steps include generating a script for deploying the first AI model to the third model deployment location, and The computer execution method according to claim 61, further comprising:

68. The steps include selecting a third model deployment location for the first AI model, which is different from the first model deployment location, based on the model deployment engine and the operating parameters, The steps include generating a script for deploying the first AI model to the third model deployment location, and The computer execution method according to claim 61, further comprising:

69. The operation parameters include the computational cost associated with the deployment of the first AI model at the first model deployment location, and the step of selecting the third model deployment location is Step 1: When the computational cost associated with deploying the first AI model at the first model deployment location is greater than the predicted computational cost associated with deploying the first AI model at the third model deployment location, it is decided to move the first AI model to the third model deployment location. The computer execution method according to claim 68, including the method described in claim 68.

70. One or more processors, One or more non-temporary computer-readable storage media storing executable instructions, wherein when the instructions are executed by the one or more processors, To receive a first request for the first artificial intelligence (AI) model to be used by an entity, to deploy the first artificial intelligence (AI) model for use in a production environment for processing input data and generating corresponding output, and to make the first AI model available. Selecting a first model deployment location for the first AI model based on the model deployment engine, The model deployment engine is configured to select the first model deployment location from one or more cloud provider environments or an on-premises environment operated by the entity. To choose, To generate a script for deploying the first AI model to the first model deployment location, Monitoring the operational parameters associated with the deployment of the first AI model at the selected model deployment location when the first AI model processes the input data and generates the corresponding output, Updating the model deployment engine based on the values ​​of the monitored operating parameters, and In response to a second request to deploy a second AI model, select a second model deployment location for the second AI model based on the updated model deployment engine. One or more non-temporary computer-readable storage media to cause the system to perform this task. A system that includes these features.

71. The model deployment engine comprises a decision tree, a knowledge graph, or a rule engine, and selects the first model deployment location based on the model deployment engine. The computational cost for deploying the first AI model at the selected model deployment location, Computational capacity of the selected model deployment location, The response time from the selected model deployment location, or Measurement of the accuracy of the first AI model when deployed at the selected model deployment location. The system according to claim 70, comprising selecting the first model deployment location based on one or more of the following.

72. The system according to claim 70, wherein selecting the first model deployment location based on the model deployment engine includes selecting the first model deployment location based on a privacy policy associated with at least one of the first AI model, the input data, or the corresponding output.

73. The aforementioned operating parameters are The computational cost used by the first AI model in the first model deployment location, The response time from the first AI model when deployed at the first model deployment location, Computational capacity available in the environment including the first model deployment location, Privacy policy of the environment including the first model deployment location, or Measurement values ​​for downtime or service interrupts in the environment, including the first model deployment location. The system according to claim 70, comprising one or more of the above.

74. The system according to claim 70, wherein the model deployment engine comprises a trained decision model, and updating the model deployment engine includes retraining the trained decision model based on the difference between the value of the monitored operating parameter and the value of the set of operating parameters on which the model deployment engine was trained.

75. The system according to claim 70, wherein the second AI model is a second instance of the first AI model, and the second model deployment location for the second AI model is a different location from the first model deployment location for the first AI model.

76. When the instruction is executed by one or more processors, Based on the updated model deployment engine, a third model deployment location for the first AI model is selected, which is different from the first model deployment location. To generate a script for deploying the first AI model to the third model deployment location. The system according to claim 70, wherein the system further performs the above.

77. When the instruction is executed by one or more processors, Based on the model deployment engine and the operating parameters, a third model deployment location for the first AI model is selected, which is different from the first model deployment location. To generate a script for deploying the first AI model to the third model deployment location. The system according to claim 70, wherein the system further performs the above.

78. The operation parameters include the computational cost associated with the deployment of the first AI model at the first model deployment location, and the selection of the third model deployment location is When the computational cost associated with deploying the first AI model at the first model deployment location is greater than the predicted computational cost associated with deploying the first AI model at the third model deployment location, it is decided to move the first AI model to the third model deployment location. The system according to claim 77, including the system described in claim 77.

79. A non-temporary computer-readable storage medium storing executable instructions, wherein when the instructions are executed by one or more processors of the system, To receive a first request for the first artificial intelligence (AI) model to be used by an entity, to deploy the first artificial intelligence (AI) model for use in a production environment to process input data and generate corresponding output, and to make the first AI model available. Selecting a first model deployment location for the first AI model based on the model deployment engine, The model deployment engine is configured to select the first model deployment location from one or more cloud provider environments or an on-premises environment operated by the entity. Choosing and To generate a script for deploying the first AI model to the first model deployment location, Monitoring the operational parameters associated with the deployment of the first AI model at the selected model deployment location when the first AI model processes the input data and generates the corresponding output, The model deployment engine is updated based on the values ​​of the monitored operating parameters. In response to a second request to deploy a second AI model, a second model deployment location for the second AI model is selected based on the updated model deployment engine. A non-temporary computer-readable storage medium that causes the aforementioned system to perform the above-mentioned function.

80. The model deployment engine comprises a decision tree, a knowledge graph, or a rule engine, and selects the first model deployment location based on the model deployment engine. The computational cost for deploying the first AI model at the selected model deployment location, Computational capacity of the selected model deployment location, The response time from the selected model deployment location, or Measurement of the accuracy of the first AI model when deployed at the selected model deployment location. A non-temporary computer-readable storage medium according to claim 79, comprising selecting the first model deployment location based on one or more of the following. US04 Pending Claim

81. A system for reducing the use of computing resources when accessing silo storage data across heterogeneous locations via an integrated metadata graph, At least one hardware processor, When executed by at least one hardware processor, Identifying a set of keywords associated with a request to access a set of data objects. In order to determine a set of semantically similar phrases corresponding to each keyword in the aforementioned set of keywords, natural language processing is performed on the aforementioned set of keywords. Accessing a metadata graph to determine a node corresponding to a set of semantically similar phrases, wherein the metadata graph comprises a set of nodes indicating (i) (a) metadata of internal data objects stored in a data silo, and (b) a location identifier of the data silo, and (ii) edges indicating a data lineage between a first node and a second node of the set of nodes, wherein the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers. In order to obtain at least one data object from the set of data objects via the data silo, the location identifier corresponding to the determined node is used to determine the data silo that stores the at least one data object from the set of data objects, and To generate a visual representation of the at least one data object for display on a graphical user interface (GUI), wherein the generated visual representation of the at least one data object includes genealogical information of the at least one data object. At least one non-temporary memory storing instructions to cause the system to perform the above action A system that includes these features.

82. The aforementioned metadata graph, Retrieving from a second set of data silos (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers, wherein each file-level metadata identifier in the set of file-level metadata identifiers points to the metadata of a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers points to the metadata of its respective data silo in the second set of data silos; To generate a set of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier, To generate a metadata data structure for mapping each semantically similar metadata identifier from the set of semantically similar metadata identifiers to a normalized file-level metadata identifier and a normalized container-level metadata identifier, The metadata graph is generated using the generated metadata data structure. The system according to claim 81, which is generated by...

83. Receiving a second user-specified query via a second GUI that instructs the request to produce the intended result, Providing the second user-specified query to an artificial intelligence model to generate a recommendation, wherein the recommendation comprises (i) a second artificial intelligence model which will be used to generate the intended result, and (ii) a second set of data objects which will be used when training the second artificial intelligence model. In response to receiving a user selection indicating acceptance of the aforementioned recommendation, (i) access the database to obtain the second artificial intelligence model, and (ii) use the metadata graph to obtain the second set of data objects, Training the second artificial intelligence model using the aforementioned set of data objects, Applying the second artificial intelligence model to produce the intended result The system according to claim 81, further comprising the instructions for performing the above.

84. To obtain a set of policies that specify usage metrics corresponding to the second set of data objects, access the governance database and, Using the set of policies that specify usage metrics corresponding to the second set of data objects, determine whether the second set of data objects is approved for use in training the second artificial intelligence model. Using a second set of policies that specify usage metrics corresponding to predictions made by the artificial intelligence model, determine whether it is approved for the output of the second artificial intelligence model to be provided to one or more computing systems. (i) Approval is given that the second set of data objects will be used to train the second artificial intelligence model, and (ii) Approval is given that the output of the second artificial intelligence model will be provided to the one or more computing systems, and the second artificial intelligence model will be applied to produce the intended result. The system according to claim 83, further comprising the instructions for performing the above.

85. A method for reducing the use of computing resources when accessing silo storage data across heterogeneous locations via an integrated metadata graph, The steps include identifying a set of keywords associated with a user-defined query for accessing a set of data objects, The steps include: performing natural language processing on the user-specified query in order to determine the set of clauses corresponding to the user-specified query; A step of accessing a metadata graph to determine the node corresponding to the set of clauses, wherein the metadata graph comprises a set of nodes each having (i) (a) metadata indicating an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges indicating the data lineage of the set of nodes, and the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers. In order to obtain at least one data object from the set of data objects via the data silo, the steps include: determining the data silo storing the at least one data object from the set of data objects using the location identifier corresponding to the determined node; The steps of generating a representation of at least one data object and Methods that include...

86. The aforementioned metadata graph, Steps of retrieving from a second set of data silos (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers, wherein each file-level metadata identifier in the set of file-level metadata identifiers indicates metadata for a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers indicates metadata for its respective data silo in the second set of data silos. The steps include generating sets of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier, The steps of generating a metadata data structure for mapping each semantically similar metadata identifier from the set of semantically similar metadata identifiers to a normalized file-level metadata identifier and a normalized container-level metadata identifier, A step of generating the metadata graph using the generated metadata data structure. The method according to claim 85, which is produced by

87. The steps include receiving a second user-specified query via a second GUI that instructs the request to produce the intended result, A step of providing the second user-specified query to an artificial intelligence model to generate a recommendation, wherein the recommendation comprises (i) a second artificial intelligence model which will be used to generate the intended result, and (ii) a second set of data objects which will be used when training the second artificial intelligence model. In response to receiving a user selection indicating acceptance of the aforementioned recommendation, the steps include (i) accessing a database to obtain the second artificial intelligence model, and (ii) obtaining the second set of data objects using the metadata graph, A step of training the second artificial intelligence model using the set of data objects, The steps include applying the second artificial intelligence model to produce the intended result, and The method according to claim 85, further comprising:

88. The steps include accessing a governance database to obtain a set of policies that specify usage metrics corresponding to the second set of data objects, The steps include determining whether the second set of data objects is approved to be used to train the second artificial intelligence model, using the set of policies that specify usage metrics corresponding to the second set of data objects, The steps include determining whether it is approved for the output of the second artificial intelligence model to be provided to one or more computing systems, using a second set of policies that specify usage metrics corresponding to predictions of the artificial intelligence model, (i) in response to approval that the second set of data objects be used to train the second artificial intelligence model, and (ii) in response to approval that the output of the second artificial intelligence model be provided to the one or more computing systems, the step of applying the second artificial intelligence model to produce the intended result; The method according to claim 87, further comprising:

89. The step of determining the set of clauses corresponding to the user-specified query is: A step of parsing a user-specified query with respect to a set of keywords, wherein each keyword in the set of keywords is associated with the set of data objects; For each keyword in the set of keywords associated with the set of data objects, the step of determining a set of semantically similar phrases corresponding to each keyword in the set of keywords: The steps include determining the set of clauses corresponding to the user-specified query using the set of semantically similar clauses corresponding to each keyword in the set of keywords, and The method according to claim 85, further comprising:

90. The step of determining semantically similar phrases corresponding to each of the aforementioned keywords in the aforementioned set of keywords is: The steps include accessing a database that specifies the mapping between a first keyword and a second keyword set, The steps include: determining the set of semantically similar phrases corresponding to each keyword using the respective keywords in response to accessing the database; The method according to claim 89, further comprising:

91. Accessing the aforementioned metadata graph The steps of traversing each node in the set of nodes in order to identify a metadata identifier that matches at least one of the phrases in the set of phrases, In response to determining that the metadata identifier matches at least one of the set of phrases, the steps include determining the node corresponding to the set of phrases. The method according to claim 85, further comprising:

92. Accessing the aforementioned metadata graph The steps of traversing each node in the set of nodes in order to identify a metadata identifier that matches at least one of the phrases in the set of phrases, In response to determining that the metadata identifier matches at least one of the set of phrases, the steps include determining a first node corresponding to the set of phrases, In response to determining that the first node corresponds to the set of clauses, a step of performing a second traverse of the nodes in the set of nodes using an edge that points to a first data system of the first node, wherein the first data system of the first node points to a second node that contains information which is the source of information associated with the first node. In order to obtain a second data object from the set of data objects via a second data silo, the steps include determining the second data silo that stores the second data object from the set of data objects, using the location identifier corresponding to the second node, The steps of generating a second representation of the second data object and The method according to claim 85, further comprising:

93. The method according to claim 85, wherein the representation of the at least one data object comprises systematic information of the at least one data object.

94. When executed by one or more processors, In order to determine the set of clauses corresponding to the user-specified query, natural language processing is performed on the user-specified query, Accessing a metadata graph to determine the node corresponding to the set of clauses, wherein the metadata graph comprises a set of nodes each having (i) (a) metadata pointing to an internal data object stored in a data silo, and (b) a location identifier for the data silo, and (ii) edges pointing to the data lineage of the set of nodes, and the metadata graph is generated using a metadata data structure based on file-level and container-level metadata identifiers. In order to obtain at least one data object from the set of data objects via the data silo, the location identifier corresponding to the determined node is used to determine the data silo that stores the at least one data object from the set of data objects, To generate a representation of at least one data object One or more non-temporary computer-readable media containing instructions for performing an action including the above.

95. The aforementioned metadata graph, Retrieving from a second set of data silos (i) a set of file-level metadata identifiers and (ii) a set of container-level metadata identifiers, wherein each file-level metadata identifier in the set of file-level metadata identifiers points to the metadata of a given data object stored in its respective data silo, and each container-level metadata identifier in the set of container-level metadata identifiers points to the metadata of its respective data silo in the second set of data silos; To generate a set of semantically similar metadata identifiers corresponding to each file-level and container-level metadata identifier, To generate a metadata data structure for mapping each semantically similar metadata identifier from the set of semantically similar metadata identifiers to a normalized file-level metadata identifier and a normalized container-level metadata identifier, The metadata graph is generated using the generated metadata data structure. The medium according to claim 94, which is produced by

96. When the instruction is executed by one or more processors, Receiving a second user-specified query via a second GUI that instructs the request to produce the intended result, Providing the second user-specified query to an artificial intelligence model to generate a recommendation, wherein the recommendation comprises (i) a second artificial intelligence model which will be used to generate the intended result, and (ii) a second set of data objects which will be used when training the second artificial intelligence model. In response to receiving a user selection indicating acceptance of the aforementioned recommendation, (i) access the database to obtain the second artificial intelligence model, and (ii) use the metadata graph to obtain the second set of data objects, Training the second artificial intelligence model using the aforementioned set of data objects, Applying the second artificial intelligence model to produce the intended result The medium according to claim 94, which further causes the medium to perform an operation including the operation.

97. When the instruction is executed by one or more processors, To obtain a set of policies that specify usage metrics corresponding to the second set of data objects, access the governance database and, Using the set of policies that specify usage metrics corresponding to the second set of data objects, determine whether the second set of data objects is approved for use in training the second artificial intelligence model. Using a second set of policies that specify usage metrics corresponding to predictions made by the artificial intelligence model, determine whether it is approved for the output of the second artificial intelligence model to be provided to one or more computing systems. (i) Approval is given that the second set of data objects will be used to train the second artificial intelligence model, and (ii) Approval is given that the output of the second artificial intelligence model will be provided to the one or more computing systems, and the second artificial intelligence model will be applied to produce the intended result. The medium according to claim 96, which further causes the medium to perform an operation including the operation.

98. Determining the set of clauses corresponding to the user-specified query is: Parsing a user-specified query with respect to a set of keywords, wherein each keyword in the set of keywords is associated with the set of data objects; For each keyword in the set of keywords associated with the set of data objects, determine the set of semantically similar phrases corresponding to each keyword in the set of keywords. The set of semantically similar phrases corresponding to each keyword in the set of keywords is used to determine the set of phrases corresponding to the user-specified query. The medium according to claim 94, further comprising:

99. Determining semantically similar phrases corresponding to each of the aforementioned keywords in the aforementioned set of keywords is Accessing a database that specifies the mapping between the first keyword and the second keyword set, In response to accessing the database, the set of semantically similar phrases corresponding to each of the keywords is determined using each of the keywords. The medium according to claim 98, further comprising:

100. Accessing the aforementioned metadata graph To identify a metadata identifier that matches at least one of the phrases in the aforementioned set of phrases, traverse each node in the aforementioned set of nodes, In response to determining that the metadata identifier matches at least one of the phrases in the set of phrases, the node corresponding to the set of phrases is determined. The medium according to claim 94, further comprising:

Images