Inferência de prioridade

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

A inferência Priority está disponível para usuários dos níveis 2 e 3 nos endpoints da API GenerateContent e da API Interactions.

Como usar o nível Priority

Para usar o nível Priority, defina o campo service_tier no corpo da solicitação como priority. O nível padrão será usado se o campo for omitido.

from google import genai

client = genai.Client()

try:
    response = client.models.generate_content(
        model="gemini-3.5-flash",
        contents="Triage this critical customer support ticket immediately.",
        config={"service_tier": "priority"},
    )

    # Validate for graceful downgrade
    if response.sdk_http_response.headers.get("x-gemini-service-tier") == "standard":
        print("Warning: Priority limit exceeded, processed at Standard tier.")

    print(response.text)

except Exception as e:
    # Standard error handling (e.g., DEADLINE_EXCEEDED)
    print(f"Error during API call: {e}")

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

const ai = new GoogleGenAI({});

async function main() {
  try {
      const result = await ai.models.generateContent({
          model: "gemini-3.5-flash",
          contents: "Triage this critical customer support ticket immediately.",
          config: {serviceTier: "priority"},
      });

      // Validate for graceful downgrade
      if (result.sdkHttpResponse.headers.get("x-gemini-service-tier") === "standard") {
          console.log("Warning: Priority limit exceeded, processed at Standard tier.");
      }

      console.log(result.text);

  } catch (e) {
      console.log(`Error during API call: ${e}`);
  }
}

await main();

package main

import (
    "context"
    "fmt"
    "log"
    "google.golang.org/genai"
)

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

    resp, err := client.Models.GenerateContent(
        ctx,
        "gemini-3.5-flash",
        genai.Text("Triage this critical customer support ticket immediately."),
        &genai.GenerateContentConfig{
            ServiceTier: "priority",
        },
    )
    if err != nil {
        log.Fatalf("Error during API call: %v", err)
    }

    // Validate for graceful downgrade
    if resp.SDKHTTPResponse.Header.Get("x-gemini-service-tier") == "standard" {
        fmt.Println("Warning: Priority limit exceeded, processed at Standard tier.")
    }

    fmt.Println(resp.Text())
}

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.5-flash:generateContent?key=$GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts":[{"text": "Analyze user sentiment in real time"}]
  }],
  "service_tier": "priority"
}'

Como funciona a inferência Priority

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

Principais benefícios

• Baixa latência: projetado para tempos de resposta de segundos para ferramentas de IA interativas, voltadas ao usuário.
• Alta confiabilidade: o tráfego é tratado com a maior criticidade e é estritamente não descartável.
• Degradação suave: 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 de serviço.
• Baixa fricção: usa o mesmo método síncrono generateContent que os níveis Standard e Flex.

Casos de uso

O processamento Priority é ideal para fluxos de trabalho essenciais para os negócios em que o desempenho e a confiabilidade são fundamentais.

• Aplicativos de IA interativos: chatbots de atendimento ao cliente e copilotos em que os usuários pagam um valor premium 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 tickets 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 Priority tem limites de taxas próprios, mesmo que o consumo seja contabilizado nos limites gerais de taxas de tráfego interativo. Os limites de taxas padrão para inferência Priority são 0,3 vezes o limite de taxas padrão para modelo / nível.

Lógica de downgrade suave

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

Responsabilidade do cliente

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

Preços

A inferência Priority custa de 75 a 100% mais do que a API Standard e é cobrada por token.

Modelos compatíveis

Os seguintes modelos oferecem suporte à inferência Priority:

A seguir

Leia sobre outras opções de inferência e otimização do Gemini:

• Inferência Flex para redução de custos de 50%.
• API Batch para processamento assíncrono em até 24 horas.
• Cache de contexto para reduzir os custos de tokens de entrada.