Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Filtri di sicurezza e dei contenuti

I modelli di AI generativa di Google sono progettati per dare la priorità alla sicurezza. Tuttavia, possono comunque generare risposte dannose, soprattutto se vengono richieste esplicitamente. Per migliorare ulteriormente la sicurezza e ridurre al minimo l'uso improprio, puoi configurare filtri dei contenuti per bloccare le risposte potenzialmente dannose.

Questa pagina riguarda i filtri di sicurezza dei modelli di generazione di testo Gemini. Per informazioni sui filtri di sicurezza e sull'AI responsabile per altri modelli Google, consulta la seguente documentazione:

Questa pagina descrive ogni tipo di filtro per la sicurezza e i contenuti, illustra i concetti chiave relativi alla sicurezza e mostra come configurare le soglie di blocco per i filtri per i contenuti configurabili. Sono inoltre disponibili esempi per mostrare come programmare un filtro dei contenuti configurabile.

I filtri di sicurezza e dei contenuti fungono da barriera, impedendo output dannosi, ma non influenzano direttamente il comportamento del modello. Per saperne di più sulla controllabilità del modello, vedi Istruzioni di sistema per la sicurezza.

Prompt non sicuri

L'API Gemini fornisce uno dei seguenti codici enum per spiegare perché un prompt è stato rifiutato:

Enum	Tipo di filtro	Descrizione
`PROHIBITED_CONTENT`	Filtro di sicurezza non configurabile	Il prompt è stato bloccato perché è stato segnalato per la presenza di contenuti vietati, in genere CSAM.
`BLOCKED_REASON_UNSPECIFIED`	N/D	Il motivo del blocco del prompt non è specificato.
`OTHER`	N/D	Questo enum si riferisce a tutti gli altri motivi per bloccare una richiesta. Tieni presente che l'API Gemini non supporta tutte le lingue. Per un elenco delle lingue supportate, consulta Lingue supportate da Gemini.

Per saperne di più, consulta il riferimento API BlockedReason.

Di seguito sono riportati esempi di output dell'API Gemini per il feedback sui prompt. Se un prompt viene bloccato, promptFeedback contiene un blockReason. Se un prompt non è bloccato, promptFeedback è vuoto, come nel seguente esempio:

{
  "promptFeedback": {
  },
  "usageMetadata": {
    "promptTokenCount": 7,
    "totalTokenCount": 7
  }
}

L'esempio seguente mostra un prompt bloccato perché contiene PROHIBITED_CONTENT:

{
  "promptFeedback": {
    "blockReason": "PROHIBITED_CONTENT"
  },
  "usageMetadata": {
    "promptTokenCount": 7,
    "totalTokenCount": 7
  }
}

L'esempio seguente mostra una richiesta bloccata per un motivo non specificato:

{
  "promptFeedback": {
    "blockReason": "BLOCKED_REASON_UNSPECIFIED"
  },
  "usageMetadata": {
    "promptTokenCount": 7,
    "totalTokenCount": 7
  }
}

Risposte non sicure

I seguenti filtri possono rilevare e bloccare risposte potenzialmente non sicure:

Filtri di sicurezza non configurabili, che bloccano il materiale pedopornografico e le informazioni che consentono l'identificazione personale (PII).
Filtri per i contenuti configurabili, che bloccano i contenuti non sicuri in base a un elenco di categorie di danni e alle soglie di blocco configurate dall'utente. Puoi configurare le soglie di blocco per ciascuno di questi danni in base a ciò che è appropriato per il tuo caso d'uso e la tua attività. Per saperne di più, consulta Filtri dei contenuti configurabili.
Filtri delle citazioni, che forniscono citazioni per il materiale di origine. Per scoprire di più, consulta Filtro delle citazioni.

Un LLM genera risposte in unità di testo chiamate token. Un modello smette di generare token perché raggiunge un punto di interruzione naturale o perché uno dei filtri blocca la risposta. L'API Gemini fornisce uno dei seguenti codici enum per spiegare perché è stata interrotta la generazione di token:

Enum	Tipo di filtro	Descrizione
`STOP`	N/D	Questo enum indica che il modello ha raggiunto un punto di interruzione naturale o la sequenza di interruzione fornita.
`MAX_TOKENS`	N/D	La generazione di token è stata interrotta perché il modello ha raggiunto il numero massimo di token specificato nella richiesta.
`SAFETY`	Filtro dei contenuti configurabile	La generazione di token è stata interrotta perché la risposta è stata segnalata per contenuti dannosi.
`RECITATION`	Filtro citazioni	La generazione del token è stata interrotta a causa di una potenziale citazione.
`SPII`	Filtro di sicurezza non configurabile	La generazione del token è stata interrotta perché la risposta è stata segnalata per contenuti con informazioni sensibili che consentono l'identificazione personale (SPII).
`PROHIBITED_CONTENT`	Filtro di sicurezza non configurabile	La generazione di token è stata interrotta perché la risposta è stata segnalata per la presenza di contenuti vietati, in genere CSAM.
`FINISH_REASON_UNSPECIFIED`	N/D	Il motivo del completamento non è specificato.
`OTHER`	N/D	Questo enum si riferisce a tutti gli altri motivi che interrompono la generazione di token. Tieni presente che la generazione di token non è supportata per tutte le lingue. Per un elenco delle lingue supportate, consulta Lingue supportate da Gemini.

Per saperne di più, consulta il riferimento API FinishReason.

Se un filtro blocca la risposta, cancella il campo Candidate.content della risposta. Non fornisce alcun feedback al modello.

Filtri dei contenuti configurabili

I filtri per i contenuti valutano i contenuti in base a un elenco di danni. Per ogni categoria di danno, i filtri dei contenuti assegnano un punteggio in base alla probabilità che i contenuti siano dannosi e un altro punteggio in base alla gravità dei contenuti dannosi.

I filtri dei contenuti configurabili non hanno il controllo delle versioni indipendente dalle versioni del modello. Google non aggiorna il filtro dei contenuti configurabile per una versione di un modello rilasciata in precedenza. Tuttavia, potrebbe aggiornare il filtro dei contenuti configurabile per una versione futura di un modello.

Categorie di danni

I filtri per i contenuti valutano i contenuti in base alle seguenti categorie di danni:

Categoria di danno	Definizione
Incitamento all'odio	Commenti negativi o dannosi rivolti all'identità e/o agli attributi protetti.
Molestie	Commenti minacciosi, intimidatori, prepotenti o illeciti rivolti a un altro individuo.
Contenuti sessualmente espliciti	Contiene riferimenti ad atti sessuali o ad altri contenuti osceni.
Contenuti pericolosi	Promuovono o consentono l'accesso a beni, servizi e attività dannosi.

Confronto tra i punteggi di probabilità e gravità

Il punteggio di sicurezza probabilità riflette la probabilità che una risposta del modello sia associata al danno in questione. Ha un punteggio di affidabilità associato compreso tra 0.0 e 1.0, arrotondato a una cifra decimale. Il punteggio di confidenza è suddiviso in quattro livelli di confidenza: NEGLIGIBLE, LOW, MEDIUM e HIGH.

Il punteggio di gravità riflette l'entità del potenziale danno di una risposta del modello. Ha un punteggio di gravità associato compreso tra 0.0 e 1.0, arrotondato a una cifra decimale. Il punteggio di gravità è suddiviso in quattro livelli: NEGLIGIBLE, LOW, MEDIUM e HIGH.

I contenuti possono avere un punteggio di probabilità basso e un punteggio di gravità alto oppure un punteggio di probabilità alto e un punteggio di gravità basso.

Opzioni di configurazione del filtro dei contenuti

Puoi utilizzare l'API Gemini o la console Google Cloud per configurare i filtri dei contenuti.

API Gemini

L'API Gemini fornisce due metodi di "blocco dei contenuti dannosi":

SEVERITY: questo metodo utilizza sia i punteggi di probabilità sia quelli di gravità.
PROBABILITÀ: questo metodo utilizza solo il punteggio di probabilità.

Il metodo predefinito è SEVERITY.

L'API Gemini fornisce le seguenti soglie di "blocco dei contenuti dannosi":

BLOCK_LOW_AND_ABOVE: blocca quando il punteggio di probabilità o il punteggio di gravità è LOW, MEDIUM o HIGH.
BLOCK_MEDIUM_AND_ABOVE: blocca quando il punteggio di probabilità o il punteggio di gravità è MEDIUM o HIGH.
BLOCK_ONLY_HIGH: blocca quando il punteggio di probabilità o il punteggio di gravità è HIGH.
HARM_BLOCK_THRESHOLD_UNSPECIFIED: blocca utilizzando la soglia predefinita.
OFF: nessun blocco delle risposte automatiche e nessun metadato restituito. Per gemini-3.5-flash e i modelli successivi, OFF è il valore predefinito.
BLOCK_NONE: l'impostazione BLOCK_NONE rimuove il blocco delle risposte automatiche. In alternativa, puoi configurare le tue linee guida per i contenuti con i punteggi restituiti. Si tratta di un campo con limitazioni che non è disponibile per tutti gli utenti nelle versioni del modello GA.

Ad esempio, il seguente codice Python mostra come impostare la soglia di blocco su BLOCK_ONLY_HIGH per la categoria di contenuti pericolosi:

generative_models.SafetySetting(
  category=generative_models.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
  threshold=generative_models.HarmBlockThreshold.BLOCK_ONLY_HIGH,
),

In questo modo verrà bloccata la maggior parte dei contenuti classificati come pericolosi. Per saperne di più, consulta il riferimento API HarmBlockThreshold.

Per esempi end-to-end in Python, Node.js, Java, Go, C# e REST, consulta Esempi di configurazione del filtro dei contenuti.

Console Google Cloud

La console Google Cloud ti consente di configurare una soglia per ogni attributo dei contenuti. Il filtro dei contenuti utilizza solo i punteggi di probabilità. Non è disponibile alcuna opzione per utilizzare i punteggi di gravità.

La console Google Cloud fornisce i seguenti valori di soglia:

Off (impostazione predefinita): nessun blocco automatico delle risposte.
Blocco ridotto: blocca quando il punteggio di probabilità è HIGH.
Blocca alcuni: blocca quando il punteggio di probabilità è MEDIUM o HIGH.
Blocco esteso: blocca quando il punteggio di probabilità è LOW, MEDIUM o HIGH.

Ad esempio, se imposti l'impostazione di blocco su Blocca alcuni per la categoria di contenuti pericolosi, tutto ciò che ha un'alta probabilità di essere contenuti pericolosi viene bloccato. Qualsiasi valore con una probabilità inferiore è consentito.

Per impostare le soglie, segui questi passaggi:

Nella sezione Agent Platform della console Google Cloud , vai alla pagina Agent Studio.

Vai ad Agent Studio
In Crea un nuovo prompt, fai clic su uno dei pulsanti per aprire la pagina di progettazione del prompt.
Fai clic su Impostazioni di sicurezza.

Si apre la finestra di dialogo Impostazioni di sicurezza.
Per ogni categoria di contenuti dannosi, configura il valore di soglia selezionato.
Fai clic su Salva.

Esempio di output per una risposta bloccata

Di seguito è riportato un esempio di output dell'API Gemini quando una risposta viene bloccata dal filtro dei contenuti configurabile perché contiene contenuti pericolosi:

{
  "candidates": [{
    "finishReason": "SAFETY",
    "safetyRatings": [{
      "category": "HARM_CATEGORY_HATE_SPEECH",
      "probability": "NEGLIGIBLE",
      "probabilityScore": 0.11027937,
      "severity": "HARM_SEVERITY_LOW",
      "severityScore": 0.28487435
    }, {
      "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
      "probability": "HIGH",
      "blocked": true,
      "probabilityScore": 0.95422274,
      "severity": "HARM_SEVERITY_MEDIUM",
      "severityScore": 0.43398145
    }, {
      "category": "HARM_CATEGORY_HARASSMENT",
      "probability": "NEGLIGIBLE",
      "probabilityScore": 0.11085559,
      "severity": "HARM_SEVERITY_NEGLIGIBLE",
      "severityScore": 0.19027223
    }, {
      "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
      "probability": "NEGLIGIBLE",
      "probabilityScore": 0.22901751,
      "severity": "HARM_SEVERITY_NEGLIGIBLE",
      "severityScore": 0.09089675
    }]
  }],
  "usageMetadata": {
    "promptTokenCount": 38,
    "totalTokenCount": 38
  }
}

Implementazione di una configurazione del filtro dei contenuti

I seguenti esempi mostrano come configurare il filtro dei contenuti utilizzando l'API Gemini:

Python

Installa

pip install --upgrade google-genai

Per saperne di più, consulta la documentazione di riferimento dell'SDK.

Imposta le variabili di ambiente per utilizzare SDK Google Gen AI con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

from google import genai
from google.genai.types import (
    GenerateContentConfig,
    HarmBlockThreshold,
    HarmCategory,
    HttpOptions,
    SafetySetting,
)

client = genai.Client(http_options=HttpOptions(api_version="v1"))

system_instruction = "Be as mean as possible."

prompt = """
    Write a list of 5 disrespectful things that I might say to the universe after stubbing my toe in the dark.
"""

safety_settings = [
    SafetySetting(
        category=HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
        threshold=HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),
    SafetySetting(
        category=HarmCategory.HARM_CATEGORY_HARASSMENT,
        threshold=HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),
    SafetySetting(
        category=HarmCategory.HARM_CATEGORY_HATE_SPEECH,
        threshold=HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),
    SafetySetting(
        category=HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
        threshold=HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
    ),
]

response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents=prompt,
    config=GenerateContentConfig(
        system_instruction=system_instruction,
        safety_settings=safety_settings,
    ),
)

# Response will be `None` if it is blocked.
print(response.text)
# Example response:
#     None

# Finish Reason will be `SAFETY` if it is blocked.
print(response.candidates[0].finish_reason)
# Example response:
#     FinishReason.SAFETY

# For details on all the fields in the response
for each in response.candidates[0].safety_ratings:
    print('\nCategory: ', str(each.category))
    print('Is Blocked:', True if each.blocked else False)
    print('Probability: ', each.probability)
    print('Probability Score: ', each.probability_score)
    print('Severity:', each.severity)
    print('Severity Score:', each.severity_score)
# Example response:
#
#     Category:  HarmCategory.HARM_CATEGORY_HATE_SPEECH
#     Is Blocked: False
#     Probability:  HarmProbability.NEGLIGIBLE
#     Probability Score:  2.547714e-05
#     Severity: HarmSeverity.HARM_SEVERITY_NEGLIGIBLE
#     Severity Score: None
#
#     Category:  HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT
#     Is Blocked: False
#     Probability:  HarmProbability.NEGLIGIBLE
#     Probability Score:  3.6103818e-06
#     Severity: HarmSeverity.HARM_SEVERITY_NEGLIGIBLE
#     Severity Score: None
#
#     Category:  HarmCategory.HARM_CATEGORY_HARASSMENT
#     Is Blocked: True
#     Probability:  HarmProbability.MEDIUM
#     Probability Score:  0.71599233
#     Severity: HarmSeverity.HARM_SEVERITY_MEDIUM
#     Severity Score: 0.30782545
#
#     Category:  HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT
#     Is Blocked: False
#     Probability:  HarmProbability.NEGLIGIBLE
#     Probability Score:  1.5624657e-05
#     Severity: HarmSeverity.HARM_SEVERITY_NEGLIGIBLE
#     Severity Score: None

Go

Scopri come installare o aggiornare Go.

Per saperne di più, consulta la documentazione di riferimento dell'SDK.

Imposta le variabili di ambiente per utilizzare SDK Google Gen AI con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/genai"
)

// generateTextWithSafety shows how to apply safety settings to a text generation request.
func generateTextWithSafety(w io.Writer) error {
	ctx := context.Background()

	client, err := genai.NewClient(ctx, &genai.ClientConfig{
		HTTPOptions: genai.HTTPOptions{APIVersion: "v1"},
	})
	if err != nil {
		return fmt.Errorf("failed to create genai client: %w", err)
	}

	systemInstruction := &genai.Content{
		Parts: []*genai.Part{
			{Text: "Be as mean as possible."},
		},
		Role: genai.RoleUser,
	}

	prompt := "Write a list of 5 disrespectful things that I might say to the universe after stubbing my toe in the dark."

	safetySettings := []*genai.SafetySetting{
		{Category: genai.HarmCategoryDangerousContent, Threshold: genai.HarmBlockThresholdBlockLowAndAbove},
		{Category: genai.HarmCategoryHarassment, Threshold: genai.HarmBlockThresholdBlockLowAndAbove},
		{Category: genai.HarmCategoryHateSpeech, Threshold: genai.HarmBlockThresholdBlockLowAndAbove},
		{Category: genai.HarmCategorySexuallyExplicit, Threshold: genai.HarmBlockThresholdBlockLowAndAbove},
	}

	config := &genai.GenerateContentConfig{
		SystemInstruction: systemInstruction,
		SafetySettings:    safetySettings,
	}
	modelName := "gemini-2.5-flash"
	resp, err := client.Models.GenerateContent(ctx, modelName,
		[]*genai.Content{{Parts: []*genai.Part{{Text: prompt}}, Role: genai.RoleUser}},
		config,
	)
	if err != nil {
		return fmt.Errorf("failed to generate content: %w", err)
	}

	fmt.Fprintln(w, resp.Text())

	if len(resp.Candidates) > 0 {
		fmt.Fprintln(w, "Finish Reason:", resp.Candidates[0].FinishReason)

		for _, rating := range resp.Candidates[0].SafetyRatings {
			fmt.Fprintf(w, "\nCategory: %v\nIs Blocked: %v\nProbability: %v\nProbability Score: %v\nSeverity: %v\nSeverity Score: %v\n",
				rating.Category,
				rating.Blocked,
				rating.Probability,
				rating.ProbabilityScore,
				rating.Severity,
				rating.SeverityScore,
			)
		}
	}

	// Example response:
	// Category: HARM_CATEGORY_HATE_SPEECH
	// Is Blocked: false
	// Probability: NEGLIGIBLE
	// Probability Score: 8.996795e-06
	// Severity: HARM_SEVERITY_NEGLIGIBLE
	// Severity Score: 0.04771039
	//
	// Category: HARM_CATEGORY_DANGEROUS_CONTENT
	// Is Blocked: false
	// Probability: NEGLIGIBLE
	// Probability Score: 2.2431707e-06
	// Severity: HARM_SEVERITY_NEGLIGIBLE
	// Severity Score: 0
	//
	// Category: HARM_CATEGORY_HARASSMENT
	// Is Blocked: false
	// Probability: NEGLIGIBLE
	// Probability Score: 0.00026123362
	// Severity: HARM_SEVERITY_NEGLIGIBLE
	// Severity Score: 0.022358216
	//
	// Category: HARM_CATEGORY_SEXUALLY_EXPLICIT
	// Is Blocked: false
	// Probability: NEGLIGIBLE
	// Probability Score: 6.1352006e-07
	// Severity: HARM_SEVERITY_NEGLIGIBLE
	// Severity Score: 0.020111412

	return nil
}

REST

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

LOCATION: la regione in cui elaborare la richiesta.
PROJECT_ID: Il tuo [ID progetto](/resource-manager/docs/creating-managing-projects#identifiers). .
MODEL_ID: l'ID modello del modello multimodale che vuoi utilizzare, ad esempio gemini-3.5-flash.
ROLE: Il ruolo in una conversazione associato ai contenuti. La specifica di un ruolo è obbligatoria anche nei casi d'uso a un solo turno. I valori accettabili includono:
- USER: specifica i contenuti inviati da te.
- MODEL: specifica la risposta del modello.
TEXT: le istruzioni di testo da includere nel prompt.
SAFETY_CATEGORY: la categoria di sicurezza per cui configurare una soglia. I valori accettabili includono:
Fai clic per espandere le categorie di sicurezza
- HARM_CATEGORY_SEXUALLY_EXPLICIT
- HARM_CATEGORY_HATE_SPEECH
- HARM_CATEGORY_HARASSMENT
- HARM_CATEGORY_DANGEROUS_CONTENT
THRESHOLD: La soglia per bloccare le risposte che potrebbero appartenere alla categoria di sicurezza specificata in base alla probabilità. I valori accettabili includono i seguenti:
Fai clic per espandere le soglie di blocco
- BLOCK_NONE
- BLOCK_ONLY_HIGH
- BLOCK_MEDIUM_AND_ABOVE (valore predefinito)
- BLOCK_LOW_AND_ABOVE
BLOCK_LOW_AND_ABOVE blocca la maggior parte dei contenuti, mentre BLOCK_ONLY_HIGH blocca il numero più basso di contenuti.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent

Corpo JSON della richiesta:

{
  "contents": {
    "role": "ROLE",
    "parts": { "text": "TEXT" }
  },
  "safetySettings": {
    "category": "SAFETY_CATEGORY",
    "threshold": "THRESHOLD"
  },
}

Per inviare la richiesta, scegli una di queste opzioni:

curl

Nota: il seguente comando presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che consente di accedere automaticamente all'interfaccia a riga di comando gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente.

Risposta

[{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": " The picture shows a table with a white tablecloth. On the table are two cups of coffee, a bowl of blueberries, and five scones with blueberries. There"
          }
        ]
      },
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "NEGLIGIBLE"
        }
      ]
    }
  ]
}
,
{
  "candidates": [
    {
      "content": {
        "role": "model",
        "parts": [
          {
            "text": " are also some pink flowers on the table. The background is a dark blue color. The picture is taken from a top-down perspective."
          }
        ]
      },
      "finishReason": "STOP",
      "safetyRatings": [
        {
          "category": "HARM_CATEGORY_HARASSMENT",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_HATE_SPEECH",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
          "probability": "NEGLIGIBLE"
        },
        {
          "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
          "probability": "NEGLIGIBLE"
        }
      ]
    }
  ],
  "usageMetadata": {
    "promptTokenCount": 262,
    "candidatesTokenCount": 59,
    "totalTokenCount": 321
  }
}

Comando curl di esempio

LOCATION="us-central1"
MODEL_ID="gemini-3.5-flash"
PROJECT_ID="test-project"

curl \
-X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://${LOCATION}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${LOCATION}/publishers/google/models/${MODEL_ID}:streamGenerateContent -d \
$'{
  "contents": {
    "role": "user",
    "parts": { "text": "Hello!" }
  },
  "safety_settings": [
    {
      "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
      "threshold": "OFF"
    },
    {
      "category": "HARM_CATEGORY_HATE_SPEECH",
      "threshold": "BLOCK_LOW_AND_ABOVE"
    },
    {
      "category": "HARM_CATEGORY_HARASSMENT",
      "threshold": "BLOCK_MEDIUM_AND_ABOVE"
    },
    {
      "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
      "threshold": "BLOCK_ONLY_HIGH"
    }
  ]
}'

Node.js

Installa

npm install @google/genai

Per saperne di più, consulta la documentazione di riferimento dell'SDK.

Imposta le variabili di ambiente per utilizzare SDK Google Gen AI con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

const {GoogleGenAI} = require('@google/genai');

const GOOGLE_CLOUD_PROJECT = process.env.GOOGLE_CLOUD_PROJECT;
const GOOGLE_CLOUD_LOCATION = process.env.GOOGLE_CLOUD_LOCATION || 'global';

async function generateWithSafetySettings(
  projectId = GOOGLE_CLOUD_PROJECT,
  location = GOOGLE_CLOUD_LOCATION
) {
  const client = new GoogleGenAI({
    vertexai: true,
    project: projectId,
    location: location,
  });

  const systemInstruction = 'Be as mean as possible.';

  const prompt =
    'Write a list of 5 disrespectful things that I might say to the universe after stubbing my toe in the dark.';

  const safetySettings = [
    {
      category: 'HARM_CATEGORY_DANGEROUS_CONTENT',
      threshold: 'BLOCK_LOW_AND_ABOVE',
    },
    {
      category: 'HARM_CATEGORY_HARASSMENT',
      threshold: 'BLOCK_LOW_AND_ABOVE',
    },
    {
      category: 'HARM_CATEGORY_HATE_SPEECH',
      threshold: 'BLOCK_LOW_AND_ABOVE',
    },
    {
      category: 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
      threshold: 'BLOCK_LOW_AND_ABOVE',
    },
  ];

  const response = await client.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: prompt,
    config: {
      systemInstruction: systemInstruction,
      safetySettings: safetySettings,
    },
  });

  // console.log(response.text);
  // console.log(response.candidates[0].finishMessage);
  //
  // for (const each of response.candidates[0].safetyRatings) {
  //   console.log('\nCategory:', String(each.category));
  //   console.log('Is Blocked:', each.blocked);
  //   console.log('Probability:', each.probability);
  //   console.log('Probability Score:', each.probabilityScore);
  //   console.log('Severity:', each.severity);
  //   console.log('Severity Score:', each.severityScore);
  // }

  // Example response:
  //
  //     Category:  HarmCategory.HARM_CATEGORY_HATE_SPEECH
  //     Is Blocked: False
  //     Probability:  HarmProbability.NEGLIGIBLE
  //     Probability Score:  2.547714e-05
  //     Severity: HarmSeverity.HARM_SEVERITY_NEGLIGIBLE
  //     Severity Score: None
  //
  //     Category:  HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT
  //     Is Blocked: False
  //     Probability:  HarmProbability.NEGLIGIBLE
  //     Probability Score:  3.6103818e-06
  //     Severity: HarmSeverity.HARM_SEVERITY_NEGLIGIBLE
  //     Severity Score: None
  //
  //     Category:  HarmCategory.HARM_CATEGORY_HARASSMENT
  //     Is Blocked: True
  //     Probability:  HarmProbability.MEDIUM
  //     Probability Score:  0.71599233
  //     Severity: HarmSeverity.HARM_SEVERITY_MEDIUM
  //     Severity Score: 0.30782545
  //
  //     Category:  HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT
  //     Is Blocked: False
  //     Probability:  HarmProbability.NEGLIGIBLE
  //     Probability Score:  1.5624657e-05
  //     Severity: HarmSeverity.HARM_SEVERITY_NEGLIGIBLE
  //     Severity Score: None

  return response;
}

Java

Scopri come installare o aggiornare Java.

Per saperne di più, consulta la documentazione di riferimento dell'SDK.

Imposta le variabili di ambiente per utilizzare SDK Google Gen AI con Vertex AI:

# Replace the `GOOGLE_CLOUD_PROJECT` and `GOOGLE_CLOUD_LOCATION` values
# with appropriate values for your project.
export GOOGLE_CLOUD_PROJECT=GOOGLE_CLOUD_PROJECT
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True


import com.google.genai.Client;
import com.google.genai.types.Candidate;
import com.google.genai.types.Content;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.HarmBlockThreshold;
import com.google.genai.types.HarmCategory;
import com.google.genai.types.HttpOptions;
import com.google.genai.types.Part;
import com.google.genai.types.SafetySetting;
import java.util.List;
import java.util.stream.Collectors;

public class SafetyWithTxt {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String modelId = "gemini-2.5-flash";
    generateContent(modelId);
  }

  // Shows how to generate content with safety settings.
  public static GenerateContentResponse generateContent(String modelId) {
    // Client Initialization. Once created, it can be reused for multiple requests.
    try (Client client =
        Client.builder()
            .location("global")
            .vertexAI(true)
            .httpOptions(HttpOptions.builder().apiVersion("v1").build())
            .build()) {

      String systemInstruction = "Be as mean as possible.";

      String prompt =
          "Write a list of 5 disrespectful things that I might say"
              + " to the universe after stubbing my toe in the dark.";

      // Set safety settings.
      List<HarmCategory.Known> categoriesToBlock =
          List.of(
              HarmCategory.Known.HARM_CATEGORY_DANGEROUS_CONTENT,
              HarmCategory.Known.HARM_CATEGORY_HARASSMENT,
              HarmCategory.Known.HARM_CATEGORY_HATE_SPEECH,
              HarmCategory.Known.HARM_CATEGORY_SEXUALLY_EXPLICIT);

      List<SafetySetting> safetySettings =
          categoriesToBlock.stream()
              .map(
                  category ->
                      SafetySetting.builder()
                          .category(category)
                          .threshold(HarmBlockThreshold.Known.BLOCK_LOW_AND_ABOVE)
                          .build())
                  .collect(Collectors.toList());

      GenerateContentResponse response =
          client.models.generateContent(
              modelId,
              prompt,
              GenerateContentConfig.builder()
                  .systemInstruction(Content.fromParts(Part.fromText(systemInstruction)))
                  .safetySettings(safetySettings)
                  .build());

      // Get response candidate.
      Candidate candidate =
          response
              .candidates()
              .flatMap(candidates -> candidates.stream().findFirst())
              .orElseThrow(
                  () -> new IllegalStateException("No response candidate generated by the model."));

      // Finish Reason will be `SAFETY` if it is blocked.
      System.out.println(candidate.finishReason());
      // Example response:
      // Optional[SAFETY]

      // For details on all the fields in the response.
      candidate
          .safetyRatings()
          .ifPresent(
              safetyRatings ->
                  safetyRatings.forEach(
                      safetyRating -> {
                        System.out.println("\nCategory: " + safetyRating.category());
                        System.out.println("Is Blocked: " + safetyRating.blocked());
                        System.out.println("Probability: " + safetyRating.probability());
                        System.out.println("Probability Score: " + safetyRating.probabilityScore());
                        System.out.println("Severity: " + safetyRating.severity());
                        System.out.println("Severity Score: " + safetyRating.severityScore());
                      }));
      // Example response:
      // Category: Optional[HARM_CATEGORY_HATE_SPEECH]
      // Is Blocked: Optional.empty
      // Probability: Optional[NEGLIGIBLE]
      // Probability Score: Optional[1.9967922E-5]
      // Severity: Optional[HARM_SEVERITY_NEGLIGIBLE]
      // Severity Score: Optional[0.05732864]
      //
      // Category: Optional[HARM_CATEGORY_DANGEROUS_CONTENT]
      // Is Blocked: Optional.empty
      // Probability: Optional[NEGLIGIBLE]
      // Probability Score: Optional[2.9124324E-6]
      // Severity: Optional[HARM_SEVERITY_NEGLIGIBLE]
      // Severity Score: Optional[0.04544826]
      //
      // Category: Optional[HARM_CATEGORY_HARASSMENT]
      // Is Blocked: Optional[true]
      // Probability: Optional[MEDIUM]
      // Probability Score: Optional[0.4593908]
      // Severity: Optional[HARM_SEVERITY_MEDIUM]
      // Severity Score: Optional[0.22082388]
      //
      // Category: Optional[HARM_CATEGORY_SEXUALLY_EXPLICIT]
      // Is Blocked: Optional.empty
      // Probability: Optional[NEGLIGIBLE]
      // Probability Score: Optional[6.453211E-8]
      // Severity: Optional[HARM_SEVERITY_NEGLIGIBLE]
      // Severity Score: Optional[0.023201048]
      return response;
    }
  }
}

Classificatore di jailbreak

Alcuni prompt tentano di aggirare le linee guida sulla sicurezza, i vincoli etici o le istruzioni operative previste, generando output potenzialmente dannosi, distorti o inappropriati. Il classificatore di jailbreak rileva e, a seconda della configurazione, blocca i prompt che tentano di aggirare le difese del modello. Questo filtro è disattivato per impostazione predefinita. Per attivarlo, imposta la soglia di blocco per JAILBREAK su uno dei seguenti valori:

BLOCK_NONE
BLOCK_LOW_AND_ABOVE
BLOCK_MEDIUM_AND_ABOVE
BLOCK_ONLY_HIGH

Il seguente codice mostra come attivare questo filtro di evasione:

generative_models.SafetySetting(
    category=generative_models.HarmCategory.HARM_CATEGORY_JAILBREAK,
    threshold=generative_models.HarmBlockThreshold.BLOCK_ONLY_HIGH,
)

Se i contenuti vengono bloccati dal classificatore di jailbreak, puoi aspettarti un risultato simile a questo:

{
  prompt_feedback: {
    block_reason: JAILBREAK
    safety_ratings: [
      {
        category: HARM_CATEGORY_JAILBREAK
        blocked: true
        severity: HARM_SEVERITY_MEDIUM
        severity_score: 0.76953125
      }
    ]
  }
}

Se imposti HarmBlockMethod su PROBABILITY, safety_ratings contiene probability e probability_score anziché severity e severity_score. Nel caso in cui il prompt non venga bloccato o segnalato, il modello restituirà comunque le classificazioni di sicurezza a seconda di HarmBlockMethod.

Fatturazione

Come altri filtri di sicurezza di Gemini, l'utilizzo del classificatore di jailbreak è senza costi.

Filtro citazioni

Le funzionalità di codice generativo di Agent Platform mirano a produrre contenuti originali. Per progettazione, Gemini limita la probabilità che i contenuti esistenti vengano replicati in dettaglio. Se una funzionalità di Gemini riporta una citazione estesa da una pagina web, Gemini cita la pagina.

A volte gli stessi contenuti possono essere presenti su più pagine web. Gemini tenta di indirizzarti a una fonte popolare. Nel caso di citazioni di repository di codice, la citazione potrebbe anche fare riferimento a una licenza open source applicabile. Il rispetto di eventuali requisiti di licenza è una tua responsabilità.

Per scoprire di più sui metadati del filtro delle citazioni, consulta il riferimento dell'API Citazioni.

Best practice

Sebbene i filtri dei contenuti contribuiscano a prevenire la visualizzazione di contenuti non sicuri, a volte potrebbero bloccare contenuti innocui o non rilevare contenuti dannosi. I modelli avanzati come Gemini 3.5 Flash sono progettati per generare risposte sicure anche senza filtri. Prova diverse impostazioni dei filtri per trovare il giusto equilibrio tra sicurezza e contenuti appropriati.

Passaggi successivi

Scopri di più sulle istruzioni di sistema per la sicurezza.
Scopri di più sul monitoraggio degli abusi.
Scopri di più sull'AI responsabile.
Scopri come elaborare le risposte bloccate.

Filtri di sicurezza e dei contenuti Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prompt non sicuri

Risposte non sicure

Filtri dei contenuti configurabili

Categorie di danni

Confronto tra i punteggi di probabilità e gravità

Opzioni di configurazione del filtro dei contenuti

API Gemini

Console Google Cloud

Esempio di output per una risposta bloccata

Implementazione di una configurazione del filtro dei contenuti

Python

Installa

Go

REST

curl

PowerShell

Risposta

Comando curl di esempio

Node.js

Installa

Java

Classificatore di jailbreak

Fatturazione

Filtro citazioni

Best practice

Passaggi successivi

Filtri di sicurezza e dei contenuti