> ## 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. For custom training loops, native JSON clients use the public operations under /v1/training/jobs and /v1/training/usage. Existing Tinker clients use tinker==0.32.0 with TINKER_BASE_URL=https://api.fastino.ai/v1/training/compat/tinker and TINKER_CREDENTIAL_CMD. Compatibility child routes are private and absent from OpenAPI. 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.
# Inicio rápido del decodificador
> Inicia un bucle de entrenamiento REST nativo para un LLM decodificador y verifica su ID canónico de trabajo.
Esta guía rápida usa un bucle de entrenamiento personalizado para entrenar
modelos Nemotron o Qwen mientras tu aplicación controla el muestreo, las
recompensas y las actualizaciones del modelo. Para ajustar un codificador
GLiNER con entrenamiento gestionado, consulta el
[inicio rápido del codificador](/es/training/encoder-quickstart).
## 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:
```bash macOS/Linux theme={null}
export FASTINO_API_KEY="fast_sk_..."
```
```powershell Windows theme={null}
$env:FASTINO_API_KEY = "fast_sk_..."
```
Envía esta clave como `X-API-Key: $FASTINO_API_KEY`. Consulta
[Autenticación](/es/authentication) para ver el contrato de autenticación
completo.
Elige una interfaz compatible:
* Los clientes JSON nativos llaman a
[`POST /v1/training/jobs/create-model`](/es/api-reference/training-jobs/interactive/create-model),
encolan operaciones del modelo bajo `/v1/training/jobs/{job_id}` y consultan
cada `future_id` devuelto hasta que esté `completed`, `failed` o
`cancelled`.
* Los programas Tinker existentes mantienen `tinker==0.32.0`; consulta
[Migrar desde Tinker](/es/training/migrate-from-tinker) para configurar el SDK.
Los clientes nativos no envían `seq_id` ni latidos. El servidor asigna el orden
de las operaciones y mantiene activa la sesión interna. Una solicitud con
`wait=true` espera como máximo 25 segundos. Por tanto, el cliente debe seguir
consultando una operación no terminal. Después de este inicio rápido, consulta
[Construye un bucle de entrenamiento personalizado](/es/training/training-loop)
para añadir recompensas, rollouts repetidos y recuperación.
El ejemplo REST nativo requiere Python 3.11 o posterior. Para configurar el SDK
de Tinker, consulta [Migrar desde Tinker](/es/training/migrate-from-tinker).
## 2. Instala las bibliotecas cliente
Necesitas Python 3.11 o posterior. `transformers` aporta el tokenizador del
modelo; el entrenamiento se ejecuta en Fastino.
```bash uv theme={null}
uv init fastino-training
cd fastino-training
uv add requests transformers
```
```bash pip theme={null}
mkdir fastino-training && cd fastino-training
python -m venv .venv
source .venv/bin/activate
pip install requests transformers
```
```powershell pip · Windows theme={null}
mkdir fastino-training
cd fastino-training
py -m venv .venv
.\.venv\Scripts\Activate.ps1
pip install requests transformers
```
## 3. Elige un modelo
| ID del modelo | Longitud de contexto (tokens) |
| - | - |
| `nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16` | 65,536 |
| `nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16` | 32,768 |
| `Qwen/Qwen3.6-35B-A3B` | 32,768 |
Se admiten rangos LoRA de 1 a 32; el valor por defecto es 32.
```bash macOS/Linux theme={null}
export FASTINO_TRAINING_MODEL="nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16"
```
```powershell Windows theme={null}
$env:FASTINO_TRAINING_MODEL = "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16"
```
## 4. Crea el trabajo
```bash theme={null}
curl -X POST "https://api.fastino.ai/v1/training/jobs/create-model" \
-H "X-API-Key: $FASTINO_API_KEY" \
-H "Content-Type: application/json" \
-d '{"base_model": "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16", "lora_config": {"rank": 32}}'
```
La respuesta contiene un `job_id` y el `future_id` del future `create`
del trabajo:
```json theme={null}
{
"job_id": "SESSION_ID:train:0",
"type": "interactive",
"base_model": "nvidia/NVIDIA-Nemotron-3-Super-120B-A12B-BF16",
"future_id": "FUTURE_ID",
"load_future_id": null
}
```
Cada llamada que hace trabajo devuelve un future. Léelo hasta que `status`
sea `completed`. Con `wait=true`, la solicitud espera hasta 25 segundos:
```bash theme={null}
curl "https://api.fastino.ai/v1/training/jobs/$TRAINING_JOB_ID/futures/$FUTURE_ID?wait=true" \
-H "X-API-Key: $FASTINO_API_KEY"
```
## 5. Entrena, guarda y muestrea
El script siguiente ejecuta el bucle completo: crea un trabajo, ejecuta tres
pasadas forward-backward y pasos del optimizador, guarda un checkpoint sampler,
muestrea desde él y detiene el trabajo.
Crea `quickstart.py`:
```python theme={null}
import os
import requests
from transformers import AutoTokenizer
API = "https://api.fastino.ai"
MODEL = os.environ["FASTINO_TRAINING_MODEL"]
session = requests.Session()
session.headers["X-API-Key"] = os.environ["FASTINO_API_KEY"]
def call(method, path, body=None):
response = session.request(method, API + path, json=body, timeout=60)
response.raise_for_status()
return response.json() if response.content else None
def wait(job_id, future_id):
path = f"/v1/training/jobs/{job_id}/futures/{future_id}?wait=true"
while True:
future = call("GET", path)
if future["status"] == "completed":
return future["result"]
if future["status"] in ("failed", "cancelled"):
raise RuntimeError(future["error"])
def datum(prompt_tokens, completion_tokens):
tokens = prompt_tokens + completion_tokens
weights = [0.0] * (len(prompt_tokens) - 1) + [1.0] * len(completion_tokens)
return {
"model_input": {"chunks": [{"type": "encoded_text", "tokens": tokens[:-1]}]},
"loss_fn_inputs": {
"target_tokens": {"data": tokens[1:], "dtype": "int64"},
"weights": {"data": weights, "dtype": "float32"},
},
}
tokenizer = AutoTokenizer.from_pretrained(MODEL)
prompt = tokenizer.apply_chat_template(
[{"role": "user", "content": "What is the capital of France?"}],
add_generation_prompt=True,
enable_thinking=False,
return_dict=False,
)
completion = tokenizer.encode("Paris.", add_special_tokens=False)
completion.append(tokenizer.eos_token_id)
batch = {"datums": [datum(prompt, completion)], "loss_fn": "cross_entropy"}
created = call(
"POST",
"/v1/training/jobs/create-model",
{"base_model": MODEL, "lora_config": {"rank": 32}},
)
job_id = created["job_id"]
jobs = f"/v1/training/jobs/{job_id}"
print(f"TRAINING_JOB_ID={job_id}")
try:
wait(job_id, created["future_id"])
for step in range(3):
backward = call("POST", f"{jobs}/forward-backward", batch)
result = wait(job_id, backward["future_id"])
update = call(
"POST",
f"{jobs}/optim-step",
{"adam_params": {"learning_rate": 1e-4}},
)
wait(job_id, update["future_id"])
print(f"step {step}: loss {result['metrics']['loss:sum']:.4f}")
saved = call(
"POST",
f"{jobs}/save-weights-for-sampler",
{"name": "quickstart", "ttl_seconds": 24 * 60 * 60},
)
wait(job_id, saved["future_id"])
sample = call(
"POST",
f"{jobs}/sample",
{
"checkpoint": "quickstart",
"prompt_tokens": prompt,
"sampling_params": {"max_tokens": 32},
},
)
sequence = wait(job_id, sample["future_id"])["sequences"][0]
print(tokenizer.decode(sequence["tokens"]))
finally:
call("POST", f"{jobs}/stop")
```
El script espera a que forward-backward termine correctamente antes de enviar
el paso del optimizador. Si un future falla o se cancela, `wait` genera un error
y no se envía la operación dependiente.
`enable_thinking=False` cierra el bloque de razonamiento del modelo antes de que
empiece la respuesta supervisada. Es un argumento de la plantilla del
tokenizer, no un campo de solicitud de la API de entrenamiento.
Ejecuta el script:
```bash theme={null}
python quickstart.py
```
Copia el valor que aparece después de `TRAINING_JOB_ID=`.
Un trabajo interactivo sin llamadas durante 30 minutos se libera. Sus
checkpoints se conservan. Detenerlo responde de inmediato e impide llamadas
nuevas, pero las operaciones ya encoladas pueden terminar antes de que se
liberen los recursos. El uso puede continuar hasta esa liberación. Aún puedes muestrear y descargar sus checkpoints sampler.
## 6. Verifica el trabajo canónico
```bash macOS/Linux theme={null}
export TRAINING_JOB_ID=""
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 = ""
Invoke-RestMethod `
-Headers @{ "X-API-Key" = "$env:FASTINO_API_KEY" } `
-Uri "https://api.fastino.ai/v1/training/jobs/$env:TRAINING_JOB_ID"
```
La respuesta describe el mismo trabajo creado mediante el endpoint REST nativo.
Usa las páginas públicas de operaciones interactivas para las operaciones del
modelo y la API canónica de trabajos para las lecturas documentadas.
## Continúa
Ajusta un codificador GLiNER con entrenamiento gestionado.
Revisa cada solicitud y respuesta de los trabajos interactivos.
Añade recompensas, actualizaciones y recuperación a un bucle personalizado.
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.