Sicherheitseinstellungen verstehen und konfigurieren

Gemini-Modelle sind so konzipiert, dass Sicherheit an erster Stelle steht. Sie können jedoch immer noch schädliche Antworten generieren, insbesondere wenn sie explizit dazu aufgefordert werden. Um die Sicherheit weiter zu erhöhen und Missbrauch zu minimieren, können Sie Sicherheitsfilter konfigurieren, um potenziell schädliche Antworten zu blockieren.

Es gibt zwei Ebenen von Sicherheitsmaßnahmen:

• Integrierte grundlegende Schutzmaßnahmen:

  • Alle Gemini-Modelle verfügen über integrierte Schutzmaßnahmen gegen schwerwiegende Schäden (wie Ausbeutung von Kindern, Cyberangriffe und gefährliche Waffen).
  • Diese Schutzmaßnahmen sind immer aktiv, werden automatisch auf alle Prompts und Antworten angewendet und können nicht geändert oder deaktiviert werden.

• Konfigurierbare Sicherheitsfilter:

  • Die Gemini API bietet zusätzliche konfigurierbare Sicherheitsfilter, die Sie mit den Sicherheitseinstellungen in Ihrer Anwendung definieren.
  • Mit diesen Einstellungen können Sie den Schwellenwert festlegen, ab dem Inhalte in vier Haupt-Schadenskategorien blockiert werden: Belästigung, Hassrede, sexuell explizite Inhalte und gefährliche Inhalte.

arrow_downward Zu den Codebeispielen

Wichtige Sicherheitskonzepte

Wenn Sie mit der Sicherheit von Gemini-Modellen arbeiten, sollten Sie einige wichtige Konzepte kennen:

• Sicherheitseinstellungen: Die Konfiguration, die Sie in Ihrem Anwendungscode definieren und in der Sie angeben, welche Kategorien schädlicher Inhalte überwacht werden sollen und ab welchem Schwellenwert Inhalte blockiert werden sollen.

• Sicherheitsfilter: Die serverseitigen Klassifikatoren, die Prompts und Modellantworten anhand der Sicherheitsdimensionen von Google bewerten. Die Filter blockieren Inhalte basierend auf Ihren konfigurierten Sicherheitseinstellungen.

• Sicherheitsbewertungen: Die Bewertungsmetadaten, die vom Modell im Antwortobjekt zurückgegeben werden. Die Bewertungen geben die Wahrscheinlichkeit und den Schweregrad potenzieller Schäden an, die für jede Schadenskategorie erkannt wurden.

Unterstützte Modelle

• gemini-4-argon
• gemini-3.8-flash (und die älteren gemini-3.7-flash, gemini-3.6-flash und gemini-3.5-flash)
• gemini-3.5-flash-lite (und die ältere 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)

Das Modell gemini-3.1-pro-preview sowie die (eingestellten) Modelle Gemini 2.5 für allgemeine Zwecke und die Bildgenerierung unterstützen diese Funktion ebenfalls.

Sicherheitseinstellungen in Ihrer App konfigurieren

Sie konfigurieren die Sicherheitseinstellungen im Rahmen der Initialisierung einer GenerativeModel-Instanz. Die Konfiguration wird für die Lebensdauer dieser Modellinstanz beibehalten.

Weitere Informationen zu den verfügbaren Schadenskategorien und den Schwellenwerten, die Sie für jede Kategorie festlegen können, finden Sie weiter unten auf dieser Seite.

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

// ...

Verfügbare Kategorien schädlicher Inhalte

Die Sicherheitsfilter bewerten Prompts und Modellantworten anhand der folgenden konfigurierbaren Schadenskategorien:

Nicht konfigurierbare Sicherheitsfilter

Zusätzlich zu den konfigurierbaren Kategorien durchlaufen alle Anfragen Filter auf Systemebene, die nicht angepasst werden können:

• Darstellungen des sexuellen Missbrauchs von Kindern / Unzulässige Inhalte: Prompts oder Antworten, die wegen unzulässiger Inhalte gemeldet wurden, werden sofort blockiert (PROHIBITED_CONTENT).

• Vertrauliche personenidentifizierbare Informationen (SPII): Antworten, bei denen das Risiko besteht, dass vertrauliche personenbezogene Daten (z. B. Finanzkontonummern oder Personalausweisnummern) offengelegt werden, werden blockiert (SPII).

Grenzwerte festlegen

Für jede Schadenskategorie, die Sie in Ihrer App kontrollieren möchten, müssen Sie einen Schwellenwert festlegen. Wenn der ausgewertete Inhalt diesen Schwellenwert erreicht oder überschreitet, wird er blockiert.

Funktionsweise der Sicherheitsbewertung: Wahrscheinlichkeit im Vergleich zum Schweregrad

Sicherheitsfilter bewerten Inhalte anhand von zwei verschiedenen Dimensionen:

• Wahrscheinlichkeit: Die Wahrscheinlichkeit, dass Inhalte in eine bestimmte Schadenskategorie fallen.

• Schweregrad: Das Ausmaß oder der Grad des potenziellen Schadens, falls der Inhalt schädlich ist.

Jeder Dimension wird eine der folgenden Stufen zugewiesen: NEGLIGIBLE, LOW, MEDIUM oder HIGH.

Inhalte können eine hohe Wahrscheinlichkeit mit niedrigem Schweregrad (z. B. milde komödiantische Scherze oder freundliche Beleidigungen) oder eine niedrige Wahrscheinlichkeit mit hohem Schweregrad (z. B. medizinische oder historische Diskussionen, in denen Gewalt erwähnt wird) haben.

Verfügbare Schwellenwerte für die Schadensblockierung

Sie können für die Kategorien von schädlichen Inhalten, die Sie in Ihrer Anwendung kontrollieren möchten, die folgenden Schwellenwerte festlegen:

Sicherheitsbewertungen prüfen und blockierte Inhalte verwalten

Inhalte können in zwei Phasen einer Anfrage blockiert werden:

1. Prompt blockiert (PromptFeedback): Der Eingabe-Prompt hat gegen Sicherheitsfilter verstoßen, bevor das Modell eine Ausgabe generiert hat. Es werden keine Antwortkandidaten zurückgegeben.

2. Antwortkandidat blockiert (finishReason == SAFETY): Das Modell hat einen Antwortkandidaten bewertet oder generiert, der den von Ihnen konfigurierten Schwellenwert überschritten hat. Der generierte Kandidatentext wird gelöscht oder unkenntlich gemacht.

Das SafetyRating-Objekt

Jeder ausgewertete Prompt oder Antwortkandidat enthält ein Array von SafetyRating-Objekten. Jede Bewertung enthält Folgendes:

• Unterkünfte, die sowohl mit Gemini Developer API als auch mit Agent Platform Gemini API (formerly Vertex AI) verfügbar sind:

  • category: Der ausgewertete HarmCategory.

  • probability: Eine diskrete Bewertung (NEGLIGIBLE, LOW, MEDIUM oder HIGH).

  • blocked: true, wenn diese bestimmte Bewertung dazu geführt hat, dass der Inhalt blockiert wurde.

• Zusätzliche Attribute, die mit dem Agent Platform Gemini API (formerly Vertex AI) verfügbar sind:

  • probabilityScore: Ein Gleitkomma-Konfidenzwert zwischen 0.0 und 1.0.

  • severity: Ein diskreter Schweregrad (NEGLIGIBLE, LOW, MEDIUM oder HIGH).

  • severityScore: Ein Gleitkommawert für den Schweregrad von 0.0 bis 1.0.

Beispiel für ein SafetyRating-Objekt

Das folgende Beispiel zeigt die unverarbeitete JSON-Antwortnutzlast, wenn ein Kandidat durch Sicherheitsfilter blockiert wird:

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

Sicherheitsfehler im Code abfangen

Wenn Inhalte blockiert werden, wird die Blockierung von den Client-SDKs als Ausnahme oder Fehlercode angezeigt, damit Ihre App sie ordnungsgemäß verarbeiten kann.

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 Practices für verantwortungsbewusstes App-Design

• Defense in Depth: Sicherheitsfilter sind eine Leitlinie, keine Anweisung. Kombinieren Sie Sicherheitseinstellungen mit expliziten Systemanweisungen und gezieltem Prompt-Design, um Ton und Umfang zu steuern.

• Angemessenes Nutzerfeedback: Die App darf nicht abstürzen oder einen leeren Bildschirm anzeigen, wenn Inhalte blockiert werden. Erkennt finishReason == SAFETY oder PromptBlockedException und zeigt eine freundliche Nachricht an, die den Nutzer darüber informiert, dass die Anfrage gemäß Ihren Inhaltsrichtlinien nicht erfüllt werden konnte.

• BLOCK_NONE für benutzerdefinierte Moderation verwenden: Wenn Sie bereits eine eigene clientseitige oder serverseitige Moderationspipeline haben, setzen Sie die Schwellenwerte auf BLOCK_NONE, um die safetyRatings des Modells ohne automatische Blockierung zu erhalten. So kann Ihre Anwendung benutzerdefinierte Moderationsrichtlinien erzwingen.

• Nutzungsbedingungen lesen: Wenn Sie weniger restriktive Einstellungen (BLOCK_ONLY_HIGH oder BLOCK_NONE) verwenden, achten Sie darauf, dass Ihre App weiterhin der Richtlinie zur unzulässigen Nutzung von generativer KI von Google entspricht.

Weitere Optionen zum Steuern der Inhaltsgenerierung

• Weitere Informationen zum Prompt-Design, damit Sie das Modell so beeinflussen können, dass es Ausgaben generiert, die Ihren Anforderungen entsprechen.
• Modellparameter konfigurieren, um zu steuern, wie das Modell eine Antwort generiert, z. B. maximale Anzahl von Ausgabetokens, Wahrscheinlichkeit wiederholter Ausgabetokens usw.
• Systemanweisungen festlegen, um das Verhalten des Modells zu steuern. Diese Funktion ist wie eine Präambel, die Sie hinzufügen, bevor das Modell weiteren Anweisungen des Endnutzers ausgesetzt wird.
• Übergeben Sie zusammen mit dem Prompt ein Antwortschema, um ein bestimmtes Ausgabeschema anzugeben. Diese Funktion wird am häufigsten verwendet, wenn JSON-Ausgaben generiert werden. Sie kann aber auch für Klassifizierungsaufgaben verwendet werden, z. B. wenn das Modell bestimmte Labels oder Tags verwenden soll.