---
title: Langage Toxique
slug: 1Phg-langage-toxique
createdAt: 2025-11-12T18:49:52.143Z
---

Le garde-fou contre le langage toxique détecte le contenu nuisible, y compris les discours de haine, les menaces, les insultes et d'autres communications qui pourraient nuire à votre communauté ou à votre marque. Contrairement aux simples filtres de mots-clés, ce garde-fou utilise l'IA pour comprendre le contexte, le ton et l'intention.

## Quand utiliser ce garde-fou

Vous devriez utiliser la détection de langage toxique lorsque vous devez protéger votre communauté des interactions nuisibles, empêcher votre IA de recevoir un contexte empoisonné qui pourrait influencer son comportement, ou maintenir la sécurité de la marque dans les résultats générés par l'IA. Ce garde-fou est particulièrement précieux dans les applications avec du contenu généré par les utilisateurs, comme les forums, les systèmes de chat et les sections de commentaires, ainsi que dans les scénarios de service client où vous devez attraper des messages hostiles avant qu'ils n'atteignent les agents ou les systèmes d'IA.

L'avantage clé par rapport à un simple filtrage par mots-clés est que ce garde-fou comprend les nuances. Quelqu'un peut être hostile sans utiliser de grossièretés, et il peut utiliser un langage fort sans être hostile. Le garde-fou analyse l'intention et le ton, pas seulement le choix des mots.

## Comprendre les niveaux de sensibilité

Le paramètre de sensibilité contrôle la rigueur du garde-fou. Pensez-y comme à l'ajustement du seuil de ce qui constitue une violation. C'est l'un des choix de configuration les plus importants que vous ferez, car il change fondamentalement le contenu qui passe ou échoue.

Une faible sensibilité ne signale que les violations graves comme les menaces explicites et les discours de haine extrêmes. Lorsque vous réglez la sensibilité sur faible, vous dites que vous vous attendez à des opinions fortes et à des désaccords robustes, et que vous ne voulez bloquer que le contenu qui franchit une ligne claire vers un territoire menaçant ou haineux. Par exemple, "Je ne suis pas d'accord avec cette approche et je pense qu'elle est mal orientée" passerait à faible sensibilité, tout comme "C'est une terrible idée." Seul un contenu comme "Je te trouverai et je te ferai du mal" ou un discours de haine explicite échouerait.

Une faible sensibilité fonctionne bien pour les forums publics où le débat est attendu, les environnements de retour professionnel où la franchise est valorisée, et les communautés techniques où les gens discutent de sujets controversés. Le compromis est que certains contenus qui mettent les gens mal à l'aise peuvent encore passer.

La sensibilité moyenne est le paramètre par défaut et représente une approche équilibrée. À ce niveau, les garde-fous signalent les violations claires, y compris les insultes et le langage hostile, tout en permettant encore le désaccord professionnel et la critique constructive. Un message comme "Je ne suis pas d'accord avec votre raisonnement" passerait, mais "Tu es un idiot" ou "Des gens comme vous sont le problème" échouerait.

La sensibilité moyenne fonctionne bien pour la plupart des applications, y compris les systèmes de service client, les communications professionnelles, les outils collaboratifs et les plateformes sociales. Elle trouve un équilibre entre la possibilité d'un discours significatif et le maintien d'un environnement respectueux.

Une haute sensibilité crée l'environnement le plus strict en signalant tout contenu potentiellement toxique, y compris la légèreté de la grossièreté et le langage désinvolte. À ce niveau, même des contenus comme "Quoi qu'il en soit, mec" ou "C'est plutôt stupide" échoueraient. Seul un contenu respectueux et neutre passe à haute sensibilité.

Une haute sensibilité est appropriée pour les applications destinées aux enfants où vous avez besoin d'une protection maximale, les plateformes éducatives où vous souhaitez modéliser une communication respectueuse, les espaces sûrs et les communautés de soutien où les gens ont besoin de se sentir en sécurité, et les contextes critiques en matière de conformité où tout problème potentiel doit être détecté.

## Options de configuration

Le garde-fou de langage toxique accepte plusieurs options de configuration qui vous permettent d'ajuster son comportement pour votre cas d'utilisation spécifique.

```typescript
// Available options:
// sensitivity: "low", "medium", or "high" (default: "medium")
// model: model identifier (default: Claude 3.5 Haiku)
// temperature: 0-1, lower values = more consistent (default: 0.1)
// maxTokens: response length limit (default: 200)

await abv.guardrails.toxicLanguage.validate(text, {
  sensitivity: "medium",
  model: "model-name",
  temperature: 0.1,
  maxTokens: 200,
});
```

```python
# Available options:
# sensitivity: "low", "medium", or "high" (default: "medium")
# model: model identifier (default: Claude 3.5 Haiku)
# temperature: 0-1, lower values = more consistent (default: 0.1)
# maxTokens: response length limit (default: 200)

abv.guardrails.toxic_language.validate(text, {
    "sensitivity": "medium",
    "model": "model-name",
    "temperature": 0.1,
    "maxTokens": 200
})
```

L'option de sensibilité est la plus importante et vous l'utiliserez fréquemment. Les options de modèle, de température et de maxTokens sont des paramètres avancés que vous n'aurez généralement pas besoin de modifier. Le modèle par défaut est optimisé pour les tâches de garde-fou et offre le meilleur équilibre entre vitesse, précision et coût. La température par défaut de 0.1 garantit des résultats cohérents. Le maxTokens par défaut de 200 est suffisant pour le champ d'explication.

## Exemples du monde réel

Examinons des exemples concrets de la manière dont différents niveaux de sensibilité gèrent divers types de contenu. Comprendre ces modèles vous aidera à choisir la bonne sensibilité pour votre application.

Considérez un message comme "Je ne suis pas d'accord avec votre approche de ce problème." Il s'agit d'un désaccord professionnel et il passe à tous les niveaux de sensibilité. Le langage est neutre et respectueux malgré l'expression d'un désaccord.

Considérez maintenant "C'est une terrible idée et montre un mauvais jugement." Cela passe à faible et moyenne sensibilité car, bien que critique, cela se concentre sur l'idée plutôt que d'attaquer la personne. Cependant, cela pourrait échouer à haute sensibilité car "terrible" et "mauvais jugement" pourraient être considérés comme désinvoltes.

Un message comme "Tu ne sais pas de quoi tu parles" échoue à moyenne et haute sensibilité car il attaque directement la compétence de la personne. Cela pourrait passer à faible sensibilité puisque cela ne contient pas de menaces explicites ou de discours de haine, bien que ce soit limite.

Un contenu comme "Tu es un idiot" ou "Les gens comme toi sont le problème" échoue à tous les niveaux de sensibilité. Ce sont des attaques personnelles claires sans valeur constructive.

Enfin, des menaces explicites comme "Je te trouverai et je te ferai du mal" échouent à tous les niveaux de sensibilité avec une confiance maximale. C'est un contenu toxique sans ambiguïté.

## Modèles de mise en œuvre

Voici comment vous utiliseriez typiquement la détection de langage toxique dans différentes parties de votre application.

Pour la validation des entrées, vous vérifiez les messages des utilisateurs avant de les envoyer à votre IA ou de les afficher à d'autres utilisateurs :

```typescript
async function validateUserMessage(message: string): Promise<boolean> {
  const result = await abv.guardrails.toxicLanguage.validate(
    message,
    { sensitivity: "medium" }
  );

  if (result.status === "pass") {
    return true;
  }

  // Log the reason for monitoring, but don't expose it to the user
  console.log("Blocked message:", result.reason);
  return false;
}

// Usage in your message handler
if (await validateUserMessage(userInput)) {
  await processMessage(userInput);
} else {
  return { error: "Your message violates our community guidelines." };
}
```

```python
async def validate_user_message(message: str) -> bool:
    result = await abv.guardrails.toxic_language.validate_async(
        message,
        {"sensitivity": "medium"}
    )
    
    if result["status"] == "pass":
        return True
    
    # Log the reason for monitoring, but don't expose it to the user
    print(f"Blocked message: {result['reason']}")
    return False

# Usage in your message handler
if await validate_user_message(user_input):
    await process_message(user_input)
else:
    return {"error": "Your message violates our community guidelines."}
```

Pour la validation des sorties, vous vérifiez les réponses générées par l'IA avant de les montrer aux utilisateurs :

```typescript
async function generateSafeResponse(prompt: string): Promise<string> {
  // Generate initial response
  let response = await callAI(prompt);

  // Validate the response
  const validation = await abv.guardrails.toxicLanguage.validate(
    response,
    { sensitivity: "high" }
  );

  // If toxic, regenerate with explicit safety instruction
  if (validation.status === "fail") {
    response = await callAI(
      prompt + "\n\nIMPORTANT: Respond in a professional, respectful tone."
    );
  }

  return response;
}
```

```python
async def generate_safe_response(prompt: str) -> str:
    # Generate initial response
    response = await call_ai(prompt)
    
    # Validate the response
    validation = await abv.guardrails.toxic_language.validate_async(
        response,
        {"sensitivity": "high"}
    )
    
    # If toxic, regenerate with explicit safety instruction
    if validation["status"] == "fail":
        response = await call_ai(
            f"{prompt}\n\nIMPORTANT: Respond in a professional, respectful tone."
        )
    
    return response
```

Pour gérer les cas ambigus, vous pourriez mettre en œuvre une file d'attente de révision pour les résultats incertains :

```typescript
async function handleUserContent(content: string) {
  const result = await abv.guardrails.toxicLanguage.validate(
    content,
    { sensitivity: "medium" }
  );

  if (result.status === "pass") {
    // Content is clearly acceptable
    await publishContent(content);
  } else if (result.status === "fail" && result.confidence > 0.8) {
    // High-confidence violation, auto-reject
    await rejectContent(content, "Community guidelines violation");
  } else {
    // Low confidence or unsure - flag for human review
    await flagForModeration(content, result);
  }
}
```

```python
async def handle_user_content(content: str):
    result = await abv.guardrails.toxic_language.validate_async(
        content,
        {"sensitivity": "medium"}
    )
    
    if result["status"] == "pass":
        # Content is clearly acceptable
        await publish_content(content)
    elif result["status"] == "fail" and result["confidence"] > 0.8:
        # High-confidence violation, auto-reject
        await reject_content(content, "Community guidelines violation")
    else:
        # Low confidence or unsure - flag for human review
        await flag_for_moderation(content, result)
```

## Optimisation des performances

Puisque la détection de langage toxique utilise l'IA, cela prend de une à trois secondes par vérification et consomme des jetons. Vous pouvez optimiser les performances en effectuant d'abord une vérification rapide basée sur des règles pour attraper les violations évidentes avant de faire l'appel coûteux à l'IA.

```typescript
async function efficientToxicCheck(text: string): Promise<boolean> {
  // Quick check for explicitly forbidden terms (under 10ms, free)
  const quickCheck = await abv.guardrails.containsString.validate(
    text,
    {
      strings: ["explicit-slur", "forbidden-term"],
      mode: "none",
    }
  );

  // If quick check fails, no need for expensive AI check
  if (quickCheck.status === "fail") {
    return false;
  }

  // Only run AI check if quick check passed
  const deepCheck = await abv.guardrails.toxicLanguage.validate(text);
  return deepCheck.status === "pass";
}
```

```python
async def efficient_toxic_check(text: str) -> bool:
    # Quick check for explicitly forbidden terms (under 10ms, free)
    quick_check = await abv.guardrails.contains_string.validate_async(
        text,
        {
            "strings": ["explicit-slur", "forbidden-term"],
            "mode": "none"
        }
    )
    
    # If quick check fails, no need for expensive AI check
    if quick_check["status"] == "fail":
        return False
    
    # Only run AI check if quick check passed
    deep_check = await abv.guardrails.toxic_language.validate_async(text)
    return deep_check["status"] == "pass"
```

## Meilleures pratiques de sécurité

Ne jamais exposer le champ de raison aux utilisateurs finaux. La raison explique pourquoi le contenu a échoué à la validation, et exposer cette information aide les acteurs malveillants à apprendre comment contourner vos garde-fous. Au lieu de cela, utilisez des messages d'erreur génériques tout en enregistrant la raison détaillée en interne pour le suivi et l'amélioration.

```typescript
// Bad - exposes validation logic
if (result.status === "fail") {
  return { error: result.reason };  // Don't do this!
}

// Good - generic message, internal logging
if (result.status === "fail") {
  logger.info("Blocked toxic content", { reason: result.reason });
  return { error: "Your message violates our community guidelines." };
}
```

```python
# Bad - exposes validation logic
if result["status"] == "fail":
    return {"error": result["reason"]}  # Don't do this!

# Good - generic message, internal logging
if result["status"] == "fail":
    logger.info(f"Blocked toxic content: {result['reason']}")
    return {"error": "Your message violates our community guidelines."}
```

## Choisir la bonne sensibilité

Voici un cadre de décision pour choisir la sensibilité en fonction de votre type d'application. Si vous construisez pour des enfants ou des populations vulnérables, utilisez toujours une haute sensibilité. Le potentiel de préjudice causé par l'autorisation de contenu toxique l'emporte de loin sur le coût des faux positifs.

Si vous construisez une application orientée client comme un service client, des réseaux sociaux ou des outils collaboratifs, une sensibilité moyenne est généralement appropriée. Elle détecte les violations claires tout en permettant des désaccords professionnels.

Si vous construisez pour des publics professionnels ou techniques où un débat robuste est attendu, envisagez une faible sensibilité. Les forums techniques, les systèmes de révision de code et les outils de retour professionnel bénéficient de la possibilité d'exprimer des opinions fortes.

Vous pouvez également ajuster la sensibilité en fonction du contexte de l'utilisateur. Les utilisateurs authentifiés avec un bon historique peuvent bénéficier d'une sensibilité plus faible tandis que les utilisateurs anonymes obtiennent une sensibilité plus élevée. Les utilisateurs qui s'identifient comme mineurs obtiennent automatiquement une haute sensibilité, quelle que soit la configuration par défaut.

## Prochaines étapes

La barrière de langage toxique est souvent utilisée en parallèle avec d'autres barrières pour une validation complète du contenu. Envisagez de la combiner avec la détection de langage biaisé pour une solution de sécurité du contenu plus complète. Vous voudrez peut-être également utiliser une chaîne de contenu pour attraper rapidement les termes interdits explicites avant d'effectuer le contrôle de langage toxique plus coûteux.

Pour des conseils d'implémentation plus détaillés, consultez la documentation des meilleures pratiques qui couvre les stratégies d'optimisation, la gestion des erreurs et les approches de surveillance.
