安全过滤器和内容过滤器

如需查看使用 Gemini API 开始使用 Responsible AI 的示例，请在以下某个环境中运行“使用 Agent Platform Gemini API 实现 Responsible AI：安全评级和阈值”笔记本：

在 Colab 中打开 | 在 Colab Enterprise 中打开 | 在 Vertex AI Workbench 中打开 | 在 GitHub 上查看

Google 的生成式 AI 模型（例如 Gemini 2.5 Flash）旨在优先考虑安全性。不过，它们仍可能会生成有害的回答，尤其是在明确提示的情况下。为了进一步提高安全性并尽量减少滥用情况，您可以配置内容过滤器来屏蔽可能有害的回答。

本页面介绍了 Gemini 文本生成模型的安全过滤器。 如需了解其他 Google 模型的安全过滤器和 Responsible AI，请参阅以下文档：

• Gemini 图片生成
• Responsible AI for Veo
• 计算机使用

本页面介绍了每种安全和内容过滤条件类型，概述了关键安全概念，并向您展示如何为可配置的内容过滤器配置屏蔽阈值。我们还提供了 示例来演示如何对 可配置的内容过滤条件进行编程。

安全和内容过滤器可作为屏障，防止有害输出，但不会直接影响模型的行为。如需详细了解模型可操控性， 请参阅安全方面的系统说明。

不安全的提示

Gemini Enterprise Agent Platform 中的 Gemini API 提供以下 enum 代码之一，以说明提示遭拒的原因：

枚举	过滤条件类型	说明
PROHIBITED_CONTENT	不可配置的安全过滤条件	系统屏蔽了此提示，因为其中包含禁止的内容（通常是 CSAM），因此被标记。
BLOCKED_REASON_UNSPECIFIED	不适用	未指定屏蔽该提示的原因。
OTHER	不适用	此枚举指的是阻止提示的所有其他原因。请注意，Gemini Enterprise Agent Platform 中的 Gemini API 不支持所有语言。如需查看受支持的语言列表，请参阅 Gemini 语言支持。

如需了解详情，请参阅 BlockedReason API 参考文档。

以下是 Gemini Enterprise Agent Platform 中的 Gemini API 针对提示反馈的输出示例。 如果提示被屏蔽，promptFeedback 会包含 blockReason。如果提示未被屏蔽，则 promptFeedback 为空，如以下示例所示：

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

以下示例展示了因包含 PROHIBITED_CONTENT 而被屏蔽的提示：

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

以下示例展示了因未指定原因而被屏蔽的提示：

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

不安全的回答

以下过滤器可以检测并屏蔽可能不安全的回答：

• 不可配置的安全过滤器，用于屏蔽儿童性虐待内容 (CSAM) 和个人可识别信息 (PII)。
• 可配置的内容过滤器，可根据危害类别列表及其用户配置的屏蔽阈值来屏蔽不安全的内容。您可以根据自己的用例和业务情况，为每种危害配置屏蔽阈值。如需了解详情，请参阅可配置的内容过滤器。
• 引用过滤器，用于提供素材的引用。如需了解详情，请参阅引用过滤器。

LLM 以文本单元（称为词元）的形式生成回答。模型会在达到自然停止点或某个过滤器屏蔽响应时停止生成词元。Gemini Enterprise Agent Platform 中的 Gemini API 提供以下 enum 代码之一来解释词元生成停止的原因：

枚举	过滤条件类型	说明
STOP	不适用	此枚举表示模型已到达自然停止点或提供的停止序列。
MAX_TOKENS	不适用	由于模型达到了请求中指定的词元数量上限，因此词元生成操作已停止。
SAFETY	可配置的内容过滤器	由于回答因有害内容而被标记，因此 token 生成操作已停止。
RECITATION	引用过滤器	由于可能存在重复内容，因此 token 生成操作已停止。
SPII	不可配置的安全过滤条件	由于回答因敏感的个人身份信息 (SPII) 内容而被标记，因此词元生成操作已停止。
PROHIBITED_CONTENT	不可配置的安全过滤条件	由于回答因包含禁止的内容（通常是 CSAM）而被标记，因此词元生成操作已停止。
FINISH_REASON_UNSPECIFIED	不适用	未指定完成原因。
OTHER	不适用	此枚举指的是停止生成词元的所有其他原因。请注意，并非所有语言都支持词元生成。如需查看受支持的语言列表，请参阅 Gemini 语言支持。

如需了解详情，请参阅 FinishReason API 参考文档。

如果过滤条件阻止回答，则会清除回答的 Candidate.content 字段。它不会向模型提供任何反馈。

可配置的内容过滤器

内容过滤器会根据一系列危害来评估内容。对于每个危害类别，内容过滤器会根据内容有害的 可能性分配一个 得分，并根据有害内容的 严重程度分配另一个 得分。

可配置的内容过滤器没有独立于模型版本的版本控制。Google 不会更新之前发布的模型版本的可配置内容过滤器。不过，它可能会更新模型的未来版本的可配置内容过滤器。

危害类别

内容过滤器会根据以下危害类别评估内容：

危害类别	定义
仇恨言论	针对身份和/或受保护属性的负面或有害评论。
骚扰	针对其他人的威胁、恐吓、欺凌或辱骂性评论。
露骨色情内容	包含对性行为或其他淫秽内容的引用。
危险内容	宣传或允许访问有害商品、服务和活动。

概率得分和严重程度得分的比较

概率安全得分反映了模型回答与相应危害相关联的可能性。其关联置信度分数介于 0.0 到 1.0 之间，四舍五入到小数点后一位。置信度分数会细分为四个置信度级别：NEGLIGIBLE、LOW、MEDIUM 和 HIGH。

严重程度得分反映了模型回答可能的危害程度。它具有关联的严重程度得分，范围介于 0.0 到 1.0 之间，四舍五入到小数点后一位。严重程度得分被细分为四个等级：NEGLIGIBLE、LOW、MEDIUM 和 HIGH。

内容可能具有较低的概率分数和较高的严重性分数，或者可能具有高概率分数和低严重程度分数。

内容过滤条件配置选项

您可以使用 Gemini Enterprise Agent Platform 中的 Gemini API 或 Google Cloud 控制台来配置 内容过滤条件。

Gemini Enterprise Agent Platform 中的 Gemini API

Gemini Enterprise Agent Platform 中的 Gemini API 提供了两种“伤害屏蔽”方法：

• SEVERITY：此方法同时使用可能性得分和严重程度得分。
• PROBABILITY：此方法仅使用概率得分。

默认方法为 SEVERITY。对于 gemini-1.5-flash 和 gemini-1.5-pro 之前的模型，默认方法为 PROBABILITY。如需了解详情，请参阅 HarmBlockMethod API 参考文档。

Gemini Enterprise Agent Platform 中的 Gemini API 提供以下“伤害屏蔽”阈值：

• BLOCK_LOW_AND_ABOVE：当概率得分或严重程度 得分为 LOW、MEDIUM 或 HIGH 时屏蔽。
• BLOCK_MEDIUM_AND_ABOVE：当概率得分或严重程度 得分为 MEDIUM 或 HIGH 时屏蔽。
• BLOCK_ONLY_HIGH：当概率得分或严重级别得分 为 HIGH 时屏蔽。
• HARM_BLOCK_THRESHOLD_UNSPECIFIED：使用默认阈值进行屏蔽。
• OFF：不会屏蔽自动回答，也不会返回元数据。 对于 gemini-2.5-flash 及后续模型，OFF 是默认值。
• BLOCK_NONE：BLOCK_NONE 设置会移除自动回答屏蔽。您可以改为使用返回的得分配置自己的内容准则。这是一个受限字段，仅可供 GA 模型版本的所有用户使用。

例如，以下 Python 代码演示了如何针对危险内容类别将伤害屏蔽阈值设为 BLOCK_ONLY_HIGH：

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

这样做会屏蔽大部分被归类为危险内容的内容。如需了解详情，请参阅 HarmBlockThreshold API 参考文档。

如需查看 Python、Node.js、Java、Go、C# 和 REST 中的端到端示例，请参阅内容过滤器配置示例。

Google Cloud 控制台

借助 Google Cloud 控制台，您可以为每个内容属性配置阈值。 内容过滤器仅使用概率得分。没有使用严重程度得分的选项。

控制台提供了以下阈值： Google Cloud

• 关闭（默认）：不屏蔽自动回复。
• 屏蔽少部分：当概率得分为 HIGH 时屏蔽。
• 屏蔽部分：当概率得分为 MEDIUM 或 HIGH 时屏蔽。
• 屏蔽大部分：当概率得分为 LOW、MEDIUM 或 HIGH 时屏蔽。

例如，如果您将“危险内容”类别的屏蔽设置设为屏蔽少部分，则系统会屏蔽包含危险内容概率较高的所有部分。允许任何包含危险内容概率较低的部分。

如需设置阈值，请参阅以下步骤：

1. 在 Google Cloud 控制台的 Agent Platform 部分中，进入 Agent Studio 页面。

   前往 Agent Studio

2. 在创建新提示下，点击任意按钮以打开提示 设计页面。

3. 点击安全设置。

   系统会打开安全设置 对话框窗口。

4. 对于每个危害类别，配置所选的阈值。

5. 点击保存 。

被屏蔽的回答的输出示例

以下是 Gemini Enterprise Agent Platform 中的 Gemini API 输出示例，其中回答因包含危险内容而被可配置内容过滤条件屏蔽：

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

实现内容过滤条件配置

以下示例展示了如何使用 Gemini Enterprise Agent Platform 中的 Gemini API 配置内容过滤条件：

Python

安装

pip install --upgrade google-genai

如需了解详情，请参阅 SDK 参考文档。

设置环境变量以将 Gen AI SDK 与 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,
    HarmCategory,
    HarmBlockThreshold,
    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-2.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

了解如何安装或更新 Go。

如需了解详情，请参阅 SDK 参考文档。

设置环境变量以将 Gen AI SDK 与 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

设置您的环境后，您可以使用 REST 测试文本提示。以下示例会向发布方模型端点发送请求。

在使用任何请求数据之前， 请先进行以下替换：

• LOCATION：处理请求的区域。可用的选项包括：

  点击即可展开可用区域的部分列表

  • us-central1
  • us-west4
  • northamerica-northeast1
  • us-east4
  • us-west1
  • asia-northeast3
  • asia-southeast1
  • asia-northeast1
• PROJECT_ID：您的项目 ID。
• MODEL_ID：您要使用的多模态模型 ID，例如 gemini-2.5-flash。
• ROLE：与内容关联的对话中的角色。即使在单轮应用场景中，也需要指定角色。 可接受的值包括：
  • USER：指定由您发送的内容。
  • MODEL：指定模型的响应。
• TEXT：要包含在提示中的文本说明。
• SAFETY_CATEGORY：要为其配置阈值的安全类别。可接受的值包括：

  点击即可展开安全类别

  • HARM_CATEGORY_SEXUALLY_EXPLICIT
  • HARM_CATEGORY_HATE_SPEECH
  • HARM_CATEGORY_HARASSMENT
  • HARM_CATEGORY_DANGEROUS_CONTENT
• THRESHOLD：基于概率阻止属于指定安全类别的回答的阈值。可接受的值包括：

  点击即可展开屏蔽阈值

  • BLOCK_NONE
  • BLOCK_ONLY_HIGH
  • BLOCK_MEDIUM_AND_ABOVE（默认）
  • BLOCK_LOW_AND_ABOVE
  BLOCK_LOW_AND_ABOVE 屏蔽得最多，而 BLOCK_ONLY_HIGH 屏蔽得最少。

HTTP 方法和网址：

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

请求 JSON 正文：

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

如需发送请求，请选择以下方式之一：

curl

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI，或者使用了 Cloud Shell，这会使您自动登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

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

注意：以下命令假定您已使用您的用户账号通过运行 gcloud init 或 gcloud auth login 登录 gcloud CLI。您可以运行 gcloud auth list 来检查当前活跃的账号。

将请求正文保存在名为 request.json 的文件中，然后执行以下命令：

$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

您应该收到类似以下内容的 JSON 响应。

响应

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

示例 curl 命令

LOCATION="us-central1"
MODEL_ID="gemini-2.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

安装

npm install @google/genai

如需了解详情，请参阅 SDK 参考文档。

设置环境变量以将 Gen AI SDK 与 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

了解如何安装或更新 Java。

如需了解详情，请参阅 SDK 参考文档。

设置环境变量以将 Gen AI SDK 与 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;
    }
  }
}

越狱分类器

预览版

此功能受服务专用条款的“通用服务条款”部分中的“非正式版产品条款”的约束。 非正式版功能“按原样”提供，可能只能获得有限的支持。 如需了解详情，请参阅 发布阶段说明。

注意： 此功能仅在 gemini-3-flash-preview 中提供。

有些提示会试图绕过安全准则、道德约束或预期的操作说明，从而导致输出可能有害、有偏见或不当。越狱分类器会检测试图规避模型防御机制的提示，并根据配置将其屏蔽。此过滤条件默认处于关闭状态。如需启用此功能，请将 JAILBREAK 的屏蔽阈值设置为以下任一值。

• BLOCK_NONE
• BLOCK_LOW_AND_ABOVE
• BLOCK_MEDIUM_AND_ABOVE
• BLOCK_ONLY_HIGH

以下代码展示了如何启用此越狱过滤器：

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

如果内容被越狱分类器屏蔽，您会看到类似以下的结果：

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

如果您将 HarmBlockMethod 设置为 PROBABILITY，则 safety_ratings 将包含 probability 和 probability_score，而不是 severity 和 severity_score。如果提示未被屏蔽或标记，模型仍会根据 HarmBlockMethod 返回安全评级。

结算

与其他 Gemini 安全过滤条件一样，使用越狱分类器是免费的。

引用过滤器

Agent Platform 的生成式代码功能旨在生成原创内容。Gemini 的设计旨在限制大量复制现有内容的可能性。如果 Gemini 功能确实直接引用了某个网页上的大量内容，则会注明相应内容来源于该页面。

有时，我们可能会在多个网页上发现相同的内容。Gemini 会尝试将您引导至热门来源。如果此类功能引用了代码库，则引用中还可能提及适用的开源许可。您须负责遵守所有许可要求。

如需了解引用过滤条件的元数据，请参阅过滤条件 API 参考文档。

最佳做法

虽然内容过滤器有助于防止出现不安全内容，但偶尔也会屏蔽良性内容或漏掉有害内容。Gemini 2.5 Flash 等高级模型即使没有过滤器也能生成安全的回答。测试不同的过滤器设置，在确保安全性和允许适当内容之间找到合适的平衡点。

后续步骤

• 了解安全方面的系统说明。
• 了解监控滥用行为。
• 详细了解 Responsible AI。
• 了解如何处理被屏蔽的回答。