> ## Documentation Index
> Fetch the complete documentation index at: https://docs.hollerith.monarcha.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ

> Commonly asked questions

Questions asked before you start. If something already broke,
[Troubleshooting](/help/troubleshooting) is the page for the symptom.

## What Hollerith is

### How is this different from a large language model?

Hollerith reads a table the way a language model reads a prompt. That is where the
resemblance ends.

It has no world knowledge to fall back on. Everything in an answer comes from the table you
handed it, and `x7` and `days_since_last_login` are the same column to it.

### Does it handle time series?

Yes, through `forecast`, which is in Beta. Row-wise `predict` has no notion of time, so a
time-indexed target belongs in [Forecast](/guides/forecasting), which never uses a fitted
context.

## Getting set up

### Do I need a GPU?

No. Inference runs on our GPUs and you reach it over HTTPS. The SDK depends on `httpx`,
`numpy` and `pandas` only, so nothing on your machine ever loads a model.

### What Python version, and what dependencies?

```sh theme={null}
pip install https://hollerith.monarcha.ai/sdk/hollerith-<version>-py3-none-any.whl
```

Python 3.11 or 3.12 — the wheel declares `>=3.11,<3.13` — and three dependencies:
`httpx>=0.27`, `numpy>=1.26`, `pandas>=2.2`. Hollerith is not on PyPI; the wheel comes from
your own deployment, and the console Quickstart tab has the URL.

### Can I use this from a language other than Python?

Yes, over REST. Python is the only SDK, but every operation is an HTTPS call — see
[REST API](/reference/rest-api). One gap: `quantiles`, `predictionLength` and `future` are
not request fields, so REST cannot ask for intervals.

### Can I run it in my own infrastructure?

No. Self-hosted and in-VPC deployment are not built, and neither are customer-managed
encryption keys. What we do with your rows is in [Data handling](/account/data-handling).

## Your data

### Does my data train the model?

No. No gradient update ever runs on anything you send; nothing you upload changes a
weight. Your table is read as context while the job runs, then purged when the job ends.

### What happens to text columns, and to dates?

Both are accepted, and both are ordinal-encoded. The model sees which rows share a value, not
what the value means or how the values order.

```python theme={null}
df["days_since_signup"] = (today - df["signup_date"]).dt.days
```

A `signup_date` tells it which customers signed up on the same day, not which came first.
Replace it with a number wherever ordering matters.

### Do I need to encode categoricals or impute missing values first?

No, and you should not. String columns are read as labels; missing values are read as
missing, which is information. An imputed median tells the model a value was observed when it
was not.

## How big your table has to be

### How many rows do I need? Is there a minimum?

There is no minimum. `fit` needs one labeled row and one feature column beside the target;
`evaluate` needs two rows to split. The iris sample is 150 rows and returns
`Evaluation(accuracy=0.9733, method=kfold, folds=5, rows=150)`.

### How large can a table get before I have to split it?

1,000,000 training rows, 2,000 columns and 100,000,000 cells; a table sits under all three.
`predict` scores at most 200,000 rows per call, so a million rows to score is five calls.
Breaching a ceiling raises `dataset_too_large` — [Limits](/reference/limits) has the rest.

## Calling it

### Is prediction deterministic?

Yes, holding the engine fixed. Nothing samples at prediction time and the engine's seed is
pinned, so the same rows scored against the same fitted context return the same predictions.

Two things move an answer: a new `fit`, which creates a new context, and a new engine
version. Store `handle.job.engine_version` beside any result you may have to explain.

### How long does a fit take?

Seconds to minutes, scaling with how much table the model reads. One recorded benchmark, a
`fit` of 1,000,000 rows × 30 columns, took 307.9 seconds.

That was measured on a GPU tier other than the live one — the shape of the curve, not a
number to plan against.

### What does it cost to score a million rows?

A context-backed `predict` bills its rows twice, so 1,000,000 scored rows is 2,000,000
billable rows. On Cloud that is 1,000,000 rows past the included allowance: $300 in the
first band, on top of the $500 base. That also spends the whole daily input-row quota —
[Usage and billing](/account/usage-and-billing) has the rest.

## Fitted contexts

### Can I keep a fitted context longer than 7 days?

No. A context lives 7 days from the `fit` that created it, predicting against it does not
extend the clock, and there is no renewal.

After that a predict raises `fitted_context_expired`, and the fix is to fit again.
[Running Hollerith in production](/guides/production) shows the recovery in code.

### Can I delete a fitted context?

No. There is no delete endpoint; a context goes when its 7 days lapse, not on request. The
rows behind it are already gone, purged when the fit reached a terminal state.

## Next

* [Quickstart](/quickstart) — install, key, and a first prediction
* [How Hollerith works](/concepts/how-hollerith-works) — why there is no training step
* [The model](/reference/model) — where it wins, and where it does not
* [Limits and quotas](/reference/limits) — every ceiling and the error you get at it
* [Troubleshooting](/help/troubleshooting) — a symptom, its cause, and the fix