Inferência de prioridade

A API Gemini Priority é um nível premium de inferência projetado para cargas de trabalho essenciais aos negócios que exigem menor latência e a maior confiabilidade a um preço premium. O tráfego do nível de prioridade tem prioridade sobre o tráfego da API padrão e do nível Flex.

A inferência de prioridade está disponível em todos os endpoints da API Interactions.

Como usar a prioridade

Para usar o nível de prioridade, defina o campo service_tier na sua solicitação como priority. O nível padrão é "standard" se o campo for omitido.

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.8-flash",
    input="Triage this critical customer support ticket immediately.",
    service_tier='priority'
)
print(interaction.output_text)

import { GoogleGenAI } from '@google/genai';

const ai = new GoogleGenAI({});

async function main() {
    const interaction = await ai.interactions.create({
        model: "gemini-3.8-flash",
        input: "Triage this critical customer support ticket immediately.",
        service_tier: "priority"
    });
    console.log(interaction.output_text);
}

await main();

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ServiceTier;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.of("Perform a priority inference task."))
        .serviceTier(ServiceTier.PRIORITY)
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, nil)
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model:       interactions.Model("gemini-3.8-flash"),
            Input:       interactions.NewInteractionsInput("Perform a priority inference task."),
            ServiceTier: interactions.ServiceTierPriority.ToPointer(),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -d '{
    "model": "gemini-3.8-flash",
    "input": "Triage this critical customer support ticket immediately.",
    "service_tier": "priority"
  }'

Como funciona a inferência de prioridade

A inferência de prioridade encaminha solicitações para filas de computação de alta criticidade, oferecendo performance rápida e previsível para aplicativos voltados ao usuário. O mecanismo principal é um downgrade suave do lado do servidor para o processamento padrão do tráfego que excede os limites dinâmicos, garantindo a estabilidade do aplicativo em vez de falhar na solicitação.

Principais vantagens

• Baixa latência: projetada para tempos de resposta de segundos em ferramentas de IA interativas e voltadas ao usuário.
• Alta confiabilidade: o tráfego é tratado com a maior criticidade e não pode ser descartado.
• Degradação gradual: picos de tráfego que excedem os limites dinâmicos são automaticamente rebaixados para o nível Standard para processamento em vez de falhar, evitando interrupções no serviço.
• Baixo atrito: usa o mesmo método síncrono create que os níveis Standard e Flex.

Casos de uso

O processamento prioritário é ideal para fluxos de trabalho essenciais para os negócios em que a performance e a confiabilidade são fundamentais.

• Aplicativos de IA interativos: bots de chat e copilotos de atendimento ao cliente em que os usuários pagam um valor extra e esperam respostas rápidas e consistentes.
• Mecanismos de decisão em tempo real: sistemas que exigem resultados altamente confiáveis e de baixa latência, como triagem de tíquetes ao vivo ou detecção de fraudes.
• Recursos premium para clientes: desenvolvedores que precisam garantir objetivos de nível de serviço (SLOs) mais altos para clientes pagantes.

Limites de taxas

O consumo de prioridade tem limites de taxa próprios, mesmo que o consumo seja contado para os limites de taxa de tráfego interativo geral. Os limites de taxa padrão para inferência de prioridade são 0,3 vezes o limite de taxa padrão para modelo / nível.

Lógica de downgrade sem dificuldades

Se os limites de prioridade forem excedidos devido ao congestionamento, as solicitações de estouro serão rebaixadas automaticamente e de maneira adequada para o processamento padrão em vez de falhar com um erro 503 ou 429. As solicitações de downgrade são cobradas pela taxa padrão, não pela taxa premium de prioridade.

Responsabilidade do cliente

• Monitoramento de respostas: os desenvolvedores precisam monitorar o cabeçalho x-gemini-service-tier na resposta da API para detectar se as solicitações estão sendo rebaixadas com frequência para standard.
• Novas tentativas: os clientes precisam implementar uma lógica de novas tentativas/espera exponencial para erros padrão, como DEADLINE_EXCEEDED.

Preços

A inferência de prioridade custa de 75 a 100% mais do que a API padrão e é faturada por token.

Modelos compatíveis

Os seguintes modelos são compatíveis com a inferência de prioridade:

A seguir

• Inferência flexível para redução de custos.
• Tokens: entenda o que são tokens.