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

# Démarrage rapide de l'API d'entraînement

> Lancez un job d'entraînement géré ou une boucle d'entraînement contrôlée par l'application, puis vérifiez son ID de job canonique.

Ce démarrage rapide couvre les deux voies de l'API d'entraînement. Utilisez
l'entraînement géré lorsque vous souhaitez que Fastino exécute la boucle.
Utilisez une boucle d'entraînement personnalisée lorsque votre application doit
contrôler l'échantillonnage, les récompenses et les mises à jour du modèle.

## 1. S'authentifier

1. Créez un [compte Fastino](https://agent.fastino.ai/).
2. Ouvrez la page des [clés API](https://agent.fastino.ai/api-keys).
3. Créez une clé et copiez-la lorsqu'elle s'affiche.

Enregistrez la clé dans une variable d'environnement :

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

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

Envoyez cette clé sous la forme `X-API-Key: $FASTINO_API_KEY`. Consultez
[Authentification](/fr/authentication) pour le contrat d'authentification
complet.

## 2. Choisir une voie

| Objectif | Voie |
| - | - |
| Fournir des données et une configuration, puis laisser Fastino exécuter l'entraînement | [Entraînement géré](#managed-training) |
| Contrôler l'échantillonnage, les récompenses et les mises à jour dans votre application | [Boucle d'entraînement personnalisée](#custom-training-loop) |

<span id="managed-training" />

## Entraînement géré

### 3. Préparer un dataset

[Importez et traitez un dataset d'entraînement](/fr/concepts/datasets), puis
attendez que sa version soit `ready`.

### 4. Choisir un modèle

Interrogez le catalogue actif avant la soumission :

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

Conservez l'ID du modèle sélectionné.

### 5. Créer le job

```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"
  }'
```

Conservez l'`id` renvoyé. Il s'agit du `job_id` utilisé par chaque route propre
à un job. Réutilisez la même valeur `Idempotency-Key` uniquement lorsque vous
réessayez exactement cette requête de création.

### 6. Interroger le job

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

Pour les jobs de configuration :

* `status` est la valeur persistée du cycle de vie, telle que `errored`.
* `normalized_status` est la valeur stable d'interrogation, telle que `failed`.
* `is_terminal_status` indique à votre client quand arrêter les interrogations.
* `error_message` décrit un échec lorsque cette information est disponible.

Continuez jusqu'à ce que `is_terminal_status` soit `true`, puis examinez le
statut final, les checkpoints, les logs et l'admissibilité au déploiement.

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

## Boucle d'entraînement personnalisée

Les boucles d'entraînement personnalisées nécessitent un accès pour l'équipe et
Python 3.11 ou une version ultérieure. Le client SDK pris en charge communique
avec l'adaptateur de compatibilité HTTP masqué de Fastino. Utilisez les
méthodes du client ci-dessous. Ne construisez pas de requêtes vers
l'adaptateur.

### 3. Installer le client testé

<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. Configurer le client

`TINKER_CREDENTIAL_CMD` est exécuté à chaque demande de token et doit afficher
un seul identifiant non vide.

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

Utilisez une clé Fastino normale commençant par `fast_sk_`. Les identifiants
commençant par `tml-` sont rejetés. Ne définissez pas `TINKER_API_KEY`.

### 5. Choisir un modèle activé

Appelez `ServiceClient.get_server_capabilities()` et sélectionnez un modèle et
un rang LoRA dans sa réponse :

<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. Créer le job et échantillonner

Créez `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()
```

Exécutez le script :

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

Copiez la valeur affichée après `TRAINING_JOB_ID=`.

### 7. Vérifier le job canonique

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

La réponse décrit le même job que celui créé par
`create_lora_training_client(...)`. Continuez à utiliser le client SDK pour les
opérations sur le modèle et l'API canonique des jobs pour les lectures de jobs
documentées.

## Continuer

<CardGroup cols={3}>
  <Card title="Datasets" icon="database" href="/fr/concepts/datasets">
    Préparez et validez les données d'entraînement.
  </Card>

  <Card title="Référence des jobs" icon="book" href="/fr/api-reference/training-jobs/create">
    Consultez le contrat complet de requête et de réponse.
  </Card>

  <Card title="Boucle d'entraînement" icon="repeat-2" href="/fr/training/training-loop">
    Ajoutez des récompenses, des mises à jour et la récupération à une boucle
    personnalisée.
  </Card>
</CardGroup>


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