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

> ## Agent Instructions
> Use https://docs.fastino.ai/llms.txt to discover and navigate pages. Use https://docs.fastino.ai/llms-full.txt when you need the complete documentation corpus. Use https://docs.fastino.ai/openapi.json as the source of truth for customer-facing routes. For GLiDE decision inference, call POST https://api.fastino.ai/v1/systemone with model fastino/GLiDE. Create managed config jobs with POST /v1/training/jobs using base_model. Both config and interactive jobs use /v1/training/jobs/{job_id} for their canonical REST lifecycle. For custom training loops, use the supported Tinker-compatible SDK client; its /v1/training/compat/tinker adapter is intentionally absent from OpenAPI and must not be called directly. Auto Train is private access and has no public route; direct interested users to sales@fastino.ai. Do not infer undocumented routes. Read API keys from FASTINO_API_KEY and never embed credentials in code, logs, or reports.

# Training API – Schnellstart

> Starten Sie einen verwalteten Trainingsjob oder einen anwendungsgesteuerten Trainingsloop und prüfen Sie anschließend seine kanonische Job-ID.

Dieser Schnellstart behandelt beide Wege der Training API. Verwenden Sie
verwaltetes Training, wenn Fastino den Loop ausführen soll. Verwenden Sie einen
benutzerdefinierten Trainingsloop, wenn Ihre Anwendung Sampling, Rewards und
Modellupdates steuern muss.

## 1. Authentifizieren

1. Erstellen Sie ein [Fastino-Konto](https://agent.fastino.ai/).
2. Öffnen Sie [API-Schlüssel](https://agent.fastino.ai/api-keys).
3. Erstellen Sie einen Schlüssel und kopieren Sie ihn, sobald er angezeigt wird.

Speichern Sie den Schlüssel in einer Umgebungsvariable:

<CodeGroup>
  ```bash macOS/Linux theme={null}
  export FASTINO_API_KEY="fast_sk_..."
  ```

  ```powershell Windows theme={null}
  $env:FASTINO_API_KEY = "fast_sk_..."
  ```
</CodeGroup>

Senden Sie diesen Schlüssel als `X-API-Key: $FASTINO_API_KEY`. Den vollständigen
Authentifizierungsvertrag finden Sie unter
[Authentifizierung](/de/authentication).

## 2. Weg auswählen

| Ziel | Weg |
| - | - |
| Daten und Konfiguration bereitstellen und Fastino das Training ausführen lassen | [Verwaltetes Training](#managed-training) |
| Sampling, Rewards und Updates in Ihrer Anwendung steuern | [Benutzerdefinierter Trainingsloop](#custom-training-loop) |

<span id="managed-training" />

## Verwaltetes Training

### 3. Datensatz vorbereiten

[Laden Sie einen Trainingsdatensatz hoch und verarbeiten Sie ihn](/de/concepts/datasets).
Warten Sie anschließend, bis seine Version den Status `ready` hat.

### 4. Modell auswählen

Fragen Sie vor der Übermittlung den Live-Katalog ab:

```bash theme={null}
curl "https://api.fastino.ai/v1/base-models?supports_training=true" \
  -H "X-API-Key: $FASTINO_API_KEY"
```

Speichern Sie die ID des ausgewählten Modells.

### 5. Job erstellen

```bash theme={null}
curl -X POST "https://api.fastino.ai/v1/training/jobs" \
  -H "X-API-Key: $FASTINO_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model_name": "my-trained-model",
    "base_model": "MODEL_ID_FROM_CATALOG",
    "datasets": [
      {"name": "my-ready-dataset", "version": "VERSION_NUMBER"}
    ],
    "training_type": "lora"
  }'
```

Speichern Sie die zurückgegebene `id`. Sie ist die `job_id`, die von jeder
jobspezifischen Route verwendet wird. Verwenden Sie denselben
`Idempotency-Key` nur dann erneut, wenn Sie exakt diesen Erstellungsrequest
wiederholen.

### 6. Job abfragen

```bash theme={null}
curl "https://api.fastino.ai/v1/training/jobs/JOB_ID" \
  -H "X-API-Key: $FASTINO_API_KEY"
```

Für Config-Jobs gilt:

* `status` ist der gespeicherte Lebenszykluswert, beispielsweise `errored`.
* `normalized_status` ist der stabile Polling-Wert, beispielsweise `failed`.
* `is_terminal_status` zeigt Ihrem Client an, wann er das Polling beenden soll.
* `error_message` beschreibt einen Fehler, sofern verfügbar.

Fragen Sie den Job weiter ab, bis `is_terminal_status` den Wert `true` hat.
Prüfen Sie anschließend den endgültigen Status, die Checkpoints, Logs und die
Eignung für die Bereitstellung.

<span id="custom-training-loop" />

## Benutzerdefinierter Trainingsloop

Benutzerdefinierte Trainingsloops erfordern Teamzugang und Python 3.11 oder
höher. Der unterstützte SDK-Client kommuniziert mit Fastinos verborgenem
HTTP-Kompatibilitätsadapter. Verwenden Sie die folgenden Client-Methoden.
Konstruieren Sie keine Adapter-Requests.

### 3. Getesteten Client installieren

<CodeGroup>
  ```bash uv theme={null}
  uv init fastino-training
  cd fastino-training
  uv add "tinker==0.33.1"
  ```

  ```bash pip theme={null}
  mkdir fastino-training && cd fastino-training
  python -m venv .venv
  source .venv/bin/activate
  pip install "tinker==0.33.1"
  ```

  ```powershell pip · Windows theme={null}
  mkdir fastino-training
  cd fastino-training
  py -m venv .venv
  .\.venv\Scripts\Activate.ps1
  pip install "tinker==0.33.1"
  ```
</CodeGroup>

### 4. Client konfigurieren

`TINKER_CREDENTIAL_CMD` wird bei jedem Token-Request ausgeführt und muss genau
eine nicht leere Anmeldeinformation ausgeben.

<CodeGroup>
  ```bash macOS/Linux theme={null}
  export TINKER_BASE_URL="https://api.fastino.ai/v1/training/compat/tinker"
  export TINKER_CREDENTIAL_CMD='printf "%s\n" "$FASTINO_API_KEY"'
  ```

  ```powershell Windows theme={null}
  $env:TINKER_BASE_URL = "https://api.fastino.ai/v1/training/compat/tinker"
  $env:TINKER_CREDENTIAL_CMD = 'powershell -NoProfile -Command "[Console]::Out.WriteLine($env:FASTINO_API_KEY)"'
  ```
</CodeGroup>

Verwenden Sie einen normalen Fastino-Schlüssel, der mit `fast_sk_` beginnt.
Anmeldedaten, die mit `tml-` beginnen, werden abgelehnt. Setzen Sie
`TINKER_API_KEY` nicht.

### 5. Aktiviertes Modell auswählen

Rufen Sie `ServiceClient.get_server_capabilities()` auf und wählen Sie aus der
Antwort ein Modell und einen LoRA-Rang:

<CodeGroup>
  ```bash macOS/Linux theme={null}
  export FASTINO_TRAINING_MODEL="<model from capabilities>"
  export FASTINO_TRAINING_LORA_RANK="<supported rank>"
  ```

  ```powershell Windows theme={null}
  $env:FASTINO_TRAINING_MODEL = "<model from capabilities>"
  $env:FASTINO_TRAINING_LORA_RANK = "<supported rank>"
  ```
</CodeGroup>

### 6. Job erstellen und sampeln

Erstellen Sie `quickstart.py`:

```python theme={null}
import os

import tinker


service_client = tinker.ServiceClient()
outcome = "errored"
try:
    capabilities = service_client.get_server_capabilities()
    print(capabilities)

    training_client = service_client.create_lora_training_client(
        base_model=os.environ["FASTINO_TRAINING_MODEL"],
        rank=int(os.environ["FASTINO_TRAINING_LORA_RANK"]),
    )

    job_id = training_client.get_info().model_data.model_id
    print(f"TRAINING_JOB_ID={job_id}")

    checkpoint = training_client.save_weights_for_sampler(
        "quickstart-sampler"
    ).result()
    sampling_client = service_client.create_sampling_client(
        model_path=checkpoint.path
    )

    tokenizer = sampling_client.get_tokenizer()
    prompt_tokens = tokenizer.apply_chat_template(
        conversation=[
            {
                "role": "user",
                "content": "Explain the purpose of a reward function in one sentence.",
            }
        ],
        add_generation_prompt=True,
        return_dict=False,
    )
    result = sampling_client.sample(
        prompt=tinker.types.ModelInput.from_ints(prompt_tokens),
        num_samples=1,
        sampling_params=tinker.types.SamplingParams(max_tokens=64),
    ).result()

    print(tokenizer.decode(result.sequences[0].tokens))
except KeyboardInterrupt:
    outcome = "interrupted"
    raise
else:
    outcome = "success"
finally:
    service_client.close(outcome).result()
```

Führen Sie das Skript aus:

```bash theme={null}
python quickstart.py
```

Kopieren Sie den nach `TRAINING_JOB_ID=` ausgegebenen Wert.

### 7. Kanonischen Job prüfen

<CodeGroup>
  ```bash macOS/Linux theme={null}
  export TRAINING_JOB_ID="<ID printed by quickstart.py>"
  curl --fail-with-body \
    -H "X-API-Key: $FASTINO_API_KEY" \
    "https://api.fastino.ai/v1/training/jobs/$TRAINING_JOB_ID"
  ```

  ```powershell Windows theme={null}
  $env:TRAINING_JOB_ID = "<ID printed by quickstart.py>"
  Invoke-RestMethod `
    -Headers @{ "X-API-Key" = "$env:FASTINO_API_KEY" } `
    -Uri "https://api.fastino.ai/v1/training/jobs/$env:TRAINING_JOB_ID"
  ```
</CodeGroup>

Die Antwort beschreibt denselben Job, der von
`create_lora_training_client(...)` erstellt wurde. Verwenden Sie weiterhin den
SDK-Client für Modelloperationen und die kanonische Jobs-API für dokumentierte
Job-Lesezugriffe.

## Fortfahren

<CardGroup cols={3}>
  <Card title="Datensätze" icon="database" href="/de/concepts/datasets">
    Bereiten Sie Trainingsdaten vor und validieren Sie sie.
  </Card>

  <Card title="Job-Referenz" icon="book" href="/de/api-reference/training-jobs/create">
    Lesen Sie den vollständigen Request- und Response-Vertrag.
  </Card>

  <Card title="Trainingsloop" icon="repeat-2" href="/de/training/training-loop">
    Ergänzen Sie einen benutzerdefinierten Loop um Rewards, Updates und
    Wiederherstellung.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.