Flex-Inferenz

Die Gemini Flex API ist eine Inferenzstufe, die im Vergleich zu den Standardpreisen eine Kostenreduzierung von 50% bietet. Im Gegenzug sind die Latenz variabel und die Verfügbarkeit erfolgt nach dem Best-Effort-Prinzip. Sie wurde für latenzunempfindliche Arbeitslasten entwickelt, die eine synchrone Verarbeitung erfordern, aber nicht die Echtzeitleistung der Standard-API benötigen.

Flex verwenden

Wenn Sie die Flex-Stufe verwenden möchten, geben Sie in Ihrer Anfrage service_tier als flex an. Standardmäßig wird für Anfragen die Standardstufe verwendet, wenn dieses Feld nicht angegeben ist.

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.6-flash",
    input="Analyze this dataset for trends...",
    service_tier='flex'
)
print(interaction.output_text)

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

const client = new GoogleGenAI({});

async function main() {
    const interaction = await client.interactions.create({
        model: 'gemini-3.6-flash',
        input: 'Analyze this dataset for trends...',
        service_tier: 'flex'
    });
    console.log(interaction.output_text);
}
await main();

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

So funktioniert die Flex-Inferenz

Die Gemini Flex-Inferenz schließt die Lücke zwischen der Standard-API und der 24-stündigen Bearbeitungszeit der Batch API. Sie nutzt Rechenkapazität außerhalb der Spitzenzeiten, die bei Bedarf reduziert werden kann, um eine kostengünstige Lösung für Hintergrundaufgaben und sequenzielle Arbeitsabläufe zu bieten.

Hauptvorteile

• Kosteneffizienz: Erhebliche Einsparungen bei nicht produktiven Bewertungen, Hintergrund-Agents und Datenanreicherung.
• Geringer Aufwand: Fügen Sie Ihren bestehenden Anfragen einfach einen einzelnen Parameter hinzu.
• Synchrone Arbeitsabläufe: Ideal für sequenzielle API-Ketten, bei denen die nächste Anfrage von der Ausgabe der vorherigen abhängt. Dadurch ist sie flexibler als Batch für agentische Arbeitsabläufe.

Anwendungsfälle

• Offline-Bewertungen: Ausführen von Regressionstests oder Bestenlisten mit „LLM-as-a-judge“.
• Hintergrund-Agents: Sequenzielle Aufgaben wie CRM-Aktualisierungen, Profilerstellung oder Inhaltsmoderation, bei denen Verzögerungen von einigen Minuten akzeptabel sind.
• Budgetbeschränkte Forschung: Akademische Experimente, die ein hohes Tokenvolumen bei einem begrenzten Budget erfordern.

Ratenlimits

Der Flex-Inferenz-Traffic wird auf Ihre allgemeinen Ratenlimits angerechnet. Es gibt keine erweiterten Ratenlimits wie bei der Batch API.

Reduzierbare Kapazität

Flex-Traffic wird mit niedrigerer Priorität behandelt. Bei einem Anstieg des Standard-Traffics können Flex-Anfragen vorzeitig beendet oder entfernt werden, um Kapazität für Nutzer mit hoher Priorität zu gewährleisten. Wenn Sie eine Inferenz mit hoher Priorität benötigen, lesen Sie den Abschnitt Inferenz mit Priorität.

Fehlercodes

Wenn die Flex-Kapazität nicht verfügbar ist oder das System überlastet ist, gibt die API Standardfehlercodes zurück:

• 503 Dienst nicht verfügbar: Das System ist derzeit ausgelastet.
• 429 Zu viele Anfragen: Ratenlimits oder Ressourcenerschöpfung.

Verantwortung des Clients

• Kein serverseitiges Fallback: Um unerwartete Kosten zu vermeiden, wird eine Flex-Anfrage nicht automatisch auf die Standardstufe aktualisiert, wenn die Flex-Kapazität voll ist.
• Wiederholungen: Sie müssen Ihre eigene clientseitige Wiederholungslogik mit exponentiellem Backoff implementieren.
• Zeitlimits: Da Flex-Anfragen in einer Warteschlange stehen können, empfehlen wir, die clientseitigen Zeitlimits auf mindestens 10 Minuten zu erhöhen, um ein vorzeitiges Schließen der Verbindung zu vermeiden.

Zeitlimits anpassen

Sie können Zeitlimits pro Anfrage für die REST API und Clientbibliotheken konfigurieren. Achten Sie immer darauf, dass das clientseitige Zeitlimit das beabsichtigte serverseitige Zeitlimit abdeckt (z.B. 600 Sekunden oder mehr für Flex-Warteschlangen). Die SDKs erwarten Zeitlimitwerte in Millisekunden.

Zeitlimits pro Anfrage

from google import genai

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

interaction = client.interactions.create(
    model="gemini-3.6-flash",
    input="why is the sky blue?",
    service_tier="flex",
)

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

const client = new GoogleGenAI({});

async function main() {
    const interaction = await client.interactions.create({
        model: "gemini-3.6-flash",
        input: "why is the sky blue?",
        service_tier: "flex",
    }, {timeout: 900000});
}

await main();

Wiederholungen implementieren

Da Flex reduzierbar ist und mit 503-Fehlern fehlschlägt, finden Sie hier ein Beispiel für die optionale Implementierung einer Wiederholungslogik, um mit fehlgeschlagenen Anfragen fortzufahren:

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

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

await main();

Preise

Die Flex-Inferenz kostet 50% der Standard-API und wird pro Token abgerechnet.

Unterstützte Modelle

Die folgenden Modelle unterstützen die Flex-Inferenz:

Nächste Schritte

• Inferenz mit Priorität für extrem niedrige Latenz.
• Tokens: Informationen zu Tokens.