Configurar filtros de segurança

Os modelos de IA generativa do Google, como o Gemini 1.5 Flash e o Gemini 1.5 Pro, foram criados para priorizar a segurança. No entanto, eles ainda podem gerar respostas prejudiciais, especialmente quando são explicitamente solicitados. Para aumentar ainda mais a segurança e minimizar o uso indevido, você pode configurar filtros de segurança para bloquear respostas potencialmente perigosas.

Esta página descreve cada um dos tipos de filtro de segurança e descreve os principais conceitos de segurança. Para filtros configuráveis, ele mostra como configurar os limites de bloqueio de cada categoria de dano para controlar com que frequência os comandos e respostas são bloqueados.

Os filtros de segurança funcionam como uma barreira, evitando resultados nocivos, mas não influenciam diretamente o comportamento do modelo. Para saber mais sobre a direção de modelos, consulte Instruções do sistema para segurança.

Comandos não seguros

A API Vertex AI Gemini fornece um dos seguintes códigos enum para explicar o motivo da rejeição de um comando:

Enum Tipo de filtro Descrição
PROHIBITED_CONTENT Filtro de segurança não configurável A solicitação foi bloqueada porque foi sinalizada por conter conteúdo proibido, geralmente material de abuso sexual infantil.
BLOCKED_REASON_UNSPECIFIED N/A O motivo para bloquear o comando não foi especificado.
OUTROS N/A Esse tipo enumerado se refere a todos os outros motivos para bloquear um comando. A API Vertex AI Gemini não é compatível com todos os idiomas. Para uma lista de idiomas compatíveis, consulte Compatibilidade com idiomas do Gemini.

Para saber mais, consulte BlockedReason.

Este é um exemplo de saída da API Vertex AI Gemini quando um comando é bloqueado por conter PROHIBITED_CONTENT:

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

Respostas não seguras

Os filtros a seguir podem detectar e bloquear respostas potencialmente não seguras:

  • Filtros de segurança não configuráveis, que bloqueiam material de abuso sexual infantil (CSAM) e informações de identificação pessoal (PII).
  • Filtros de segurança configuráveis, que bloqueiam conteúdo não seguro com base em uma lista de categorias de danos e os limites de bloqueio configurados pelo usuário. Você pode configurar limites de bloqueio para cada um desses danos com base no que é apropriado para seu caso de uso e negócios. Para saber mais, consulte Filtros de segurança configuráveis.
  • Filtros de citação, que fornecem citações para o material de origem. Para saber mais, consulte Filtro de citação.

Um LLM gera respostas em unidades de texto chamadas tokens. Um modelo interrompe a geração tokens porque ele chega a um ponto de parada natural ou porque um dos filtros bloqueia a resposta. A API Vertex AI Gemini fornece um dos códigos enum a seguir para explicar por que a geração de token foi interrompida:

Enum Tipo de filtro Descrição
PARAR N/A Esse tipo enumerado indica que o modelo atingiu um ponto de parada natural ou a sequência de parada fornecida.
MAX_TOKENS N/A A geração de tokens foi interrompida porque o modelo atingiu o número máximo de tokens especificado na solicitação.
SEGURANÇA Filtro de segurança configurável A geração de tokens foi interrompida porque a resposta foi sinalizada por motivos de segurança.
RECITATION Filtro de citações A geração de tokens foi interrompida devido a uma possível recitação.
SPII Filtro de segurança não configurável A geração de tokens foi interrompida porque a resposta foi sinalizada por conteúdo com informações sensíveis de identificação pessoal (SPII).
PROHIBITED_CONTENT Filtro de segurança não configurável A geração do token foi interrompida porque a resposta foi sinalizada por incluir conteúdo proibido, geralmente material de abuso sexual infantil.
FINISH_REASON_UNSPECIFIED N/A O motivo da finalização não foi especificado.
OUTROS N/A Esse tipo enumerado refere-se a todos os outros motivos que interrompem a geração de tokens. Observe que a geração de tokens não é compatível com todos os idiomas. Para uma lista de idiomas compatíveis, consulte Compatibilidade com idiomas do Gemini.

Para saber mais, consulte FinishReason.

Se um filtro bloquear a resposta, ele anulará o campo Candidate.content da resposta. Ele não fornece feedback ao modelo.

Filtros de segurança configuráveis

Os filtros de segurança avaliam o conteúdo com base em uma lista de danos. Para cada categoria de danos, os filtros de segurança atribuem uma pontuação com base na probabilidade do conteúdo ser inseguro e outra pontuação com base na gravidade do conteúdo nocivo.

Os filtros de segurança configuráveis não têm controle de versões independente do modelo. O Google não atualiza o filtro de segurança configurável para uma versão lançada anteriormente de um modelo. No entanto, é possível que atualize o filtro de segurança configurável para uma versão futura de um modelo.

Categorias de dano

Os filtros de segurança avaliam o conteúdo com base nas seguintes categorias de danos:

Categoria de dano Definição
Discurso de ódio Comentários negativos ou nocivos voltados à identidade e/ou atributos protegidos.
Assédio Comentários ameaçadores, intimidadores, abusivos ou violentos direcionados a outra pessoa
Sexualmente explícito Contém referências a atos sexuais ou outro conteúdo sexual.
Conteúdo perigoso Promove ou permite o acesso a produtos, serviços e atividades prejudiciais.

Comparação de pontuações de probabilidade e de gravidade

A pontuação de segurança de probability reflete a probabilidade de uma resposta de modelo estar associada ao respectivo dano. Ele tem pontuação de confiança associada entre 0.0 e 1.0, arredondada para uma casa decimal. A pontuação de confiança é criterizada em quatro níveis de confiança de segurança: NEGLIGIBLE, LOW, MEDIUM e HIGH.

A pontuação de segurança severity reflete a magnitude de quão prejudicial a resposta de um modelo pode ser. Ele tem uma pontuação de gravidade associada que vai de 0.0 para 1.0, arredondada para uma casa decimal. A pontuação de gravidade é criterizada em quatro níveis: NEGLIGIBLE, LOW, MEDIUM e HIGH.

O conteúdo pode ter uma pontuação de probabilidade baixa e uma pontuação de gravidade alta ou uma pontuação de probabilidade alta e uma pontuação de gravidade baixa.

Como configurar filtros de segurança

Use a API Vertex AI Gemini ou o console do Google Cloud para configurar o filtro de segurança.

API Gemini da Vertex AI

A API Vertex AI Gemini fornece dois "bloqueios de dano", métodos:

  • SEVERITY: esse método usa pontuações de probabilidade e gravidade.
  • PROBABILITY: esse método usa apenas a pontuação de probabilidade.

O método padrão é SEVERITY. Para modelos anteriores a gemini-1.5-flash e gemini-1.5-pro, o método padrão é PROBABILITY. Para saber mais, consulte a referência da API HarmBlockMethod.

A API Vertex AI Gemini fornece os seguintes limites de "bloqueio de dano":

  • BLOCK_LOW_AND_ABOVE: bloqueia quando a pontuação de probabilidade ou de gravidade é LOW, MEDIUM ou HIGH.
  • BLOCK_MEDIUM_AND_ABOVE: bloqueia quando a pontuação de probabilidade ou de gravidade é MEDIUM ou HIGH. Para gemini-1.5-flash-001 e gemini-1.5-pro-001, BLOCK_MEDIUM_AND_ABOVE é o valor padrão.
  • BLOCK_ONLY_HIGH: bloqueia quando a pontuação de probabilidade ou de gravidade é HIGH.
  • HARM_BLOCK_THRESHOLD_UNSPECIFIED: bloqueia usando o limite padrão.
  • DESATIVADA: nenhum bloqueio de resposta automática nem metadados de segurança são retornados. Para gemini-1.5-flash-002 e gemini-1.5-pro-002, OFF é o valor padrão.
  • BLOCK_NONE: a configuração de segurança BLOCK_NONE remove o bloqueio de respostas automáticas. Em vez disso, você pode configurar suas próprias diretrizes de segurança com as pontuações retornadas. Este é um campo restrito que não está disponível para todos os usuários nas versões de modelo do GA.

Por exemplo, o código Python a seguir demonstra como definir o limite de bloqueio de danos para BLOCK_ONLY_HIGH na categoria de conteúdo perigoso:

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

Isso vai bloquear a maior parte do conteúdo classificado como perigoso. Para saber mais, consulte a referência da API HarmBlockThreshold.

Para conferir exemplos completos em Python, Node.js, Java, Go, C# e REST, consulte os Exemplos de configuração do filtro de segurança.

Console do Google Cloud

O console do Google Cloud permite configurar um limite para cada atributo de segurança. O filtro de segurança usa apenas as pontuações de probabilidade. Não há a opção de usar as pontuações de gravidade.

O console do Google Cloud fornece os seguintes valores de limite:

  • Desativado (padrão): não há bloqueio de respostas automáticas.
  • Bloquear poucos: bloquear quando a pontuação de probabilidade for HIGH.
  • Bloquear alguns: bloquear quando a pontuação de probabilidade for MEDIUM ou HIGH.
  • Bloquear muitos: bloquear quando a pontuação de probabilidade for LOW, MEDIUM ou HIGH.

Por exemplo, se você definir a configuração de bloqueio como Bloquear poucos na categoria "Conteúdos perigosos", tudo com alta probabilidade de ser um conteúdo nocivo será bloqueado. Qualquer item com menor probabilidade de risco é permitido. O limite padrão é Block some.

Para definir os limites, consulte as seguintes etapas:

  1. Na seção "Vertex AI" do console do Google Cloud, acesse a página do Vertex AI Studio.

    Acessar o Vertex AI Studio

  2. Em Criar um novo comando, clique em qualquer um dos botões para abrir a página de criação de comandos.

  3. Clique em Configurações de segurança.

    A caixa de diálogo Configurações de segurança é aberta.

  4. Para cada categoria de dano, configure o valor limite desejado.

  5. Clique em Salvar.

Exemplo de saída quando uma resposta é bloqueada pelo filtro de segurança configurável

Este é um exemplo de saída da API Vertex AI Gemini quando uma resposta é bloqueada pelo filtro de segurança configurável por conter conteúdo perigoso:

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

Exemplos de configuração do filtro de segurança

Os exemplos a seguir demonstram como configurar o filtro de segurança usando a API Vertex AI Gemini:

Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Para mais informações, consulte a documentação de referência da API Python. 

import vertexai

from vertexai.generative_models import (
    GenerativeModel,
    HarmCategory,
    HarmBlockThreshold,
    Part,
    SafetySetting,
)

# TODO(developer): Update and un-comment below line
# PROJECT_ID = "your-project-id"
vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel("gemini-1.5-flash-002")

# Safety config
safety_config = [
    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,
    ),
]

image_file = Part.from_uri(
    "gs://cloud-samples-data/generative-ai/image/scones.jpg", "image/jpeg"
)

# Generate content
response = model.generate_content(
    [image_file, "What is in this image?"],
    safety_settings=safety_config,
)

print(response.text)
print(response.candidates[0].safety_ratings)
# Example response:
# The image contains a beautiful arrangement of blueberry scones, flowers, coffee, and blueberries.
# The scene is set on a rustic blue background. The image evokes a sense of comfort and indulgence.
# ...

Node.js

Antes de testar esse exemplo, siga as instruções de configuração para Node.js no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Node.js.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

const {
  VertexAI,
  HarmCategory,
  HarmBlockThreshold,
} = require('@google-cloud/vertexai');

/**
 * TODO(developer): Update these variables before running the sample.
 */
const PROJECT_ID = process.env.CAIP_PROJECT_ID;
const LOCATION = 'us-central1';
const MODEL = 'gemini-1.5-flash-001';

async function setSafetySettings() {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: PROJECT_ID, location: LOCATION});

  // Instantiate the model
  const generativeModel = vertexAI.getGenerativeModel({
    model: MODEL,
    // The following parameters are optional
    // They can also be passed to individual content generation requests
    safetySettings: [
      {
        category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
        threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
      },
      {
        category: HarmCategory.HARM_CATEGORY_HARASSMENT,
        threshold: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
      },
    ],
  });

  const request = {
    contents: [{role: 'user', parts: [{text: 'Tell me something dangerous.'}]}],
  };

  console.log('Prompt:');
  console.log(request.contents[0].parts[0].text);
  console.log('Streaming Response Text:');

  // Create the response stream
  const responseStream = await generativeModel.generateContentStream(request);

  // Log the text response as it streams
  for await (const item of responseStream.stream) {
    if (item.candidates[0].finishReason === 'SAFETY') {
      console.log('This response stream terminated due to safety concerns.');
      break;
    } else {
      process.stdout.write(item.candidates[0].content.parts[0].text);
    }
  }
  console.log('This response stream terminated due to safety concerns.');
}

Java

Antes de testar esse exemplo, siga as instruções de configuração para Java no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Java.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

import com.google.cloud.vertexai.VertexAI;
import com.google.cloud.vertexai.api.Candidate;
import com.google.cloud.vertexai.api.GenerateContentResponse;
import com.google.cloud.vertexai.api.GenerationConfig;
import com.google.cloud.vertexai.api.HarmCategory;
import com.google.cloud.vertexai.api.SafetySetting;
import com.google.cloud.vertexai.generativeai.GenerativeModel;
import java.util.Arrays;
import java.util.List;

public class WithSafetySettings {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-google-cloud-project-id";
    String location = "us-central1";
    String modelName = "gemini-1.5-flash-001";
    String textPrompt = "your-text-here";

    String output = safetyCheck(projectId, location, modelName, textPrompt);
    System.out.println(output);
  }

  // Use safety settings to avoid harmful questions and content generation.
  public static String safetyCheck(String projectId, String location, String modelName,
      String textPrompt) throws Exception {
    // Initialize client that will be used to send requests. This client only needs
    // to be created once, and can be reused for multiple requests.
    try (VertexAI vertexAI = new VertexAI(projectId, location)) {
      StringBuilder output = new StringBuilder();

      GenerationConfig generationConfig =
          GenerationConfig.newBuilder()
              .setMaxOutputTokens(2048)
              .setTemperature(0.4F)
              .build();

      List<SafetySetting> safetySettings = Arrays.asList(
          SafetySetting.newBuilder()
              .setCategory(HarmCategory.HARM_CATEGORY_HATE_SPEECH)
              .setThreshold(SafetySetting.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE)
              .build(),
          SafetySetting.newBuilder()
              .setCategory(HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT)
              .setThreshold(SafetySetting.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE)
              .build()
      );

      GenerativeModel model = new GenerativeModel(modelName, vertexAI)
          .withGenerationConfig(generationConfig)
          .withSafetySettings(safetySettings);

      GenerateContentResponse response = model.generateContent(textPrompt);
      output.append(response).append("\n");

      // Verifies if the above content has been blocked for safety reasons.
      boolean blockedForSafetyReason = response.getCandidatesList()
          .stream()
          .anyMatch(candidate -> candidate.getFinishReason() == Candidate.FinishReason.SAFETY);
      output.append("Blocked for safety reasons?: ").append(blockedForSafetyReason);

      return output.toString();
    }
  }
}

Go

Antes de testar esse exemplo, siga as instruções de configuração para Go no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para Go.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

import (
	"context"
	"fmt"
	"io"
	"mime"
	"path/filepath"

	"cloud.google.com/go/vertexai/genai"
)

// generateMultimodalContent generates a response into w, based upon the  provided image.
func generateMultimodalContent(w io.Writer, projectID, location, modelName string) error {
	// location := "us-central1"
	// model := "gemini-1.5-flash-001"
	ctx := context.Background()

	client, err := genai.NewClient(ctx, projectID, location)
	if err != nil {
		return fmt.Errorf("unable to create client: %w", err)
	}
	defer client.Close()

	model := client.GenerativeModel(modelName)
	model.SetTemperature(0.4)
	// configure the safety settings thresholds
	model.SafetySettings = []*genai.SafetySetting{
		{
			Category:  genai.HarmCategoryHarassment,
			Threshold: genai.HarmBlockLowAndAbove,
		},
		{
			Category:  genai.HarmCategoryDangerousContent,
			Threshold: genai.HarmBlockLowAndAbove,
		},
	}

	// Given an image file URL, prepare image file as genai.Part
	img := genai.FileData{
		MIMEType: mime.TypeByExtension(filepath.Ext("320px-Felis_catus-cat_on_snow.jpg")),
		FileURI:  "gs://cloud-samples-data/generative-ai/image/320px-Felis_catus-cat_on_snow.jpg",
	}

	res, err := model.GenerateContent(ctx, img, genai.Text("describe this image."))
	if err != nil {
		return fmt.Errorf("unable to generate contents: %w", err)
	}

	fmt.Fprintf(w, "generated response: %s\n", res.Candidates[0].Content.Parts[0])
	return nil
}

C#

Antes de testar esse exemplo, siga as instruções de configuração para C# no Guia de início rápido da Vertex AI sobre como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Vertex AI para C#.

Para autenticar na Vertex AI, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


using Google.Api.Gax.Grpc;
using Google.Cloud.AIPlatform.V1;
using System.Text;
using System.Threading.Tasks;
using static Google.Cloud.AIPlatform.V1.SafetySetting.Types;

public class WithSafetySettings
{
    public async Task<string> GenerateContent(
        string projectId = "your-project-id",
        string location = "us-central1",
        string publisher = "google",
        string model = "gemini-1.5-flash-001"
    )
    {
        var predictionServiceClient = new PredictionServiceClientBuilder
        {
            Endpoint = $"{location}-aiplatform.googleapis.com"
        }.Build();


        var generateContentRequest = new GenerateContentRequest
        {
            Model = $"projects/{projectId}/locations/{location}/publishers/{publisher}/models/{model}",
            Contents =
            {
                new Content
                {
                    Role = "USER",
                    Parts =
                    {
                        new Part { Text = "Hello!" }
                    }
                }
            },
            SafetySettings =
            {
                new SafetySetting
                {
                    Category = HarmCategory.HateSpeech,
                    Threshold = HarmBlockThreshold.BlockLowAndAbove
                },
                new SafetySetting
                {
                    Category = HarmCategory.DangerousContent,
                    Threshold = HarmBlockThreshold.BlockMediumAndAbove
                }
            }
        };

        using PredictionServiceClient.StreamGenerateContentStream response = predictionServiceClient.StreamGenerateContent(generateContentRequest);

        StringBuilder fullText = new();

        AsyncResponseStream<GenerateContentResponse> responseStream = response.GetResponseStream();
        await foreach (GenerateContentResponse responseItem in responseStream)
        {
            // Check if the content has been blocked for safety reasons.
            bool blockForSafetyReason = responseItem.Candidates[0].FinishReason == Candidate.Types.FinishReason.Safety;
            if (blockForSafetyReason)
            {
                fullText.Append("Blocked for safety reasons");
            }
            else
            {
                fullText.Append(responseItem.Candidates[0].Content.Parts[0].Text);
            }
        }

        return fullText.ToString();
    }
}

REST

Depois de configurou seu ambiente use REST para testar uma solicitação de texto. O exemplo a seguir envia uma solicitação ao publisher endpoint do modelo.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • LOCATION: a região para processar a solicitação. As opções disponíveis incluem:

    Clicar para abrir uma lista parcial das regiões disponíveis

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • PROJECT_ID: o ID do projeto.
  • MODEL_ID: o ID do modelo multimodal que você quer usar. As opções são:
    • gemini-1.0-pro
    • gemini-1.0-pro-vision
  • ROLE: o papel em uma conversa associada ao conteúdo. É necessário especificar um papel mesmo em casos de uso de turno único. Os valores aceitáveis são os seguintes:
    • USER: especifica o conteúdo que é enviado por você.
    • MODEL: especifica a resposta do modelo.
  • TEXT: as instruções de texto a serem incluídas no comando.
  • SAFETY_CATEGORY: a categoria de segurança para a qual configurar um limite. Os valores aceitáveis são os seguintes:

    Clique para expandir as categorias de segurança

    • HARM_CATEGORY_SEXUALLY_EXPLICIT
    • HARM_CATEGORY_HATE_SPEECH
    • HARM_CATEGORY_HARASSMENT
    • HARM_CATEGORY_DANGEROUS_CONTENT
  • THRESHOLD: o limite de bloqueio de respostas que podem pertencer à categoria de segurança especificada com base na probabilidade. Os valores aceitáveis são os seguintes:

    Clique para expandir os limites de bloqueio

    • BLOCK_NONE
    • BLOCK_ONLY_HIGH
    • BLOCK_MEDIUM_AND_ABOVE (padrão)
    • BLOCK_LOW_AND_ABOVE
     BLOCK_LOW_AND_ABOVE bloqueia mais, e BLOCK_ONLY_HIGH bloqueia a menor.

Método HTTP e URL: 

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

Corpo JSON da solicitação:

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

Para enviar a solicitação, escolha uma destas opções:

curl

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

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

Salve o corpo da solicitação em um arquivo com o nome request.json e execute o comando a seguir: 

$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

Você receberá uma resposta JSON semelhante a seguinte.

Exemplo de comando curl

LOCATION="us-central1"
MODEL_ID="gemini-1.0-pro"
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"
    }
  ]
}'

Filtro de citações

Os recursos de código generativo da Vertex AI têm como objetivo produzir conteúdo original. Por padrão, o Gemini limita a probabilidade de que o conteúdo atual seja replicado extensamente. Se um recurso do Gemini fizer uma citação extensa de uma página da Web, o Gemini cita essa página.

Às vezes, o mesmo conteúdo pode ser encontrado em várias páginas da Web. O Gemini tenta apontar para uma fonte conhecida. No caso de citações de repositórios de código, a citação também pode referenciar uma licença de código aberto aplicável. É sua responsabilidade obedecer aos requisitos de licença.

Para saber mais sobre os metadados do filtro de citações, consulte a referência da API Citation.

Filtro de integridade cívica

O filtro de integridade cívica detecta e bloqueia comandos que mencionam ou se relacionam a eleições e candidatos políticos. Esse filtro fica desativado por padrão. Para ativar essa opção, defina o limite de bloqueio para CIVIC_INTEGRITY como um dos seguintes valores. Não faz diferença qual valor você especifica.

  • BLOCK_LOW_AND_ABOVE
  • BLOCK_MEDIUM_AND_ABOVE
  • BLOCK_ONLY_HIGH

O código Python a seguir mostra como ativar o filtro de integridade cívica:

  generative_models.SafetySetting(
          category=generative_models.HarmCategory.CIVIC_INTEGRITY,
          threshold=generative_models.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
      ),

Para mais detalhes sobre o filtro de integridade cívica, entre em contato com seu representante do Google Cloud.

Práticas recomendadas

Embora os filtros de segurança ajudem a evitar conteúdo não seguro, eles podem bloquear conteúdo seguro ou não detectar conteúdo não seguro. Modelos avançados, como Gemini 1.5 Flash e Gemini 1.5 Pro, são projetados para gerar respostas seguras, mesmo sem filtros. Teste diferentes configurações de filtro para encontrar o equilíbrio certo entre segurança e permissão de conteúdo adequado.

A seguir