---
title: "AI Endpoints - Modèles de décision"
description: "Découvrez comment classer, noter et répondre par oui ou non à des questions sur un texte avec les modèles de décision OVHcloud AI Endpoints"
url: https://docs.ovhcloud.com/fr/guides/public-cloud/ai-machine-learning/ai-endpoints-decision-models
lang: fr
lastUpdated: 2026-11-18
---
> For AI agents: the complete documentation index is available at https://docs.ovhcloud.com/fr/llms.txt, the full documentation bundle is available at https://docs.ovhcloud.com/fr/llms-full.txt.

# AI Endpoints - Modèles de décision

**Note :** AI Endpoints est couvert par les **[Conditions particulières OVHcloud Public Cloud](https://contract.eu.ovhapis.com/1.0/pdf/Conditions_particulieres_OVH_Stack-fr.pdf)** (voir l’Annexe 10 – « Conditions spécifiques – AI Endpoints »).

## Introduction

[AI Endpoints](https://www.ovhcloud.com/fr/public-cloud/ai-endpoints/) est une plateforme serverless proposée par OVHcloud qui offre un accès simplifié à une sélection de modèles d'IA pré-entraînés, mondialement reconnus. La plateforme est conçue pour être simple, sécurisée et intuitive, ce qui en fait une solution idéale pour les développeurs souhaitant enrichir leurs applications avec des capacités d'IA sans expertise poussée en IA ni préoccupations sur la confidentialité des données.

Les **modèles de décision** (Decision Models) sont conçus pour répondre à des questions typées sur un texte, avec des **probabilités calibrées**. Au lieu de générer du texte libre que vous devez ensuite analyser, vous décrivez les questions à poser et obtenez des réponses structurées, directement exploitables dans la logique de votre application (routage, modération, tri, analyse, etc.).

Vous pouvez poser trois types de questions, détaillés dans [Types de questions](#types-de-questions) : `choice` choisit une option, `score` évalue le texte sur des niveaux ordonnés et `noul` répond par oui ou non.

Les modèles de décision sont disponibles via l'endpoint `/v1/systemone`, qui suit le format **System One** créé par TypeSafe. Les clients déjà écrits pour ce format n'ont besoin que d'une nouvelle URL de base, d'une clé API AI Endpoints et du nom d'un modèle de notre [Catalogue](https://www.ovhcloud.com/fr/public-cloud/ai-endpoints/catalog/) pour fonctionner avec AI Endpoints. L'endpoint `/v1/decisions`, compatible OpenAI, n'est pas encore disponible.

## Prérequis

Les exemples fournis dans ce guide peuvent être utilisés avec l'un des environnements suivants :

### Python

Un environnement [Python](https://www.python.org/) avec la bibliothèque [requests](https://pypi.org/project/requests/) installée.
```sh
pip install requests
```

### JavaScript

Un environnement [Node.js](https://nodejs.org/en) en version 18 ou supérieure (les exemples utilisent la fonction `fetch` intégrée et `await` au niveau supérieur : enregistrez-les dans un fichier `.mjs`).

### cURL

Un terminal standard, avec [cURL](https://curl.se/) installé sur le système.

_Ces exemples utilisent le modèle de décision `clef-flash`._

### Authentification

Les exemples fournis dans ce guide sont authentifiés et attendent que la variable d'environnement `OVH_AI_ENDPOINTS_ACCESS_TOKEN` soit définie :

```sh
export OVH_AI_ENDPOINTS_ACCESS_TOKEN='your_api_key'
```

Suivez les instructions du guide « [AI Endpoints - Premiers pas](https://docs.ovhcloud.com/fr/guides/public-cloud/ai-machine-learning/ai-endpoints-getting-started.md) » pour créer une clé API et pour plus d'informations sur l'authentification.

## Démarrage rapide

L'endpoint est disponible à l'URL suivante :

```text
https://oai.endpoints.kepler.ai.cloud.ovh.net/api/v1/systemone
```

Une requête contient trois éléments :

- `model` : le modèle de décision à utiliser.
- `state` : ce sur quoi vous souhaitez poser des questions. Il s'agit généralement d'un texte, mais cela peut aussi être n'importe quel objet JSON (un ticket, un e-mail, un document...), envoyé au modèle sous forme de texte JSON.
- `questions` : un objet dont chaque clé est le nom que vous donnez à une question, et chaque valeur décrit la question (son `type` et ses critères).

### Poser une seule question

Ce premier exemple classe un message client dans un service.

#### Python

```python
import os
import requests

url = "https://oai.endpoints.kepler.ai.cloud.ovh.net/api/v1/systemone"
headers = {
    "Authorization": f"Bearer {os.getenv('OVH_AI_ENDPOINTS_ACCESS_TOKEN')}",
    "Content-Type": "application/json"
}
payload = {
    "model": "clef-flash",
    "state": "Bonjour, je souhaite télécharger la facture du mois dernier pour mon projet Public Cloud. Où puis-je la trouver ?",
    "questions": {
        "department": {
            "type": "choice",
            "criteria": {
                "billing": "Paiements, factures et remboursements",
                "technical": "Questions techniques sur un service",
                "sales": None
            }
        }
    }
}

response = requests.post(url, json=payload, headers=headers)

if response.status_code == 200:
    print(response.json())
else:
    print("Error:", response.status_code, response.text)
```

#### JavaScript

```javascript
const url = "https://oai.endpoints.kepler.ai.cloud.ovh.net/api/v1/systemone";

const payload = {
  model: "clef-flash",
  state: "Bonjour, je souhaite télécharger la facture du mois dernier pour mon projet Public Cloud. Où puis-je la trouver ?",
  questions: {
    department: {
      type: "choice",
      criteria: {
        billing: "Paiements, factures et remboursements",
        technical: "Questions techniques sur un service",
        sales: null,
      },
    },
  },
};

const response = await fetch(url, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.OVH_AI_ENDPOINTS_ACCESS_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

if (response.ok) {
  console.log(JSON.stringify(await response.json(), null, 2));
} else {
  console.error("Error:", response.status, await response.text());
}
```

#### cURL

```sh
curl https://oai.endpoints.kepler.ai.cloud.ovh.net/api/v1/systemone \
  -H "Authorization: Bearer $OVH_AI_ENDPOINTS_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "clef-flash",
    "state": "Bonjour, je souhaite télécharger la facture du mois dernier pour mon projet Public Cloud. Où puis-je la trouver ?",
    "questions": {
      "department": {
        "type": "choice",
        "criteria": {
          "billing": "Paiements, factures et remboursements",
          "technical": "Questions techniques sur un service",
          "sales": null
        }
      }
    }
  }'
```

La réponse ressemble à ce qui suit :

```json
{
  "model": "clef-flash",
  "answers": {
    "department": {
      "type": "choice",
      "choice": "billing",
      "confidence": 0.968,
      "probabilities": {
        "billing": 0.968,
        "technical": 0.026,
        "sales": 0.006
      }
    }
  },
  "usage": {
    "input_tokens": 167,
    "output_tokens": 0
  },
  "object": "decision"
}
```

Seuls les tokens d'entrée (`usage.input_tokens`) sont facturés : les modèles de décision ne génèrent pas de texte, `output_tokens` vaut donc `0`.

### Poser plusieurs questions à la fois

Vous pouvez poser plusieurs questions sur le même texte dans une seule requête. Chaque question est identifiée par sa clé dans `questions` et sa réponse revient sous la même clé dans `answers`.

L'exemple suivant combine les trois types de questions sur un même message client :

#### Python

```python
import os
import requests

url = "https://oai.endpoints.kepler.ai.cloud.ovh.net/api/v1/systemone"
headers = {
    "Authorization": f"Bearer {os.getenv('OVH_AI_ENDPOINTS_ACCESS_TOKEN')}",
    "Content-Type": "application/json"
}
payload = {
    "model": "clef-flash",
    "state": "Bonjour, je viens de déployer ma première instance Public Cloud et je souhaite activer les sauvegardes automatiques avant le lancement de mon site la semaine prochaine. Comment procéder, et pour quel tarif ?",
    "questions": {
        "department": {
            "type": "choice",
            "criteria": {
                "billing": "Problèmes de facture, de paiement ou d'abonnement",
                "technical": "Questions techniques sur un service",
                "sales": "Tarifs, offres ou questions sur les produits"
            }
        },
        "frustration": {
            "type": "score",
            "criteria": [
                "Calme, expose simplement les faits",
                "Frustré mais courtois",
                "Très en colère, langage virulent"
            ]
        },
        "is_urgent": {
            "type": "noul",
            "instructions": "Le message exprime une urgence ou une contrainte de temps"
        }
    }
}

response = requests.post(url, json=payload, headers=headers)

if response.status_code == 200:
    for question, answer in response.json()["answers"].items():
        print(question, answer)
else:
    print("Error:", response.status_code, response.text)
```

#### JavaScript

```javascript
const url = "https://oai.endpoints.kepler.ai.cloud.ovh.net/api/v1/systemone";

const payload = {
  model: "clef-flash",
  state: "Bonjour, je viens de déployer ma première instance Public Cloud et je souhaite activer les sauvegardes automatiques avant le lancement de mon site la semaine prochaine. Comment procéder, et pour quel tarif ?",
  questions: {
    department: {
      type: "choice",
      criteria: {
        billing: "Problèmes de facture, de paiement ou d'abonnement",
        technical: "Questions techniques sur un service",
        sales: "Tarifs, offres ou questions sur les produits",
      },
    },
    frustration: {
      type: "score",
      criteria: [
        "Calme, expose simplement les faits",
        "Frustré mais courtois",
        "Très en colère, langage virulent",
      ],
    },
    is_urgent: {
      type: "noul",
      instructions: "Le message exprime une urgence ou une contrainte de temps",
    },
  },
};

const response = await fetch(url, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.OVH_AI_ENDPOINTS_ACCESS_TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

if (response.ok) {
  const { answers } = await response.json();
  for (const [question, answer] of Object.entries(answers)) {
    console.log(question, answer);
  }
} else {
  console.error("Error:", response.status, await response.text());
}
```

#### cURL

```sh
curl https://oai.endpoints.kepler.ai.cloud.ovh.net/api/v1/systemone \
  -H "Authorization: Bearer $OVH_AI_ENDPOINTS_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "clef-flash",
    "state": "Bonjour, je viens de déployer ma première instance Public Cloud et je souhaite activer les sauvegardes automatiques avant le lancement de mon site la semaine prochaine. Comment procéder, et pour quel tarif ?",
    "questions": {
      "department": {
        "type": "choice",
        "criteria": {
          "billing": "Problèmes de facture, de paiement ou d'\''abonnement",
          "technical": "Questions techniques sur un service",
          "sales": "Tarifs, offres ou questions sur les produits"
        }
      },
      "frustration": {
        "type": "score",
        "criteria": [
          "Calme, expose simplement les faits",
          "Frustré mais courtois",
          "Très en colère, langage virulent"
        ]
      },
      "is_urgent": {
        "type": "noul",
        "instructions": "Le message exprime une urgence ou une contrainte de temps"
      }
    }
  }'
```

L'exemple Python affiche une ligne par question. La sortie ressemble à ceci :

```text
department {'type': 'choice', 'choice': 'technical', 'confidence': 0.6382, 'probabilities': {'billing': 0.0294, 'technical': 0.6382, 'sales': 0.3324}}
frustration {'type': 'score', 'score': 0.0242, 'confidence': 0.9774, 'legend': {'0': 'Calme, expose simplement les faits', '1': 'Frustré mais courtois', '2': 'Très en colère, langage virulent'}, 'probabilities': {'0': 0.9774, '1': 0.0209, '2': 0.0016}}
is_urgent {'type': 'noul', 'noul': 0.175}
```

## Types de questions

### Choice

Une question `choice` choisit **une option** parmi une liste que vous définissez.

```json
"department": {
  "type": "choice",
  "instructions": "Quel service doit traiter ce message ?",
  "criteria": {
    "billing": "Problèmes de facture, de paiement ou d'abonnement",
    "technical": "Questions techniques sur un service",
    "sales": null
  }
}
```

- `criteria` est un objet dont chaque **clé est une option** et chaque **valeur est une description** qui aide le modèle à comprendre le sens de l'option.
- La description peut être `null` lorsque le nom de l'option se suffit à lui-même. Des descriptions précises conduisent généralement à des réponses plus fiables.
- `instructions` indique ce qui est demandé. Il est facultatif pour une question `choice`, mais recommandé.
- **L'ordre compte** : conservez un ordre stable et ne triez pas les options différemment d'une requête à l'autre.

La réponse contient le `choice` sélectionné, les `probabilities` de chaque option (dont la somme vaut 1) et la `confidence` accordée au choix sélectionné, comprise entre 0 et 1 (plus la valeur est élevée, plus la certitude est grande) :

```json
{
  "type": "choice",
  "choice": "technical",
  "confidence": 0.6382,
  "probabilities": { "billing": 0.0294, "technical": 0.6382, "sales": 0.3324 }
}
```

### Score

Une question `score` évalue le texte sur des **niveaux ordonnés**.

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

- `criteria` est une **liste ordonnée** qui décrit chaque niveau de l'échelle, du plus bas au plus élevé. Le premier élément correspond au niveau `0`, le deuxième au niveau `1`, et ainsi de suite. Fournissez entre 2 et 10 niveaux.
- `instructions` indique ce qui est demandé. Il est facultatif pour une question `score`, mais recommandé.
- **L'ordre compte** : ne réordonnez pas les niveaux d'une requête à l'autre.

La réponse contient le `score`, une `legend` qui associe chaque niveau à sa description, les `probabilities` de chaque niveau et la même `confidence` que pour une question `choice` :

```json
{
  "type": "score",
  "score": 0.0242,
  "confidence": 0.9774,
  "legend": {
    "0": "Calme, expose simplement les faits",
    "1": "Frustré mais courtois",
    "2": "Très en colère, langage virulent"
  },
  "probabilities": { "0": 0.9774, "1": 0.0209, "2": 0.0016 }
}
```

Le `score` est une **valeur continue** comprise entre le niveau le plus bas et le niveau le plus élevé. Il s'agit de la moyenne des niveaux pondérée par leur probabilité (ici, `0 × 0,9774 + 1 × 0,0209 + 2 × 0,0016 ≈ 0,024`), ce qui permet de distinguer un texte clairement situé sur un niveau d'un texte situé entre deux niveaux.

### Noul

Une question `noul` répond par **oui ou non** à une question sur le texte.

```json
"is_urgent": {
  "type": "noul",
  "instructions": "Le message exprime une urgence ou une contrainte de temps"
}
```

- `instructions` est obligatoire pour une question `noul`. Il s'agit d'une affirmation qui décrit la propriété à vérifier, et la réponse est la probabilité que cette affirmation soit vraie pour le texte.
- `criteria` est facultatif. Il peut être omis, ou contenir les clés optionnelles `"true"` et `"false"` pour décrire le sens de chaque réponse.

La réponse contient une valeur unique comprise entre `0` et `1` :

```json
{
  "type": "noul",
  "noul": 0.175
}
```

Une valeur proche de `1` signifie que l'affirmation est très probablement vraie, une valeur proche de `0` qu'elle est très probablement fausse.

## Limites de l'endpoint

- Les modèles de décision lisent **uniquement du texte** : les images, l'audio et les champs inconnus dans la requête sont refusés.
- Une question `choice` accepte de 2 à 255 options et une question `score` de 2 à 10 niveaux.
- Le contexte de `clef-flash` est de 16 384 tokens, état et questions compris.
- Les limites de débit sont décrites dans le guide « [AI Endpoints - Caractéristiques, capacités et limites](https://docs.ovhcloud.com/fr/guides/public-cloud/ai-machine-learning/ai-endpoints-capabilities.md) ».
- La qualité des réponses dépend de la clarté de vos critères et de vos instructions. Utilisez des options distinctes et des descriptions précises.

## Conclusion

Dans ce guide, nous avons expliqué comment utiliser les modèles de décision disponibles sur [AI Endpoints](https://www.ovhcloud.com/fr/public-cloud/ai-endpoints/). Vous pouvez désormais classer, noter et qualifier des textes avec des probabilités calibrées via le format System One, et intégrer ces réponses dans vos propres applications.

## Aller plus loin

Parcourez la [documentation AI Endpoints](https://docs.ovhcloud.com/fr/guides/public-cloud/ai-machine-learning/overview.md) complète pour mieux comprendre les concepts principaux et démarrer.

Pour une formation ou une assistance technique sur la mise en œuvre de nos solutions, contactez votre commercial ou consultez la page [Professional Services](https://www.ovhcloud.com/fr/professional-services/) pour obtenir un devis et faire analyser votre projet par nos experts.

## Votre avis nous intéresse !

N’hésitez pas à nous faire part de vos questions, retours et suggestions pour améliorer le service :

- Sur le [serveur Discord OVHcloud](https://discord.gg/ovhcloud)
