> 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.

# Workflow Overview

> Understand where data preparation and model execution happen, how context reaches NIM, and what to retain when reusing a Kumo Engine model.

Follow the data from preparation to prediction in three workflows: direct Python inference, task-specific training with Kumo Engine, and Relational inference through NIM. For Forecast and Anomaly, see the separate [Kumo-TS workflow](/about-nvidia-kumo/overview#workflow-kumo-ts).

## Prediction Workflows

The branches below are alternative execution paths. NIM is the deployed NVIDIA Inference Microservice that hosts the Relational model.

```mermaid
%%{init: {"flowchart": {"nodeSpacing": 36, "rankSpacing": 44, "padding": 20}, "themeVariables": {"fontSize": "16px", "fontFamily": "NVIDIA, sans-serif"}}}%%
flowchart TB
    accTitle: Three paths from structured data to prediction outputs
    accDescr: Structured data is prepared for Structured Data Models, Kumo Engine, or Structured Data Models Client. Structured Data Models runs pretrained inference in Python, Kumo Engine scores with a trained or loaded model, and Structured Data Models Client requests inference from a deployed NIM. Each path produces prediction outputs in its own format.
    D["<b>Structured data</b>"]
    D --> S["<b>Structured Data<br />Models</b><br />Typed tensors<br />Model-specific context"]
    S --> F["Pretrained model<br />Inference in Python"]
    F ---> O["<b>Use predictions</b><br />Analyze results or integrate<br />them into applications"]
    D --> E["<b>Kumo Engine</b><br />Graph snapshot<br />Task rows"]
    E --> T["Train or load<br />a compatible fitted model"]
    T --> P["Score with<br />the fitted model"]
    P --> O
    D --> C["<b>Structured Data<br />Models Client</b><br />Relational graph<br />Sampled context"]
    C --> N["Deployed NIM<br />HTTP inference"]
    N ---> O
    classDef neutral fill:transparent,stroke:#898989,stroke-width:1px;
    classDef sdm fill:transparent,stroke:#76B900,stroke-width:3px;
    classDef engine fill:transparent,stroke:#008AF9,stroke-width:3px;
    classDef client fill:transparent,stroke:#A846DB,stroke-width:3px;
    classDef output fill:#76B900,stroke:#76B900,stroke-width:2px,color:#0B0B0B;
    class D,F,T,P,N neutral;
    class S sdm;
    class E engine;
    class C client;
    class O output;
```

Scroll horizontally to view all three paths.

## Where Execution Happens

### Structured Data Models

Prepare typed tables, labeled context, and query rows, then pass them to a pretrained model running in your Python process. For relational inference, include the related tables the model needs. The selected model and workload determine device and memory requirements; check the [installation guide](https://nvidia.github.io/structured-data-models/install.html).

### Kumo Engine

Kumo Engine reads source tables and materializes a graph snapshot into a local index used for training and scoring. Source data can reside in a warehouse or object store; the graph index still needs [local working storage](/kumo-engine/get-started-with-kumo-engine/prerequisites#local-storage) on the compute running Kumo Engine.

A saved model bundle does not include source data, the graph index, or prediction outputs. To score in a later session, load the model and provide a compatible snapshot; [retain the model and other artifacts separately](/kumo-engine/user-code-guide/train-a-model/publish-and-retrieve-models).

### Structured Data Models Client

The Structured Data Models Client tab documents [Kumo Relational Client](/client/overview) (`kumo-relational-client`). It builds a graph from connected tables and samples relevant records. It sends the prepared prediction context to a compatible Kumo Relational NIM endpoint, where the model runs, and returns the predictions to your application.

The client connects to an existing NIM deployment and does not require a GPU on the client host. The NIM deployment requires GPU compute. See [Client and NIM setup](/kumo-relational/get-started/sdk-getting-started) for installation and connection instructions, and [client platform requirements](https://github.com/kumo-ai/kumo-relational-client#requirements) for supported environments.

## Next Steps

Continue with the setup and task guides for your path:

* [Install Structured Data Models and run inference](/structured-data-models/user-guide).
* [Choose a Kumo Engine deployment environment](/kumo-engine/get-started-with-kumo-engine/available-deployment-options). Use [GPU Sizing](/kumo-engine/get-started-with-kumo-engine/gpu-sizing) to plan compute and scratch capacity.
* [Run the Kumo Relational Client quickstart](/kumo-relational/get-started/rfm).