Inferencia flexible

La API de Gemini Flex es un nivel de inferencia que ofrece una reducción del 50% en el costo en comparación con las tarifas estándar, a cambio de una latencia variable y una disponibilidad con el mejor esfuerzo. Está diseñada para cargas de trabajo tolerantes a la latencia que requieren procesamiento síncrono, pero no necesitan el rendimiento en tiempo real de la API estándar.

Cómo usar Flex

Para usar el nivel Flex, especifica service_tier como flex en tu solicitud. De forma predeterminada, las solicitudes usan el nivel estándar si se omite este campo.

from google import genai

client = genai.Client()

try:
    interaction = client.interactions.create(
        model="gemini-3.5-flash",
        input="Analyze this dataset for trends...",
        service_tier='flex'
    )
    print(interaction.output_text)
except Exception as e:
    print(f"Flex request failed: {e}")

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

const client = new GoogleGenAI({});

async function main() {
    try {
        const interaction = await client.interactions.create({
            model: 'gemini-3.5-flash',
            input: 'Analyze this dataset for trends...',
            service_tier: 'flex'
        });
        console.log(interaction.output_text);
    } catch (e) {
        console.log(`Flex request failed: ${e}`);
    }
}
await main();

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Api-Revision: 2026-05-20" \
  -d '{
      "model": "gemini-3.5-flash",
      "input": "Analyze this dataset for trends...",
      "service_tier": "flex"
  }'

Cómo funciona la inferencia flexible

La inferencia de Gemini Flex une la brecha entre la API estándar y el tiempo de respuesta de las 24 horas de la API de Batch. Utiliza capacidad de procesamiento fuera de las horas pico y "descartable" para proporcionar una solución rentable para las tareas en segundo plano y los flujos de trabajo secuenciales.

Ventajas clave

• Eficiencia en los costos: Ahorros significativos en las evaluaciones que no son de producción, los agentes en segundo plano y el enriquecimiento de datos.
• Baja fricción: Simplemente agrega un solo parámetro a tus solicitudes existentes.
• Flujos de trabajo síncronos: Son ideales para cadenas de APIs secuenciales en las que la próxima solicitud depende del resultado de la anterior, lo que los hace más flexibles que los flujos de trabajo por lotes para los flujos de trabajo de agentes.

Casos de uso

• Evaluaciones sin conexión: Ejecución de pruebas de regresión o tablas de clasificación de "LLM como juez".
• Agentes en segundo plano: Tareas secuenciales como actualizaciones de CRM, creación de perfiles o moderación de contenido en las que se aceptan minutos de retraso.
• Investigación con presupuesto limitado: Experimentos académicos que requieren un gran volumen de tokens con un presupuesto limitado.

Límites de frecuencia

El tráfico de inferencia flexible se incluye en los límites de frecuencia generales y no ofrece límites de frecuencia extendidos como la API de Batch.

Capacidad que se puede reducir

El tráfico flexible se trata con menor prioridad. Si hay un aumento repentino en el tráfico estándar, es posible que se interrumpan o descarten las solicitudes de Flex para garantizar la capacidad de los usuarios de alta prioridad. Si buscas inferencia de alta prioridad, consulta Inferencia prioritaria.

Códigos de error

Cuando la capacidad flexible no esté disponible o el sistema esté congestionado, la API devolverá códigos de error estándar:

• 503 Service Unavailable: El sistema está al máximo de su capacidad.
• 429 Too Many Requests: Se excedieron los límites de frecuencia o se agotaron los recursos.

Responsabilidad del cliente

• Sin alternativa del lado del servidor: Para evitar cargos inesperados, el sistema no actualizará automáticamente una solicitud de Flex al nivel Estándar si la capacidad de Flex está completa.
• Reintentos: Debes implementar tu propia lógica de reintento del cliente con retirada exponencial.
• Tiempos de espera: Debido a que las solicitudes de Flex pueden permanecer en una cola, recomendamos aumentar los tiempos de espera del cliente a 10 minutos o más para evitar el cierre prematuro de la conexión.

Cómo ajustar los períodos de espera

Puedes configurar tiempos de espera por solicitud para la API de REST y las bibliotecas cliente. Siempre asegúrate de que el tiempo de espera del cliente cubra el período de espera previsto del servidor (p.ej., más de 600 s para las colas de espera de Flex). Los SDKs esperan valores de tiempo de espera en milisegundos.

Tiempos de espera por solicitud

from google import genai

client = genai.Client(http_options={"timeout": 900000})

try:
    interaction = client.interactions.create(
        model="gemini-3.5-flash",
        input="why is the sky blue?",
        service_tier="flex",
    )
except Exception as e:
    print(f"Flex request failed: {e}")

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

const client = new GoogleGenAI({});

async function main() {
    try {
        const interaction = await client.interactions.create({
            model: "gemini-3.5-flash",
            input: "why is the sky blue?",
            service_tier: "flex",
        }, {timeout: 900000});
    } catch (e) {
        console.log(`Flex request failed: ${e}`);
    }
}

await main();

Implementa reintentos

Dado que Flex es descartable y falla con errores 503, a continuación, se muestra un ejemplo de cómo implementar de forma opcional la lógica de reintento para continuar con las solicitudes fallidas:

import time
from google import genai

client = genai.Client()

def call_with_retry(max_retries=3, base_delay=5):
    for attempt in range(max_retries):
        try:
            return client.interactions.create(
                model="gemini-3.5-flash",
                input="Analyze this batch statement.",
                service_tier="flex",
            )
        except Exception as e:
            if attempt < max_retries - 1:
                delay = base_delay * (2 ** attempt) # Exponential Backoff
                print(f"Flex busy, retrying in {delay}s...")
                time.sleep(delay)
            else:
                print("Flex exhausted, falling back to Standard...")
                return client.interactions.create(
                    model="gemini-3.5-flash",
                    input="Analyze this batch statement."
                )

interaction = call_with_retry()
print(interaction.output_text)

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

const ai = new GoogleGenAI({});

async function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function callWithRetry(maxRetries = 3, baseDelay = 5) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      console.log(`Attempt ${attempt + 1}: Calling Flex tier...`);
      const interaction = await ai.interactions.create({
        model: "gemini-3.5-flash",
        input: "Analyze this batch statement.",
        service_tier: 'flex',
      });
      return interaction;
    } catch (e) {
      if (attempt < maxRetries - 1) {
        const delay = baseDelay * (2 ** attempt);
        console.log(`Flex busy, retrying in ${delay}s...`);
        await sleep(delay * 1000);
      } else {
        console.log("Flex exhausted, falling back to Standard...");
        return await ai.interactions.create({
          model: "gemini-3.5-flash",
          input: "Analyze this batch statement.",
        });
      }
    }
  }
}

async function main() {
    const interaction = await callWithRetry();
    console.log(interaction.output_text);
}

await main();

Precios

La inferencia flexible tiene un precio del 50% de la API estándar y se factura por token.

Modelos compatibles

Los siguientes modelos admiten la inferencia flexible:

¿Qué sigue?

• Inferencia priorizada para una latencia ultrabaja
• Tokens: Comprende los tokens.