Comprendi e configura le impostazioni di sicurezza

I modelli Gemini sono progettati per dare priorità alla sicurezza. Tuttavia, possono comunque generare risposte dannose, soprattutto quando vengono esplicitamente richiesti. Per migliorare ulteriormente la sicurezza e ridurre al minimo l'uso improprio, puoi configurare i filtri di sicurezza per bloccare le risposte potenzialmente dannose.

Sono previsti due livelli di protezione di sicurezza:

• Protezioni di base integrate:

  • Tutti i modelli Gemini sono dotati di protezioni integrate contro danni gravi (come sfruttamento minorile, attacchi informatici e armi pericolose).
  • Queste protezioni sono sempre attive, vengono applicate automaticamente a tutti i prompt e le risposte e non possono essere modificate o disattivate.

• Filtri di sicurezza configurabili:

  • L'Gemini API fornisce filtri di sicurezza configurabili aggiuntivi che puoi definire utilizzando le impostazioni di sicurezza nella tua app.
  • Queste impostazioni ti consentono di controllare la soglia di blocco dei contenuti in quattro categorie di danno principali: molestie, incitamento all'odio, contenuti sessualmente espliciti e contenuti pericolosi.

arrow_downward Vai agli esempi di codice

Concetti importanti sulla sicurezza

Quando si lavora con la sicurezza per i modelli Gemini, ecco alcuni concetti importanti da comprendere:

• Impostazioni di sicurezza: la configurazione definita nel codice dell'app che specifica quali categorie di contenuti dannosi monitorare e con quale soglia bloccare i contenuti.

• Filtri di sicurezza: i classificatori lato server che valutano i prompt e le risposte del modello in base alle dimensioni di sicurezza di Google. I filtri bloccano i contenuti in base alle impostazioni di sicurezza configurate.

• Valutazioni della sicurezza: i metadati di valutazione restituiti dal modello nell'oggetto della risposta. Le valutazioni indicano la probabilità e la gravità del potenziale danno rilevato per ogni categoria di danno.

Modelli supportati

• gemini-4-argon
• gemini-3.8-flash (e i modelli precedenti gemini-3.7-flash, gemini-3.6-flash e gemini-3.5-flash)
• gemini-3.5-flash-lite (e il precedente 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)

Anche il modello gemini-3.1-pro-preview e i modelli Gemini 2.5 per uso generico e per la generazione di immagini (deprecati) supportano questa funzionalità.

Configura le impostazioni di sicurezza nella tua app

Le impostazioni di sicurezza vengono configurate durante l'inizializzazione di un'istanza GenerativeModel. La configurazione viene mantenuta per tutta la durata dell'istanza del modello.

Scopri di più sulle categorie di contenuti dannosi disponibili e sulle soglie che puoi impostare per ogni categoria più avanti in questa pagina.

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
);

// ...

Categorie di contenuti dannosi disponibili

I filtri di sicurezza valutano i prompt e le risposte del modello in base alle seguenti categorie di danni configurabili:

Filtri di sicurezza non configurabili

Oltre alle categorie configurabili, tutte le richieste passano attraverso filtri a livello di sistema che non possono essere modificati:

• Materiale pedopornografico/contenuti vietati: i prompt o le risposte segnalati per contenuti vietati vengono immediatamente bloccati (PROHIBITED_CONTENT).

• Informazioni sensibili che consentono l'identificazione personale (SPII): le risposte che rischiano di esporre dati personali sensibili (come numeri di conti finanziari o documenti di identità nazionali) vengono bloccate (SPII).

Imposta soglie

Per ogni categoria di contenuti dannosi che vuoi controllare nella tua app, devi impostare una soglia. Se i contenuti valutati raggiungono o superano questa soglia, vengono bloccati.

Come funziona la valutazione della sicurezza: probabilità e gravità

I filtri di sicurezza valutano i contenuti in base a due dimensioni distinte:

• Probabilità: l'affidabilità del modello che i contenuti rientrino in una determinata categoria di danno.

• Gravità: l'entità o il grado del potenziale danno se i contenuti sono dannosi.

A ogni dimensione viene assegnato uno di questi livelli: NEGLIGIBLE, LOW, MEDIUM o HIGH.

I contenuti possono avere una probabilità elevata con un livello di gravità basso (ad esempio, battute comiche blande o insulti amichevoli) o una probabilità bassa con un livello di gravità elevato (ad esempio, discussioni mediche o storiche che menzionano la violenza).

Soglie di blocco dei contenuti dannosi disponibili

Puoi impostare una delle seguenti soglie per le categorie di contenuti dannosi che vuoi controllare nella tua app:

Ispeziona le valutazioni di sicurezza e gestisci i contenuti bloccati

I contenuti possono essere bloccati in due fasi durante una richiesta:

1. Prompt bloccato (PromptFeedback): il prompt di input ha violato i filtri di sicurezza prima che il modello generasse un output. Non vengono restituiti candidati di risposta.

2. Candidato di risposta bloccato (finishReason == SAFETY): il modello ha valutato o generato un candidato di risposta che ha superato la soglia configurata. Il testo candidato generato viene cancellato o oscurato.

L'oggetto SafetyRating

Ogni prompt o risposta candidata valutata contiene un array di oggetti SafetyRating. Ogni classificazione fornisce quanto segue:

• Proprietà disponibili sia con Gemini Developer API che con Agent Platform Gemini API (formerly Vertex AI):

  • category: l'oggetto HarmCategory valutato.

  • probability: una valutazione discreta (NEGLIGIBLE, LOW, MEDIUM o HIGH).

  • blocked: true se questa classificazione specifica ha causato il blocco dei contenuti.

• Proprietà aggiuntive disponibili con Agent Platform Gemini API (formerly Vertex AI):

  • probabilityScore: un punteggio di affidabilità in virgola mobile compreso tra 0.0 e 1.0.

  • severity: un livello di gravità discreto (NEGLIGIBLE, LOW, MEDIUM o HIGH).

  • severityScore: un punteggio di gravità in virgola mobile compreso tra 0.0 e 1.0.

Esempio di oggetto SafetyRating

L'esempio seguente illustra il payload della risposta JSON non elaborata quando un candidato viene bloccato dai filtri di sicurezza:

{
  "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
  }
}

Rileva gli errori di sicurezza nel codice

Quando i contenuti vengono bloccati, gli SDK client mostrano il blocco come un'eccezione o un codice di errore, in modo che l'app possa gestirlo correttamente.

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}");
}

Best practice per la progettazione responsabile delle app

• Difesa in profondità: i filtri di sicurezza sono una protezione, non un'istruzione. Combina le impostazioni di sicurezza con istruzioni di sistema esplicite e un prompt design mirato per guidare il tono e l'ambito.

• Feedback degli utenti fluido: non causare mai arresti anomali o mostrare una schermata vuota quando i contenuti sono bloccati. Rileva finishReason == SAFETY o PromptBlockedException e visualizza un messaggio amichevole che informa l'utente che la richiesta non può essere soddisfatta in base alle tue norme relative ai contenuti.

• Utilizza BLOCK_NONE per la moderazione personalizzata: se hai già una pipeline di moderazione lato client o lato server, imposta le soglie su BLOCK_NONE per ricevere i safetyRatings del modello senza blocco automatico, consentendo alla tua app di applicare policy di moderazione personalizzate.

• Esamina i Termini di servizio: se utilizzi impostazioni meno restrittive (BLOCK_ONLY_HIGH o BLOCK_NONE), assicurati che la tua app continui a rispettare le Norme relative all'uso vietato di Google.

Altre opzioni per controllare la generazione di contenuti

• Scopri di più sulla progettazione dei prompt per influenzare il modello in modo che generi un output specifico per le tue esigenze.
• Configura i parametri del modello per controllare il modo in cui il modello genera una risposta, ad esempio i token di output massimi, la probabilità di token di output ripetuti e così via.
• Imposta le istruzioni di sistema per guidare il comportamento del modello. Questa funzionalità è come un preambolo che aggiungi prima che il modello venga esposto a ulteriori istruzioni dell'utente finale.
• Passa uno schema di risposta insieme al prompt per specificare uno schema di output specifico. Questa funzionalità viene utilizzata più comunemente quando si genera un output JSON, ma può essere utilizzata anche per attività di classificazione (ad esempio quando vuoi che il modello utilizzi etichette o tag specifici).