Inférence flexible

L'API Gemini Flex est un niveau d'inférence qui offre une réduction de coût de 50% par rapport aux tarifs standards, en échange d'une latence variable et d'une disponibilité au mieux. Elle est conçue pour les charges de travail tolérantes à la latence qui nécessitent un traitement synchrone, mais qui n'ont pas besoin des performances en temps réel de l'API standard.

Utiliser Flex

Pour utiliser le niveau Flex, spécifiez service_tier comme flex dans votre requête. Par défaut, les requêtes utilisent le niveau standard si ce champ est omis.

Python

from google import genai

client = genai.Client()

try:
    interaction = client.interactions.create(
        model="gemini-3-flash-preview",
        input="Analyze this dataset for trends...",
        service_tier='flex'
    )
    print(interaction.steps[-1].content[0].text)
except Exception as e:
    print(f"Flex request failed: {e}")

JavaScript

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

const client = new GoogleGenAI({});

async function main() {
    try {
        const interaction = await client.interactions.create({
            model: 'gemini-3-flash-preview',
            input: 'Analyze this dataset for trends...',
            serviceTier: 'flex'
        });
        console.log(interaction.steps.at(-1).content[0].text);
    } catch (e) {
        console.log(`Flex request failed: ${e}`);
    }
}
await main();

REST

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-flash-preview",
      "input": "Analyze this dataset for trends...",
      "service_tier": "flex"
  }'

Fonctionnement de l'inférence Flex

L'inférence Gemini Flex comble le fossé entre l'API standard et le délai de traitement de 24 heures de l'API Batch. Elle utilise une capacité de calcul hors pointe et "déchargeable" pour fournir une solution économique pour les tâches en arrière-plan et les workflows séquentiels.

Fonctionnalité Flex Priorité Standard Lot
Tarifs 50% de remise 75 à 100% de plus que Standard Plein tarif 50% de remise
Latence Minutes (objectif de 1 à 15 min) Faible (secondes) De secondes à minutes Jusqu'à 24 heures
Fiabilité Optimisation limitée (désactivable) Élevée (non amovible) Élevée / Moyenne-haute Élevée (pour le débit)
Interface Synchrone Synchrone Synchrone Asynchrone

Principaux avantages

  • Rentabilité : économies substantielles pour les évaluations hors production, les agents en arrière-plan et l'enrichissement des données.
  • Faible friction : il vous suffit d'ajouter un seul paramètre à vos requêtes existantes.
  • Workflows synchrones : idéaux pour les chaînes d'API séquentielles où la requête suivante dépend de la sortie de la précédente, ce qui les rend plus flexibles que les workflows par lot pour les workflows agentiques.

Cas d'utilisation

  • Évaluations hors connexion : exécution de tests de régression "LLM-as-a-judge" ou de classements.
  • Agents en arrière-plan : tâches séquentielles telles que les mises à jour CRM, la création de profils ou la modération de contenu, pour lesquelles quelques minutes de retard sont acceptables.
  • Recherche avec budget limité : expériences universitaires nécessitant un volume de jetons élevé avec un budget limité.

Limites de débit

Le trafic d'inférence flexible est comptabilisé dans vos limites de débit générales. Il n'offre pas de limites de débit étendues comme l'API Batch.

Capacité délestable

Le trafic flexible est traité avec une priorité plus faible. En cas de pic de trafic standard, les requêtes Flex peuvent être préemptées ou évincées pour garantir la capacité des utilisateurs à haute priorité. Si vous recherchez une inférence à haute priorité, consultez Inférence prioritaire.

Codes d'erreur

Lorsque la capacité flexible n'est pas disponible ou que le système est saturé, l'API renvoie des codes d'erreur standards :

  • 503 Service Unavailable : le système est actuellement à sa capacité maximale.
  • 429 Trop de requêtes : limites de débit ou épuisement des ressources.

Responsabilité du client

  • Aucune solution de secours côté serveur : pour éviter les frais inattendus, le système ne passera pas automatiquement une requête Flex au niveau Standard si la capacité Flex est pleine.
  • Nouvelles tentatives : vous devez implémenter votre propre logique de nouvelles tentatives côté client avec un intervalle exponentiel entre les tentatives.
  • Délais avant expiration : étant donné que les requêtes Flex peuvent être mises en file d'attente, nous vous recommandons d'augmenter les délais avant expiration côté client à 10 minutes ou plus pour éviter une fermeture prématurée de la connexion.

Ajuster les délais d'inactivité

Vous pouvez configurer des délais avant expiration par requête pour l'API REST et les bibliothèques clientes. Assurez-vous toujours que le délai d'expiration côté client couvre la fenêtre de patience du serveur prévue (par exemple, 600 s et plus pour les files d'attente Flex). Les SDK attendent des valeurs de délai avant expiration en millisecondes.

Délais avant expiration des requêtes

Python

from google import genai

client = genai.Client()

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

JavaScript

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

const client = new GoogleGenAI({});

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

await main();

Implémenter des nouvelles tentatives

Étant donné que Flex est supprimable et échoue avec des erreurs 503, voici un exemple d'implémentation facultative d'une logique de nouvelle tentative pour poursuivre les requêtes ayant échoué :

Python

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-flash-preview",
                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:
                # Fallback to standard on last strike (Optional)
                print("Flex exhausted, falling back to Standard...")
                return client.interactions.create(
                    model="gemini-3-flash-preview",
                    input="Analyze this batch statement."
                )

# Usage
interaction = call_with_retry()
print(interaction.steps[-1].content[0].text)

JavaScript

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-flash-preview",
        input: "Analyze this batch statement.",
        serviceTier: '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-flash-preview",
          input: "Analyze this batch statement.",
        });
      }
    }
  }
}

async function main() {
    const interaction = await callWithRetry();
    console.log(interaction.steps.at(-1).content[0].text);
}

await main();

Tarifs

L'inférence flexible est facturée 50% du prix de l'API standard et facturée par jeton.

Modèles compatibles

Les modèles suivants sont compatibles avec l'inférence flexible :

Modèle Inférence flexible
Gemini 3.1 Flash-Lite ✔️
Aperçu de Gemini 3.1 Flash-Lite ✔️
Gemini 3.1 Pro (preview) ✔️
Preview Gemini 3 Flash ✔️
Gemini 2.5 Pro ✔️
Gemini 2.5 Flash ✔️
Gemini 2.5 Flash-Lite ✔️

Étape suivante