> ## 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.
# Démarrage rapide Pioneer : de l'inscription à l'inférence
> Générez une clé d'API Pioneer, parcourez les modèles disponibles et exécutez votre première prédiction NER en quelques minutes avec un appel d'inférence.
Ce guide vous propose le chemin le plus rapide vers une intégration Pioneer opérationnelle. À la fin, vous aurez effectué un appel d'inférence réussi et compris la structure de l'API. Il vous suffit d'un compte Pioneer et d'un terminal.
Créez un compte sur [pioneer.ai](https://pioneer.ai).
Une fois connecté, rendez-vous dans **Paramètres → Clés d'API** et générez une nouvelle clé. Copiez-la dans un endroit sûr — vous ne pourrez plus la consulter après avoir fermé la boîte de dialogue.
Ne versionnez pas votre clé d'API. Utilisez une variable d'environnement ou un gestionnaire de secrets plutôt que de l'inscrire en dur dans vos fichiers sources.
Définissez votre clé comme variable d'environnement afin que les exemples ci-dessous fonctionnent tels quels :
```bash theme={null}
export PIONEER_API_KEY="your_api_key_here"
```
Avant d'exécuter une inférence, vous pouvez parcourir les modèles proposés par Pioneer. Utilisez `GET /base-models` pour consulter le catalogue complet. Passez `?supports_inference=true` pour filtrer sur les modèles que vous pouvez appeler immédiatement, ou `?task_type=decoder` pour n'afficher que les 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 réponse liste les IDs de modèles que vous pouvez passer à `/v1/chat/completions`. Par exemple, `fastino/gliner2-base-v1` est le modèle de base GLiNER pour les tâches de NER.
Appelez `POST /v1/chat/completions` avec un modèle, un message et un schéma définissant ce que vous souhaitez extraire. L'exemple ci-dessous utilise le modèle de base GLiNER pour extraire des entités nommées à partir d'une phrase.
```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);
```
Le champ `schema` indique au modèle ce qu'il doit rechercher. Pour les modèles encodeurs (GLiNER), vous pouvez fournir :
* `entities` — une liste de chaînes de types d'entités pour la NER
* `classifications` — une liste d'objets `{task, labels}` pour la classification de texte
* `structures` — un dictionnaire de définitions de structures pour l'extraction JSON
* `relations` — une liste de définitions de relations
Pour les modèles décodeurs (LLM), omettez `schema` et envoyez un message de chat classique.
`model` peut être un ID de modèle de base comme `fastino/gliner2-base-v1`, ou l'ID d'une tâche d'entraînement terminée. Une fois un modèle affiné, remplacez l'ID du modèle de base par l'ID de votre tâche pour servir les prédictions depuis votre modèle personnalisé.
Si vous utilisez déjà le SDK Anthropic, pointez-le vers `https://api.pioneer.ai` et utilisez votre clé d'API 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"]}
}'
```
Passez les champs spécifiques à Pioneer comme `schema` via l'option extra-body du SDK.
Lorsque vous êtes prêt à affiner sur vos propres données, lancez une tâche d'entraînement. Vous aurez besoin d'un jeu de données déjà téléversé ou créé — consultez [Jeux de données](/fr/concepts/datasets) pour savoir comment en créer un.
```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 réponse inclut un `id` de tâche. Interrogez `GET /felix/training-jobs/{id}` pour vérifier le statut. Une fois la tâche à `complete`, utilisez l'ID de la tâche comme `model` dans les appels à `/v1/chat/completions`.
Valeurs de statut de tâche : `requested` → `running` → `complete` (ou `failed` / `stopped`).
## Étapes suivantes
Parcours de bout en bout : téléversement du jeu de données, entraînement, évaluation et inférence.
Affinez Nemotron 3.5 Lightning sur vos données de domaine avec LoRA.
Générez des données d'entraînement labellisées sans annotation manuelle.
Référence complète pour chaque endpoint avec les schémas de requête et de réponse.