Filtri di sicurezza e dei contenuti

Per vedere un esempio di come iniziare a utilizzare l'AI responsabile con l'API Gemini di Gemini Enterprise Agent Platform, esegui il notebook "AI responsabile con l'API Gemini di Agent Platform: valutazioni e soglie di sicurezza" in uno dei seguenti ambienti:

Apri in Colab | Apri in Colab Enterprise | Apri in Agent Platform Workbench | Visualizza su GitHub

I modelli di AI generativa di Google sono progettati per dare priorità alla sicurezza. Tuttavia, possono comunque generare risposte dannose, soprattutto quando vengono richiesti esplicitamente. Per migliorare ulteriormente la sicurezza e ridurre al minimo l'uso improprio, puoi configurare i 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:

• Gemini per la generazione di immagini
• AI responsabile per Veo
• Uso del computer

Questa pagina descrive ogni tipo di filtro dei contenuti e di sicurezza, illustra i concetti chiave della sicurezza e mostra come configurare le soglie di blocco per i filtri dei contenuti configurabili. Sono inoltre disponibili esempi che mostrano 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 scoprire di più sulla controllabilità del modello, consulta Istruzioni di sistema per la sicurezza.

Prompt non sicuri

L'API Gemini fornisce uno dei seguenti codici enum per spiegare il motivo per cui 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 un prompt. 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 dei prompt. Se un prompt viene bloccato, promptFeedback contiene un blockReason. Se un prompt non è bloccato, promptFeedback è vuoto, come nell'esempio seguente:

{
  "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 un prompt bloccato 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 (CSAM) e le informazioni che consentono l'identificazione personale (PII).
• Filtri dei contenuti configurabili, che bloccano i contenuti non sicuri in base a un elenco di categorie di danni e alle relative 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 scoprire 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 interrompe la generazione di 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 il motivo per cui la generazione dei token è stata interrotta:

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 dei 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 delle citazioni	La generazione dei token è stata interrotta a causa di una potenziale recitazione.
SPII	Filtro di sicurezza non configurabile	La generazione dei 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 dei token è stata interrotta perché la risposta è stata segnalata per contenuti vietati, in genere CSAM.
FINISH_REASON_UNSPECIFIED	N/D	Il motivo della fine non è specificato.
OTHER	N/D	Questo enum si riferisce a tutti gli altri motivi che interrompono la generazione dei 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 dei contenuti valutano i contenuti in base a un elenco di danni. Per ogni categoria di contenuti dannosi, 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 un controllo delle versioni indipendente dalle versioni del modello. Google non aggiorna il filtro dei contenuti configurabile per una versione di release 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 dei contenuti valutano i contenuti in base alle seguenti categorie di contenuti dannosi:

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	Riferimenti ad atti sessuali o ad altri contenuti osceni.
Contenuti pericolosi	Promuovono o consentono l'accesso a beni, servizi e attività dannosi.

Confronto tra punteggi di probabilità e punteggi di gravità

Il punteggio di sicurezza della probabilità riflette la probabilità che una risposta del modello sia associata al rispettivo danno. 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 danno che una risposta del modello potrebbe causare. 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 o 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 i punteggi di probabilità e gravità.
• PROBABILITY: 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: non viene restituito alcun blocco automatico delle risposte e nessun metadato. 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. Puoi invece configurare le tue norme relative ai contenuti con i punteggi restituiti.

Ad esempio, il seguente codice Python mostra come impostare la soglia di blocco dei contenuti dannosi 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 dei filtri dei contenuti.

Console Google Cloud

La console Google Cloud consente di configurare una soglia per ogni attributo dei contenuti. Il filtro dei contenuti utilizza solo i punteggi di probabilità. Non è possibile 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 i contenuti quando il punteggio di probabilità è MEDIUM o HIGH.
• Blocco esteso: blocca i contenuti quando il punteggio di probabilità è LOW, MEDIUM o HIGH.

Ad esempio, se imposti l'impostazione di blocco su Blocca pochi per la categoria di contenuti pericolosi, vengono bloccati tutti i contenuti con un'alta probabilità di essere pericolosi. Qualsiasi elemento con una probabilità inferiore è consentito.

Per impostare le soglie, segui questi passaggi:

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

   Vai ad Agent Studio

2. In Crea un nuovo prompt, fai clic su uno dei pulsanti per aprire la pagina di progettazione del prompt.

3. Fai clic su Impostazioni di sicurezza.

   Si apre la finestra di dialogo Impostazioni di sicurezza.

4. Per ogni categoria di contenuti dannosi, configura il valore di soglia selezionato.

5. Fai clic su Salva.

Output di esempio 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é include 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 l'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 l'Go.

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

Imposta le variabili di ambiente per utilizzare l'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. .
• MODEL_ID: l'ID del modello multimodale che vuoi utilizzare, ad esempio gemini-3.5-flash.
• ROLE: il ruolo in una conversazione associata ai contenuti. La specifica di un ruolo è obbligatoria anche nei casi d'uso a turno singolo. 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:

  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 il maggior numero di elementi, mentre BLOCK_ONLY_HIGH blocca il minor numero di elementi.

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 l'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 l'Java.

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

Imposta le variabili di ambiente per utilizzare l'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

Anteprima

Questa funzionalità è soggetta ai "Termini dell'offerta pre-GA" nella sezione dei Termini di servizio generali dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.

Nota: questa funzionalità è disponibile solo in gemini-3-flash-preview.

Alcuni prompt tentano di aggirare le linee guida sulla sicurezza, i vincoli etici o le istruzioni operative previste, portando a 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 attivarla, 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 per il jailbreak:

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

Se i contenuti sono 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 valutazioni di sicurezza in base a HarmBlockMethod.

Fatturazione

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

Filtro delle 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 di una pagina web, Gemini cita la pagina.

A volte gli stessi contenuti possono essere trovati su più pagine web. Gemini tenta di indirizzarti a una fonte molto conosciuta. 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 API Citation.

Best practice

Sebbene i filtri dei contenuti aiutino a prevenire i contenuti non sicuri, occasionalmente 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.