API Inference

Use a API Inference para gerar solicitações do Gemini.

A família de modelos do Gemini inclui modelos que funcionam com solicitações de comando multimodais. O termo multimodal indica que é possível usar mais de uma modalidade, ou tipo de entrada, em um comando. Os modelos que não são multimodais aceitam solicitações apenas com texto. As modalidades podem incluir texto, áudio, vídeo e muito mais.

Para mais informações gerais, consulte:

Modelos com suporte:

Modelo Versão
Flash 1.5 do Gemini (pré-lançamento) gemini-1.5-flash-preview-0514
Gemini 1.5 Pro (Pré-lançamento) gemini-1.5-pro-preview-0514
Gemini 1.0 Pro Vision gemini-1.0-pro-001
gemini-1.0-pro-vision-001
Gemini 1.0 Pro gemini-1.0-pro
gemini-1.0-pro-001
gemini-1.0-pro-002

Limitações:

Se você fornecer muitas imagens, a latência poderá ser alta.

Exemplo de sintaxe

Sintaxe para gerar uma resposta de modelo.

Não streaming

curl

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}:generateContent \
-d '{
  "contents": [{
    ...
  }],
  "generation_config": {
    ...
  },
  "safety_settings": {
    ...
  }
  ...
}'

Python

gemini_model = GenerativeModel(MODEL_ID)
generation_config = GenerationConfig(...)

model_response = gemini_model.generate_content([...], generation_config, safety_settings={...})

De streaming

curl

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": [{
      ...
    }],
    "generation_config": {
      ...
    },
    "safety_settings": {
      ...
    }
    ...
  }'

Python

gemini_model = GenerativeModel(MODEL_ID)
model_response = gemini_model.generate_content([...], generation_config, safety_settings={...}, stream=True)

Lista de parâmetros

Confira exemplos para detalhes de implementação.

Corpo da solicitação

O corpo da solicitação contém dados com os seguintes parâmetros:

Parâmetros

contents

Obrigatório: Content

O conteúdo da conversa atual com o modelo.

Para consultas de turno único, esta é uma instância única. Para consultas com várias interações, esse é um campo repetido que contém o histórico da conversa e a solicitação mais recente.

system_instruction

Opcional: Content

O usuário forneceu instruções do sistema para o modelo.

Observação: somente text pode ser usado em parts, e o conteúdo de cada part precisa estar em um parágrafo separado.

tools

Opcional. Consulte API de chamada de função.

tool_config

Opcional. Consulte API de chamada de função.

safety_settings

Opcional: SafetySetting

Configurações conforme a solicitação para bloquear conteúdo não seguro.

Aplicado em GenerateContentResponse.candidates.

generation_config

Opcional: GenerationConfig

Configurações de geração.

Conteúdo

O tipo de dados estruturados de base que contém várias partes de uma mensagem.

Essa classe consiste em duas properties principais: role e parts. A propriedade role indica o indivíduo que produz o conteúdo, enquanto a propriedade parts contém vários elementos, cada um representando um segmento de dados em uma mensagem.

Parâmetros

role

Opcional: string

A identidade da entidade que cria a mensagem. Os valores a seguir são compatíveis:

  • user: indica que a mensagem é enviada por uma pessoa real, geralmente uma mensagem gerada pelo usuário.
  • model: indica que a mensagem é gerada pelo modelo.

O valor model é usado para inserir mensagens do modelo na conversa durante conversas com vários turnos.

Para conversas que não têm vários turnos, esse campo pode ser deixado em branco ou sem definição.

parts

Part

Uma lista de partes ordenadas que compõem uma única mensagem. Partes diferentes podem ter tipos MIME IANA distintos.

Parte

Um tipo de dados que contém mídia que faz parte de uma mensagem Content de várias partes.

Parâmetros

text

Opcional: string

Um comando de texto ou snippet de código.

inline_data

Opcional: Blob

Dados inline em bytes brutos.

file_data

Opcional: FileData

Dados armazenados em um arquivo.

function_call

Opcional: FunctionCall.

Ele contém uma string que representa o campo FunctionDeclaration.name e um objeto JSON estruturado com todos os parâmetros para a chamada de função prevista pelo modelo.

Consulte API de chamada de função.

function_response

Opcional: FunctionResponse.

A saída resultante de uma FunctionCall que contém uma string que representa o campo FunctionDeclaration.name e um objeto JSON estruturado com qualquer saída da chamada de função. Ele é usado como contexto para o modelo.

Consulte API de chamada de função.

video_metadata

Opcional: VideoMetadata

Metadados do vídeo. Os metadados só devem ser especificados enquanto os dados do vídeo estiverem apresentados em inline_data ou file_data.

Blob

blob de conteúdo Se possível, envie como texto em vez de bytes brutos.

Parâmetros

mime_type

string

Tipo MIME IANA dos dados.

data

bytes

Bytes brutos.

FileData

Dados baseados em URI.

Parâmetros

mime_type

string

Tipo MIME IANA dos dados.

file_uri

string

O URI do Cloud Storage para o arquivo que armazena os dados

FunctionCall

Um FunctionCall previsto retornado do modelo que contém uma string que representa o FunctionDeclaration.name e um objeto JSON estruturado contendo os parâmetros e os valores deles.

Parâmetros

name

string

O nome da função a ser chamada.

args

Struct

Os parâmetros e valores da função no formato de objeto JSON.

Consulte a API de chamada de função para mais detalhes sobre o parâmetro.

FunctionResponse

A saída resultante de um FunctionCall que contém uma string que representa o FunctionDeclaration.name. Também contém um objeto JSON estruturado com a saída da função e o usa como contexto para o modelo. Ela precisa conter o resultado de uma FunctionCall feita com base na previsão do modelo.

Parâmetros

name

string

O nome da função a ser chamada.

response

Struct

A resposta da função no formato de objeto JSON.

VideoMetadata

Metadados que descrevem o conteúdo do vídeo de entrada.

Parâmetros

start_offset

Opcional: google.protobuf.Duration

O deslocamento inicial do vídeo.

end_offset

Opcional: google.protobuf.Duration

O deslocamento final do vídeo.

SafetySetting

Configurações de segurança.

Parâmetros

category

Opcional: HarmCategory

A categoria de dano.

threshold

Opcional: HarmBlockThreshold

O limite do bloqueio de danos.

max_influential_terms

Opcional: int

O número máximo de termos influentes que mais contribuem para as pontuações de segurança, o que pode causar possíveis bloqueios.

method

Opcional: HarmBlockMethod

Especifique se o limite é usado para pontuação de probabilidade ou gravidade. Se não for especificado, o limite será usado para a pontuação de probabilidade.

HarmCategory

Categorias de CRM que bloqueiam conteúdo.

Parâmetros

HARM_CATEGORY_UNSPECIFIED

A categoria de danos não foi especificada.

HARM_CATEGORY_HATE_SPEECH

A categoria de danos é discurso de ódio.

HARM_CATEGORY_DANGEROUS_CONTENT

A categoria de danos é um conteúdo perigoso.

HARM_CATEGORY_HARASSMENT

A categoria de dano é assédio.

HARM_CATEGORY_SEXUALLY_EXPLICIT

A categoria de dano é conteúdo sexualmente explícito.

HarmBlockThreshold

Níveis de limites de probabilidade usados para bloquear uma resposta.

Parâmetros

HARM_BLOCK_THRESHOLD_UNSPECIFIED

Limite de bloqueio de danos não especificado.

BLOCK_LOW_AND_ABOVE

Bloquear o limite inferior e superior (ou seja, bloquear mais).

BLOCK_MEDIUM_AND_ABOVE

Bloquear limite médio e superior.

BLOCK_ONLY_HIGH

Bloquear apenas o limite superior (ou seja, bloquear menos).

BLOCK_NONE

Bloquear nenhum

HarmBlockMethod

Um limite de probabilidade que bloqueia uma resposta com base em uma combinação de probabilidade e gravidade.

Parâmetros

HARM_BLOCK_METHOD_UNSPECIFIED

O método do bloco de danos não foi especificado.

SEVERITY

O método do bloqueio de danos usa pontuações de probabilidade e gravidade.

PROBABILITY

O método do bloqueio de danos usa a pontuação de probabilidade.

GenerationConfig

Configurações usadas ao gerar o comando.

Parâmetros

temperature

Opcional: float

Controla a aleatoriedade das previsões.

top_p

Opcional: float

Se especificado, a amostragem de núcleos é usada.

top_k

Opcional: se especificado, a amostragem top-k é usada.

candidate_count

Opcional: int

Número de candidatos a serem gerados.

max_output_tokens

Opcional: int

O número máximo de tokens de saída a serem gerados por mensagem.

stop_sequences

Opcional: List[string]

Sequências de paradas.

presence_penalty

Opcional: float

Penalidades positivas.

frequency_penalty

Opcional: float

Penalidades de frequência.

response_mime_type

Opcional: string (enum)

Tipo MIME da resposta de saída do texto candidato gerado.

Tipo MIME compatível:

  • text/plain (padrão): saída de texto.
  • application/json: resposta JSON nos candidatos.
  • O modelo precisa ser solicitado a emitir o tipo de resposta apropriado. Caso contrário, o comportamento será indefinido.

Este é um recurso em fase de pré-lançamento.

Examples

Resposta de texto sem streaming

Gere uma resposta de modelo sem streaming com base em uma entrada de texto.

REST

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

  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região para processar a solicitação.
  • TEXT: as instruções de texto a serem incluídas no comando.

Método HTTP e URL: 

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

Corpo JSON da solicitação:

{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "TEXT"
    }]
  }]
}'

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:generateContent"

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:generateContent" | Select-Object -Expand Content

Python 

import vertexai

from vertexai.generative_models import GenerativeModel

vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel(MODEL_ID)
response = model.generate_content("Write a story about a magic backpack.")

print(response)

NodeJS 

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function generateContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-002'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  // Instantiate the model
  const generativeModel = vertexAI.getGenerativeModel({
    model: model,
  });

  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            text: 'Write a story about a magic backpack.',
          },
        ],
      },
    ],
  };

  console.log(JSON.stringify(request));

  const result = await generativeModel.generateContent(request);

  console.log(result.response.candidates[0].content.parts[0].text);
}

Resposta multimodal que não é de streaming

Gere uma resposta de modelo sem streaming com base em uma entrada multimodal, como texto e imagem.

REST

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

  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região para processar a solicitação.
  • TEXT: as instruções de texto a serem incluídas no comando.
  • FILE_URI: O URI do Cloud Storage para o arquivo que armazena os dados
  • MIME_TYPE: o tipo MIME TIANA dos dados.

Método HTTP e URL: 

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

Corpo JSON da solicitação:

{
"contents": [{
  "role": "user",
  "parts": [
    {
      "text": "TEXT"
    },
    {
      "file_data": {"file_uri": "FILE_URI", "MIME_TYPE"}
    },
    {
      "file_data": {"file_uri": "FILE_URI", "MIME_TYPE"}
    }
  ]
}]
}

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:generateContent"

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:generateContent" | Select-Object -Expand Content

Python 

import vertexai

from vertexai.generative_models import GenerativeModel, Part

vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel(MODEL_ID)
response = model.generate_content(
    [
        Part.from_uri(
            "gs://cloud-samples-data/generative-ai/video/animals.mp4", "video/mp4"
        ),
        Part.from_uri(
            "gs://cloud-samples-data/generative-ai/image/character.jpg",
            "image/jpeg",
        ),
        "Are these video and image correlated?",
    ]
)

print(response)

NodeJS 

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function generateContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.5-pro-preview-0409'
) {
  // Initialize Vertex AI
  const vertexAI = new VertexAI({project: projectId, location: location});
  const generativeModel = vertexAI.getGenerativeModel({model: model});

  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            file_data: {
              file_uri: 'gs://cloud-samples-data/video/animals.mp4',
              mime_type: 'video/mp4',
            },
          },
          {
            file_data: {
              file_uri:
                'gs://cloud-samples-data/generative-ai/image/character.jpg',
              mime_type: 'image/jpeg',
            },
          },
          {text: 'Are this video and image correlated?'},
        ],
      },
    ],
  };

  const result = await generativeModel.generateContent(request);

  console.log(result.response.candidates[0].content.parts[0].text);
}

Resposta de texto de streaming

Gerar uma resposta de modelo de streaming com base em uma entrada de texto.

REST

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

  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região para processar a solicitação.
  • TEXT: as instruções de texto a serem incluídas no comando.

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": "user",
    "parts": [{
      "text": "TEXT"
    }]
  }]
}'

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

Python 

import vertexai

from vertexai.generative_models import GenerativeModel

vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel(MODEL_ID)
responses = model.generate_content(
    "Write a story about a magic backpack.", stream=True
)

for response in responses:
    print(response)

NodeJS 

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function generateContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.0-pro-002'
) {
  // Initialize Vertex with your Cloud project and location
  const vertexAI = new VertexAI({project: projectId, location: location});

  // Instantiate the model
  const generativeModel = vertexAI.getGenerativeModel({
    model: model,
  });

  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            text: 'Write a story about a magic backpack.',
          },
        ],
      },
    ],
  };

  console.log(JSON.stringify(request));

  const result = await generativeModel.generateContentStream(request);
  for await (const item of result.stream) {
    console.log(item.candidates[0].content.parts[0].text);
  }
}

Resposta multimodal de streaming

Gere uma resposta de modelo de streaming com base em uma entrada multimodal, como texto e imagem.

REST

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

  • PROJECT_ID: o ID do projeto.
  • LOCATION: a região para processar a solicitação.
  • TEXT: as instruções de texto a serem incluídas no comando.

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": "user",
    "parts": [{
      "text": "TEXT"
    }]
  }]
}'

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

Python 

import vertexai

from vertexai.generative_models import GenerativeModel, Part

vertexai.init(project=PROJECT_ID, location="us-central1")

model = GenerativeModel(MODEL_ID)
responses = model.generate_content(
    [
        Part.from_uri(
            "gs://cloud-samples-data/generative-ai/video/animals.mp4", "video/mp4"
        ),
        Part.from_uri(
            "gs://cloud-samples-data/generative-ai/image/character.jpg",
            "image/jpeg",
        ),
        "Are these video and image correlated?",
    ],
    stream=True,
)

for response in responses:
    print(response)

NodeJS 

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

/**
 * TODO(developer): Update these variables before running the sample.
 */
async function generateContent(
  projectId = 'PROJECT_ID',
  location = 'us-central1',
  model = 'gemini-1.5-pro-preview-0409'
) {
  // Initialize Vertex AI
  const vertexAI = new VertexAI({project: projectId, location: location});
  const generativeModel = vertexAI.getGenerativeModel({model: model});

  const request = {
    contents: [
      {
        role: 'user',
        parts: [
          {
            file_data: {
              file_uri: 'gs://cloud-samples-data/video/animals.mp4',
              mime_type: 'video/mp4',
            },
          },
          {
            file_data: {
              file_uri:
                'gs://cloud-samples-data/generative-ai/image/character.jpg',
              mime_type: 'image/jpeg',
            },
          },
          {text: 'Are this video and image correlated?'},
        ],
      },
    ],
  };

  const result = await generativeModel.generateContentStream(request);

  for await (const item of result.stream) {
    console.log(item.candidates[0].content.parts[0].text);
  }
}

A seguir