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

# Quickstart

> Get started in minutes

Hollerith predicts missing values in tables. You hand it a labeled table, it reads that table
at prediction time. There is no training step and nothing to tune.

<Steps titleSize="h2">
  <Step title="Install the SDK">
    Hollerith is a private SDK. It is not on PyPI, and `pip install hollerith` will not work.
    During the closed beta it ships as a pre-built wheel served from your control plane. Your
    console's Quickstart tab shows the exact current URL.

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

    Set your API key. Create one on the API Keys page in the console — see [Authentication](/authentication).

    ```sh theme={null}
    export HOLLERITH_API_KEY="hk_live_YOUR_KEY_HERE"
    export HOLLERITH_BASE_URL="https://hollerith.monarcha.ai"
    ```

    Both are required. `HOLLERITH_BASE_URL` has no default — without it the client raises a
    `ValueError` before it ever reaches the API.

    Confirm the install:

    ```sh theme={null}
    python -c "import hollerith; print(hollerith.__version__)"
    ```

    ```
    0.1.2.dev157
    ```
  </Step>

  <Step title="Make your first prediction">
    This example uses the iris sample from the console: 150 rows, 4 columns, one labeled
    species column.

    ```python theme={null}
    from hollerith import Hollerith
    import pandas as pd

    df = pd.read_csv("iris.csv")
    split = df.pop("__hollerith_split")
    train = df[split == "train"]
    test = df[split == "test"]

    model = Hollerith()                          # reads HOLLERITH_API_KEY
    model.fit(train, target="species")        # no training — the table becomes the context
    preds = model.predict(test.drop(columns="species"))
    print(preds[:5])
    ```

    ```
    ['setosa', 'setosa', 'versicolor', 'virginica', 'setosa']
    ```

    `fit` uploads the table and returns a context to predict against. `predict` reads it.

    Download the CSV from the console's Quickstart tab, or run the same dataset there without
    writing any code.

    A console run uses your signed-in session, never an API key — the browser is never sent one.
    It takes the same validation, worker, metering and cleanup path as an SDK job, so it shows up
    under Usage and bills the same rows.
  </Step>

  <Step title="Measure the accuracy">
    A prediction is worth little without a number beside it. Pass `evaluate=True` to `fit` and
    Hollerith scores itself on held-out rows.

    ```python theme={null}
    model.fit(train, target="species", evaluate=True)
    print(model.evaluation_)
    ```

    ```
    Evaluation(accuracy=0.9733, method=kfold, folds=5, rows=150)
    ```

    One metric comes back: accuracy for classification, RMSE for regression. Compare it against
    whatever you are running today — [Evaluating accuracy](/guides/evaluating-accuracy) covers how
    to make that comparison fair.

    `evaluate=True` runs a second job and bills it separately.

    A score means nothing without a floor to compare it against. On a table where 90% of rows
    share one label, 0.90 is what guessing gets you — [Evaluating accuracy](/guides/evaluating-accuracy)
    covers how to set that floor before you read the number.
  </Step>
</Steps>

## What just happened

`fit` did not train anything. It sent your table to a context the model reads while
predicting, closer to handing someone a reference sheet than making them study for the exam.
That is why it takes seconds and why there is nothing to tune.

The context is reusable. Predict against it as many times as you need without fitting again.

<Steps titleSize="h2">
  <Step title="Swap in your own table" stepNumber={4}>
    Two lines change:

    ```python theme={null}
    df = pd.read_csv("your_data.csv")
    model.fit(train, target="your_label_column")
    ```

    Your table needs one row per thing you are predicting and one column holding the label.
    Categoricals and missing values are read directly, with no encoding and no imputation.

    Text and date columns are accepted, but read as categories — the model sees which rows share
    a value, not what the value means. The columns you predict on must match the columns you fit
    on.
  </Step>
</Steps>

## Predict a number

Same shape, numeric target. Hollerith reads the task from the target column.

```python theme={null}
model = Hollerith()
model.fit(train, target="quality", evaluate=True)
print(model.evaluation_)
```

```
Evaluation(RMSE=0.62, method=kfold, folds=5, rows=640)
```

A target of small whole numbers is read as classification unless you say otherwise. Pass
`task="regression"` when that is wrong.

## Next steps

* [Limits and quotas](/reference/limits) — how large a table can get, and how long a context lives
* [Evaluating accuracy](/guides/evaluating-accuracy) — what `evaluation_` reports, and how to compare fairly
* [Python SDK](/reference/python-sdk) — every argument `Hollerith()` takes
* [Preparing your table](/guides/preparing-your-table) — dtypes, targets, and the traps