guide

Comment ajouter la modération de contenu à votre chatbot ou agent IA

EvoLink Team

Product Team

29 avril 2026

10 min de lecture

Ajouter la modération de contenu à un chatbot ou à un agent IA ne se résume pas à bloquer les gros mots. Un workflow de production doit vérifier les entrées utilisateur, les sorties du modèle et les actions que l'agent est autorisé à exécuter.

Le modèle mental le plus sûr est le suivant :

input moderation
  -> model or agent reasoning
  -> tool-call validation
  -> output moderation
  -> allow / review / block

Ce guide vous montre où placer chaque couche, ce que la modération peut et ne peut pas résoudre, et comment utiliser EvoLink Moderation 1.0 pour un routage simple basé sur le niveau de risque.

En bref

Modérez les entrées utilisateur avant qu'elles n'atteignent votre chatbot ou agent.
Modérez les sorties du modèle avant qu'elles ne soient visibles par les utilisateurs.
Validez les appels d'outils avant qu'un agent n'exécute une action.
Ne considérez pas la modération de contenu comme une défense complète contre l'injection de prompt.
Faites appel à l'examen humain pour les cas à risque moyen ou à fort impact.
Le champ evolink_summary.risk_level d'EvoLink peut simplifier la logique autoriser / examiner / bloquer.

La modération de contenu n'est pas la même chose que la sécurité des agents

La modération de contenu permet d'identifier du texte ou des images nuisibles. Elle peut réduire le risque de prompts dangereux, de sorties nocives et de contenus utilisateur contraires aux politiques d'utilisation.

La sécurité des agents est plus large. Elle englobe l'injection de prompt, les permissions d'outils, l'accès aux données, les approbations humaines, les sorties structurées, les évaluations, la journalisation et la conception des workflows.

Le guide de sécurité des agents d'OpenAI recommande de combiner des techniques telles que les garde-fous, les approbations d'outils, l'évaluation des traces, les évaluations et la conception structurée des workflows. L'OWASP traite également l'injection de prompt comme un risque de sécurité LLM distinct pouvant entraîner des fuites de données, des actions non souhaitées ou un détournement d'outils.

Sources :

Le point essentiel : la modération est un garde-fou parmi d'autres. Elle ne doit pas être le seul.

Couche 1 : modération des entrées

La modération des entrées vérifie le message de l'utilisateur avant qu'il n'atteigne votre modèle.

Elle permet de détecter :

les demandes manifestement nuisibles
les messages utilisateur contraires aux politiques
les textes abusifs ou harcelants
les images téléchargées non sécurisées
les prompts demandant du contenu interdit

La modération des entrées est utile car elle empêche les requêtes manifestement dangereuses d'entrer dans le workflow du modèle.

def handle_user_message(user_input: str):
    input_check = client.moderations.create(
        model="evolink-moderation-1.0",
        input=user_input
    )

    if input_check.evolink_summary.risk_level == "high":
        return {
            "status": "blocked",
            "message": "I can't help with that request."
        }

    return run_chatbot(user_input)

Limitation importante : la modération des entrées ne constitue pas une défense complète contre l'injection de prompt. Les attaquants peuvent utiliser des prompts indirects, du texte encodé, des images, des documents externes ou des sorties d'outils pour influencer les agents plus loin dans le workflow.

Couche 2 : modération des sorties

La modération des sorties vérifie la réponse du modèle avant qu'elle n'atteigne l'utilisateur.

Elle permet de détecter :

le contenu généré non sécurisé
les réponses contraires aux politiques
les conseils nuisibles dans des domaines sensibles
les réponses qui passent à travers malgré une entrée apparemment inoffensive

def safe_chat(user_input: str):
    input_check = moderate(user_input)
    if input_check.evolink_summary.risk_level == "high":
        return "I can't help with that request."

    answer = llm.generate(user_input)

    output_check = moderate(answer)
    if output_check.evolink_summary.risk_level == "high":
        return "I generated a response that needs to be revised. Please try rephrasing."

    return answer

La modération des sorties est particulièrement utile pour les chatbots publics, les copilotes IA et les workflows de génération de contenu où la réponse du modèle est visible par l'utilisateur.

Couche 3 : validation des appels d'outils

Pour les agents IA, les appels d'outils représentent souvent la couche la plus risquée.

Si un agent peut envoyer des e-mails, interroger des bases de données, mettre à jour des tickets, appeler des API ou écrire des fichiers, l'appel d'outil doit être validé avant exécution. Il ne s'agit pas seulement de modération, mais aussi d'autorisation et d'application des politiques.

Éléments à valider :

le nom de l'outil
le périmètre autorisé par utilisateur ou compte
l'approbation humaine requise
les valeurs de paramètres autorisées
les opérations de lecture vs écriture
les destinataires externes
les actions destructrices
le risque d'exfiltration de données

def validate_tool_call(tool_name: str, args: dict, user_context: dict):
    if tool_name == "send_email":
        if not args["to"].endswith("@company.com"):
            return False, "External email requires approval."

    if tool_name == "database_query":
        query = args.get("query", "")
        forbidden = ["DROP ", "DELETE ", "TRUNCATE "]
        if any(word in query.upper() for word in forbidden):
            return False, "Destructive database operation blocked."

    if tool_name == "refund_customer":
        if args["amount"] > user_context["approval_limit"]:
            return False, "Refund amount requires human approval."

    return True, None

Le guide de sécurité des agents d'OpenAI recommande également de maintenir les approbations d'outils activées pour les outils MCP afin que les utilisateurs finaux puissent examiner et confirmer les opérations.

Couche 4 : routage autoriser / examiner / bloquer

Une modération binaire sûr/dangereux est généralement trop rigide. Un schéma de production plus utile est :

Risque	Action
Faible	autoriser
Moyen	mettre en file d'examen, avertir ou limiter la diffusion
Élevé	bloquer ou exiger un recours

EvoLink Moderation renvoie un champ evolink_summary.risk_level conçu pour ce type de routage.

def route_by_risk(content: str):
    result = client.moderations.create(
        model="evolink-moderation-1.0",
        input=content
    )

    risk = result.evolink_summary.risk_level

    if risk == "high":
        log_block(result)
        return {"action": "block"}

    if risk == "medium":
        queue_for_review(content, result)
        return {"action": "review"}

    return {"action": "allow"}

Pour les détails de l'API, consultez la documentation de l'API EvoLink Moderation.

Schéma complet de modération pour chatbot

Voici une structure pratique de bout en bout :

def handle_chatbot_turn(user_input: str, user_context: dict):
    # 1. Moderate input
    input_route = route_by_risk(user_input)
    if input_route["action"] == "block":
        return "I can't help with that request."
    if input_route["action"] == "review":
        log_review_event("input", user_input)

    # 2. Generate model response and proposed tool calls
    agent_result = agent.run(user_input, user_context)

    # 3. Validate tool calls before execution
    for call in agent_result.tool_calls:
        ok, reason = validate_tool_call(call.name, call.args, user_context)
        if not ok:
            log_security_event(call, reason)
            return "That action requires additional review."

    # 4. Execute approved tools
    tool_outputs = execute_tool_calls(agent_result.tool_calls)

    # 5. Generate final response
    final_answer = agent.format_response(tool_outputs)

    # 6. Moderate output
    output_route = route_by_risk(final_answer)
    if output_route["action"] == "block":
        return "I need to revise that response."
    if output_route["action"] == "review":
        queue_for_review(final_answer, output_route)

    return final_answer

L'implémentation exacte variera, mais la structure reste stable : vérifier l'entrée, contraindre les actions, vérifier la sortie et journaliser les décisions.

Gestion des faux positifs

Les faux positifs sont inévitables. L'objectif est de réduire les risques sans bloquer trop souvent les utilisateurs légitimes.

Utilisez une file d'examen pour :

le contenu à risque moyen
le contexte ambigu
les catégories sensibles en termes de politique
les utilisateurs à forte valeur ou les actions à fort impact
les recours

Journalisez chaque décision de modération avec suffisamment de contexte pour déboguer ultérieurement :

hash du contenu
identifiant utilisateur ou identifiant de compte
niveau de risque
catégories déclenchées
action entreprise
réévaluation par un examinateur
horodatage

Évitez de journaliser le contenu sensible brut à moins de disposer d'une politique claire de conservation et de confidentialité.

Ce que vous pouvez promettre en interne

Ne promettez pas que la modération rend un chatbot « sûr à 100 % ».

Une promesse plus réaliste est :

les entrées nuisibles sont vérifiées avant l'exécution du modèle
les sorties du modèle sont vérifiées avant l'affichage à l'utilisateur
les appels d'outils de l'agent sont validés avant exécution
les cas à haut risque ou ambigus peuvent être transmis à des humains
les journaux et les résultats d'examen servent à affiner les seuils

Voilà une posture de production réaliste.

Erreurs courantes

Erreur 1 : ne modérer que les entrées

Les vérifications d'entrée sont utiles, mais le modèle peut tout de même générer des sorties non sécurisées. Modérez les sorties avant de les montrer aux utilisateurs.

Erreur 2 : considérer les prompts comme des barrières de sécurité

Les prompts système orientent le comportement, mais ils ne doivent pas constituer la seule couche de sécurité. Utilisez les permissions d'outils, les workflows structurés et les approbations.

Erreur 3 : laisser les agents exécuter des outils sans validation

Validez toujours les appels d'outils en dehors du modèle. Le modèle doit proposer des actions ; c'est votre application qui décide si l'action est autorisée.

Erreur 4 : bloquer systématiquement les cas incertains

Des systèmes trop stricts génèrent de la frustration chez les utilisateurs. Envoyez les cas incertains vers la file d'examen au lieu de toujours les bloquer.

Erreur 5 : ne conserver aucun journal

Sans journaux, vous ne pouvez pas ajuster les seuils, investiguer les incidents ni comprendre les faux positifs.

Checklist d'implémentation

Modérer les entrées utilisateur avant les appels au modèle.
Modérer les sorties du modèle avant l'affichage à l'utilisateur.
Valider les appels d'outils de l'agent avant exécution.
Utiliser le routage autoriser / examiner / bloquer.
Mettre en file d'examen le contenu à risque moyen.
Ajouter un système de signalement et de recours si nécessaire.
Journaliser les niveaux de risque, catégories, actions et réévaluations.
Éviter de stocker le contenu sensible brut sauf obligation.
Tester avec des exemples réels issus de votre produit.
Réexaminer les seuils une fois les données de production disponibles.

FAQ

Faut-il modérer les entrées ou les sorties du chatbot ?

Les deux. La modération des entrées peut réduire les requêtes dangereuses avant qu'elles n'atteignent le modèle. La modération des sorties peut intercepter le contenu généré non sécurisé avant que les utilisateurs ne le voient.

La modération de contenu empêche-t-elle l'injection de prompt ?

Non. La modération peut détecter certains contenus dangereux ou suspects, mais l'injection de prompt nécessite des défenses plus larges telles que la validation des outils, les sorties structurées, le principe du moindre privilège, les approbations humaines et l'isolation des workflows.

Où placer la modération dans un agent IA ?

Placez la modération avant le modèle pour les entrées utilisateur, avant l'affichage pour les sorties du modèle, et combinez-la avec la validation des appels d'outils avant l'exécution de toute action de l'agent.

En quoi EvoLink aide-t-il pour la modération de chatbot ?

EvoLink Moderation 1.0 fournit un endpoint de modération compatible OpenAI avec evolink_summary.risk_level, facilitant le routage du contenu de chatbot vers des workflows autoriser, examiner ou bloquer.

L'examen humain est-il toujours nécessaire ?

Pour les systèmes en production, oui. L'examen humain est important pour les recours, les cas à risque moyen, les évolutions de politique et les décisions à fort impact.