> For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://docs.nvidia.com/sdgm/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/sdgm/_mcp/server. # Overview > Choose a Kumo model and execution path, build your first workflow, and find runnable examples and reference guides. ## What Is NVIDIA Kumo? NVIDIA Kumo is a family of open models, libraries, and tools for making predictions from tabular, relational, and time-series data. Use Kumo to forecast outcomes, score risk, detect anomalies, and generate recommendations. Use a pretrained model to make predictions directly, connect to a deployed model through a client, or train your own task-specific model with [Kumo Engine](/kumo-engine/get-started-with-kumo-engine/overview). ## Choose a Model These pretrained foundation models let you make predictions for supported tasks without training a model on your own data. Choose by the structure of your data and the prediction you need. | Model | Data and task | Required inputs | Outputs | Run with | | ---------------------------------------------------------------- | ----------------------------------------- | ---------------------------------------------------------------- | ------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [Kumo Tabular](https://huggingface.co/nvidia/Kumo-Tabular) | Single-table classification or regression | Labeled context and query rows | Class probabilities (classification) or numeric predictions (regression) | [Structured Data Models](https://github.com/NVIDIA/structured-data-models) | | [Kumo Relational](https://huggingface.co/nvidia/Kumo-Relational) | Prediction across related tables | Context, query rows, and related tables; graph and query for NIM | Class probabilities (classification) or numeric predictions (regression) | [Structured Data Models](https://github.com/NVIDIA/structured-data-models); [Kumo Relational Client with NIM](https://github.com/kumo-ai/kumo-relational-client) | | [Kumo Forecast](https://huggingface.co/nvidia/Kumo-Forecast) | Time-series forecasting | History, timestamps, target, and horizon | Future target values | [Kumo-TS](https://github.com/NVIDIA/Kumo-TS) | | [Kumo Anomaly](https://huggingface.co/nvidia/Kumo-Anomaly) | Time-series anomaly detection | Numeric signal sequences | Anomaly flags and scores | [Kumo-TS](https://github.com/NVIDIA/Kumo-TS) | ## Choose a Library or Tool Use **Kumo Engine** to train your own task-specific models, **Structured Data Models** to run pretrained foundation models directly in Python, or **Structured Data Models Client** to request predictions from a compatible Kumo Relational NIM endpoint. For the Kumo Forecast and Kumo Anomaly workflows documented below, use **Kumo-TS**. | Library or tool | Use it to… | Execution and requirements | | ----------------------------------------------------------------- | ------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | | [Kumo Engine](/kumo-engine/get-started-with-kumo-engine/overview) | Train and evaluate a task-specific model on your relational data. | Runs in a supported GPU-enabled Linux or notebook environment. Requires local working storage. | | [Structured Data Models](/structured-data-models/overview) | Run pretrained Kumo Tabular or Kumo Relational models directly in Python. | Runs in your Python process. Device and memory requirements depend on the selected model. | | [Structured Data Models Client](/client/overview) | Request predictions from a deployed Kumo Relational NIM using Kumo Relational Client. | The client runs in your application; inference runs on the NIM server. Requires a reachable, compatible endpoint. | | [Kumo-TS](https://github.com/NVIDIA/Kumo-TS#getting-started) | Run the Kumo Forecast or Kumo Anomaly workflows documented below. | Runs in Python. Forecast and Anomaly require separate environments. | ## Build Your First Workflow #### Structured Data Models Run Kumo Tabular or Kumo Relational in Python #### Install the library 1 Check Python, PyTorch, and device requirements in the [SDM setup guide](/structured-data-models/user-guide#1-set-up-your-environment) and your model card. Then install Structured Data Models (SDM). #### Prepare the rows you want to predict 2 Use rows with known outcomes as labeled context, and keep the rows you want to predict separate. For Relational, include the related tables and their keys. The [table semantics guide](https://nvidia.github.io/structured-data-models/tensor.html) explains how to represent your columns. #### Run the model and read the predictions 3 Pass the context and query rows to the model. Classification returns class probabilities; regression returns numeric predictions. [**Install SDM and run inference**](/structured-data-models/user-guide) #### Kumo-TS Forecast values or detect anomalies #### Install Forecast or Anomaly 1 Use [Kumo-TS setup](https://github.com/NVIDIA/Kumo-TS#getting-started) to install your chosen package. If you use both packages, keep them in separate Python environments. #### Prepare your time series 2 For Forecast, identify the timestamp column, the value to predict, and how far ahead to forecast. For Anomaly, provide the numeric signals you want to check. #### Run the model and inspect the results 3 Check that the forecast covers the horizon you requested. For Anomaly, inspect the anomaly flags and error scores to find unusual readings. [**Set up Kumo Forecast or Kumo Anomaly**](https://github.com/NVIDIA/Kumo-TS#getting-started) #### Structured Data Models Client Request predictions with Kumo Relational Client #### Install the client and connect to NIM 1 You need a reachable, compatible Kumo Relational NIM endpoint and a supported Python environment. Use [Deploy, Install, and Connect](/kumo-relational/get-started/sdk-getting-started) to install `kumo-relational-client[relational]`, check platform requirements, and verify the connection. The client host does not need a GPU. #### Build a graph from your tables 2 Load the related tables and connect them through their keys. Check the inferred column types and time columns, then validate the graph before making predictions. #### Write a query and request predictions 3 Describe the outcome you want in a predictive query, send the request, and inspect the returned pandas DataFrame. [**Run the Kumo Relational Client quickstart**](/kumo-relational/get-started/rfm) #### Kumo Engine Train a model for your own prediction task #### Set up your environment 1 Choose a supported Linux or notebook environment and configure GPU compute and working storage using the [deployment guide](/kumo-engine/get-started-with-kumo-engine/available-deployment-options). #### Connect your tables and define the task 2 Build a graph from your tables and their key relationships. Write a predictive query that identifies what to predict, which entities to score, and any future prediction window. #### Train, evaluate, and predict 3 Train the model, review its evaluation metrics, and use the fitted model to generate predictions. The [training guide](/kumo-engine/user-code-guide/train-a-model/training) explains how to inspect the metrics and saved model files. [**Train and evaluate the Linux example**](/kumo-engine/user-code-guide/code-examples/linux-deployment/binary-classification) ## Examples You Can Run Explore a use case to find the model, tools, and example to start with. #### 🗂️ Classify records from labeled examples Classify vehicle silhouettes from 18 numerical features using Kumo Tabular and the OpenML Vehicle dataset. The notebook runs the small model on CPU, uses labeled examples as context, and returns class probabilities for held-out rows. It compares prediction accuracy and ROC AUC with a majority-class baseline. A GPU is not required. The notebook installs its dependencies and downloads the dataset and pretrained weights, so you need internet access. Use a separate notebook environment for its pinned dependencies. * **Model:** [Kumo Tabular](https://huggingface.co/nvidia/Kumo-Tabular) * **Library:** [Structured Data Models](/structured-data-models/overview) * **Example:** [Open the Kumo Tabular CPU notebook guide](/structured-data-models/user-guide#kumo-tabular-example-notebook) * **Benchmarks:** [Tabular evaluation results and limitations](https://huggingface.co/blog/nvidia/kumo-tabular#performance) #### 🔄 Predict customer churn Estimate which customers are likely to stop buying so you can prioritize follow-up. The AdventureWorks notebook uses customer and order history to predict whether an active customer will place no orders in the next 90 days. You will build a graph from four related tables, describe churn in a predictive query, and inspect the predicted outcome and its probabilities without training a task-specific model. Before running, install the client and prepare a compatible NIM endpoint and the AdventureWorks data files. * **Model:** [Kumo Relational](https://huggingface.co/nvidia/Kumo-Relational) * **Setup:** [Connect Kumo Relational Client to NIM](/kumo-relational/get-started/sdk-getting-started) * **Example:** [Open the AdventureWorks notebook](/kumo-relational/user-guide/examples-and-notebooks/notebooks) and follow “Predict customer churn.” #### 🛍️ Recommend products a customer may buy Use purchase history and the relationships between customers, orders, and products to suggest what a customer may buy next. The AdventureWorks notebook requests the top 10 products a customer is likely to order in the next 30 days. You will learn how to express a recommendation task in a predictive query and read the ranked product IDs and scores returned by Kumo Relational. Before running, install the client and prepare a compatible NIM endpoint and the AdventureWorks data files. * **Model:** [Kumo Relational](https://huggingface.co/nvidia/Kumo-Relational) * **Setup:** [Connect Kumo Relational Client to NIM](/kumo-relational/get-started/sdk-getting-started) * **Example:** [Open the AdventureWorks notebook](/kumo-relational/user-guide/examples-and-notebooks/notebooks) and follow “Recommend products.” #### 📈 Forecast future readings from a time series Predict future values from a history of timestamped measurements. The Kumo Forecast example reads an ETTh sample CSV and predicts the next 100 values of its LULL signal. Install the Forecast environment and provide the CSV files expected by the script, or update the paths and columns for your own data. Context-enhanced forecasting requires a separate history CSV. Kumo Forecast is intended for research and development only. * **Model:** [Kumo Forecast](https://huggingface.co/nvidia/Kumo-Forecast) * **Library:** [Kumo-TS Forecast setup and guide](https://github.com/NVIDIA/Kumo-TS/blob/main/Kumo-Forecast/README.md) * **Example:** [Open the forecasting code](https://github.com/NVIDIA/Kumo-TS/blob/main/Kumo-Forecast/sdk/quick_example.py) #### 🔎 Spot unusual sensor readings Find readings that depart from the usual patterns across a set of sensors. The Kumo Anomaly example generates synthetic sensor data with spikes, dips, shifts, and noise, then returns anomaly flags and error scores. Install the Anomaly environment and allow model-weight downloads or supply local weights. Confirm that inference produced the Anomaly flags and MAE scores; a dataset preview alone does not confirm prediction. Kumo Anomaly is intended for research and development only. * **Model:** [Kumo Anomaly](https://huggingface.co/nvidia/Kumo-Anomaly) * **Library:** [Kumo-TS Anomaly setup and guide](https://github.com/NVIDIA/Kumo-TS/blob/main/Kumo-Anomaly/README.md) * **Example:** [Open the anomaly-detection code](https://github.com/NVIDIA/Kumo-TS/blob/main/Kumo-Anomaly/examples/quick_example.py) #### 🛠️ Train a model to predict repeat purchases Build a model for a prediction task you define on your own relational data. This Kumo Engine guide uses AdventureWorks to predict whether active customers will order again in the next 90 days. You will prepare the tables and graph, train and evaluate the model, then save it with its training metrics and predictions for later use. Before running, configure the documented GPU environment and writable local scratch, then download and prepare the AdventureWorks data. * **Tool:** [Kumo Engine](/kumo-engine/get-started-with-kumo-engine/overview) * **Training:** [Define and train a task-specific model](/kumo-engine/user-code-guide/train-a-model/training) * **Guide and code:** [Predict a yes or no outcome on Linux](/kumo-engine/user-code-guide/code-examples/linux-deployment/binary-classification) ## Continue Building ### Integrate with APIs [Structured Data Models model API](https://nvidia.github.io/structured-data-models/api/models.html) · [Relational Client Python API](/kumo-relational/reference/python-api-reference) · [Relational NIM REST API](/kumo-relational/reference/nim-rest-api) ### Deploy and manage execution [Kumo Engine deployment options](/kumo-engine/get-started-with-kumo-engine/available-deployment-options) · [Relational NIM deployment and connection](/kumo-relational/get-started/sdk-getting-started) ### Check compatibility and resolve issues For SDM import, model download, device, or input errors, start with [SDM Troubleshooting](/structured-data-models/troubleshooting). For setup requirements, follow [SDM environment setup](/structured-data-models/user-guide#1-set-up-your-environment), [Kumo Relational Client setup](/kumo-relational/get-started/sdk-getting-started), [Kumo Engine prerequisites](/kumo-engine/get-started-with-kumo-engine/prerequisites), or [Kumo-TS package requirements](https://github.com/NVIDIA/Kumo-TS). For prediction issues, check the input schema and expected outputs in your selected example. ### Understand the concepts and architecture [Core Concepts](/about-nvidia-kumo/core-concepts) · [Workflow Overview](/about-nvidia-kumo/architecture)