Comprendre et configurer les paramètres de sécurité

Les modèles Gemini sont conçus en faisant de la sécurité la première des priorités. Toutefois, ils peuvent toujours générer des réponses nuisibles, en particulier lorsqu'ils reçoivent des requêtes explicites en ce sens. Pour renforcer la sécurité et limiter les cas d'utilisation abusive, vous pouvez configurer des filtres de sécurité afin de bloquer les réponses potentiellement nuisibles.

Deux niveaux de protection sont fournis :

• Protections de base intégrées :

  • Tous les modèles Gemini intègrent des protections contre les préjudices graves (tels que l'exploitation d'enfants, les cyberattaques et les armes dangereuses).
  • Ces protections sont toujours actives, appliquées automatiquement à toutes les requêtes et réponses, et ne peuvent pas être modifiées ni désactivées.

• Filtres de sécurité configurables :

  • Gemini API fournit des filtres de sécurité configurables supplémentaires que vous définissez à l'aide des paramètres de sécurité de votre application.
  • Ces paramètres vous permettent de contrôler le seuil à partir duquel le contenu est bloqué dans quatre principales catégories de préjudice : harcèlement, incitation à la haine, contenu à caractère sexuel explicite et contenu dangereux.

arrow_downward Accéder aux exemples de code

Concepts de sécurité importants

Voici quelques concepts importants à comprendre lorsque vous travaillez avec la sécurité des modèles Gemini :

• Paramètres de sécurité : configuration que vous définissez dans le code de votre application pour spécifier les catégories de préjudice à surveiller et le seuil à partir duquel bloquer le contenu.

• Filtres de sécurité : classificateurs côté serveur qui évaluent les prompts et les réponses du modèle par rapport aux dimensions de sécurité de Google. Les filtres bloquent le contenu en fonction des paramètres de sécurité que vous avez configurés.

• Scores de sécurité : métadonnées d'évaluation renvoyées par le modèle dans l'objet de réponse. Les évaluations indiquent la probabilité et la gravité des préjudices potentiels détectés pour chaque catégorie de préjudice.

Modèles compatibles

• gemini-4-argon
• gemini-3.8-flash (et les versions plus anciennes gemini-3.7-flash, gemini-3.6-flash et gemini-3.5-flash)
• gemini-3.5-flash-lite (et l'ancien gemini-3.1-flash-lite)
• gemini-nano-banana-2.1 (Nano Banana 2.1)
• gemini-3.1-flash-image (Nano Banana 2)
• gemini-3.1-flash-lite-image (Nano Banana 2 Lite)
• gemini-3-pro-image (Nano Banana Pro)

Le modèle gemini-3.1-pro-preview, ainsi que les modèles Gemini 2.5 à usage général et de génération d'images (qui sont obsolètes), sont également compatibles avec cette fonctionnalité.

Configurer les paramètres de sécurité dans votre application

Vous configurez les paramètres de sécurité lors de l'initialisation d'une instance GenerativeModel. La configuration est conservée pendant toute la durée de vie de cette instance de modèle.

Découvrez les catégories de préjudice disponibles et les seuils que vous pouvez définir pour chaque catégorie plus loin sur cette page.

import FirebaseAILogic

let safetySettings = [
  SafetySetting(harmCategory: .harassment, threshold: .blockOnlyHigh),
  SafetySetting(harmCategory: .hateSpeech, threshold: .blockMediumAndAbove)
]

// Specify the safety settings as part of creating the `GenerativeModel` instance.
let model = FirebaseAI.firebaseAI(backend: .googleAI()).generativeModel(
  modelName: "GEMINI_MODEL_NAME",
  safetySettings: safetySettings
)

// ...

// ...

val safetySettings = listOf(
    SafetySetting(HarmCategory.HARASSMENT, HarmBlockThreshold.ONLY_HIGH),
    SafetySetting(HarmCategory.HATE_SPEECH, HarmBlockThreshold.MEDIUM_AND_ABOVE)
)

// Specify the safety settings as part of creating the `GenerativeModel` instance.
val model = Firebase.ai(backend = GenerativeBackend.googleAI()).generativeModel(
    modelName = "GEMINI_MODEL_NAME",
    safetySettings = safetySettings
)

// ...

// ...

List safetySettings = List.of(
    new SafetySetting(HarmCategory.HARASSMENT, HarmBlockThreshold.ONLY_HIGH),
    new SafetySetting(HarmCategory.HATE_SPEECH, HarmBlockThreshold.MEDIUM_AND_ABOVE)
);

// Specify the safety settings as part of creating the `GenerativeModel` instance.
GenerativeModelFutures model = GenerativeModelFutures.from(
    FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel(
            /* modelName */ "GEMINI_MODEL_NAME",
            /* generationConfig is optional */ null,
            safetySettings
        )
);

// ...

import { HarmBlockThreshold, HarmCategory, getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

const safetySettings = [
  {
    category: HarmCategory.HARM_CATEGORY_HARASSMENT,
    threshold: HarmBlockThreshold.BLOCK_ONLY_HIGH,
  },
  {
    category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
    threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
  },
];

// Specify the safety settings as part of creating the `GenerativeModel` instance.
const model = getGenerativeModel(ai, {
  model: "GEMINI_MODEL_NAME",
  safetySettings,
});

// ...

import 'package:firebase_ai/firebase_ai.dart';

final safetySettings = [
  SafetySetting(HarmCategory.harassment, HarmBlockThreshold.high),
  SafetySetting(HarmCategory.hateSpeech, HarmBlockThreshold.medium),
];

// Specify the safety settings as part of creating the `GenerativeModel` instance.
final model = FirebaseAI.googleAI().generativeModel(
  model: 'GEMINI_MODEL_NAME',
  safetySettings: safetySettings,
);

// ...

// ...

var safetySettings = new SafetySetting[] {
  new SafetySetting(HarmCategory.Harassment, SafetySetting.HarmBlockThreshold.OnlyHigh),
  new SafetySetting(HarmCategory.HateSpeech, SafetySetting.HarmBlockThreshold.MediumAndAbove)
};

// Specify the safety settings as part of creating the `GenerativeModel` instance.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());
var model = ai.GetGenerativeModel(
  modelName: "GEMINI_MODEL_NAME",
  safetySettings: safetySettings
);

// ...

Catégories de préjudice disponibles

Les filtres de sécurité évaluent les prompts et les réponses du modèle par rapport aux catégories de préjudice configurables suivantes :

Filtres de sécurité non configurables

En plus des catégories configurables, toutes les requêtes passent par des filtres au niveau du système qui ne peuvent pas être ajustés :

• Contenus d'abus sexuels sur mineurs/Contenu interdit : les requêtes ou les réponses signalées pour contenu interdit sont immédiatement bloquées (PROHIBITED_CONTENT).

• Informations personnelles sensibles : les réponses susceptibles d'exposer des données à caractère personnel sensibles (comme des numéros de compte financier ou des numéros d'identification nationale) sont bloquées (SPII).

Définir les seuils

Pour chaque catégorie de préjudice que vous souhaitez contrôler dans votre application, vous devez définir un seuil. Si le contenu évalué atteint ou dépasse ce seuil, il est bloqué.

Fonctionnement de l'évaluation de la sécurité : probabilité et gravité

Les filtres de sécurité évaluent le contenu selon deux dimensions distinctes :

• Probabilité : niveau de confiance du modèle quant à l'appartenance du contenu à une catégorie de préjudice donnée.

• Gravité : ampleur ou degré du préjudice potentiel si le contenu est nuisible.

Chaque dimension se voit attribuer l'un des niveaux suivants : NEGLIGIBLE, LOW, MEDIUM ou HIGH.

Un contenu peut avoir une probabilité élevée avec un niveau de gravité faible (par exemple, des plaisanteries légères ou des insultes amicales) ou une probabilité faible avec un niveau de gravité élevé (par exemple, des discussions médicales ou historiques mentionnant de la violence).

Seuils de blocage de préjudice disponibles

Vous pouvez définir l'un des seuils suivants pour les catégories de préjudice que vous souhaitez contrôler dans votre application :

Inspecter les évaluations de sécurité et gérer le contenu bloqué

Le contenu peut être bloqué à deux étapes d'une requête :

1. Requête bloquée (PromptFeedback) : la requête d'entrée a enfreint les filtres de sécurité avant que le modèle ne génère une sortie. Aucune réponse candidate n'est renvoyée.

2. Réponse candidate bloquée (finishReason == SAFETY) : le modèle a évalué ou généré une réponse candidate qui a dépassé le seuil que vous avez configuré. Le texte candidat généré est effacé ou masqué.

L'objet SafetyRating

Chaque requête ou réponse candidate évaluée contient un tableau d'objets SafetyRating. Chaque classification fournit les informations suivantes :

• Propriétés disponibles avec Gemini Developer API et Agent Platform Gemini API (formerly Vertex AI) :

  • category : HarmCategory évalué.

  • probability : note discrète (NEGLIGIBLE, LOW, MEDIUM ou HIGH).

  • blocked : true si cette évaluation spécifique a entraîné le blocage du contenu.

• Propriétés supplémentaires disponibles avec Agent Platform Gemini API (formerly Vertex AI) :

  • probabilityScore : score de confiance à virgule flottante compris entre 0.0 et 1.0.

  • severity : niveau de gravité discret (NEGLIGIBLE, LOW, MEDIUM ou HIGH).

  • severityScore : score de gravité à virgule flottante compris entre 0.0 et 1.0.

Exemple d'objet SafetyRating

L'exemple suivant illustre la charge utile de réponse JSON brute lorsqu'un candidat est bloqué par des filtres de sécurité :

{
  "candidates": [
    {
      "finishReason": "SAFETY",
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "NEGLIGIBLE",
          "blocked": false
        },
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE",
          "blocked": false
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "NEGLIGIBLE",
          "blocked": false
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "HIGH",
          "blocked": true
        }
      ]
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 24,
    "totalTokenCount": 24
  }
}

Détecter les erreurs de sécurité dans le code

Lorsque du contenu est bloqué, les SDK clients affichent le blocage sous la forme d'une exception ou d'un code d'erreur afin que votre application puisse le gérer correctement.

do {
  let response = try await model.generateContent("Your prompt here")
  print(response.text ?? "No text generated.")
} catch GenerateContentError.promptBlocked(let response) {
  // The input prompt was blocked
  if let feedback = response.promptFeedback {
    let reason = feedback.blockReason?.rawValue ?? "unknown"
    print("Prompt blocked for reason: \(reason)")
    for rating in feedback.safetyRatings {
      let cat = rating.category.rawValue
      let prob = rating.probability.rawValue
      print("Category: \(cat), probability: \(prob)")
    }
  }
} catch GenerateContentError.responseStoppedEarly(let reason, let response) {
  // Candidate response was blocked or stopped early
  if reason == .safety {
    print("Response blocked due to safety.")
    if let candidate = response.candidates.first {
      for rating in candidate.safetyRatings where rating.blocked {
        print("Blocked by category: \(rating.category.rawValue)")
      }
    }
  }
} catch {
  print("Unexpected error: \(error)")
}

try {
  val response = model.generateContent("Your prompt here")
  val candidate = response.candidates.firstOrNull()

  if (candidate?.finishReason == FinishReason.SAFETY) {
    val blockedRating =
      candidate.safetyRatings.firstOrNull { it.blocked }
    println("Response blocked by category: ${blockedRating?.category}")
  } else {
    println(response.text)
  }
} catch (e: PromptBlockedException) {
  val reason = e.response?.promptFeedback?.blockReason
  println("Prompt was blocked: $reason")
} catch (e: Exception) {
  println("Error generating content: ${e.message}")
}

try {
  GenerateContentResponse response = model.generateContent("Your prompt here").get();
  Candidate candidate = response.getCandidates().isEmpty() ? null : response.getCandidates().get(0);

  if (candidate != null && candidate.getFinishReason() == FinishReason.SAFETY) {
    SafetyRating blockedRating = null;
    for (SafetyRating rating : candidate.getSafetyRatings()) {
      if (Boolean.TRUE.equals(rating.getBlocked())) {
        blockedRating = rating;
        break;
      }
    }
    System.out.println("Response blocked by category: " +
        (blockedRating != null ? blockedRating.getCategory() : "unknown"));
  } else {
    System.out.println(response.getText());
  }
} catch (ExecutionException e) {
  if (e.getCause() instanceof PromptBlockedException) {
    PromptBlockedException pbe = (PromptBlockedException) e.getCause();
    GenerateContentResponse blockedResponse = pbe.getResponse();
    String reason = (blockedResponse != null && blockedResponse.getPromptFeedback() != null)
        ? String.valueOf(blockedResponse.getPromptFeedback().getBlockReason())
        : "unknown";
    System.out.println("Prompt was blocked: " + reason);
  } else {
    System.out.println("Error generating content: " + e.getMessage());
  }
} catch (InterruptedException e) {
  System.out.println("Generation was interrupted: " + e.getMessage());
}

try {
  const response = await model.generateContent("Your prompt here");

  // Check if the prompt was blocked
  if (response.promptFeedback?.blockReason) {
    console.warn(`Prompt blocked: ${response.promptFeedback.blockReason}`);
    return;
  }

  const candidate = response.candidates?.[0];
  if (candidate?.finishReason === "SAFETY") {
    const blockedRating = candidate.safetyRatings?.find((r) => r.blocked);
    console.warn(`Response blocked by category: ${blockedRating?.category}`);
  } else {
    console.log(response.text);
  }
} catch (error) {
  console.error("Error generating content:", error);
}

try {
  final response = await model.generateContent([Content.text('Your prompt here')]);

  // Check if the prompt was blocked
  if (response.promptFeedback?.blockReason != null) {
    print('Prompt blocked: ${response.promptFeedback?.blockReason}');
    return;
  }

  final candidate = response.candidates.firstOrNull;
  if (candidate?.finishReason == FinishReason.safety) {
    final blockedRating =
        candidate?.safetyRatings?.where((r) => r.isBlocked == true).firstOrNull;
    print('Response blocked by category: ${blockedRating?.category.name}');
  } else {
    print(response.text);
  }
} catch (e) {
  print('Error generating content: $e');
}

try {
  var response = await model.GenerateContentAsync("Your prompt here");

  // Check if the prompt was blocked
  if (response.PromptFeedback?.BlockReason != null) {
    Debug.LogWarning($"Prompt blocked: {response.PromptFeedback.BlockReason}");
    return;
  }

  var candidate = response.Candidates.FirstOrDefault();
  if (candidate?.FinishReason == FinishReason.Safety) {
    var blockedRating = candidate.SafetyRatings?.FirstOrDefault(r => r.Blocked);
    Debug.LogWarning($"Response blocked by category: {blockedRating?.Category}");
  } else {
    Debug.Log(response.Text);
  }
} catch (Exception ex) {
  Debug.LogError($"Error generating content: {ex.Message}");
}

Bonnes pratiques pour concevoir des applications de manière responsable

• Défense en profondeur : les filtres de sécurité sont des garde-fous, pas des instructions. Combinez les paramètres de sécurité avec des instructions système explicites et une conception de requêtes ciblée pour guider le ton et la portée.

• Commentaires utilisateur appropriés : ne plantez jamais et n'affichez pas d'écran vide lorsque le contenu est bloqué. Détectez finishReason == SAFETY ou PromptBlockedException et affichez un message convivial informant l'utilisateur que la requête n'a pas pu être traitée conformément à vos consignes relatives au contenu.

• Utiliser BLOCK_NONE pour la modération personnalisée : si vous disposez déjà de votre propre pipeline de modération côté client ou côté serveur, définissez les seuils sur BLOCK_NONE pour recevoir les safetyRatings du modèle sans blocage automatisé, ce qui permet à votre application d'appliquer des règles de modération personnalisées.

• Consultez les conditions d'utilisation : si vous utilisez des paramètres moins restrictifs (BLOCK_ONLY_HIGH ou BLOCK_NONE), assurez-vous que votre application respecte toujours le Règlement sur les utilisations interdites de Google.

Autres options pour contrôler la génération de contenu

• Découvrez comment concevoir des requêtes afin d'influencer le modèle pour qu'il génère des résultats adaptés à vos besoins.
• Configurez les paramètres du modèle pour contrôler la façon dont le modèle génère une réponse, comme le nombre maximal de jetons de sortie, la probabilité de jetons de sortie répétés, etc.
• Définissez des instructions système pour orienter le comportement du modèle. Cette fonctionnalité est semblable à un préambule que vous ajoutez avant que le modèle ne soit exposé à d'autres instructions de l'utilisateur final.
• Transmettez un schéma de réponse avec le prompt pour spécifier un schéma de sortie spécifique. Cette fonctionnalité est le plus souvent utilisée pour générer une sortie JSON, mais elle peut également être utilisée pour des tâches de classification (par exemple, lorsque vous souhaitez que le modèle utilise des étiquettes ou des tags spécifiques).