Source: https://ailoot.ai/docs/fr-ch/api/systemone/
Canonical: https://ailoot.ai/docs/fr-ch/api/systemone/
Language: fr-ch

[API](https://ailoot.ai/docs/fr-ch/) 

# Jev — modèle de décision

[Markdown](https://ailoot.ai/docs/fr-ch/api/systemone/index.md)

Le modèle de décision Jev de TypeSafe répond à des questions typées sur du texte ou du JSON : choix d’une option, évaluation sur une échelle ou oui/non avec des probabilités. Ce n’est ni un chat ni un générateur de texte.

POST`https://api.ailoot.ai/v1/systemone`

Jev — modèle de décision

```bash
curl https://api.ailoot.ai/v1/systemone \
  -H "Authorization: Bearer $AILOOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "Au secours ! Mes versements échouent depuis 3 jours.",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "Cela exprime-t-il une urgence ?"
      }
    }
  }' 
```

```python
import json, os, urllib.request

body = {
    "model": "jev-latest",
    "state": "Au secours ! Mes versements échouent depuis 3 jours.",
    "questions": {
        "is_urgent": {"type": "noul", "instructions": "Cela exprime-t-il une urgence ?"},
    },
}
req = urllib.request.Request(
    "https://api.ailoot.ai/v1/systemone",
    data=json.dumps(body).encode(),
    headers={"Authorization": "Bearer " + os.environ["AILOOT_API_KEY"],
             "Content-Type": "application/json"},
)
with urllib.request.urlopen(req, timeout=60) as resp:
    result = json.load(resp)
print(result["answers"]["is_urgent"]["noul"])  # 0.95
```

```js
const resp = await fetch("https://api.ailoot.ai/v1/systemone", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.AILOOT_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "jev-latest",
    state: "Au secours ! Mes versements échouent depuis 3 jours.",
    questions: {
      is_urgent: { type: "noul", instructions: "Cela exprime-t-il une urgence ?" },
    },
  }),
});
const result = await resp.json();
if (!resp.ok) throw new Error(`${resp.status} ${JSON.stringify(result)}`);
console.log(result.answers.is_urgent.noul); // 0.95
```

200 OK

```json
{
  "model": "jev-1.13.0",
  "answers": {
    "is_urgent": {
      "type": "noul",
      "noul": 0.95
    }
  },
  "usage": { "input_tokens": 296, "output_tokens": 20 }
}
```

Jev est un modèle de décision de classe System One proposé par TypeSafe. Il ne rédige pas de texte et ne dialogue pas : vous transmettez un **état** (`state`) — sous forme de texte ou de JSON — et un ensemble de **questions**, puis recevez des valeurs typées accompagnées de probabilités. Votre code peut directement effectuer des branchements, trier et router sans analyser du texte libre.

Toutes les questions d’une requête sont évaluées en parallèle et indépendamment, sur le même `state`. Selon TypeSafe, ajouter des questions modifie très peu le temps de réponse et les questions n’interfèrent pas entre elles.

| Élément | En bref |
| --- | --- |
| Modèle | `jev-latest` — alias de la dernière version stable de Jev ; [fiche du catalogue](https://ailoot.ai/models/fr-ch/#m=jev-latest) |
| Méthode | `POST /v1/systemone`. Ce n’est pas un chat : les formats OpenAI, Anthropic et Gemini ne conviennent pas à Jev. La réponse arrive entière, sous la forme d’un seul JSON |
| Entrées acceptées | Uniquement du texte : chaîne, objet JSON ou tableau de textes. Convertissez d’abord les images, l’audio et la vidéo en texte |
| Contexte | 64K tokens par requête, state et toutes les questions réunis ; state avec la question la plus longue : jusqu’à 32K |
| Langue | Selon TypeSafe, le modèle est le plus précis en anglais. Il accepte d’autres langues, avec une précision inférieure : testez-le sur vos données |
| Prix | Entrée : 0.084 USD pour 1 million de tokens ; sortie gratuite |

## [](https://ailoot.ai/docs/fr-ch/api/systemone/#request)Requête

### Authentification

| Paramètre | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `Authorization` | header | obligatoire | Clé Ailoot au format `Bearer sk-…`. |

### Corps de la requête

| Paramètre | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `model` | string | obligatoire | `jev-latest`. |
| `state` | string \| object \| array | obligatoire | Contenu à évaluer : chaîne de texte ou JSON, demande d’un client, enregistrement de base de données, échange ou état actuel de votre application. Un objet avec des noms de champs clairs est généralement plus pratique qu’une seule chaîne. |
| `questions` | object | obligatoire | Questions. Vous choisissez les clés et les réponses utilisent les mêmes clés. La clé n’influence pas la réponse : la question est définie dans `instructions`. |
| `questions.*.type` | string | obligatoire | `noul`, `choice` ou `score` — voir ci-dessous. |
| `questions.*.instructions` | string \| object \| array | obligatoire | La question elle-même. Une longue question contenant des données peut être transmise sous forme d’objet : la question dans un champ et les données dans les autres. Référencez les champs par leur nom entre accents graves. |
| `questions.*.criteria` | object \| array |  | Options de réponse propres à chaque type : descriptions de oui et non pour noul (facultatives), dictionnaire d’options pour choice, liste ordonnée de niveaux pour score. |

## [](https://ailoot.ai/docs/fr-ch/api/systemone/#question-types)Types de questions

| Type | Question posée | Valeur retournée |
| --- | --- | --- |
| `noul` | L’affirmation est-elle vraie : oui ou non | `noul` — probabilité de « oui », de 0 à 1 |
| `choice` | Quelle option parmi celles proposées convient | `choice`, `probabilities`, `confidence` |
| `score` | Où se situe state sur votre échelle de niveaux | `score`, `legend`, `probabilities`, `confidence` |

Vous pouvez combiner plusieurs types dans une même requête.

### noul — oui ou non

Le champ `criteria` est facultatif : il peut décrire la signification de oui (`true`) et de non (`false`). La réponse `noul` — nombre de 0 (non) à 1 (oui).

```json
"is_urgent": {
  "type": "noul",
  "instructions": "Cela exprime-t-il une urgence ?",
  "criteria": {
    "true": "Explicitement soumis à une contrainte de temps",
    "false": "Aucune urgence exprimée"
  }
}
```

```json
"is_urgent": {
  "type": "noul",
  "noul": 0.95
}
```

### choice — choix d’une option

`criteria` — dictionnaire « option → description ». Si aucune description n’est nécessaire, indiquez `null`. Jusqu’à 255 options. Dans la réponse, `choice` — l’option la plus probable, `probabilities` — la probabilité de chaque option (somme égale à 1), `confidence` — confiance de 0 à 1.

```json
"department": {
  "type": "choice",
  "instructions": "Quelle équipe doit s’en charger ?",
  "criteria": {
    "billing": "Paiements, facturation, remboursements",
    "technical": "Bugs, pannes, intégrations",
    "sales": "Tarifs, passages à une offre supérieure, nouveaux clients"
  }
}
```

```json
"department": {
  "type": "choice",
  "choice": "billing",
  "probabilities": { "billing": 0.88, "technical": 0.12, "sales": 0.0 },
  "confidence": 0.81
}
```

### score — évaluation sur une échelle

`criteria` — niveaux classés du plus bas au plus haut, au maximum 10 (TypeSafe recommande au moins deux). Dans la réponse, `score` — valeur pondérée par les probabilités des niveaux, qui peut se situer entre deux niveaux, `legend` — numéro du niveau et sa description, `probabilities` et `confidence`. Selon TypeSafe, `score` convient à une comparaison avec un seuil, mais pas à une valeur exacte entre les niveaux.

```json
"frustration": {
  "type": "score",
  "instructions": "À quel point le client est-il frustré ?",
  "criteria": ["Calme", "Frustré", "Très en colère"]
}
```

```json
"frustration": {
  "type": "score",
  "score": 1.05,
  "legend": { "0": "Calme", "1": "Frustré", "2": "Très en colère" },
  "probabilities": { "0": 0.0, "1": 0.95, "2": 0.05 },
  "confidence": 0.92
}
```

## [](https://ailoot.ai/docs/fr-ch/api/systemone/#response)Réponse

| Paramètre | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `model` | string |  | Version du modèle ayant répondu. L’alias jev-latest évolue vers de nouvelles versions. Si vous avez réglé les seuils de `confidence` pour une version précise, surveillez ce champ. |
| `answers` | object |  | Une réponse pour chaque question, sous les mêmes clés. Chaque réponse comporte `type`; pour choice et score, également `confidence`. |
| `usage` | object |  | `input_tokens` et `output_tokens`. Seuls les tokens d’entrée sont facturés. |

`confidence` est pratique comme seuil : si la confiance est élevée, agissez automatiquement ; si elle est faible, soumettez la réponse à une personne ou à un modèle de grande taille pour vérification. La réponse indique quoi choisir, et `confidence` — s’il convient d’agir.

## [](https://ailoot.ai/docs/fr-ch/api/systemone/#many-questions)Plusieurs questions en une seule requête

Posez toutes les questions sur un même state dans une requête unique : elles sont évaluées en parallèle et state n’est transmis qu’une fois. Selon TypeSafe, dans leur exemple avec 13 questions, une requête commune était 12,2 fois moins chère et 10 fois plus rapide que 13 requêtes séparées envoyées successivement, pour les mêmes réponses.

Il vaut mieux décomposer un jugement complexe en questions simples et combiner les réponses dans le code. Par exemple, au lieu de « évaluer la demande », évaluez séparément le marché, la faisabilité et la différenciation par rapport aux concurrents. Les pondérations changent alors dans le code, et non dans la question.

```json
{
  "model": "jev-latest",
  "state": "Au secours ! Mes versements échouent depuis 3 jours.",
  "questions": {
    "department": {
      "type": "choice",
      "instructions": "Quelle équipe doit s’en charger ?",
      "criteria": {
        "billing": "Paiements, facturation, remboursements",
        "technical": "Bugs, pannes, intégrations",
        "sales": "Tarifs, passages à une offre supérieure, nouveaux clients"
      }
    },
    "frustration": {
      "type": "score",
      "instructions": "À quel point le client est-il frustré ?",
      "criteria": ["Calme", "Frustré", "Très en colère"]
    },
    "is_urgent": {
      "type": "noul",
      "instructions": "Cela exprime-t-il une urgence ?"
    }
  }
}
```

## [](https://ailoot.ai/docs/fr-ch/api/systemone/#use-cases)Quand l’utiliser

- **Routage.** Orienter une demande vers le bon service et une requête vers le traitement adapté : du code simple, un modèle de grande taille ou une personne.
- **Tri et priorité.** Urgence, tonalité et risque évalués sur une échelle, avec des seuils dans le code.
- **Modération et vérifications.** Vérifier si un message enfreint les règles, si une source confirme une citation ou si un document répond à une question, avant de transmettre le texte.
- **Notation et classement.** Évaluer des documents, des candidats ou des passages trouvés selon votre grille, puis décider dans le code lesquels seront retenus.
- **Remplacer une fragile consigne « renvoie du JSON ».** Un appel qui renvoie des valeurs typées par construction, plutôt qu’un texte à analyser.

## [](https://ailoot.ai/docs/fr-ch/api/systemone/#not-for)Quand ne pas l’utiliser

- **Chat, réponses aux utilisateurs, génération de texte ou de code.** Jev ne rédige pas de texte ; pour cela, utilisez les [modèles textuels](https://ailoot.ai/models/fr-ch/?kind=text).
- **Modèle pour Claude Code, Cursor et d’autres agents.** Vous ne pouvez pas remplacer le modèle d’un agent par jev-latest : l’agent a besoin d’un modèle qui rédige du texte et appelle des outils. Vous pouvez appeler Jev depuis le code que l’agent écrit pour vous.
- **Arithmétique, comptage et comparaison de dates.** Selon TypeSafe, il est plus fiable de les effectuer dans le code et de ne demander au modèle que l’interprétation sémantique, par exemple extraire les éléments d’une date via choice.
- **Images, audio et vidéo.** Le modèle accepte uniquement du texte. Convertissez ces données en texte au préalable.

Le modèle fonctionne le mieux lorsque chaque question porte sur un jugement précis et limité. Formulez directement la condition : selon TypeSafe, il interprète la question littéralement. Un grand state contenant des données superflues réduit la précision : filtrez-le dans le code.

## [](https://ailoot.ai/docs/fr-ch/api/systemone/#price)Prix

Seuls les tokens d’entrée sont facturés — champ `usage.input_tokens` de la réponse : **0.084 USD pour 1 million**. Les tokens de sortie sont gratuits.

La requête de l’exemple de cette page (296 tokens d’entrée) coûte moins de $0.0001.

Avant la requête, Ailoot réserve le montant sur le solde puis, après la réponse, effectue un seul débit selon l’utilisation réelle. Voir [le fonctionnement](https://ailoot.ai/docs/fr-ch/billing/reserve/).

## [](https://ailoot.ai/docs/fr-ch/api/systemone/#limits)Limites

| Élément | Limite |
| --- | --- |
| Requête entière : state et toutes les questions | 64K tokens |
| state avec la question la plus longue | 32K tokens |
| Nombre d’options dans un choice | jusqu’à 255 |
| Nombre de niveaux dans un score | de 2 à 10 |
| Entrée | uniquement du texte : chaîne, objet JSON ou tableau de textes |

Les limites du modèle sont celles indiquées par TypeSafe. Les restrictions de votre clé et de votre solde s’appliquent comme pour tout modèle Ailoot : [Erreurs et limites](https://ailoot.ai/docs/fr-ch/errors/).

## [](https://ailoot.ai/docs/fr-ch/api/systemone/#errors)Erreurs

Les erreurs sont renvoyées dans le format commun de l’API Ailoot : un code, un message clair et le Request ID. Les erreurs les plus fréquentes pour cette méthode sont :

| Code | Quand | Que faire |
| --- | --- | --- |
| **400** `invalid_request` | Corps non validé : state, model ou questions manquants, type inconnu, plus de 255 options dans choice ou plus de 10 niveaux dans score | Corrigez la requête d’après le message d’erreur. Sans modification, elle échouera à nouveau |
| **400** `context_length_exceeded` | state et les questions dépassent ensemble la limite du modèle | Filtrez state dans le code et conservez les données utiles aux questions |
| **401** `invalid_api_key` | Clé absente ou incorrecte | Transmettez la clé dans l’en-tête Authorization |
| **402** `insufficient_balance` | Solde disponible insuffisant pour la réservation | Rechargez le solde |
| **404** `model_not_found`, `unsupported_endpoint` | ID incorrect ou modèle appelé avec une mauvaise méthode, par exemple via /v1/chat/completions | Appelez jev-latest uniquement via POST /v1/systemone |
| **429** `rate_limit_exceeded` | Trop de requêtes | Attendez le nombre de secondes indiqué dans l’en-tête Retry-After, puis réessayez |
| **503** `model_overloaded`, `model_unavailable` | Modèle temporairement surchargé ou indisponible | Si X-Should-Retry : true, réessayez après le nombre de secondes indiqué dans Retry-After ; si false, vérifiez d’abord le Request ID dans l’historique |
| **504** `model_timeout` | Le modèle n’a pas répondu à temps | Ne renvoyez pas la requête avant d’avoir vérifié le Request ID dans l’historique |

La liste complète des codes figure sur la page [Erreurs et limites](https://ailoot.ai/docs/fr-ch/errors/).

Encore des questions ? Envoyez le Request ID et une description : nous vous aiderons à l’analyser.[Contacter l’assistance](mailto:support@ailoot.ai)

## Ailoot · L’entreprise et son portefeuille de projets





Ailoot s’appuie sur une expérience opérationnelle éprouvée, une large clientèle, un service stable et un suivi continu des KPI.





L’entreprise et son portefeuille de projets : des millions de clients ; des ventes qui se chiffrent en milliards chaque mois.





Ailoot met cette expérience opérationnelle au service de l’accès API aux fonctions d’IA dans les produits des clients, leurs agents, applications et automatisations.