Comprende y establece la configuración de seguridad

Los modelos de Gemini están diseñados para priorizar la seguridad. Sin embargo, aún pueden generar respuestas dañinas, en especial cuando se les solicita de forma explícita. Para mejorar aún más la seguridad y minimizar el uso inadecuado, puedes configurar filtros de seguridad para bloquear respuestas potencialmente dañinas.

Se proporcionan dos capas de protección de seguridad:

• Protecciones principales integradas:

  • Todos los modelos de Gemini incluyen protecciones integradas contra daños graves (como explotación infantil, ciberataques y armas peligrosas).
  • Estas protecciones están siempre activas, se aplican automáticamente a todas las instrucciones y respuestas, y no se pueden modificar ni inhabilitar.

• Filtros de seguridad configurables:

  • La Gemini API proporciona filtros de seguridad configurables adicionales que defines con la configuración de seguridad de tu app.
  • Estos parámetros de configuración te permiten controlar el umbral en el que se bloquea el contenido en cuatro categorías de daño principales: Hostigamiento, Incitación al odio o a la violencia, Contenido sexual explícito y Contenido peligroso.

arrow_downward Ir a las muestras de código

Conceptos de seguridad importantes

Cuando trabajes con la seguridad de los modelos de Gemini, estos son algunos conceptos importantes que debes comprender:

• Configuración de seguridad: Es la configuración que defines en el código de tu app y que especifica qué categorías de daño se deben supervisar y en qué umbral se debe bloquear el contenido.

• Filtros de seguridad: Son los clasificadores del servidor que evalúan las instrucciones y las respuestas del modelo en función de las dimensiones de seguridad de Google. Los filtros bloquean el contenido según la configuración de seguridad que establezcas.

• Calificaciones de seguridad: Son los metadatos de evaluación que devuelve el modelo en el objeto de respuesta. Las calificaciones indican la probabilidad y la gravedad del daño potencial detectado para cada categoría de daño.

Modelos compatibles

• gemini-4-argon
• gemini-3.8-flash (y los modelos anteriores gemini-3.7-flash, gemini-3.6-flash y gemini-3.5-flash)
• gemini-3.5-flash-lite (y la versión anterior 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)

El modelo gemini-3.1-pro-preview, así como los modelos Gemini 2.5 de uso general y de generación de imágenes (que están obsoletos), también admiten esta capacidad.

Configura los parámetros de seguridad en tu app

La configuración de seguridad se establece como parte de la inicialización de una instancia de GenerativeModel. La configuración se mantiene durante el ciclo de vida de esa instancia del modelo.

Obtén información sobre las categorías de daño disponibles y los umbrales que puedes establecer para cada categoría más adelante en esta página.

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

// ...

Categorías de daño disponibles

Los filtros de seguridad evalúan las instrucciones y las respuestas del modelo en función de las siguientes categorías de daño configurables:

Filtros de seguridad no configurables

Además de las categorías configurables, todas las solicitudes pasan por filtros a nivel del sistema que no se pueden ajustar:

• Material de abuso sexual infantil (CSAM) / contenido prohibido: Las instrucciones o respuestas marcadas por contenido prohibido se bloquean de inmediato (PROHIBITED_CONTENT).

• Información de identificación personal sensible (IIPS): Se bloquean las respuestas que corren el riesgo de exponer datos personales sensibles (como números de cuentas financieras o IDs nacionales) (SPII).

Establece umbrales

Para cada categoría de daño que quieras controlar en tu app, debes establecer un umbral. Si el contenido evaluado cumple o supera ese umbral, se bloquea.

Cómo funciona la evaluación de seguridad: Probabilidad vs. gravedad

Los filtros de seguridad evalúan el contenido en dos dimensiones distintas:

• Probabilidad: Es la confianza del modelo de que el contenido se encuentra dentro de una categoría de daño determinada.

• Gravedad: Es la magnitud o el grado de daño potencial en caso de que el contenido sea dañino.

A cada dimensión se le asigna uno de estos niveles: NEGLIGIBLE, LOW, MEDIUM o HIGH.

El contenido puede tener una probabilidad alta con un nivel de gravedad bajo (por ejemplo, bromas cómicas leves o insultos amistosos) o probabilidad baja con un nivel de gravedad alto (por ejemplo, debates médicos o históricos que mencionen violencia).

Umbrales de bloqueo de daño disponibles

Puedes establecer cualquiera de los siguientes umbrales para las categorías de daño que quieres controlar en tu app:

Inspecciona las clasificaciones de seguridad y controla el contenido bloqueado

El contenido se puede bloquear en dos etapas durante una solicitud:

1. Instrucción bloqueada (PromptFeedback): La instrucción de entrada infringió los filtros de seguridad antes de que el modelo generara cualquier resultado. No se devuelven candidatos de respuesta.

2. Candidato de respuesta bloqueado (finishReason == SAFETY): El modelo evaluó o generó una respuesta candidata que superó el umbral configurado. El texto candidato generado se borra o se oculta.

El objeto SafetyRating

Cada instrucción o respuesta candidata evaluada contiene un array de objetos SafetyRating. Cada calificación proporciona lo siguiente:

• Propiedades disponibles con Gemini Developer API y Agent Platform Gemini API (formerly Vertex AI):

  • category: Es el HarmCategory evaluado.

  • probability: Es una calificación discreta (NEGLIGIBLE, LOW, MEDIUM o HIGH).

  • blocked: Es true si esta calificación específica provocó que se bloqueara el contenido.

• Propiedades adicionales disponibles con Agent Platform Gemini API (formerly Vertex AI):

  • probabilityScore: Es una puntuación de confianza de punto flotante de 0.0 a 1.0.

  • severity: Es un nivel de gravedad discreto (NEGLIGIBLE, LOW, MEDIUM o HIGH).

  • severityScore: Es una puntuación de gravedad de punto flotante de 0.0 a 1.0.

Ejemplo de objeto SafetyRating

En el siguiente ejemplo, se ilustra la carga útil de la respuesta JSON sin procesar cuando los filtros de seguridad bloquean un candidato:

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

Detecta errores de seguridad en el código

Cuando se bloquea el contenido, los SDKs de cliente muestran el bloqueo como una excepción o un código de error para que tu app pueda controlarlo de forma correcta.

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

Prácticas recomendadas para el diseño responsable de apps

• Defensa en profundidad: Los filtros de seguridad son una protección, no una instrucción. Combina la configuración de seguridad con instrucciones del sistema explícitas y un diseño de instrucciones específico para guiar el tono y el alcance.

• Comentarios de los usuarios de forma correcta: Nunca se debe producir una falla ni mostrar una pantalla en blanco cuando se bloquea el contenido. Detecta finishReason == SAFETY o PromptBlockedException y muestra un mensaje amigable que informe al usuario que la solicitud no se pudo completar según tus lineamientos del contenido.

• Usa BLOCK_NONE para la moderación personalizada: Si ya tienes tu propia canalización de moderación del cliente o del servidor, establece los umbrales en BLOCK_NONE para recibir el safetyRatings del modelo sin bloqueo automatizado, lo que permite que tu app aplique políticas de moderación personalizadas.

• Revisa las Condiciones del Servicio: Si usas parámetros de configuración menos restrictivos (BLOCK_ONLY_HIGH o BLOCK_NONE), asegúrate de que tu app siga cumpliendo con la Política de Uso Prohibido de Google.

Otras opciones para controlar la generación de contenido

• Obtén más información sobre el diseño de instrucciones para que puedas influir en el modelo para que genere un resultado específico para tus necesidades.
• Configura los parámetros del modelo para controlar cómo el modelo genera una respuesta, como la cantidad máxima de tokens de salida, la probabilidad de que se repitan los tokens de salida, etcétera.
• Establecer instrucciones del sistema para dirigir el comportamiento del modelo Esta función es como un preámbulo que agregas antes de que el modelo se exponga a otras instrucciones del usuario final.
• Pasa un esquema de respuesta junto con la instrucción para especificar un esquema de salida específico. Esta función se usa con mayor frecuencia cuando se genera un resultado JSON, pero también se puede usar para tareas de clasificación (como cuando quieres que el modelo use etiquetas específicas).