NVIDIA Kumo Relational: A foundation model that predicts straight from your database

NVIDIA has unveiled Kumo Relational, a pretrained model that makes predictions like customer churn or fraud directly on relational enterprise databases, with no training. NVIDIA says it beats supervised approaches such as XGBoost pipelines on common benchmarks. Weights and code are openly available.

Model releases Try it yourself Oct 21, 2026 5 min read Source: Hugging Face Blog

What's it about

NVIDIA has released Kumo Relational, a pretrained "relational foundation model." It makes predictions directly on relational databases, meaning databases with several linked tables, such as users, orders and products. Typical tasks include customer churn, demand forecasting and fraud detection. According to NVIDIA, the model needs no task-specific training, no feature engineering (manually deriving metrics from raw data) and no squashing of the tables into a single one. It's available now, with weights on Hugging Face and code on GitHub.

Why foundation models for structured data

NVIDIA draws a parallel to language models: every text task used to need its own model and pipeline, but LLMs have largely replaced that. The same is supposed to hold for tabular data, for three reasons (vendor claims):

Accuracy: On RelBench V1 classification tasks, Kumo Relational beats gradient-boosted trees (e.g. XGBoost) on expert-built features by almost 4 AUROC points on average. On SAP SALT, it beats XGBoost on engineered features by 7 MRR points without adaptation and by 13 after fine-tuning.
Simplicity: One model replaces many individual pipelines. A new prediction becomes a query instead of a project.
Agents: Agents can ask predictive questions, such as which customer is about to churn, via the Predictive Query Language (PQL).

How the model works

Most models for tabular data work on a flat table. Kumo Relational instead works directly on the database and respects tables, foreign keys and timestamps. It learns through in-context learning: at runtime, it receives examples that each link a subgraph around an entity at a point in time to the known outcome (e.g. "this user churned").

There are three steps:

Automatic context generation: Tasks are written in PQL, a declarative language (you say what you want, not how to get it). The system replays historical database states and gives the model only data from before the cutoff time, which prevents data leakage.
Reasoning within tables: A lightweight network uses column and row attention to spot relevant columns and rows and filter out noise.
Reasoning across tables: A larger network spreads row embeddings across primary/foreign key relationships using graph attention, followed by cross-sample attention over the context examples. Because this runs on embeddings rather than on every cell, the design avoids quadratic cost.

Training on synthetic data

Diverse relational databases are rarely public. So the model was pretrained entirely on synthetic data, moving step by step from single tables to more complex structures. The generator builds on PluRel (ICML 2026). It creates a schema, foreign-key links that resemble real data, and column values from structural causal models with temporal trends and dependencies between tables. Since generation is cheap, the training data is practically unlimited. Training loss follows a power law, and NVIDIA says the gains carry over to real databases.

Results

The model was tested on 41 tasks across 15 databases from RelBench V1 and V2, SAP SALT and 4DBInfer (e-commerce, medicine, business, social, academic). None of these datasets appeared in pretraining. According to NVIDIA, the model beats the strongest supervised models on classification and regression, and it is the best in-context model on the RelBench leaderboard. On RelArena-α, it sits on the Pareto front of accuracy and efficiency and is about 430 times faster than rt-plurel at similar accuracy.

On SAP SALT, it beats large AutoGluon ensembles by 8% MRR, and by 16% with fine-tuning. It works with just 0.2% of the training data as context, stays stable when up to 75% of foreign-key links are removed, and loses little from extra noisy columns.

Usage and license

The model runs in memory, through database and warehouse connectors, or through kumo-engine, which NVIDIA says processes more than 500 billion rows using memory-mapped I/O at up to 5 GB/s. The GPU-native library structured-data-models (pip install) downloads the weights from Hugging Face on first use. Alternatively, it runs as an NVIDIA NIM, accessed through the structured-data-models-client client with PQL queries such as "PREDICT COUNT(orders.*, 0, 30, days) FOR EACH users.user_id". Code: Apache 2.0. Weights: OpenMDW License 1.1.

What you need to try it

The source gives no exact figures. The model is built for GPUs (device="cuda"), so you need an NVIDIA graphics card, ideally in a GPU notebook such as Google Colab. Expect a few GB of free disk space for weights and data. Pure CPU or Mac use isn't described. A quickstart notebook is in the client repository.

Our take

If a pretrained model can match or beat purpose-built pipelines without any training, that would save companies with large databases a lot of work. All figures come from NVIDIA or its own paper, and independent replications are still missing. NVIDIA names the limits itself: it works best on data with meaningful relationships and temporal dynamics. With very large training sets, specialized supervised models may still come out ahead, and the predictive signal has to be reachable within a few hops.

Sources

Hugging Face Blog huggingface.co

#nvidia#tabular-data#foundation-model#databases#open-weights

Read the original source

Try it yourself: Kumo Relational

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

You connect several tables of a database and use PQL to describe what you want predicted, such as customer churn or order counts. The model returns the prediction in a single pass, with no training of your own.

Who is it worth it for?

For data science and ML teams with relational data and access to an NVIDIA GPU. It isn't meant for beginners or for pure text tasks.

Downloadsee Model Card

Licenseopenmdw-1.1

TypeAI model

Hugging Facenvidia/Kumo-Relational

What your computer needs

Graphics card (NVIDIA) at least 2 GB VRAMCalculated, not measured: one weights file (classifier.pt or regressor.pt) is 0.12 GB, times 1.2 plus 1 GB comes to just over 1 GB, rounded up to 2 GB. Large tables and a higher num_estimators need more.

Mac (Apple Silicon M1–M5) from 8 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it

Storage approx. 4 GB freeModel download plus programs

There is one model variant. Run it directly through the Python library in a GPU notebook, or as an NVIDIA NIM service with a client.

The library is GPU-native; the example uses device="cuda".
The source doesn't state a specific VRAM requirement.
A GPU notebook (e.g. Colab) is enough to get started with the quickstart.
For very large databases (500 billion+ rows), kumo-engine with memory-mapped I/O is used.
Weights are downloaded from Hugging Face on first call.

How do I find out what my computer has?

Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

This model runs with its developers' own program (NVIDIA/structured-data-models on GitHub). The commands below come from the Model Card and the developers' instructions.

Windows 10 / 11

Windows 10 / 11: not officially tested. The source only mentions CUDA and says nothing about Windows. It should work with an NVIDIA card but is untested. Alternative: WSL2 or Google Colab.

Check the prerequisites. You need Python 3.11 or newer, Git and an NVIDIA graphics card with a current driver. Open PowerShell and check the versions.
```
python --version
git --version
nvidia-smi
```
Create a folder. Create a new, empty folder and change into it.
```
mkdir kumo-test
cd kumo-test
```
Create a virtual environment. A virtual environment is an isolated Python folder. If PowerShell blocks activation, you need to allow script execution.
```
python -m venv .venv
.venv\Scripts\Activate.ps1
```
Install the package. This installs the package that contains the model. It is untested on Windows.
```
pip install structured-data-models
```
Download the model (optional). The weights are small (about 0.12 GB). The program probably downloads them itself; otherwise, grab them here in advance.
```
pip install huggingface_hub
hf download nvidia/Kumo-Relational
```

Load the model. Save this code as demo.py. It loads the classification model onto the graphics card.

import sdm

model = sdm.models.KumoRelational(task="classification", device="cuda")
print("Model loaded:", type(model).__name__)

Run it. Run the file. If you see "Model loaded," everything works.
```
python demo.py
```
Result. The Kumo Relational model is loaded and ready to make predictions across linked tables.

macOS

macOS: not officially tested. The source only mentions CUDA (NVIDIA). Macs don't have CUDA, and whether the program runs with device="cpu" is untested. Alternative: a Linux/Windows PC with an NVIDIA card, or Google Colab.

Check the prerequisites. You need Python 3.11 or newer and Git. If your Mac asks for the Xcode command line tools, install them.
```
python3 --version
git --version
```
Create a folder. Create a new, empty folder and change into it.
```
mkdir kumo-test
cd kumo-test
```
Create a virtual environment. A virtual environment is an isolated Python folder.
```
python3 -m venv .venv
source .venv/bin/activate
```
Install the package. This installs the package that contains the model. Whether it works on a Mac is untested.
```
pip install structured-data-models
```
Download the model (optional). The weights are small (about 0.12 GB). The program probably downloads them itself; otherwise, grab them here in advance.
```
pip install huggingface_hub
hf download nvidia/Kumo-Relational
```

Load the model. Save the code as demo.py. We use "cpu" instead of "cuda" because a Mac has no NVIDIA card. This is untested.

import sdm

model = sdm.models.KumoRelational(task="classification", device="cpu")
print("Model loaded:", type(model).__name__)

Run it. Run the file.
```
python3 demo.py
```
Result. The Kumo Relational model is loaded and ready to make predictions across linked tables.

Linux

Linux: supported. The source uses device="cuda", meaning an NVIDIA graphics card with CUDA. The source doesn't provide a ready-made sample file with tables, so you need your own linked tables.

Check the prerequisites. You need Python 3.11 or newer, Git and an NVIDIA graphics card with the NVIDIA driver installed. The program also needs PyTorch 2.7 or later (usually installed along with it).
```
python3 --version
nvidia-smi
```
Create a folder. Create a new, empty folder for the project and change into it.
```
mkdir kumo-test
cd kumo-test
```
Create a virtual environment. A virtual environment is an isolated Python folder, so nothing else on your machine gets mixed up.
```
python3 -m venv .venv
source .venv/bin/activate
```
Install the package. The structured-data-models package includes the KumoRelational model. This can take a few minutes.
```
pip install structured-data-models
```
Download the model (optional). The weights are only about 0.12 GB per task. The program probably downloads them itself. If not, fetch them in advance with this command.
```
pip install huggingface_hub
hf download nvidia/Kumo-Relational
```
Load the model. Save this code as demo.py and run it. It loads the classification model (yes/no or category prediction) onto the graphics card.
```
import sdm

model = sdm.models.KumoRelational(task="classification", device="cuda")
print("Model loaded:", type(model).__name__)
```
Run it. Run the file. If you see "Model loaded," everything works.
```
python demo.py
```
Make your own prediction. For real predictions you need your own tables: example rows with a known outcome (x_context, y_context), new rows (x_query) and the linked tables (related_context_tables, related_query_tables). How to build them is covered in the structured-data-models docs.
```
probs = model(
    x_context=x_context,
    y_context=y_context,
    x_query=x_query,
    related_context_tables=related_context,
    related_query_tables=related_query,
    num_estimators=8,
)
```
Result. The Kumo Relational model is loaded and ready to make predictions across linked tables.

Try it

PREDICT COUNT(orders.*, 0, 30, days) FOR EACH users.user_id

Which customers are likely to churn in the next 30 days?

How many units will each product sell next month?

If something goes wrong

Install with pip install structured-data-models; a CUDA-capable GPU is required.

The weights are under the OpenMDW License 1.1, so check the license terms first.

Foreign keys and timestamps must be defined cleanly, otherwise the model lacks the relationship signal.

It isn't a chat model; it works with tables and PQL.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: openmdw-1.1.

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.