Nori Quickstart - Synthefy Docs

Synthefy Nori (Tabular) predicts continuous values from tabular data. You give it some labeled rows as examples, and it predicts on new rows — no training, no fine-tuning required. GitHub · 🤗 Hugging Face There are two ways to use it:

Run locally

Install the Python package and run inference on your own machine or server.

Call the API

Send a request to our hosted endpoint. No setup, no GPU required.

Local

Install the open-source package:

pip install synthefy-nori

Model weights download automatically from Hugging Face on first use — no API key needed. It uses a GPU when one is available and falls back to CPU. This is the ~6M base by default; pass model="nori-30m" for the larger variant (see Models).

Your first prediction

NoriRegressor is a scikit-learn–style estimator: fit stores your labeled rows as context (there is no training step) and predict returns one value per query row in a single forward pass.

from synthefy_nori import NoriRegressor

X_train = [[0.0, 1.0], [1.0, 0.0], [0.5, 0.5], [0.2, 0.8]]
y_train = [0.1, 0.9, 0.5, 0.3]
X_test  = [[0.3, 0.7], [0.8, 0.2]]

model = NoriRegressor(model="nori")
model.fit(X_train, y_train)
print(model.predict(X_test))

[0.36, 0.74]

Want one code path that runs locally or against the hosted API? Use the synthefy client’s SynthefyNoriClient(mode="auto") (see the API section) — it runs locally when synthefy-nori is installed and falls back to the hosted endpoint otherwise.

With a DataFrame

import pandas as pd
from synthefy_nori import NoriRegressor

df = pd.read_csv("data.csv")
target_col = "price"
feature_cols = [c for c in df.columns if c != target_col]

train = df.sample(frac=0.8, random_state=42)
test  = df.drop(train.index)

model = NoriRegressor(model="nori").fit(train[feature_cols].values, train[target_col].values)
predictions = model.predict(test[feature_cols].values)

Prediction intervals

Nori returns a full predictive distribution, so you get uncertainty for free — pass output_type="quantiles":

q10, q50, q90 = model.predict(X_test, output_type="quantiles", quantiles=[0.1, 0.5, 0.9])

Handle missing values

You don’t need to fill in missing values beforehand — the model handles them natively.

import numpy as np
from synthefy_nori import NoriRegressor

X_train = [[0.0, 1.0], [1.0, np.nan], [0.5, 0.5], [np.nan, 0.8]]
y_train = [0.1, 0.9, 0.5, 0.3]
X_test  = [[0.3, 0.7], [0.8, np.nan]]

model = NoriRegressor(model="nori").fit(X_train, y_train)
print(model.predict(X_test))

[0.37, 0.69]

API

The hosted API runs the same model on our infrastructure — no installation or GPU required. Set up your API key in the API key guide. Install the client:

pip install synthefy

Make a request

Send your labeled rows (X_train, y_train) and the rows you want to predict (X_test) in a single call:

import os
from synthefy import SynthefyNoriClient

client = SynthefyNoriClient(
    api_key=os.environ["SYNTHEFY_NORI_API_KEY"],
    mode="remote",
    model="synthefy/nori",  # the model slug; this is also the default
)

X_train = [[0.0, 1.0], [1.0, 0.0], [0.5, 0.5], [0.2, 0.8]]
y_train = [0.1, 0.9, 0.5, 0.3]
X_test  = [[0.3, 0.7], [0.8, 0.2]]

predictions = client.predict(X_train, y_train, X_test)
print(predictions)

curl -X POST https://inference.baseten.co/predict \
  -H "Authorization: Bearer $SYNTHEFY_NORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "synthefy/nori",
    "task": "regression",
    "X_train": [[0.0, 1.0], [1.0, 0.0], [0.5, 0.5], [0.2, 0.8]],
    "y_train": [0.1, 0.9, 0.5, 0.3],
    "X_test":  [[0.3, 0.7], [0.8, 0.2]]
  }'

The cURL example posts to the generic, slug-routed inference endpoint and authenticates with a Baseten API key (Bearer scheme). Request body

Field	Required	Description
`model`	Required	The model slug — `synthefy/nori` (base) or `synthefy/nori-30m`. Routes the request to the model — omitting it returns a `400`.
`task`	Optional	`"regression"` or `"reg"`; defaults to `"regression"`. This is a regression-only deployment.
`X_train`	Required	Context feature matrix, `n_context × n_features` (array of arrays of numbers).
`y_train`	Required	Context targets, aligned 1:1 with `X_train` rows (array of numbers).
`X_test`	Required	Query feature matrix, `n_query × n_features` (array of arrays of numbers).

null/NaN cells are allowed in X_train and X_test and are imputed server-side.

Request size limit

A single request is capped at 100 MB. Larger requests are rejected with HTTP 413 Request Entity Too Large.

The limit applies to the whole request, i.e. all of X_train, y_train, and X_test together. Since size grows with rows × features, you only approach 100 MB with very large inputs (on the order of millions of values). If you hit the limit, send fewer example rows, use fewer features, or split X_test into smaller batches. You can reuse the same X_train/y_train across those calls.

Response

The client returns one value per row in X_test as a plain list:

[0.36, 0.74]

The underlying HTTP endpoint (used by the cURL example) returns the full envelope on a 200 (values illustrative):

{
  "task": "regression",
  "predictions": [0.3861955995072203, 0.7150392187985302],
  "usage": {
    "prompt_tokens": 4,
    "completion_tokens": 3,
    "total_tokens": 7
  }
}

Read predictions — one value per X_test row, in order. The response also includes a usage block (token counts) for API compatibility; it isn’t meaningful for a tabular model, so you can ignore it. (The Python client returns just the predictions list.)

The first request after a scale-to-zero idle triggers a checkpoint download and warmup and can take ~60–90 seconds. Warm requests return in ~1–2 seconds.

Models

Nori comes in two sizes. Select one with the model parameter — a friendly name works everywhere (client and package, local and remote):

Model	Params	`model=` name	API slug	Notes
Nori	~6M	`"nori"` / `"nori-6m"`	`synthefy/nori`	General-purpose tabular in-context regression. The default.
Nori-30M	~29M	`"nori-30m"`	`synthefy/nori-30m`	Larger scaling-law variant.

# Hosted API — the friendly name selects the deployment
client = SynthefyNoriClient(
    api_key=os.environ["SYNTHEFY_NORI_API_KEY"],
    mode="remote",
    model="nori-30m",
)

# Local / package — the same name also selects which checkpoint to download
from synthefy_nori import NoriRegressor
model = NoriRegressor(model="nori-30m")

model defaults to the ~6M base ("nori"). In local mode the selector now picks the checkpoint too (downloaded from Hugging Face on first use). The raw API slug (e.g. synthefy/nori) is also accepted by the client, and it’s what the cURL endpoint expects in the model field.

Resources

API key

Set up your API key to call the hosted Nori API.

Product page

Learn more about Synthefy Nori (Tabular).

GitHub

Source code for training, inference, and evaluation.

Hugging Face

Pretrained model weights.

Run locally

Call the API

​Local

​Your first prediction

​With a DataFrame

​Prediction intervals

​Handle missing values

​API

​Make a request

​Request size limit

​Response

​Models

​Resources

API key

Product page

GitHub

Hugging Face

Local

Your first prediction

With a DataFrame

Prediction intervals

Handle missing values

API

Make a request

Request size limit

Response

Models

Resources