---
title: Langage Toxique
slug: langage-toxique
createdAt: 2025-11-12T19:00:24.686Z
---

Le garde-fou de 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.

knmknknkjn

![]()

## Quand utiliser ce garde-fou

![]()



![](https://api.archbee.com/api/optimize/511c8QBH-VHiwWnyzIwUb/VykU-mmfrerRGqlMnfIsU-20260413-174252.png)

L'avantage clé par rapport au 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 de la barrière de protection. 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 sensibilité faible 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 suis fortement en désaccord 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.

La sensibilité faible 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 pourraient encore passer.

La sensibilité moyenne est le paramètre par défaut et représente une approche équilibrée. À ce niveau, la barrière de protection signale 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" échoueraient.

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.

La 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 un contenu comme "Peu importe, mec" ou "C'est plutôt stupide" échouerait. 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 contre le 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é traitent divers types de contenu. Comprendre ces schémas 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 qui passe à tous les niveaux de sensibilité. Le langage est neutre et respectueux malgré l'expression du désaccord.

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

Un message comme "Tu ne sais pas de quoi tu parles" échoue à un niveau de sensibilité moyen et élevé car il attaque directement la compétence de la personne. Cela pourrait passer à faible sensibilité puisqu'il 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 place 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 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 dommages causés par l'autorisation de contenu toxique l'emporte de loin sur le coût des faux positifs.

Si vous construisez une application destinée aux clients 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 pourraient avoir 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 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'exécuter 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.

```javascript
asdasdasdasdasdasdasdasdasdsa
```

