Quickstart

Nori 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, and no API key is needed. It uses a GPU when one is available and falls back to CPU. Always name a size — "nori-100m", "nori-30m", or "nori-6m". Omitting model= raises instead of silently selecting a 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-30m")
model.fit(X_train, y_train)
print(model.predict(X_test))

[0.37, 0.72]

Want one code path for local and hosted execution? Use SynthefyNoriClient and choose mode="local" or mode="remote" deliberately. It never switches backends because a package or credential happens to be present. See the Python Client guide.

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-30m").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-30m").fit(X_train, y_train)
print(model.predict(X_test))

[0.38, 0.71]

API

The hosted API runs the same model on our infrastructure, so no installation or GPU is required. Set up your API key in the API key guide. From Python, use the synthefy client. The same call works in either place: mode="remote" sends your rows to the hosted endpoint, while mode="local" runs the model on your machine. The client never selects a mode automatically.

Make a request

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

# pip install synthefy — see /nori/client for the full client guide
import os
from synthefy import SynthefyNoriClient

client = SynthefyNoriClient(
    api_key=os.environ["SYNTHEFY_NORI_API_KEY"],
    mode="remote",
    model="synthefy/nori-30m",
)

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

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

curl -X POST https://inference.baseten.co/predict \
  -H "Authorization: Bearer $SYNTHEFY_NORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "synthefy/nori-30m",
    "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 your Synthefy Nori API key (Bearer scheme). Request body

Field	Required	Description
`model`	Required	The model slug: `synthefy/nori-6m` (~6M base), `synthefy/nori-30m` (~29.2M), or `synthefy/nori-30m-thinking-medium`. Routes the request to the model; omitting it returns a `400`. See Models.
`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 64 MiB (about 67 MB). Larger requests are rejected with HTTP 413 Request Entity Too Large, before the model sees them.

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 it 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.37, 0.72]

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": 2,
    "total_tokens": 6
  }
}

Read predictions, one value per X_test row, in order. The response also includes the request dimensions used for metering and billing inside an OpenAI-compatible usage object: prompt_tokens is the number of context rows, and completion_tokens is the number of feature columns. The Python client returns only the predictions list.

The first request after a scale-to-zero idle starts a replica, loads the baked checkpoint, and warms the model; it can take ~60–90 seconds. Warm requests return in ~1–2 seconds.

Models

Select a model with the model parameter. Nori, Nori-30M and Nori-100M run locally or on the hosted API, and their names work in both the Python client (SynthefyNoriClient) and the synthefy-nori package (NoriRegressor). Nori Thinking is hosted-API only.

Model	Params	`model=` name	Hosted-API id	Availability
Nori (base)	~6M	`"nori-6m"`	`synthefy/nori-6m`	Local + API
Nori-30M	~29.2M	`"nori-30m"`	`synthefy/nori-30m`	Local + API
Nori-100M	~98.3M	`"nori-100m"`	`synthefy/nori-100m`	Local + API
Nori Thinking	~29.2M	`"nori-30m-thinking"` / `"nori-30m-thinking-medium"`	`synthefy/nori-30m-thinking-medium`	API only

model= name — what you pass to SynthefyNoriClient(model=…) or NoriRegressor(model=…).
Hosted-API id — the value in the request body’s model field on the raw HTTP endpoint (what the cURL example sends). The client fills it in for you from the friendly name; local inference doesn’t use it.
Availability — Local + API runs on your machine (weights download from Hugging Face on first use) or on the hosted endpoint. API only runs on the hosted endpoint only.

Nori-100M is the largest Nori. Its checkpoint is Synthefy/Nori-100M (42 layers, embed_dim 352, 8 heads). Run it locally with NoriRegressor(model="nori-100m"), which pulls the weights from Hugging Face on first use, or on the hosted API with model="nori-100m". It carries ~3× the parameters of Nori-30M, so expect a larger download and more GPU memory per call — see Large Tables if you run out.

Nori Thinking is hosted-API only. It spends extra test-time compute to lift accuracy, is slower and premium-priced, and has no downloadable checkpoint. Only the medium budget is available today; both "nori-30m-thinking" and "nori-30m-thinking-medium" route to it. Selecting Thinking for local inference (SynthefyNoriClient(mode="local", …) or NoriRegressor(model="nori-30m-thinking-medium")) raises an error pointing you at the hosted API. Use mode="remote".

The current, authoritative list of models your key can call (and their limits) is returned live by GET /forecasting-api/nori/available-models, and shown per model in the console.

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

# Local / package — the selector picks which checkpoint to download
from synthefy_nori import NoriRegressor
model = NoriRegressor(model="nori-100m")  # 6m/30m/100m run locally; Thinking does not

Always name a size: "nori-6m", "nori-30m", or — for local inference — "nori-100m". Both the synthefy client and NoriRegressor require model= and raise a ValueError if you omit it — there is no default, so no request silently runs on a size you did not choose. In local mode the selector picks the checkpoint (downloaded from Hugging Face on first use). The raw Hosted-API slug (e.g. synthefy/nori-30m) is also accepted by the client and is what the cURL endpoint expects in the model field.

Next steps

Python Client

Auth, retries, DataFrames and text columns, handled for you.

Examples

End-to-end worked examples on real datasets.

Missing Values & Imputation

Pass NaNs straight through, with no pre-filling required.

Explainability

SHAP values, feature interactions, and partial dependence.

Run it in your cloud

Deploy on Amazon SageMaker, or call Nori from Snowflake SQL.

Product page

Learn more about Synthefy Nori (Tabular).

Get Started

Guides

Integration

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

Next steps

Python Client

Examples

Missing Values & Imputation

Explainability

Run it in your cloud

Product page

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

​Next steps

Python Client

Examples

Missing Values & Imputation

Explainability

Run it in your cloud

Product page

Local

Your first prediction

With a DataFrame

Prediction intervals

Handle missing values

API

Make a request

Request size limit

Response

Models

Next steps