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

# Guía rápida de la API de entrenamiento

> Inicia un trabajo de entrenamiento gestionado o un bucle de entrenamiento controlado por la aplicación y, después, verifica su ID canónico de trabajo.

Esta guía rápida cubre las dos vías de la API de entrenamiento. Usa el
entrenamiento gestionado cuando quieras que Fastino ejecute el bucle. Usa un
bucle de entrenamiento personalizado cuando tu aplicación deba controlar el
muestreo, las recompensas y las actualizaciones del modelo.

## 1. Autentícate

1. Crea una [cuenta de Fastino](https://agent.fastino.ai/).
2. Abre [Claves de API](https://agent.fastino.ai/api-keys).
3. Crea una clave y cópiala cuando se muestre.

Guarda la clave en una variable de entorno:

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

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

Envía esta clave como `X-API-Key: $FASTINO_API_KEY`. Consulta
[Autenticación](/es/authentication) para ver el contrato de autenticación
completo.

## 2. Elige una vía

| Objetivo | Vía |
| - | - |
| Proporcionar datos y configuración y dejar que Fastino ejecute el entrenamiento | [Entrenamiento gestionado](#managed-training) |
| Controlar el muestreo, las recompensas y las actualizaciones en tu aplicación | [Bucle de entrenamiento personalizado](#custom-training-loop) |

<span id="managed-training" />

## Entrenamiento gestionado

### 3. Prepara un dataset

[Sube y procesa un dataset de entrenamiento](/es/concepts/datasets) y espera
hasta que su versión esté `ready`.

### 4. Elige un modelo

Consulta el catálogo activo antes del envío:

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

Guarda el ID del modelo seleccionado.

### 5. Crea el trabajo

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

Guarda el `id` devuelto. Es el `job_id` que usan todas las rutas específicas
del trabajo. Reutiliza la misma `Idempotency-Key` únicamente al reintentar esta
misma solicitud de creación.

### 6. Consulta el trabajo

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

Para los trabajos de configuración:

* `status` es el valor persistido del ciclo de vida, como `errored`.
* `normalized_status` es el valor estable para las consultas, como `failed`.
* `is_terminal_status` indica al cliente cuándo dejar de consultar.
* `error_message` describe un fallo cuando está disponible.

Continúa hasta que `is_terminal_status` sea `true` y, después, inspecciona el
estado final, los checkpoints, los logs y la posibilidad de despliegue.

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

## Bucle de entrenamiento personalizado

Los bucles de entrenamiento personalizados requieren acceso para el equipo y
Python 3.11 o posterior. El cliente del SDK compatible se comunica con el
adaptador de compatibilidad HTTP oculto de Fastino. Usa los métodos del
cliente que se indican a continuación. No construyas solicitudes al adaptador.

### 3. Instala el cliente probado

<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. Configura el cliente

`TINKER_CREDENTIAL_CMD` se ejecuta con cada solicitud de token y debe imprimir
una única credencial no vacía.

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

Usa una clave normal de Fastino que comience por `fast_sk_`. Las credenciales
que comienzan por `tml-` se rechazan. No establezcas `TINKER_API_KEY`.

### 5. Elige un modelo habilitado

Llama a `ServiceClient.get_server_capabilities()` y selecciona un modelo y un
rango de LoRA de su respuesta:

<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. Crea el trabajo y muestrea

Crea `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()
```

Ejecuta el script:

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

Copia el valor que se imprime después de `TRAINING_JOB_ID=`.

### 7. Verifica el trabajo canónico

<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 respuesta describe el mismo trabajo creado por
`create_lora_training_client(...)`. Sigue usando el cliente del SDK para las
operaciones del modelo y la API canónica de trabajos para las lecturas de
trabajos documentadas.

## Continúa

<CardGroup cols={3}>
  <Card title="Datasets" icon="database" href="/es/concepts/datasets">
    Prepara y valida los datos de entrenamiento.
  </Card>

  <Card title="Referencia de trabajos" icon="book" href="/es/api-reference/training-jobs/create">
    Consulta el contrato completo de solicitud y respuesta.
  </Card>

  <Card title="Bucle de entrenamiento" icon="repeat-2" href="/es/training/training-loop">
    Añade recompensas, actualizaciones y recuperación a un bucle personalizado.
  </Card>
</CardGroup>


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