TL;DR
NVIDIA Kumo Relational is a pre-trained relational foundation model that makes predictions instantly on enterprise databases. Given a predictive query, it gathers historic examples as context examples and predicts outcomes just like churn, demand, or fraud in a single forward transfer. It needs no task-specific teaching, no operate engineering, and no flattening of tables. Kumo Relational is the first few-shot foundation model to outperform supervised machine learning on frequent relational benchmarks. All through 41 duties on 15 databases, it beats supervised relational deep learning fashions and expert-engineered gradient-boosted tree pipelines, and on the SAP SALT enterprise benchmark it surpasses AutoGluon ensembles by 8% in indicate reciprocal rank (MRR). It scales to databases with 500B+ rows and works for folks and brokers alike, by the use of NVIDIA’s open-source, GPU-native structured-data-models and kumo-engine libraries, or as an NVIDIA NIM.
The Shift to Structured Data Foundation Fashions
Foundation fashions have already rewritten the playbook for language and imaginative and prescient. Not means again, manufacturing NLP meant a faithful model per course of, each fed by its private pipeline of tokenization, lemmatization, and n-grams. LLMs made that stack largely outdated for 3 causes: they’ve been additional appropriate than the easiest task-specific fashions, far simpler to put into manufacturing, and versatile enough to open a model new interval of agentic functions.
The an identical shift is now underway for structured data. Relational databases vitality the world’s most essential enterprise alternatives, however predictive modeling on them nonetheless requires weeks of operate engineering, task-specific teaching, and tuned pipelines. Structured data foundation fashions change that for the same three causes:
Greater accuracy at current: As drop-in replacements, these fashions already beat many manufacturing pipelines, notably XGBoost. On RelBench V1 classification duties, Kumo Relational outperforms gradient-boosted bushes on expert-engineered choices by virtually 4 AUROC elements on frequent. On SAP SALT, it beats XGBoost on engineered choices by 7 MRR elements out of the sphere and by 13 MRR elements after fine-tuning. These outcomes make a compelling case for altering manufacturing XGBoost pipelines with Kumo Relational.
Simplicity and agility: One pre-trained model replaces separate pipelines for explicit individual duties. A model new prediction turns right into a query in its place of a endeavor, so ML teams can lastly sort out use situations that typical ML made too laborious to assemble at every stage of the group.
Brokers which will predict: LLMs let brokers study, write, and trigger. Structured data foundation fashions enable them to anticipate what happens subsequent, just like which purchaser will churn, and act on it. Kumo Relational is already constructed to be known as by brokers, and its Predictive Query Language (PQL) supplies them a straightforward interface for asking predictive questions.
As we communicate, we’re introducing Kumo Relational (Paper, GitHub, HuggingFace), a pre-trained foundation model that brings this paradigm to relational data. Be part of a database, describe what to predict, and get predictions in a single forward transfer. No teaching required.
How Kumo Relational Works
Most foundation fashions for structured data operate on a single flat desk. Precise-world data lives in relational databases in its place: prospects linked to orders linked to merchandise, all evolving over time. Flattening these relationships into one row by the use of information aggregation (e.g., “frequent order price throughout the ultimate 30 days”) loses fine-grained structural indicators and takes essential human effort.
Kumo Relational is a Relational Foundation Model that operates instantly on the database, respecting its tables, worldwide keys, and timestamps. It is pre-trained as quickly as on synthetic relational data that shows real-world datasets and adapts to each new course of by the use of in-context learning by reasoning over context examples at inference time. Each occasion pairs an space subgraph spherical an entity at a time restrict with its ground-truth aim (e.g., “this shopper churned” or “this merchandise purchased 142 fashions”).
Decide 1. Overview of the Kumo Relational system. Be part of a database, specify a predictive query, and Kumo Relational handles the rest, from context expertise to model inference.
To make a prediction, Kumo Relational has to do three points: (1) understand the values inside each desk, (2) relate data all through tables, and (3) relate context examples with acknowledged targets to the entity being predicted. Proper right here is the best way it really works:
Decide 2. Kumo Relational construction: (a) context enter, (b) reasoning inside tables, (c) reasoning all through tables.
Computerized Context Expertise: Duties are written throughout the Predictive Query Language (PQL), a declarative interface the place you state what to predict reasonably than how. For temporal duties, Kumo Relational replays historic database states: it samples entity-centric subgraphs as a lot as an anchor timestamp and computes each aim from events after that timestamp, whereas serving the model solely the data from sooner than it. This prevents data leakage.
Reasoning Inside Tables: A lightweight-weight neighborhood processes each desk independently by the use of column consideration (relating values inside a column) and row consideration (relating choices inside a row). The model learns which columns and rows matter for the current prediction and filters out noise sooner than it propagates.
Reasoning All through Tables: An even bigger neighborhood distributes the row embeddings all through the relational development by the use of graph consideration over primary-key/foreign-key relationships, adopted by cross-sample consideration all through context examples. That’s the place relational reasoning happens, just like linking a shopper’s profile to their transaction historic previous. Because of this stage works on row embeddings reasonably than on every cell in every desk, the design avoids quadratic worth and scales to huge contexts and deeper subgraphs.
How Kumo Relational Was Constructed
Kumo Relational is pre-trained on fully synthetic relational data simulated to duplicate real-world relational databases with varied predictive queries. Pre-training proceeds in ranges, from single tables to increasingly sophisticated relational constructions.
The various relational databases wished for pre-training are rarely public, so synthetic data fills the opening. Kumo Relational’s generator builds on the technique of PluRel (Kothapalli et al., ICML 2026), which extends single-table data generators to full relational databases. PluRel generates each database in three ranges: a schema, foreign-key hyperlinks between rows that cluster as they do in precise data, and column values from Structural Causal Fashions with temporal tendencies and cross-table dependencies. Expertise is lightweight, so pre-training data is efficiently limitless. Pre-training loss follows an affect laws as synthetic databases are added, with good factors that carry over to precise databases.
Through this pre-training, the model learns to filter, correlate, and combination information all through tables in its place of relying on mounted aggregations.
Effectivity
Throughout the paper, we evaluated Kumo Relational on 41 benchmarks all through 15 relational databases from RelBench V1 and V2, SAP SALT, and 4DBInfer, spanning e-commerce, medical, enterprise, social, and tutorial domains. None of these datasets have been seen in pre-training. Kumo Relational outperforms the strongest supervised fashions in every classification and regression, along with relational deep learning fashions and expert-engineered tabular ensembles. It is the top-performing in-context learning model on the RelBench leaderboard. On RelArena-α, it sits on the accuracy-efficiency Pareto entrance:
Decide 3. RelArena-α leaderboard as of 2026-09-21: Elo all through duties versus full course of runtime (log scale). Kumo Relational is about 430× before rtl-plurel at associated accuracy.
On the SAP SALT enterprise benchmark, Kumo Relational surpasses huge AutoGluon ensembles by 8% in indicate reciprocal rank (MRR), and fine-tuning extends its lead over AutoGluon to 16%. It moreover holds up beneath exhausting conditions: it performs successfully with as little as 0.2% of the teaching data as context, stays regular when as a lot as 75% of foreign-key hyperlinks are eradicated, and barely degrades when noisy columns are added.
Limitations
Kumo Relational performs best on data with important relationships and temporal dynamics, just like shopper habits over time. On duties with very huge teaching items, task-specific supervised fashions ought to nonetheless edge out in-context predictions. Predictive indicators need to be reachable inside a restricted number of hops.
Demo
Kumo Relational runs in-context learning natively over databases: in memory, by the use of database and warehouse connectors, or by the use of kumo-engine that handles 500B+ rows by the use of memory-mapped I/O at as a lot as 5 GB/s. The model itself is on the market in NVIDIA’s newly launched, GPU-native structured-data-models library, the an identical open-source library that powers our sister model, Kumo Tabular. The library downloads the weights from the Hugging Face Hub on first use, so you’ll load the model in a GPU-backed pocket e-book and predict instantly from it. The interface is designed to naturally delay tabular foundation fashions to relational signal by passing additional related multi-table context and query information:
import sdm
model = sdm.fashions.KumoRelational(gadget="cuda")
pred = model(
x_context=sdm.TableTensor(...),
y_context=sdm.TableTensor(...),
x_query=sdm.TableTensor(...),
related_context_tables=sdm.RelatedTables(tables={...}),
related_query_tables=sdm.RelatedTables(tables={...}),
)
See the library’s relational examples for RelBench and SAP SALT pipelines.
To run the model as a separate service in its place, deploy it as an NVIDIA NIM and stage the open-source structured-data-models-client at it out of your pocket e-book. You write the prediction in PQL, and the consumer gathers the context examples and related tables, then sends the request:
import sdm_client
shopper = sdm_client.SDMClient(url="http://localhost:8001")
query = sdm_client.PredictiveQuery(
"PREDICT COUNT(orders.*, 0, 30, days) FOR EACH prospects.user_id",
{"prospects": ..., "orders": ...},
)
pred = shopper.predict(
query.materialize(indices=[1, 2, 3]),
model=sdm_client.KumoRelational(),
)
See the consumer’s occasion notebooks for end-to-end runs in opposition to an space NIM and on Databricks.
Start Setting up with NVIDIA Kumo Relational
NVIDIA Kumo Relational is on the market at current. Be taught the evaluation paper, uncover the quickstart pocket e-book, or start making predictions by your self data. The code is launched beneath the Apache 2.0 license and the model weights beneath the OpenMDW License Settlement, mannequin 1.1. NVIDIA believes Dependable AI is a shared responsibility, and now we have now established insurance coverage insurance policies and practices to permit enchancment for a wide array of AI functions. When downloaded or utilized in accordance with our phrases of service, builders must work with their supporting model crew to ensure this model meets requirements for the associated commerce and use case and addresses surprising product misuse. Please report model top quality, menace, security vulnerabilities, or NVIDIA AI points proper right here.
Acknowledgements
We thank the whole Kumo crew for his or her invaluable help. Explicit thanks go to Adi Wadaskar, Hema Raghavan, Manush Murali, Zack Drach, Vanja Josifovski, Myungwhan Kim, Siyang Xie, Alan Krumholz, Effy Fang, Abdullah Al-chihabi, Disha Dubey, Devan Johnson, Joseph Oliveira, Angela Liu, Miha Pelko, Vedaant Jain, Sally Liu, Aleksandar S. Sokolovski, and Alex Porter.
