Embodiments described herein are generally related to data analytics environments, and are particularly directed to systems and methods for providing a revision history for use with a data analytics environment. The system includes a computer that includes one or more processors and that provides access to the data analytics environment, a revision history handler application running at the data analytics environment, and a user interface running at a client device and being in operative communication with the revision history handler application. The revision history handler application is configured to store, in a workbook folder of an artifacts catalog of the data analytics environment, current workbook metadata relating to a current workbook, a plurality of previous workbook versions of the current workbook, and a plurality of previous workbook version metadata sets each being related to a corresponding one of a plurality of previous workbook versions of the current workbook.
In some embodiments, a system generates a first query to be executed on a first data repository and a second query to be executed on a second data repository based on an initial user query using a first LLM, executes the first query on the first data repository to generate a first set of results, executes the second query on the second data repository to generate a second set of results, merges the first and second sets of results using a second LLM to form a merged set of results, selects a subset of the merged set of results based on a comparison of the merged set of results to the initial user query, generates a prompt based on the initial user query and the subset of the merged set of results, and submits the prompt to a third LLM to generate a response to the initial user query.
In response to a user invoking a graph operation on a graph in an in-memory graph algorithm (IMGA) runtime in a relational database management system (RDBMS), the RDBMS generates a set of one or more graph indexes in memory. The graph is represented as one or more vertex tables and one or more edge tables. The RDBMS generates the set of one or more graph indexes by generating a mapping of each database table vertex identifier to a corresponding internal identifier. For each edge table of the one or more edge tables, the RDBMS generates a graph index data structure representing edges of the edge table. The graph index data structure represents each edge in the edge table as a source internal identifier and a destination internal identifier. The RDBMS can then execute the graph operation in the IMGA runtime using the set of one or more graph indexes.
Techniques for managing a database cluster are disclosed. A database cluster stores a database in a distributed manner among multiple nodes. Applications query a node in the database cluster with a database language query to access data in the database. If the node determines it is in a pre-shutdown state, the node returns both query results and a status indicator. Based on receiving the indication of the pre-shutdown status, the application may continue to query the node to obtain data from the database for an ongoing task or operation. The application may then switch over to another node in the database cluster prior to the node changing to an inaccessible or shutdown state.
G06F 11/20 - Error detection or correction of the data by redundancy in hardware using active fault-masking, e.g. by switching out faulty elements or by switching in spare elements
G06F 16/27 - Replication, distribution or synchronisation of data between databases or within a distributed database systemDistributed database system architectures therefor
G06F 16/28 - Databases characterised by their database models, e.g. relational or object models
5.
SYSTEM AND METHOD FOR ENRICHMENT OF DATA FROM EXTERNAL WEB SOURCES USING A LARGE LANGUAGE MODEL
Embodiments described herein are generally related to data analytics environments, and are particularly directed to systems and methods for use with a data analytics environment to provide enrichment of data from external sources via a large language model. In accordance with an embodiment, the systems and methods can utilize a high-powered LLM to suggest data-related factors that may not be explicitly represented in the user's dataset. For example, upon a user's selection of a pair of datapoints, the systems and methods can utilize a LLM to provide suggestions for root causes of those datapoints, even though such root causes are not explicitly represented in the dataset.
Techniques for triggering regeneration of content by a generative AI model based on changes to stored data are disclosed. A system inputs a prompt to a generative AI model to generate content based on a target data set stored at a memory location. The system monitors the target data set to detect changes to the target data set. Responsive to detecting changes to the target data set, the system triggers the generative AI model to generate updated content based on the updated version of the target data set that is currently stored at the memory location. For example, in the context of project proposal generation, when details such as scope, timelines, or budget are updated to the underlying dataset, the system automatically regenerates the proposal content using a generative AI model. This enables organizations to deliver timely, accurate, high-quality proposals to prospective customers, increasing the likelihood of winning deals.
Techniques for a unified data format that may be used across memory tiers are provided. In one technique, a compression unit is generated that comprises a plurality of data blocks. The compression unit stores tabular data in a columnar format. The plurality of data blocks includes (1) a primary header block that represents a first set of rows of the tabular data and (2) a secondary header block that represents a second set of rows, of the tabular data, that is different than the first set of rows. The compression unit is stored in persistent storage.
Embodiments described herein are generally related to data analytics environments, and are particularly directed to systems and methods for use with a data analytics environment to provide a data modeling assistant for use with the data analytics environment. A method can provide, by a computer including one or more processors, access to a data analytics environment. The method can receive, at the data analytics environment, an instruction to ingest a first dataset, the first data set being retrieved from a computing device or from a storage accessible by the data analytics environment. The method can semantically profile, during the data analytics environment and during ingestion of the first dataset, the first dataset to generate a set of metrics and metadata associated with the first dataset. The method can generate a recommendation for the first dataset.
A system accesses a code module that includes one or more units of code and instructs a machine learning model to generate a test suite based on a specification for the code module. The test suite includes tests for testing the code module to verify that one or more units of code successfully execute in accordance with the specification. The specification includes preconditions that precede successful execution of the one or more units of code and postconditions that exist following successful execution of the one or more units of code. The machine learning model generates the test suite. The system receives the test suite from the machine learning model. The system stores and/or transmits the test suite for use in testing the code module.
Systems, methods, and other embodiments associated with ensuring that detection of degraded signals is not able to be masked by degradation in other signals are described. In one example embodiment, a method accesses a multivariate machine learning model that is trained to monitor a set of time series signals and a test observation of the signals has a degradation on an m-th signal. A baseline bias for the m-th signal is determined using the test observation and a model-estimated value of the m-th signal. A Jacobian matrix of the model is generated based on a finite difference smaller than an observed value of the m-th signal. A masking bias is determined based on the baseline bias and a next K largest entries of an m-th row of the Jacobian matrix. And, the degradation is certified to be un-maskable or not based on the masking bias and the finite difference.
Embodiments described herein are generally related to data analytics environments, and are particularly directed to systems and methods for augmenting large language models with graph knowledge generated by universal modelling of datasets. In accordance with an embodiment, a method for augmenting large language models with graph knowledge generated by universal modeling of datasets, is provided. The method can provide, by a computer including one or more processors, access to a data analytics environment. The method can create a graph schema associated with a dataset of the data analytics environment. The method can receive a query associated with the dataset of the data analytics environment. The method can receive, at a large language model, a parsed version of the query, together with the graph schema. The method can, based upon the received parsed query and the graph schema, generate, by the large language model, a graph query.
Computer-based academic intervention techniques are disclosed. A system monitors an application programming interface (API) of a computer system. While monitoring the API during a current academic period, the system detects a change in non-academic data exposed by the API. Responsive to detecting the change in the non-academic data, the system identifies a subset of the non-academic data that is associated with a particular student, and applies a machine-learning model to the subset of non-academic data to obtain a predicted likelihood of the particular student making satisfactory academic progress (SAP) at an academic institution where the particular student is enrolled. Responsive to determining that the predicted likelihood of the particular student making SAP at the academic institution does not satisfy a threshold criterion, the system presents a warning in a graphical user interface that the particular student is at risk of not making SAP.
Techniques for generating a markup language-based request for script generation are disclosed. In some embodiments, a system receives user input comprising a target natural language prompt. The system may generate a supplemented prompt comprising the target natural language prompt and example prompt data, the example prompt data comprising (a) a set of example natural language prompts and (b) a set of example markup language-based requests that correspond to the set of example natural language prompts. Next, the system may submit the supplemented prompt to a generative artificial intelligence (AI) model, wherein the generative AI model generates a target markup language-based request based on the supplemented prompt. The system may then receive the target markup language-based request from the generative AI model. Next, the system may submit the target markup language-based request to a script generator, wherein the script generator generates a customized script based on the target markup language-based request.
Systems, methods, and computer-readable media are provided for determining matches between records of different systems based on aggregate record data, and graphically marking potentially matched groups of data along with predicted confidence levels. Preliminary matching tools may allow allow users to define various rules based on which a majority of the transactions can be matched and reconciled. However, remaining transactions are disposed of in an interactive matching process. The matches may be determined unidirectionally from a source transaction to transactions from a target ledger, or bidirectionally from transactions in the target ledger to transactions other than the source transaction. Transactions may be matched many-to-many, one-to-many, or many-to-one, and a proposed order of match selections may be presented in a user interface. Match metadata or insights may be displayed to show a confidence of the match, reasons for the confidence, and/or a confidence of other matches that may be more beneficial than a match with a source transaction. The confidence and match insights may be generated by a machine learning model with access to transactions from a source transaction ledger and a target transaction ledger. The machine learning model may be trained on manual activity for prior matches that have been made. Matches may be performed using a hybrid machine learning model that accounts for random forests, decision trees, neural networks, naïve bayes algorithm, and/or a generalized linear model. Machine learning models also incorporate ongoing feedback from the users who can either accept or reject suggested matches and hence the models undergo an evolution process and constantly update from user patterns.
A system executes a first testing process utilizing a sandbox sub-environment executing in an execution environment of a computing network to perform a first set of testing operations associated with a new certificate bundle that includes a new CA certificate. Responsive to successful testing via the sandbox sub-environment, the new certificate bundle is installed on a host executing in the execution environment. The system utilizes a testing service executing on the host to perform a second set of testing operations associated with the new certificate bundle. Responsive to successful testing via the testing service executing on the host, the new CA certificate is activated in the execution environment by issuing entity certificates to a set of nodes associated with the host for execution against the new CA certificate.
H04L 9/32 - Arrangements for secret or secure communicationsNetwork security protocols including means for verifying the identity or authority of a user of the system
A system executes an initialization process for initializing a virtual machine. To execute the initialization process, the system generates an element loading schedule that includes a set of element identifiers that identify a set of elements for initializing the virtual machine arranged in a sequence corresponding to a traversal of the set of elements to transitive closure. The system initializes a background data area and loads a first subset of elements, of the elements for initializing the virtual machine, on the background data area in accordance with the sequence of the set of element identifiers in the element loading schedule. The system initializes a runtime data area and maps the first subset of elements from the background data area to the runtime data area.
A computer-implemented method includes performing a schema upgrade in a sharded database of a distributed system, by replacing in each shard a first version of a database schema with a second version of the database schema. The schema upgrade is performed for the first and second shards asynchronously, resulting in first and second versions of an application executing simultaneously with the first and second versions of the database schema respectively. The method also includes preventing execution of a change against a first shard on which the schema upgrade has been performed while the schema upgrade has not been performed on a second shard, in a case where the change is not compliant with the first version of the database schema. On completion of the schema upgrade in one of the shards, the upgraded schema becomes readable for an application using that shard.
G06F 16/27 - Replication, distribution or synchronisation of data between databases or within a distributed database systemDistributed database system architectures therefor
18.
SIMPLIFIED EXPENSE POLICY AND COMPLIANCE RECOMMENDATION WITH GENERATIVE AI
Systems, methods, and other embodiments associated with simplified expense policy and compliance enforcement based on generative AI are described. In one embodiment, an AI expense method includes retrieving a document that describes an expense policy. The AI expense method dynamically composes a prompt to a generative artificial intelligence model by populating a template prompt with the document. The prompt requests that the generative artificial intelligence model extract expense rules from the documents. The AI expense method generates the expense rules in response to the prompt with the generative artificial intelligence model. The generative artificial intelligence model is trained to produce the expense rules (i) to conform to the expense policy in the document, and (ii) in a format that is deployable to an expense management system. And, the AI expense method and deploys the expense rules to the expense management system.
Embodiments described herein are generally related to a data analytics environment and computer-based techniques for providing data-based notifications within the data analytics environment. The technique involves establishing rules based on specific data and conditions such that, when the specific data meets the conditions, a notification is provided to a user. The technique involves receiving user input indicative of parameters for a data watch construct, configuring the data watch construct based on the user input, receiving a trigger for a notification from the data watch construct when a configured condition is satisfied, and displaying the notification to the user.
An interactive digital assistant action interface includes a computer including processors that provide access to a data analytics environment, a chat-assistance service or application, and a large language model (LLM). The chat-assistance service or application delivers to the LLM a prompt corresponding to a received query and a desired task is determined based on the LLM receiving the prompt. One or more processes, steps, and/or APIs of the determined desired task are executed at the data analytics environment, and results of the one or more processes, steps, and/or APIs of the determined desired task being executed at the data analytics environment are provided.
Improved network traffic flow processing techniques are described. In a network device providing multiple processing planes, each processing plane comprising multiple processing units, techniques are described that take advantage of flow affinity/locality principles such that the same processing component of a processing plane, which previously performed processing for a network flow, is used for performing subsequent processing for the same network flow. This enables faster processing of network traffic flows by the network device. In certain implementations, the techniques described herein can be implemented in a network virtualization device (NVD) that is configured to perform network virtualization functions.
Systems, methods, and computer-readable media are provided for automatically and intelligently creating journal entries, such as journal entries to solve mismatches identified via the intercompany elimination reporting process. In an example, a machine learning model is trained to generate journal entries such as journal entries based on certain characteristics of historical journal entries associated with historical discrepancies. The trained machine learning model may be used, for example, to automatically generate a journal entry by recording a ledger acknowledging a discrepancy between a first data entry of a first entity and a second data entry of a second entity. The journal entry automatically generated using the machine learning model may reconcile the discrepancy, for example, by recording the ledger in alignment with the first data entry of the first entity or in alignment with the second data entry of the second entity.
Techniques for processing “Sessionless” transactions are provided. In one technique, a commit transaction instruction (that includes a transaction identifier) is received from a requesting entity at a first instance of a database server. In response a prepare message is transmitted to a second instance of the database server. A response that indicates that the second instance successfully performed an action in response to the prepare message is received from the second instance based on the prepare message. After the response is received, a transaction that is identified by the transaction identifier is committed. A response, to the commit transaction instruction, that indicates that the transaction is committed is transmitted to the requesting entity. Other techniques include piggybacking transaction instructions with database operation instructions and allowing different database server instances to perform work for a single transaction.
Systems, methods, and computer-readable media are provided for triggering functionality on data to be generated in a user interface and/or data shown or visualized in a user interface based on a natural language request that references actions to be performed and data items to use in performing the actions. The user interface actions are triggered based on a structured object generated by a large language model (LLM), which may then be processed, validated, and used to carry out the actions. The LLM may be further instructed based on available interface functionality control(s) and which content has been selected on the user interface. The structured object may be used to generate output content that is based on the selected content, such as a summary or other text transformation, a targeted visualization, output document for consumption by another application, or other consumable content. The output content may be stored in association with a content consumer for display in a user interface.
G06F 3/04845 - Interaction techniques based on graphical user interfaces [GUI] for the control of specific functions or operations, e.g. selecting or manipulating an object, an image or a displayed text element, setting a parameter value or selecting a range for image manipulation, e.g. dragging, rotation, expansion or change of colour
G06F 3/04847 - Interaction techniques to control parameter settings, e.g. interaction with sliders or dials
Systems, methods, and computer-readable media are provided for generating natural language project summaries via large language models including deterministically derived data value narratives. A computer-implemented method includes processing a first input configuring data stored in association with a plurality of fields, generating a narrative for a project, and causing display of the narrative in a report for the project. The narrative is generated by applying one or more deterministic operations to derive one or more values for the project based at least in part on at least one field of the plurality of fields, based at least in part on the configured data, generating a prompt, prompting a large language model with the prompt to generate a result, and storing the result as the narrative for the project. The prompt includes the one or more derived values and a context comprising the project for which a narrative is being generated.
Embodiments described herein are generally related to data analytics environments, and to systems and methods for providing aggregated summaries and aspect scores associated with unstructured textual data. In accordance with an embodiment, the system uses a key-based or batch approach that assesses factors associated with an unstructured textual dataset, such as, for example, a total number of text entries per key, or the character length of each text entry. Based on a consideration of such factors, the system sends batches of text entries, and a prompt, to a large language model processor, to collect intermediate batch results. The intermediate batch results can be used first to develop a numerical score or summary for each key, directed to various aspects of interest within the data; and subsequently to generate aggregated summaries and/or aspect scores associated with the textual dataset, for use in displaying visualizations or returning additional analytical information.
Techniques for generating actionable recommendations to improve program performance using generative AI are disclosed. A system invokes an application programming interface (API) service to obtain a set of program attributes. The program is made up of multiple projects that share a strategic objective. The system determines an overall performance classification for the program and a set of key program metrics that influence the overall performance classification. The system generates a prompt using the key program metrics. The system provides the prompt to a generative AI model to generate a program summary and a set of actionable recommendations to improve program performance by improving one or more of the key program metrics.
Systems, methods, and computer-readable media are provided for training and using a multi-layer neural network to detect a set of most likely action tuples each comprising a next user interface, a next operation, and a next data slice at least in part by training the multi-layer neural network to predict sequentially next user input and sequentially previous user input for adjacent groups. An example method may include providing a particular data structure as input to the multi-layer neural network to predict a particular action tuple comprising a next particular operation, a next particular user interface, and a next particular data slice to be used by a particular user as the particular user navigates a particular user interface. The method may also include causing display of a summary of the particular action tuple and an option to perform a particular user interface navigation to a particular user navigation target.
Techniques for autoencoder based anomaly detection and efficient storage of metrics within a cloud environment are disclosed. In an example, an input data stream is received from a cloud resource operating within a cloud environment, input data stream indicative of a metric associated with the cloud resource. An autoencoder (i) encodes the input data stream to generate a reduced size data stream, (ii) decodes the reduced size data stream to generate an output data stream that is an estimated reconstruction of the input data stream, (iii) compares the input and output data stream, to generate a stream of reconstruction errors, and (iv) generates a stream of z scores, based on the stream of reconstruction errors. In an example, one or more data points within the input data stream are flagged as being anomalous data points, based at least in part on the stream of z scores.
H04L 41/142 - Network analysis or design using statistical or mathematical methods
H04L 43/04 - Processing captured monitoring data, e.g. for logfile generation
H04L 43/0811 - Monitoring or testing based on specific metrics, e.g. QoS, energy consumption or environmental parameters by checking availability by checking connectivity
30.
SYSTEM AND METHOD FOR USE OF IN-MEMORY DATA GRID AS A VECTOR DATABASE FOR USE IN RETRIEVAL-AUGMENTED GENERATION
In accordance with an embodiment, described herein are systems and methods for use of an in-memory data grid as a vector database, with linearly-scalable data ingestion, for use in generative artificial intelligence (AI), data visualization, or other applications that include the use of a large language model (LLM) or a retrieval-augmented generation (RAG) process. In accordance with an embodiment, the in-memory data grid provides functionality to represent content as document chunks containing text, embedding, and metadata, which allows the system to support a variety of RAG framework integrations in a consistent manner. To further support the use of RAG processes, the system can support document ingestion via various types of document sources, such as the use of HTTP URLs that allow retrieval of documents using HTTP GET calls; or, for example in cloud environments, the use of object storage and/or other cloud provider storage services as appropriate.
Techniques for conducting membership inference attacks are disclosed. In an example, a plurality of target interactions of a target user with an item providing platform are monitored. A plurality of target recommendations for the target user is received from a recommendation system of the item providing platform. Using an attack classifier and based on (i) the plurality of target interactions and (ii) the plurality of target recommendations, an inference is made as to whether at least a subset of the plurality of target interactions and/or at least a subset of the plurality of target recommendations were used to train the recommendation system. The attack classifier is trained using training data associated with a plurality of autonomous users (such as autonomous sock puppets) interacting with the item providing platform. In an example, the item providing platform is one of a video providing platform, an audio providing platform, or a shopping platform.
Systems, methods, and other embodiments associated with a framework to configure and generate operational data signals for controls are described. In one embodiment, a method includes accepting input that defines a configuration for a functional sensor in a metadata repository of an enterprise data system. The configuration specifies condition(s) on data source(s) for triggering a signal associated with initiation of a task. The method monitors the data source(s) of the enterprise data system with the functional sensor for transaction changes that satisfy the condition(s) for triggering the signal. The method detects a transaction change that satisfies the condition(s) using the functional sensor. The method emits the signal in response to detection that the condition(s) for triggering the signal are satisfied. And, in response to receiving the signal, the method automatically executes the task in the enterprise data system.
The present disclosure relates to intelligent network encryption of traffic between a source and a destination. In an example, a network element receives, during a session between the source and the destination, first traffic exchanged between the source and the destination. The network element determines whether a traffic exchange between the source and the destination is expected to be secured by at least one of the source or the destination at any of a network layer, a transport layer, or an application layer. The network element generates a decision whether to secure the first session at the network layer based on whether the traffic exchange is expected to be secured or unsecured. The network element implements the decision on at least one of the first traffic or second traffic exchanged between the source and the destination during the first session.
A method implements incremental security protection generation. The method includes adding an incremental column to a table including an initial set of columns to form an updated set of columns. The initial set of columns include a status for at least one column of the initial set of columns. The method further includes adding a predicate to an allowlist for the incremental column. The method further includes transitioning the status of the incremental column from corresponding to a learning phase to corresponding to an enforcement phase responsive to a switch factor of the incremental column. The method further includes sending an access query including an access command, to access the incremental column, to a database in response to checking the access command against the allowlist with the status of the incremental column corresponding to the enforcement phase.
Systems, methods, and computer-readable media are provided for accessing a user request received in a user session with an application. Item(s) of data may be selected in the user session in association with the user request. A data management system determines that the request is for or otherwise relevant to item(s) of application functionality such as financial exceptions, account balances, and/or operations detail. The data management system generates a prompt by adding structured data return template(s) for triggering the item(s) of application functionality, the user request, and, if applicable, structured text representing the item(s) of data to a prompt template. The data management system prompts a large language model with the prompt and receives a result. The result includes a data structure conforming to the structured data return template(s) and that is based at least in part on the item(s) of data. The data management system triggers the relevant item(s) of application functionality based at least in part on the result and causes display of information indicating the item(s) of application functionality have been triggered.
Techniques are disclosed herein for adaptive training data augmentation to facilitate training named entity recognition (NER) models. Adaptive augmentation techniques are disclosed herein that take into consideration the distribution of different entity types within training data. The adaptive augmentation techniques generate adaptive numbers of augmented examples (e.g., utterances) based on the distribution of entities to make sure enough numbers of examples for minority class entities are generated during augmentation of the training data.
Systems, methods, and computer-readable media are provided for generating a prompt that specifies a plurality of fields and corresponding values of record(s). The prompt specifies a data structure to use for filling in components of a change order and includes a particular natural language description of a particular issue that caused the change order. A large language model is prompted with the prompt to generate a result based at least in part on the corresponding values of the record(s). The result from the large language model includes a particular data structure comprising particular values of a particular change order, which may then be displayed on a user interface along with an option to save the particular change order. Information from the record(s) and/or result(s) from the large language model may indicate whether or not manual labor, financial resources, and/or other resources are impacted by the change, and an impact may be stored in association with the change order reflecting a corresponding type of impact. The user interface may display another option to provide natural language input to modify the particular change order, causing the large language model to be re-prompted to generate another result to trigger change order creation.
G06F 3/0484 - Interaction techniques based on graphical user interfaces [GUI] for the control of specific functions or operations, e.g. selecting or manipulating an object, an image or a displayed text element, setting a parameter value or selecting a range
Systems and methods for implementing a secure multiparty protocol for fine-tuning of language models are disclosed. An end-to-end privacy-preserving protocol using secure multi-party computation (MPC) and executed on a plurality of computing nodes enables fine-tuning a language model targeting classification tasks using private, sensitive data while providing secure protection of the training data and without sacrificing model accuracy.
A method for suppressing subscription notifications to resource update originators includes receiving, by a producer NF and from a first consumer NF, a subscription request message requesting to be notified of changes in a resource. The method further includes creating, by the producer NF in a subscription database, and in response to the subscription request message from the first consumer NF, a record including a resource identifier, a notification URI, and information identifying the first consumer NF. The method further includes receiving, by the producer NF and from a resource update originator, a resource update request message for updating the resource. The method further includes suppressing transmission of a subscription notification request message concerning the resource to a notification URI in a subscription database record when the resource update originator identifying information obtained from the resource update request message matches the information identifying the consumer NF in the database record.
H04L 41/0604 - Management of faults, events, alarms or notifications using filtering, e.g. reduction of information by using priority, element types, position or time
H04L 61/4511 - Network directoriesName-to-address mapping using standardised directoriesNetwork directoriesName-to-address mapping using standardised directory access protocols using domain name system [DNS]
40.
Multimodal Data Ingestion And Retrieval For Agent Systems
Techniques for multimodal document retrieval are disclosed herein. Multimodal documents that include both textual and graphical components are retrieved from a knowledge base by a multimodal retrieval augmented generation (RAG) agent in response to a query. The documents and/or components or chunks thereof are retrievable by the RAG agent from the knowledge base using the semantic summaries and/or vector search of embeddings in the knowledge base that are generated from text extracted from processing non-textual components of the data. The RAG agent classifies the query type to determine whether to use a semantic match for text or image summaries, full text semantic search, vector cosine similarity search, and/or other multimodal vector search. The RAG agent performs types of searches selected based on the modality used to generate the response to the query.
For reliability, availability, and serviceability (RAS) of a database, here are novel performance optimization rules that generate a configuration of a new database or an improved configuration of an existing database. These rules perform a service level agreement (SLA) assessment to detect which database architecture options are needed. The rules recommend improvements to the database's current architecture so that recovery time objectives (RTO) and recovery point objectives (RPO) can be achieved by non-expert technicians. The rules analyze database diagnostics from health monitoring, diagnostic logs, persistent and network storage statistics, database performance statistics, and operating system (OS) statistics. The rules may analyze a database configuration that contains an interactively completed questionnaire or a diagnostic report generated by database infrastructure. The rules can be used speculatively to predict the RAS performance characteristics of an unimplemented configuration or used remedially to generate suggestions for improving RAS performance of a deployed configuration.
G06F 16/21 - Design, administration or maintenance of databases
42.
METHODS, SYSTEMS, AND COMPUTER READABLE MEDIA FOR DYNAMICALLY ADJUSTING PRODUCER NETWORK FUNCTION (NF) SERVICE-BASED INTERFACE (SBI) RESPONSE MESSAGE PROCESSING TIMEOUTS AT SERVICE COMMUNICATION PROXY (SCP) OR CONSUMER NF
A method for dynamically adjusting and using producer NF SBI response timeout values includes transmitting, by a sending NF and to a producer NF, a first SBI request message. The method further includes receiving, by the sending NF and from the producer NF, a maximum SBI request message processing time value. The method further includes dynamically adjusting, by the sending NF and based on the maximum SBI request message processing time value, an SBI response timeout value for the producer NF. The method further includes transmitting, by the sending NF and to the producer NF, a second SBI request message. The method further includes using, by the sending NF, the SBI response timeout value for the producer NF to determine when to indicate that a transaction associated with the second SBI request message has timed out.
Systems, methods, and computer-readable media are provided for triggering functionality on data to be generated in a user interface and/or data shown or visualized in a user interface based on a natural language request that references actions to be performed and data items to use in performing the actions. The user interface actions are triggered based on a structured object generated by a large language model (LLM), which may then be processed, validated, and used to carry out the actions. The structured object may cause generation, on the user interface, of a representation of slice(s) of data across different dimensions with different filter(s) applied to include one or more dimensions and exclude one or more other dimensions. The slice(s) of data may be determined based on available dimension(s) and/or dimension value(s) specified, in the prompt, for the data schema. If the representation is a grid, a shape of a grid may be recommended for showing the slice(s) of data determined.
Systems, methods, and computer-readable media are provided for triggering functionality on data to be generated in a user interface and/or data shown or visualized in a user interface based on a natural language request that references actions to be performed and data items to use in performing the actions. The user interface actions are triggered based on a structured object generated by a large language model (LLM), which may then be processed, validated, and used to carry out the actions. The LLM may be instructed to use control(s) of a displayed representation of a set of data, and the structured object generated by the LLM may cause updating, on the user interface, the displayed representation to reflect change(s) requested (e.g., to adjust filters, change a visualization or view, or zoom in or out on a set of multidimensional data). The control(s) may be selected from among representation transformation action(s) that are also available to be performed against the displayed representation via direct user input.
Systems, methods, and computer-readable media are provided for detecting an anomaly involving multiple dimensions, and generating a summary of the anomaly at least in part by prompting an LLM with key-value pairs relevant to the anomaly. The key-value pairs provided may be determined by drilling down into dimensional members most relevant to the anomaly (e.g., Top N and/or Bottom N members) to provide context for the LLM to summarize the anomaly and account for various levels in a multidimensional hierarchy. The key-value pairs may additionally or alternatively be determined by comparing values from different times relevant to the anomaly to provide context for the LLM to summarize the anomaly and account for relevant time variances. The key-value pairs of the Top N and/or Bottom N members and/or time variant comparison values may be included to enrich the LLM's summary to account for the multidimensional hierarchy and/or relevant time variances without overwhelming the LLM with extraneous information.
Techniques for processing "Sessionless" transactions are provided. In one technique, a commit transaction instruction (that includes a transaction identifier) is received from a requesting entity at a first instance of a database server. In response a prepare message is transmitted to a second instance of the database server. A response that indicates that the second instance successfully performed an action in response to the prepare message is received from the second instance based on the prepare message. After the response is received, a transaction that is identified by the transaction identifier is committed. A response, to the commit transaction instruction, that indicates that the transaction is committed is transmitted to the requesting entity. Other techniques include piggybacking transaction instructions with database operation instructions and allowing different database server instances to perform work for a single transaction.
Systems, methods, and other embodiments associated with generative Al assistance that is integrated into a command line interface (CLI) to a cloud platform are described. In one embodiment, an example method includes intercepting, in a command line interface to a cloud platform, a malformed command to the cloud platform. The method records the malformed command in a conversation history and passes the malformed command to the cloud platform to execute. The method intercepts a response to the malformed command that was returned from the cloud platform to the command line interface. The method passes the response to a generative artificial intelligence model to initiate generation of an enhanced response that includes a correction to the malformed command based at least in part on the response and context from the conversation history. And, the method presents the enhanced response in the command line interface.
Embodiments described herein are generally related to data analytics environments, and are particularly directed to systems and methods for use with a data analytics environment to provide an AI-based assistant for use in software development. In accordance with an embodiment, an exemplary method can provide access to a data analytics environment by a computer including one or more processors. The method can provide a first agent operating on the computer, wherein the first agent monitors an application running at an application server. The method can provide a second agent operating on the computer, wherein the second agent comprises a connection to one or more large language models. The method can, upon detection by the first agent, of an error or exception associated with the application running at the application server, utilize, by the second agent, the LLM to generate a fix responsive to the detected error or exception.
Systems, methods, and computer-readable media are provided for receiving partial text input and providing suggested input text based on example text input associated with one or more prompt templates for prompting an LLM to cause a particular type of application functionality. Systems, methods, and computer-readable media are also provided for selecting a prompt template based on content of text input, and generating a prompt based on the prompt template for prompting an LLM to cause a particular type of application functionality.
Techniques for generating visualizations with generative artificial intelligence (AI) using enriched prompts are disclosed. A system identifies proprietary content in a request to a generative AI model. The proprietary content corresponds to content that the generative AI model is not trained on to generate outputs. The system generates an enriched prompt for the generative AI model based on a mapping of proprietary terms to non-proprietary terms and content. The enriched prompt includes content from the request, including the proprietary terms and the mapping of proprietary terms to non-proprietary terms and content. The generative AI model generates the requested visualization, including proprietary content, based on the enriched prompt.
Embodiments described herein are generally related to cloud computing, cloud infrastructure, or data analytics environments, and are particularly directed to systems and methods for use with a data analytics environment or other cloud computing environment to provide an open data share for data formats with Delta Sharing. The systems and methods described herein allow for a data sharing service to share data to a client regardless of the format of the data. In accordance with an embodiment, a data share server generates a data log associated with a data table at data source. The data share server can receive a request from a data sharing client. Based upon the created data log associated with the data source, the data share server can share the data table, together with the generated data log associated therewith, to the data sharing client.
Embodiments described herein are generally related to data analytics environments, and are particularly directed to systems and methods for use with a data analytics environment to provide hi-query AI for use with the data analytics environment. Systems and methods disclosed can provide for query processing and semantic analysis. The system can take a user's natural language question and run a semantic search to discern the query's intent and find tables relevant to the question, and generate a query to run against a data store or data warehouse.
Disclosed herein are various approaches for visualizing a graph-organized file system (GOFS) using a graphical user interface. A GOFS may represent a graph comprising a plurality of nodes and one or more edges representing one or more relationships between the plurality of nodes. A user interface comprising a representation of at least a portion of the graph may be rendered in a display accessible to one or more computing devices. A file system command for the GOFS may be received via the user interface, and the user interface may be modified based at least in part on executing the file system command.
Systems, methods, and computer-readable media are provided for detecting user-specific context for a receipt and embedding the user-specific context in a prompt to provide a hint that helps a large language model detect value(s) for field(s) from the receipt. The receipt may then be integrated with an expense management system.
G06F 3/0484 - Interaction techniques based on graphical user interfaces [GUI] for the control of specific functions or operations, e.g. selecting or manipulating an object, an image or a displayed text element, setting a parameter value or selecting a range
G06F 40/40 - Processing or translation of natural language
Systems, methods, and computer-readable media are provided for using a first machine learning model to predict a first type of member data for a journal entry based on partial information of the journal entry, and using a second machine learning model to predict a second type of member data based on the first type of member data as predicted, optionally accounting for a confidence score of the first type of member data. Systems, methods, and computer-readable media are also provided for predicting one or more items of metadata for a journal entry and graphically marking the one or more items of metadata for review, distinguishing reviewed items from items yet to be reviewed.
Various techniques are provided for enabling an iterator (called persistent key-value (KV) iterator) that uses a special key structure embedded with secondary index information for efficient search (or query) of a key-value database (KVDB). In some embodiments, the key structure comprises a plurality of fields categorized into two groups, infrastructure hierarchy fields and object characteristic fields. Keys for the KVDB may be partitioned into one or more levels of hierarchy to generate many smaller key lists for easy search/query of the KVDB. These smaller key lists can be used for concurrent searches/queries.
G06F 16/27 - Replication, distribution or synchronisation of data between databases or within a distributed database systemDistributed database system architectures therefor
G06F 16/28 - Databases characterised by their database models, e.g. relational or object models
57.
Process Optimization System with Machine Learning Model to Optimize Process Execution
Systems, methods, and other embodiments associated with a process optimizer are described. In one embodiment, a method includes executing an optimization by inputting, into a trained machine learning model, a candidate process template includes a candidate sequence of tasks to be executed for completing a process type. The machine learning model may evaluate the candidate sequence of tasks including assigned task parameters for executing the process type based on at least learned internalized patterns. The machine learning model may predict one or more delays associated with the candidate sequence of tasks based on similar properties as in the internalized patterns. An optimized sequence of tasks for the candidate process template may be generated by changing an order of the candidate sequence of tasks and changing one or more of the assigned task parameters to reduce the one or more predicted delays.
Techniques are described herein for adaptively selecting and deploying language models, such as large language models (LLMs), to extract data from electronic documents. User overrides of extracted data are tracked and used to compute accuracy benchmarks for multiple language models. The benchmark data may drive the selection of which language model is used to extract data in a given context. The process may select different language models for different contexts depending on which language model is most accurate for the given context. Attributes other than accuracy, such as cost and latency, may also be a factor in which language model is selected. The adaptive approach allows for ongoing improvement in data extraction through reinforcement feedback while optimizing for one or more target factors, such as model accuracy, latency, and/or cost.
Techniques for generating augmented prompts are disclosed herein. Augmented prompts and/or guardrails for augmenting prompts are identified and/or generated. Augmented prompts intended to secure output generated by a generative model resulting from the augmented prompts are scored for efficacy. A risk classifier and a rules-based dictionary for augmenting prompts according to a risk class of an initial prompt are used to generate training data. The training data is used to train and/or fine-tune an error-to-prompt model. Augmented prompts and/or efficacy scores for the augmented prompts are used for feedback-based optimization of the error-to-prompt model. The error-to-prompt model selects and/or generates prompt augmentations, such as guardrail phrases, edits, deletions, or the like that secure output generated by the augmented prompt.
A system loads a set of elements on a runtime data area and associates the set of elements with a set of memory addresses that point directly to a set of memory blocks allocated for the set of elements on the runtime data area. The system determines a trigger for commencing executing a garbage collection process. Responsive to determining the trigger, the system determines a reference configuration for configuring references for the garbage collection process and associates the set of elements with a set of references that conform to the reference configuration. Subsequent to associating the set of elements with the set of references, the system commences executing the garbage collection process. The garbage collection process includes, concurrently while loading elements on the runtime data area, reclaiming memory allocated for elements that are unreachable on the runtime data area.
Techniques for scanning a machine learning (ML) model, which is received over a network, are disclosed. Information associated with the ML model is received. A container image is accessed, based on the information associated with the ML model. A software container is loaded using the container image. The ML model is loaded within the container. A plurality of system calls from the ML model within the container is detected. One or more system calls of the plurality of system calls are categorized as suspicious, e.g., based on the one or more system calls being outside a normal or expected behavior of the ML model. Responsive at least in part on categorizing the one or more system calls of the plurality of system calls to be suspicious, the ML model is tagged as possibly being malicious. A result indicative of the ML model being tagged as possibly being malicious is output.
G06F 21/55 - Detecting local intrusion or implementing counter-measures
G06F 21/53 - Monitoring users, programs or devices to maintain the integrity of platforms, e.g. of processors, firmware or operating systems during program execution, e.g. stack integrity, buffer overflow or preventing unwanted data erasure by executing in a restricted environment, e.g. sandbox or secure virtual machine
A system executes a first thread to load a first set of elements on a background data area, and concurrently while executing the first thread, the system executes a second thread to load the first set of elements on a runtime data area. The background data area and the runtime data area are implemented on separate memory regions. The first thread loads a first subset of elements of the first set of elements on the background data area concurrently, while the second thread loads a second subset of elements of the first set of elements on the runtime data area.
Systems, methods, and computer-readable media are provided for providing access, via a read-optimized database service, to functionally oriented pre-built metadata based logical objects. Each logical object provides access to a set of resources defined by a logical schema relevant to a functional area. Each logical schema is determined based at least in part on a read-optimized, synchronized version of one or more underlying related database structures stored to a read-optimized database accessible via the logical schema using the read-optimized database service, with the logical schema being different than the database schema of the underlying database structures. Requests to the read-optimized database service from a consumer of a particular functional area are evaluated against a particular set of logical resources associated with the functional area and translated to map to relevant underlying database structures, thus eliminating the requirement for consumer to understand underlying complex database structures as well as to shield consumers from underlying database structure changes in the future. Further some of the key text data in reference logical objects can be vectorized for usage in LLM-RAG use cases for assisting in semantic/similarity search of user queries. An attribute defaulting configuration interface and process is also described.
G06F 16/27 - Replication, distribution or synchronisation of data between databases or within a distributed database systemDistributed database system architectures therefor
64.
USING GENERATIVE AI TO CONTROL MULTI-DIMENSIONAL DATA VISUALIZATIONS USING NATURAL LANGUAGE
Systems, methods, and computer-readable media are provided for triggering functionality on data to be generated in a user interface and/or data shown or visualized in a user interface based on a natural language request that references actions to be performed and data items to use in performing the actions. The user interface actions are triggered based on a structured object generated by a large language model (LLM), which may then be processed, validated, and used to carry out the actions. The LLM may be instructed to use control(s) of a displayed representation of a set of data, and the structured object generated by the LLM may cause updating, on the user interface, the displayed representation to reflect change(s) requested (e.g., to adjust filters, change a visualization or view, or zoom in or out on a set of multidimensional data). The control(s) may be selected from among representation transformation action(s) that are also available to be performed against the displayed representation via direct user input.
Techniques for real-time scheduling for distributed query processing are provided. In one technique, a global counter and multiple local counters are stored, each local counter corresponding to a different query of multiple queries. Each query is scheduled based on the multiple local counters and the global counter. In response to determining that a particular query is waiting for data to arrive at a computing node, a first current value of the global counter is stored in association with the particular query. In response to determining that the data has arrived at the computing node: a current value of the global counter is identified; a difference between the second current value and the first current value is determined; and a current value of the local counter of the particular query is updated based on the difference.
Systems, articles, and computer-implemented methods are provided for generating summaries of a plurality of insights in multi-dimensional data to describe underlying trends using a large language model. A data structure is generated describing the plurality of insights where the data structure encapsulates for each insight of the plurality of insights to be included: a member of a data hierarchy that fits a descendant dimension that includes the insight, a value of the descendant dimension that fits the insight, and a characteristic of the insight. The data structure is included within a prompt to a large language model to summarize the plurality of insights. The prompt may also include data representing a relationship between the plurality of insights, such as how a first insight of the plurality of insights contributes to a second insight of the plurality of insights.
Techniques for multimodal document retrieval are disclosed herein. Multimodal documents that include both textual and graphical components are retrieved from a knowledge base by a multimodal retrieval augmented generation (RAG) agent in response to a query. The documents and/or components or chunks thereof are retrievable by the RAG agent from the knowledge base using the semantic summaries and/or vector search of embeddings in the knowledge base that are generated from text extracted from processing non-textual components of the data. The RAG agent classifies the query type to determine whether to use a semantic match for text or image summaries, full text semantic search, vector cosine similarity search, and/or other multimodal vector search. The RAG agent performs types of searches selected based on the modality used to generate the response to the query.
In accordance with an embodiment, described herein are systems and methods for use of an in-memory data grid as a vector database, with linearly-scalable data ingestion, for use in generative artificial intelligence (AI), data visualization, or other applications that include the use of a large language model (LLM) or a retrieval-augmented generation (RAG) process. In accordance with an embodiment, where AI-related tasks or processes, such as content ingestion and vectorization, or vector similarity searches, can be performed in parallel, the in-memory data grid provides efficient scaling and execution of such processes. When tasked with large amounts of content to be vectorized—for example in a cloud environment or as part of an on-premise solution—the system can scale its processing of the content, in parallel where indicated, to perform an optimal utilization of available computing hardware resources, and expeditiously perform required tasks or processes.
Techniques for remediating discrepancies between datasets by applying a trained, time-aware machine learning model to determine whether or not to auto-reconcile discrepancies are disclosed. To train a time-aware machine learning model, a system generates a training dataset of event records that records event attributes, including a time associated with the event and a magnitude associated with the event. The dataset of event records includes a first set of event records that are candidates for reconciliation and a second set of event records against which the first set would be reconciled. The time-aware machine learning model generates a recommendation for auto-reconciliation of dataset discrepancies based on discrepancy data and auto-reconciliation data. The discrepancy data and auto-reconciliation data are based on (a) a current time period or a time period corresponding to a current candidate remediation record and (b) time periods preceding the current time period.
Techniques are described for enforcing the flow of traffic through one or more gateways using ZPR policy. A method includes accessing a ZPR policy, identifying from the ZPR policy, one or more ZPR statements that specify one or more gateways and a connection between one or more first endpoints a first virtual cloud network (VCN) and one or more second endpoints that are external from the first VCN; generating rules to enforce the flow of traffic; and distributing one or more first rules of the rules to at least one of the one or more gateways to enforce the flow of traffic, and one or more second rules of the rules to a first enforcement point (EP) associated with the first VCN and one or more third rules or the rules to a second EP associated with the one or more second endpoints.
Techniques for applying a generative artificial intelligence (AI) model to identify and correct anomalies in remediation records are disclosed. A system trains and applies a generative AI model to displayed datasets to predict remediation record anomalies. If the system detects the generation of a remediation record in a dataset to reconcile the displayed datasets, the system generates a generative AI prompt that includes the remediation record. The generative AI model generates an output that identifies anomalies in the remediation record and the datasets being reconciled. The generative AI model further generates recommendations for remediating errors in the remediation record.
Here is an innovative way to generate a finetuning corpus that maximizes the accuracy of a target large language model (LLM) that generates a database statement. From a natural language request, the target LLM infers an incorrect database statement that, based on a first database schema, could not satisfy a technical requirement. Based on the natural language request, a correct database statement is generated that, based on a second database schema, could satisfy the technical requirement. For the second database schema, a restatement of the natural language request is generated. In inputs during finetuning, the target LLM accepts: the correct database statement, the incorrect database statement, and the restatement of the natural language request.
In some embodiments, a system transforms an initial user query into a first rewritten query using a first query rewriting algorithm, executes a search of a data repository using the first rewritten query to generate a set of results, executes a chunking process on the set of results to generate chunks of data, transforms the initial user query into a second rewritten query using a second query rewriting algorithm, generates corresponding embeddings for the second rewritten query and the chunks of data using a reranking model, selects a subset of the chunks of data based on a comparison of the embeddings for the chunks of data and the embedding for the initial user query, generates a prompt based on the initial user query and the subset of the chunks of data, submits the prompt to a Large Language Model (LLM) to generate a response to the initial user query.
Systems, methods, and other embodiments associated with predicting, controlling, and optimizing journal closing are described. In one embodiment, a method includes training a machine learning model based on historical journal entries, wherein the machine learning model learns combinations of features from journal entries that were approved and journal entries that were not approved. The model may evaluate a target set of journal entries using extracted features from individual journal entries. The model predicts which of the individual journal entries qualify for automatic approval by identifying combinations of the extracted features from the individual journal entries that have a multi-dimensional similarity to the learned combinations of features that were previously approved from the historical journal entries. Entries that are automatically approved may be marked with an automatically approved status and may be automatically transferred to a closing process.
Techniques for generating permissions policies for nested sets of software artifacts are disclosed. A system detects a selection of a target action and a target software artifact. The system identifies an entity associated with the selection. The system analyzes permissions metadata of the target software artifact to identify user-defined permission configuration rules specifying one or more additional software artifacts and one or more additional actions associated with the additional software artifacts. The system performs an iterative analysis of permissions metadata in the nested software artifacts to generate a composite permissions policy for the entity that combines the permissions specified in the user-defined permission configuration rules for the set of nested software artifacts.
The present embodiments relate to determining a critical path that identifies an order for bootstrapping a subset of resources within a data center under build. A cloud infrastructure orchestration service (CIOS) can identify from configuration files associated with resources to be bootstrapped within the data set, a set of capabilities. The CIOS can identify a first set of capabilities on which publishing each respective capability depends. User input can be received identifying a selected flock. The CIOS can identify the unpublished capabilities on which capabilities corresponding to the selected flock depend. Those unpublished capabilities can be ranked and provided via a visualization to the user. The unpublished capabilities can be ranked according to identifying, for a respective unpublished capability, a set of capabilities that are capable of being published responsive to publishing the respective unpublished capability.
A resource analytics system (RAS) is disclosed that creates a single, centralized, and trusted source of cloud resource inventory that provides near real-time visibility for a user into cloud resources deployed across different geographical regions within a cloud environment. The RAS obtains resource metadata related to a set of resources deployed in a cloud environment and provides the resource metadata in a source relational data model. The RAS extracts user-specific resource metadata from the source relational data model and populates a target relational data model with the user-specific resource metadata. The target relational data model is created in a user tenancy associated with a user. The RAS receives a request to query the user-specific resource metadata in the target relational data model and obtains a query result related to execution of the query. The RAS causes display of the query result via one or more user interfaces.
A technique is disclosed that facilitates the efficient creation and processing of an API specification for a service. The technique enables a particular service within an enterprise to use a function provided by another service within the enterprise in the API specification associated with the particular service, where the description of the function is not copied into the API specification. In certain embodiments, an include file is created that comprises a description of the function. The include file is identified and provided in the API specification of the particular service. An API specification generation system then processes the API specification comprising the include file to generate a final API specification for the service. The final API specification is provided via a user interface of a computing device.
Embodiments described herein are generally related to data analytics environments, and are particularly directed to systems and methods for use with a data analytics environment to enable use of AI in providing customer support. Machine learning AI models are trained based on one or more previous service request lifecycles of service requests of a customer to determine latent emotions of the customer based on determined customer problem data. A customer service prioritization signal related to a current service request of the customer is generated by a predictive analytics application that includes the models. The customer service prioritization signal is indicative of a need to prioritize a current service request of the customer based on the determined latent emotions of the customer and is generated during and prior to the end of the lifecycle of the current service request whereby escalation of the current service request may be deferred or prevented.
A method for network analytics data director (NADD)-assisted producer network function (NF) selection includes receiving, at the NADD and from consumer NFs, copies of service-based interface (SBI) messages transmitted to and received from producer NFs. The method further includes calculating, by the NADD, delay values associated with transport and processing of the SBI messages by the producer NFs. The method further includes providing, by the NADD, the delay values to a consumer NF. The method further includes using, by the consumer NF, the delay values to select a producer NF for processing an SBI request message originated or received by the consumer NF. The method further includes transmitting, by the consumer NF, the SBI request message to the producer NF.
H04L 41/40 - Arrangements for maintenance, administration or management of data switching networks, e.g. of packet switching networks using virtualisation of network functions or resources, e.g. SDN or NFV entities
81.
INTELLIGENTLY SUMMARIZING DECISION TREE LOGIC WITH LARGE LANGUAGE MODELS
Systems, methods, and computer-readable media are provided for accessing a stored data structure representing a decision tree, determining a plurality of rows of text representing leaf nodes of the decision tree and a plurality of conditions that describe paths to the leaf nodes along with a label for the corresponding leaf node, generating a prompt including the plurality of rows of text and a request to generate a result comprising a natural language summary column, executing the prompt against a large language model, receiving a result comprising a natural language summary column, storing a first natural language summary of a first path from the natural language summary column in association with a first leaf node in the stored data structure, and storing a second natural language summary of a second path from the natural language summary column in association with a second leaf node in the stored data structure.
A multi-cloud control plane of a source cloud environment receives from a control plane of a target cloud environment, a first request for accessing a service provided in the source cloud environment, the first request including a plurality of identifiers that enable identifying a first set of resources in the target cloud environment that are allocated to a customer. A first identifier is extracted from the plurality of identifiers included in the first request. Responsive to validating the first identifier, the multi-cloud control plane obtains a resource principal session token (RSPT), and information related to a second set of resources in the source cloud environment that are allocated to the customer. The multi-cloud control plane triggers the service provided in the source cloud environment based on the RSPT, wherein the service deploys service-based resources based on the second set of resources in the source cloud environment.
Embodiments described herein are generally related to data analytics environments, and are particularly directed to systems and methods for use with a data analytics environment to determine a probability of failure or downtime in work orders. In accordance with an embodiment, an example method can provide access to a work order application at a data analytics environment, the work order application providing a work order canvas at which a work order comprising an instance of a work order asset is identified. The method can generate, by a prediction engine of the data analytics environment, an indication of a likelihood of success of the work order, wherein the prediction engine utilizes data associated with the instance of the work order asset to provide the indication of the likelihood of success. The method can provide the indication of the likelihood of success of the work order via an interface.
Systems, articles, and computer-implemented methods are disclosed for generating natural language summaries of a multi-dimensional analysis of a detected anomaly within a member of multi-dimensional data by prompting a LLM with a prompt generated to include data about the anomaly in a manner understandable by the LLM. The prompt to the LLM includes a path to a member of the hierarchy containing an anomaly with a delimiter between the member and ancestor nodes. The delimiter allows the ancestral context of the member of the hierarchy to be understood by the LLM. The prompt also includes a metric defining a magnitude of the anomaly in relation to another value, such as an average, a value of the anomaly, a time corresponding to the anomaly, and one or more examples of other anomalies with included data about those anomalies matching the type of data provided for the detected anomaly.
Techniques are described herein for implementing, deploying, and utilizing an in-memory information access framework for enterprise data using highly-resolved, semantically-complete, read-only data objects. Extraction workloads efficiently access enterprise data without incurring significant performance degradation to transaction entry workloads. Consumers access enterprise information in a user-intelligible fashion without any knowledge of the underlying data storage and relationship details of complex physical schema designs. Consumers access subsets of the read-only data objects by defining reusable and parametrized data slices. Consumers combine related data slices into data slice collections. Initially, the system receives a request for a dataset by specifying a data slice. The system accesses metadata for an object or view associated with the data slice to determine operations for accessing the requested dataset. The system generates a database query for retrieving the requested dataset. The system executes the database query on a database to retrieve and return the requested dataset.
Systems, methods, and computer-readable media are provided for detecting an anomaly involving multiple dimensions, and generating a summary of the anomaly at least in part by prompting an LLM with key-value pairs relevant to the anomaly. The key-value pairs provided may be determined by drilling down into dimensional members most relevant to the anomaly (e.g., Top N and/or Bottom N members) to provide context for the LLM to summarize the anomaly and account for various levels in a multidimensional hierarchy. The key-value pairs may additionally or alternatively be determined by comparing values from different times relevant to the anomaly to provide context for the LLM to summarize the anomaly and account for relevant time variances. The key-value pairs of the Top N and/or Bottom N members and/or time variant comparison values may be included to enrich the LLM's summary to account for the multidimensional hierarchy and/or relevant time variances without overwhelming the LLM with extraneous information.
Systems, methods, and computer-readable media are provided for triggering functionality on data to be generated in a user interface and/or data shown or visualized in a user interface based on a natural language request that references actions to be performed and data items to use in performing the actions. The user interface actions are triggered based on a structured object generated by a large language model (LLM), which may then be processed, validated, and used to carry out the actions. The LLM may be further instructed based on available interface functionality control(s) and which content has been selected on the user interface. The structured object may be used to generate output content that is based on the selected content, such as a summary or other text transformation, a targeted visualization, output document for consumption by another application, or other consumable content. The output content may be stored in association with a content consumer for display in a user interface.
Systems and methods for implementing a secure multiparty protocol for fine-tuning of language models are disclosed. An end-to-end privacy-preserving protocol using secure multi-party computation (MPC) and executed on a plurality of computing nodes enables fine-tuning a language model targeting classification tasks using private, sensitive data while providing secure protection of the training data and without sacrificing model accuracy.
Current generative AI systems using large language models (LLMs) face challenges including non-deterministic outputs, hallucinations, outdated information, and resource-intensive training. This disclosure introduces topic maps for constrained retrieval augmented generation to address these issues. The technique leverages existing LLMs while constraining outputs to specific, user-defined content domains. Topic maps, composed of topic names, descriptions, and relevant resource references, create a curated knowledge base that guides agent responses. This approach reduces hallucinations, improves consistency, and allows for dynamic updates without model retraining. The method involves receiving a query, identifying relevant topic maps, transmitting the query and references to an AI agent, and generating constrained responses. By providing a structured, updatable knowledge framework, this method enhances the accuracy, reliability, and adaptability of generative AI systems.
A communication that is associated with a subject is accessed via an interface. One or more clinical concepts are determined based on the communication by using natural language processing and an ontological knowledge graph, where the ontological knowledge graph defines semantics, constraints, and relationships between a plurality of terms. An electronic health record is queried using the one or more clinical concepts. In response to the query, a set of records corresponding to the one or more clinical concepts from the electronic health record is received. An output is generated based on the set of records by using a generative artificial intelligence (GenAI) model, where the output comprises a summary of the set of records, a trend, or a categorization of information of the set of records. The interface is updated with the output.
G16H 10/60 - ICT specially adapted for the handling or processing of patient-related medical or healthcare data for patient-specific data, e.g. for electronic patient records
91.
USING METADATA TO ASSIST GENERATIVE AI TO ACHIEVE NATURAL LANGUAGE TO SQL QUERY CONSTRUCTION WITH ADDED SECURITY
A database query processing method includes receiving a natural language request for information contained within a database from a user in an application session, prompting a large language model to generate a SQL request, and receiving a particular SQL request from the large language model that is parsed to identify a command to access one or more database structures. A security predicate is appended to the command, creating a modified SQL request, to enforce one or more database access constraints constraining a user-authenticated client device that submitted the request that is not enforced in a database session between the application and a database. The modified SQL request is used to access data in the database session, and a visualization of the accessed data is caused to be displayed in the application session.
Autonomous learning of context-specific allowlists with confidences includes performing operations. The operations include obtaining a first batch of observations of an operation in a context and partitioning the first batch of observations by the context to obtain subsets of observations. The operations further include, for each subset of a plurality of subsets of observations to obtain metrics and confidence ratings, selecting, according to the context, a context-specific allowlist from multiple context-specific allowlists, comparing the operation in each observation in the subset to the context-specific allowlist to obtain a metric regarding the subset, calculating a confidence rating for the metric from the subset, and updating the context-specific allowlist for the first batch of observations. The operations further include deploying the plurality of context-specific allowlists when the metrics and the confidences satisfy a threshold.
Systems, methods, and other embodiments associated with generative AI assistance that is integrated into a command line interface (CLI) to a cloud platform are described. In one embodiment, an example method includes intercepting, in a command line interface to a cloud platform, a command to the cloud platform. The example method recording the command in a conversation history and passing the command to the cloud platform to execute. The example method includes intercepting a response to the command that was returned from the cloud platform to the command line interface. The example method includes recording the response in the conversation history and passing the response to a large language model (LLM) to initiate generation of an enhanced response in context of the conversation history. The example method includes receiving the enhanced response from the LLM. And, the example method includes presenting the enhanced response in the command line interface.
Techniques described herein are directed toward a counter hash generation scheme. One embodiment includes a method for counter hash generation. The method includes a device receiving an instruction to transmit an artifact from a source system to a target system, the artifact comprising a plurality of blocks. The device receives a block from the source system. The device generates an initialization vector based at least in part on the artifact. The device generates a nonce based at least in part on the initialization vector and a block value, each block being assigned a respective block value by a counter. The device generates a combined data instance based at least in part on a combination of the nonce, data of the block, and a length of the block. The device generates a hash of the combined data instance. The device transmits the hash and the block to the target system.
G06F 16/11 - File system administration, e.g. details of archiving or snapshots
H04L 9/06 - Arrangements for secret or secure communicationsNetwork security protocols the encryption apparatus using shift registers or memories for blockwise coding, e.g. D.E.S. systems
H04L 9/32 - Arrangements for secret or secure communicationsNetwork security protocols including means for verifying the identity or authority of a user of the system
Skills and skills metadata may be used to define a process for building a data center. Skills of one service may depend on skills corresponding to the same or different service. A dependency graph may be generated based on these dependencies. The graph may specify an order by which orchestration operations are to be performed to build the services, thereby building the data center. During execution of the process for building the data center, health states corresponding to the skills may be tracked (based at least in part on alarms and/or namespaces associated with the skills). When an unhealthy skill is identified, the system may traverse the dependency graph to identify a root cause (e.g., failed operations corresponding to a skill on which the unhealthy skill directly/indirectly depends). A notification and/or various options may be provided to address the unhealthy state of one or both skills.
A database query processing method includes receiving a natural language request for information contained within a database from a user in an application session, prompting a large language model to generate a SQL request, and receiving a particular SQL request from the large language model that is parsed to identify a command to access one or more database structures. A security predicate is appended to the command, creating a modified SQL request, to enforce one or more database access constraints constraining a user-authenticated client device that submitted the request that is not enforced in a database session between the application and a database. The modified SQL request is used to access data in the database session, and a visualization of the accessed data is caused to be displayed in the application session.
One or more embodiments initialize a signature validation object in a secure element (SE) platform runtime environment and utilize the signature validation object to perform signature validation operations. A system accesses an authentication path that includes a set of hash values corresponding to a set of nodes of a tree structure associated with a hash-based signature protocol utilized to generate a digital signature. The system computes a root hash value corresponding to a root node of the tree structure based on the set of hash values of the authentication path. The system verifies the root hash value against a root public key associated with the digital signature. The system determines that the digital signature is valid responsive at least in part to successfully verifying the root hash value against the root public key.
H04L 9/32 - Arrangements for secret or secure communicationsNetwork security protocols including means for verifying the identity or authority of a user of the system
H04L 9/00 - Arrangements for secret or secure communicationsNetwork security protocols
In accordance with an embodiment, described herein are a system and method for use with a distributed event streaming environment (e.g., a Kafka environment), for making services resilient of producer failures. When a determination is made that one or more messages could not be sent to a particular topic after a timeout error, those messages are stored in a centralized cache (e.g., as provided by a database service). A key-partitioner algorithm or process is used to pre-compute a partition ID into which the message will be re-sent. The pre-computed partition ID is used to compute the key of the cache entry for the message as stored within the centralized cache. A recurrent watchdog per group of microservice resources (e.g., per pod) operates to query the centralized cache for the messages to be re-sent into the partitions pertaining to those resources (i.e., that pod).
Techniques for initiating system actions based on text content are disclosed. A system applies a semantic analysis model at run-time to human-understandable text to identify actionable content within the human-understandable text. The system analyzes metadata associated with the text to identify a mapping between one or more data objects associated and the semantic content in the text. The system identifies one or more contact lists associated, respectively, with the one or more data objects. Using a database schema, the system analyzes the contact lists to determine whether to modify the contact lists.
G06F 16/383 - Retrieval characterised by using metadata, e.g. metadata not derived from the content or metadata generated manually using metadata automatically derived from the content
Techniques for initiating commands in a user interface by disambiguating user input terms are disclosed. As a system displays a set of data, the system receives a user input that includes a set of terms. The system determines the terms correspond to multiple different interpretations. The system selects a particular interpretation for the terms based on context data. The context data includes data, such as user profile data and display data. The user profile data includes data for a user entering the terms and data of other users related to the user entering the terms. The system selects and executes a command based on selecting the particular interpretation for the terms.
