L'API Moderation de Mistral

Classifier le contenu après génération

Les guardrails filtrent les prompts en entrée. Mais que faire du contenu généré par le modèle ? Un prompt anodin peut produire une réponse problématique. C’est le rôle de l’API Moderation : analyser le contenu a posteriori et attribuer des scores de risque par catégorie.

L’API Moderation est votre deuxième ligne de défense — elle complète les guardrails pour créer une architecture de sécurité complète.

Le modèle Mistral Moderation 2

Le modèle dédié à la modération s’appelle mistral-moderation-2603 (version de mars 2026). C’est un classifieur spécialisé, distinct des modèles de génération :

• Rapide : conçu pour la classification, pas la génération
• 11 catégories de contenu analysées simultanément
• Scores continus de 0.0 à 1.0 par catégorie
• Deux modes : texte brut ou conversationnel

L’endpoint /v1/moderations

Mode texte brut (raw-text)

Le mode le plus simple. Vous envoyez un ou plusieurs textes à classifier :

from mistralai import Mistral
import os

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# Modérer un texte simple
response = client.classifiers.moderate(
    model="mistral-moderation-2603",
    inputs=["Texte à analyser pour modération"]
)

# Accéder aux résultats
for result in response.results:
    print(f"Catégories : {result.categories}")
    print(f"Scores : {result.category_scores}")

Mode conversationnel

Pour modérer des échanges complets (prompt + réponse), utilisez le mode conversationnel :

# Modérer une conversation complète
response = client.classifiers.moderate_chat(
    model="mistral-moderation-2603",
    inputs=[
        [
            {"role": "user", "content": "Comment soigner un mal de tête ?"},
            {"role": "assistant", "content": "Prenez du paracétamol 1g..."}
        ]
    ]
)

# Le classifieur évalue le contexte complet
for result in response.results:
    print(f"Scores santé : {result.category_scores.get('health', 0)}")

Le mode conversationnel est plus précis car il prend en compte le contexte de l’échange. Un même texte peut avoir un score différent selon qu’il répond à une question légitime ou malveillante.

Structure de la réponse

La réponse de l’API contient pour chaque texte analysé :

{
  "id": "mod-abc123",
  "model": "mistral-moderation-2603",
  "results": [
    {
      "categories": {
        "sexual": false,
        "hate": false,
        "violence": false,
        "criminal": false,
        "selfharm": false,
        "health": true,
        "financial": false,
        "law": false,
        "pii": false,
        "jailbreaking": false,
        "unpredictable": false
      },
      "category_scores": {
        "sexual": 0.01,
        "hate": 0.02,
        "violence": 0.03,
        "criminal": 0.01,
        "selfharm": 0.01,
        "health": 0.72,
        "financial": 0.05,
        "law": 0.08,
        "pii": 0.02,
        "jailbreaking": 0.01,
        "unpredictable": 0.04
      }
    }
  ]
}

• categories : booléens selon les seuils par défaut de Mistral
• category_scores : scores bruts de 0.0 à 1.0 — c’est ce que vous utiliserez

Modérer plusieurs textes en batch

L’API accepte plusieurs textes dans une seule requête, idéal pour le traitement par lots :

# Modérer plusieurs textes en une seule requête
texts = [
    "Premier texte à analyser",
    "Deuxième texte à analyser",
    "Troisième texte à analyser"
]

response = client.classifiers.moderate(
    model="mistral-moderation-2603",
    inputs=texts
)

# Chaque texte a son propre résultat
for i, result in enumerate(response.results):
    max_score = max(result.category_scores.values())
    max_cat = max(result.category_scores, key=result.category_scores.get)
    print(f"Texte {i+1}: score max = {max_score:.2f} ({max_cat})")

Guardrails vs Moderation API : quand utiliser quoi

Exemple : pipeline complet

def pipeline_securise(user_message: str) -> dict:
    """Pipeline avec guardrails + modération."""
    # Étape 1 : Générer avec guardrails
    try:
        response = client.chat.complete(
            model="mistral-large-latest",
            messages=[{"role": "user", "content": user_message}],
            guardrails={
                "enabled": True,
                "custom_category_thresholds": {"jailbreaking": 0.1},
                "action": "block",
                "block_on_error": True
            }
        )
    except Exception as e:
        if "403" in str(e):
            return {"status": "blocked_input", "content": None}
        raise

    generated = response.choices[0].message.content

    # Étape 2 : Modérer la sortie
    moderation = client.classifiers.moderate(
        model="mistral-moderation-2603",
        inputs=[generated]
    )

    scores = moderation.results[0].category_scores
    max_score = max(scores.values())

    if max_score > 0.5:
        return {"status": "blocked_output", "scores": scores}

    return {"status": "ok", "content": generated, "scores": scores}

Points clés à retenir

• L’API Moderation utilise le modèle mistral-moderation-2603 pour classifier le contenu
• Deux modes disponibles : texte brut et conversationnel
• Les scores vont de 0.0 à 1.0 — vous définissez vos propres seuils de décision
• Le mode conversationnel est plus précis car il prend en compte le contexte
• Combinez guardrails (entrée) + modération (sortie) pour une défense en profondeur