> ## Documentation Index
> Fetch the complete documentation index at: https://pioneer-kelton-add-decoder-inference-prices.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Fine-tune Nemotron 3.5 Lightning on Pioneer

> LoRA fine-tune Nemotron 3.5 Lightning on Pioneer with supervised fine-tuning via one training endpoint — from dataset prep to a deployed decoder model.

Pioneer supports parameter-efficient (LoRA) post-training on the Nemotron 3.5 Lightning family. You bring your training data, choose the general, finance, or healthcare target, and Pioneer handles the infrastructure, routing, and serving. The result is a fine-tuned adapter you can call over the same API, with no GPU management required.

New decoder training jobs use supervised fine-tuning (SFT) through the [`POST /felix/training-jobs`](/api-reference/training-jobs) endpoint.

## Training method

SFT trains the model to imitate the assistant turns in your examples. Supply
chat-format `messages` with the user instruction and desired assistant response.

<Note>
  Decoder SFT is **LoRA-based**. A completed job produces a low-rank adapter
  that is hot-swapped onto the shared base model at serve time and exposed
  behind the same inference endpoints as base models — reference the training
  job's `id` as the `model_id` at inference time. `training_type` defaults to
  `"lora"` and is the only supported value for decoder LLMs; `"full"` is
  reserved for [GLiNER encoder models](/guides/fine-tune-ner).
</Note>

## End-to-end walkthrough

<Steps>
  <Step title="Choose a decoder base model">
    Use `GET /base-models` to see the full current catalog, filtered to models that support training:

    <CodeGroup>
      ```bash cURL theme={null}
      curl "https://api.pioneer.ai/base-models?task_type=decoder&supports_training=true" \
        -H "X-API-Key: YOUR_API_KEY"
      ```
    </CodeGroup>

    The supported decoder targets are:

    | Model ID                                            | Label                                     | Context |
    | --------------------------------------------------- | ----------------------------------------- | ------- |
    | `nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16` | Nemotron 3.5 Lightning 30B-A3B            | 8K      |
    | `fastino/Fastino-Nemotron-3.5-Lightning-Finance`    | Fastino Nemotron 3.5 Lightning Finance    | 8K      |
    | `fastino/Fastino-Nemotron-3.5-Lightning-Healthcare` | Fastino Nemotron 3.5 Lightning Healthcare | 8K      |

    Use the general Lightning target unless your data is specifically finance or
    healthcare. These targets have an 8K qualified context window, so split or
    truncate longer examples before training.

    All listed decoder targets support LoRA SFT.
  </Step>

  <Step title="Prepare your training data">
    Format each example as a chat conversation with an assistant response:

    ```bash theme={null}
    # Each row: {"messages": [{"role": "user" | "assistant" | "system", "content": "..."}]}
    # Generate synthetically:
    curl -X POST https://api.pioneer.ai/generate \
      -H "X-API-Key: YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "task_type": "decoder",
        "dataset_name": "my-sft-dataset",
        "num_examples": 200,
        "domain_description": "Customer support for a SaaS product"
      }'
    ```

    See the [Synthetic Data guide](/guides/synthetic-data) for the full set of `/generate` options, including auto-labelling existing text. Once generated or uploaded, wait until the dataset status is `ready` before starting training.
  </Step>

  <Step title="Start a training job">
    Submit your SFT job with `POST /felix/training-jobs`:

    ```bash theme={null}
    curl -X POST https://api.pioneer.ai/felix/training-jobs \
      -H "X-API-Key: YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d '{
        "model_name": "my-sft-model",
        "base_model": "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16",
        "training_type": "lora",
        "datasets": [{"name": "my-sft-dataset", "version": "1"}],
        "lora_r": 16,
        "lora_alpha": 32,
        "learning_rate": 2e-5,
        "nr_epochs": 3
      }'
    ```

    Pioneer routes your job automatically to the best available provider. The response includes your job ID:

    ```json theme={null}
    { "id": "uuid-of-training-job", "status": "requested" }
    ```
  </Step>

  <Step title="Poll until training is complete">
    Check job status by polling `GET /felix/training-jobs/:id`.

    <CodeGroup>
      ```bash cURL theme={null}
      curl https://api.pioneer.ai/felix/training-jobs/YOUR_JOB_ID \
        -H "X-API-Key: YOUR_API_KEY"
      ```
    </CodeGroup>

    Status transitions: `requested` → `running` → `complete` → `deployed` (or `failed` / `stopped`). The terminal success state is `deployed`, reached automatically once the adapter is live behind the inference endpoints.

    You can also stream training logs while the job is running:

    <CodeGroup>
      ```bash cURL theme={null}
      curl https://api.pioneer.ai/felix/training-jobs/YOUR_JOB_ID/logs \
        -H "X-API-Key: YOUR_API_KEY"
      ```
    </CodeGroup>
  </Step>

  <Step title="Run inference on your fine-tuned model">
    Once the job status is `deployed`, use your job ID as the `model_id` (or `model`) on any of the three inference interfaces.

    **Pioneer native API** — use `"task": "generate"` for decoder models:

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X POST https://api.pioneer.ai/inference \
        -H "X-API-Key: YOUR_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "model_id": "YOUR_JOB_ID",
          "task": "generate",
          "messages": [{"role": "user", "content": "Summarize this article: ..."}]
        }'
      ```
    </CodeGroup>

    **OpenAI-compatible endpoint** — drop-in replacement for the OpenAI SDK:

    <CodeGroup>
      ```python Python (OpenAI SDK) theme={null}
      from openai import OpenAI

      client = OpenAI(
          api_key="YOUR_API_KEY",
          base_url="https://api.pioneer.ai/v1"
      )

      response = client.chat.completions.create(
          model="YOUR_JOB_ID",
          messages=[{"role": "user", "content": "Summarize this article: ..."}]
      )
      print(response.choices[0].message.content)
      ```

      ```bash cURL (OpenAI-compatible) theme={null}
      curl -X POST https://api.pioneer.ai/v1/chat/completions \
        -H "X-API-Key: YOUR_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "model": "YOUR_JOB_ID",
          "messages": [{"role": "user", "content": "Summarize this article: ..."}]
        }'
      ```
    </CodeGroup>

    **Anthropic-compatible endpoint:**

    <CodeGroup>
      ```bash cURL (Anthropic-compatible) theme={null}
      curl -X POST https://api.pioneer.ai/v1/messages \
        -H "X-API-Key: YOUR_API_KEY" \
        -H "Content-Type: application/json" \
        -d '{
          "model": "YOUR_JOB_ID",
          "max_tokens": 1024,
          "messages": [{"role": "user", "content": "Summarize this article: ..."}]
        }'
      ```
    </CodeGroup>

    Streaming is supported on all three interfaces.
  </Step>
</Steps>

<Note>
  Downloading your trained model weights is available on the Pro plan and above. Use `GET /felix/training-jobs/:id/download` to retrieve the weights once training is complete.
</Note>

## LoRA hyperparameters

LoRA capacity and the core optimization settings are configurable; the defaults are sensible starting points for SFT.

| Field                        | Default | Purpose                                                                     |
| ---------------------------- | ------- | --------------------------------------------------------------------------- |
| `lora_r`                     | `16`    | LoRA rank — adapter capacity. Raise it for harder tasks or larger datasets. |
| `lora_alpha`                 | `32`    | LoRA scaling factor (typically \~2× `lora_r`).                              |
| `lora_dropout`               | `0.1`   | Dropout applied to the adapter during training.                             |
| `learning_rate`              | `2e-5`  | Peak AdamW learning rate.                                                   |
| `batch_size`                 | `4`     | Per-step batch size.                                                        |
| `nr_epochs`                  | `100`   | Epoch ceiling; early stopping usually halts well before this.               |
| `validation_data_percentage` | `0.2`   | Fraction of the dataset held out for validation.                            |

## Supported models

The only decoder training targets are:

| Base model                                          | Intended domain                  |
| --------------------------------------------------- | -------------------------------- |
| `nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16` | General-purpose decoder training |
| `fastino/Fastino-Nemotron-3.5-Lightning-Finance`    | Finance                          |
| `fastino/Fastino-Nemotron-3.5-Lightning-Healthcare` | Healthcare                       |

GLiNER2 Base, Large, Multi, and Multi Large encoder targets are also supported
through the same endpoint. See the encoder
fine-tuning guides for [NER](/guides/fine-tune-ner),
[classification](/guides/fine-tune-classification), and
[structured extraction](/guides/fine-tune-extraction).

Use `GET /base-models?supports_training=true` immediately before submitting a
job. It is the live source of truth for the training targets and algorithms
available to your workspace.

## Serverless inference for base models

If you want to run inference on a base model without fine-tuning, use one of
the supported inference families:

| Model ID                                            | Label                          | Context          |
| --------------------------------------------------- | ------------------------------ | ---------------- |
| `nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16` | Nemotron 3.5 Lightning 30B-A3B | 8K               |
| `deepseek-ai/DeepSeek-V4-Flash`                     | DeepSeek V4 Flash              | See live catalog |
| `zai-org/GLM-5.2`                                   | GLM 5.2                        | See live catalog |
| `claude-opus-5`                                     | Claude Opus 5                  | See live catalog |
| `claude-sonnet-5`                                   | Claude Sonnet 5                | See live catalog |
| `claude-haiku-4-5`                                  | Claude Haiku 4.5               | See live catalog |
| `gpt-5.5`                                           | GPT-5.5                        | See live catalog |
| `gpt-5.6-terra`                                     | GPT-5.6 Terra                  | See live catalog |

Use `GET /base-models?task_type=decoder&supports_inference=true` to see the current serverless catalog.

## Next steps

* [Synthetic Data](/guides/synthetic-data) — generate training data without manual annotation
* [Adaptive Inference](/guides/adaptive-inference) — automatically retrain on live production data
* [Agent Skills](/guides/agent-skills) — let an AI coding agent manage training and inference for you
* [Training Jobs API](/api-reference/training-jobs) — every endpoint, parameter, and response field