> ## 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.
# Guía rápida de Pioneer: del registro a tu primera inferencia
> Genera una API key de Pioneer, explora los modelos disponibles y ejecuta tu primera predicción de NER en minutos con una llamada de inferencia funcional.
Esta guía te lleva por el camino más rápido hasta una integración funcional con Pioneer. Al terminar, habrás realizado una llamada de inferencia con éxito y entenderás la forma de la API. Solo necesitas una cuenta de Pioneer y una terminal.
Crea una cuenta en [pioneer.ai](https://pioneer.ai).
Una vez que hayas iniciado sesión, ve a **Settings → API Keys** y genera una nueva clave. Cópiala en un lugar seguro — no podrás volver a verla después de cerrar el diálogo.
Mantén tu API key fuera del control de versiones. Usa una variable de entorno o un gestor de secretos en lugar de escribirla directamente en tus archivos fuente.
Establece tu clave como una variable de entorno para que los ejemplos siguientes funcionen tal cual:
```bash theme={null}
export PIONEER_API_KEY="your_api_key_here"
```
Antes de ejecutar inferencia, puedes explorar los modelos que Pioneer tiene disponibles. Usa `GET /base-models` para ver el catálogo completo. Pasa `?supports_inference=true` para filtrar por los modelos que puedes llamar inmediatamente, o `?task_type=decoder` para ver solo los LLM.
```bash curl theme={null}
curl https://api.pioneer.ai/base-models?supports_inference=true \
-H "X-API-Key: $PIONEER_API_KEY"
```
```python Python theme={null}
import os
import requests
response = requests.get(
"https://api.pioneer.ai/base-models",
params={"supports_inference": "true"},
headers={"X-API-Key": os.environ["PIONEER_API_KEY"]}
)
print(response.json())
```
```javascript JavaScript theme={null}
const response = await fetch(
"https://api.pioneer.ai/base-models?supports_inference=true",
{
headers: {
"X-API-Key": process.env.PIONEER_API_KEY
}
}
);
const data = await response.json();
console.log(data);
```
La respuesta lista los IDs de modelo que puedes pasar a `/v1/chat/completions`. Por ejemplo, `fastino/gliner2-base-v1` es el modelo base de GLiNER para tareas de NER.
Llama a `POST /v1/chat/completions` con un modelo, un mensaje y un esquema que defina qué quieres extraer. El ejemplo siguiente usa el modelo base de GLiNER para extraer entidades nombradas de una frase.
```bash curl theme={null}
curl -X POST https://api.pioneer.ai/v1/chat/completions \
-H "X-API-Key: $PIONEER_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "fastino/gliner2-base-v1",
"messages": [
{"role": "user", "content": "Apple announced the MacBook Pro at WWDC in Cupertino."}
],
"schema": {
"entities": ["organization", "product", "event", "location"]
},
"threshold": 0.5
}'
```
```python Python theme={null}
import os
import requests
response = requests.post(
"https://api.pioneer.ai/v1/chat/completions",
headers={
"X-API-Key": os.environ["PIONEER_API_KEY"],
"Content-Type": "application/json"
},
json={
"model": "fastino/gliner2-base-v1",
"messages": [{
"role": "user",
"content": "Apple announced the MacBook Pro at WWDC in Cupertino."
}],
"schema": {
"entities": ["organization", "product", "event", "location"]
},
"threshold": 0.5
}
)
print(response.json())
```
```javascript JavaScript theme={null}
const response = await fetch("https://api.pioneer.ai/v1/chat/completions", {
method: "POST",
headers: {
"X-API-Key": process.env.PIONEER_API_KEY,
"Content-Type": "application/json"
},
body: JSON.stringify({
model: "fastino/gliner2-base-v1",
messages: [{
role: "user",
content: "Apple announced the MacBook Pro at WWDC in Cupertino."
}],
schema: {
entities: ["organization", "product", "event", "location"]
},
threshold: 0.5
})
});
const data = await response.json();
console.log(data);
```
El campo `schema` indica al modelo qué debe buscar. Para modelos encoder (GLiNER), puedes proporcionar:
* `entities` — una lista de cadenas de tipos de entidad para NER
* `classifications` — una lista de objetos `{task, labels}` para clasificación de texto
* `structures` — un diccionario de definiciones de estructura para extracción JSON
* `relations` — una lista de definiciones de relaciones
Para modelos decoder (LLM), omite `schema` y envía un mensaje de chat normal.
`model` puede ser el ID de un modelo base como `fastino/gliner2-base-v1`, o el ID de un trabajo de entrenamiento completado. Una vez que hayas ajustado un modelo, sustituye el ID del modelo base por el ID de tu trabajo para servir predicciones desde tu modelo personalizado.
Si ya estás usando el SDK de Anthropic, apúntalo a `https://api.pioneer.ai` y usa tu API key de Pioneer.
```bash curl (Anthropic-compatible) theme={null}
curl -X POST https://api.pioneer.ai/v1/messages \
-H "X-API-Key: $PIONEER_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "Content-Type: application/json" \
-d '{
"model": "fastino/gliner2-base-v1",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Extract entities from: Apple launched the iPhone in San Francisco."}
],
"schema": {"entities": ["organization", "product", "location"]}
}'
```
Pasa los campos específicos de Pioneer, como `schema`, mediante la opción extra-body del SDK.
Cuando estés listo para ajustar el modelo con tus propios datos, inicia un trabajo de entrenamiento. Necesitarás un conjunto de datos ya subido o creado — consulta [Conjuntos de datos](/es/concepts/datasets) para saber cómo crear uno.
```bash curl theme={null}
curl -X POST https://api.pioneer.ai/felix/training-jobs \
-H "X-API-Key: $PIONEER_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model_name": "my-ner-model",
"base_model": "fastino/gliner2-base-v1",
"datasets": [{"name": "my-dataset"}],
"training_type": "lora",
"nr_epochs": 5,
"learning_rate": 5e-5
}'
```
```python Python theme={null}
import os
import requests
response = requests.post(
"https://api.pioneer.ai/felix/training-jobs",
headers={
"X-API-Key": os.environ["PIONEER_API_KEY"],
"Content-Type": "application/json"
},
json={
"model_name": "my-ner-model",
"base_model": "fastino/gliner2-base-v1",
"datasets": [{"name": "my-dataset"}],
"training_type": "lora",
"nr_epochs": 5,
"learning_rate": 5e-5
}
)
print(response.json())
# {"id": "uuid-of-training-job", "status": "requested"}
```
La respuesta incluye un `id` de trabajo. Consulta `GET /felix/training-jobs/{id}` para comprobar el estado. Cuando el trabajo llegue a `complete`, usa el ID del trabajo como `model` en las llamadas a `/v1/chat/completions`.
Valores de estado del trabajo: `requested` → `running` → `complete` (o `failed` / `stopped`).
## Próximos pasos
Recorrido de extremo a extremo: subida del conjunto de datos, entrenamiento, evaluación e inferencia.
Ajusta Nemotron 3.5 Lightning con los datos de tu dominio usando LoRA.
Genera datos de entrenamiento etiquetados sin anotación manual.
Referencia completa de cada endpoint con esquemas de solicitud y respuesta.