Гибкий вывод

API Gemini Flex — это уровень обработки данных, предлагающий 50% снижение стоимости по сравнению со стандартными тарифами в обмен на переменную задержку и доступность по принципу «наилучших усилий». Он разработан для рабочих нагрузок, устойчивых к задержкам, требующих синхронной обработки, но не нуждающихся в производительности реального времени стандартного API.

Как использовать Flex

Для использования уровня Flex укажите service_tier как flex в теле запроса. По умолчанию запросы используют стандартный уровень, если это поле опущено.

Python 

import google.genai as genai

client = genai.Client()

try:
    response = client.models.generate_content(
        model="gemini-3-flash-preview",
        contents="Analyze this dataset for trends...",
        config={'service_tier': 'flex'},
    )
    print(response.text)
except Exception as e:
    print(f"Flex request failed: {e}")

JavaScript 

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

const ai = new GoogleGenAI({});

async function main() {
  try {
    const response = await ai.models.generateContent({
      model: "gemini-3-flash-preview",
      contents: "Analyze this dataset for trends...",
      config: { serviceTier: "flex" },
    });
    console.log(response.text);
  } catch (e) {
    console.log(`Flex request failed: ${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)
    }

    result, err := client.Models.GenerateContent(
        ctx,
        "gemini-3-flash-preview",
        genai.Text("Analyze this dataset for trends..."),
        &genai.GenerateContentConfig{
            ServiceTier: "flex",
        },
    )
    if err != nil {
        log.Printf("Flex request failed: %v", err)
        return
    }
    fmt.Println(result.Text())
}

ОТДЫХ 

"https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent?key=$GOOGLE_API_KEY" \
-H 'Content-Type: application/json' \
-d '{
  "contents": [{
    "parts":[{"text": "Summarize the latest research on quantum computing."}]
  }],
  "service_tier": "FLEX"
}'

Как работает вывод Flex

Функция Gemini Flex Inference устраняет разрыв между стандартным API и 24-часовым временем обработки данных в рамках пакетного API . Она использует вычислительные мощности в непиковые часы, которые можно «отключать», предоставляя экономичное решение для фоновых задач и последовательных рабочих процессов.

Особенность Флекс Приоритет Стандарт Партия
Цены скидка 50% На 75-100% больше, чем стандартная версия. Полная цена скидка 50%
Задержка Минуты (целевое значение 1–15 минут) Низкий уровень (секунды) Секунды в минуты До 24 часов
Надежность Максимально возможные варианты (можно сбросить) Высокая (не линяет) Высокий / Средне-высокий Высокий (для обеспечения высокой пропускной способности)
Интерфейс Синхронный Синхронный Синхронный Асинхронный

Основные преимущества

  • Экономическая эффективность : существенная экономия на непроизводственных оценках, фоновых агентах и ​​обогащении данных.
  • Простота в использовании : нет необходимости управлять пакетными объектами, идентификаторами заданий или опросом; просто добавьте один параметр к существующим запросам.
  • Синхронные рабочие процессы : идеально подходит для последовательных цепочек API, где следующий запрос зависит от результата предыдущего, что делает его более гибким, чем пакетный режим, для агентных рабочих процессов.

Варианты использования

  • Офлайн-оценка : проведение регрессионных тестов или составление рейтинговых таблиц с участием студентов магистратуры в роли экспертов.
  • Фоновые агенты : Последовательные задачи, такие как обновление CRM, создание профилей или модерация контента, где допустима задержка в несколько минут.
  • Исследования с ограниченным бюджетом : академические эксперименты, требующие большого количества токенов при ограниченном бюджете.

Ограничения скорости

Трафик, передаваемый через Flex Inference, учитывается в общих лимитах скорости ; он не предлагает расширенных лимитов скорости, как Batch API .

Вместимость, которую можно свернуть

Трафик Flex обрабатывается с более низким приоритетом. При резком увеличении стандартного трафика запросы Flex могут быть вытеснены или отброшены для обеспечения пропускной способности для пользователей с высоким приоритетом. Если вам требуется определение приоритета, проверьте параметр «Определение приоритета».

коды ошибок

В случае нехватки ресурсов Flex или перегрузки системы API вернет стандартные коды ошибок:

  • Ошибка 503: Сервис недоступен : система в данный момент перегружена.
  • 429 Слишком много запросов : Ограничения скорости или исчерпание ресурсов.

Ответственность клиента

  • Отсутствие резервного варианта на стороне сервера : Во избежание непредвиденных расходов система не будет автоматически переводить запрос Flex на стандартный уровень, если пропускная способность Flex исчерпана.
  • Повторные попытки : Вам необходимо реализовать собственную логику повторных попыток на стороне клиента с экспоненциальной задержкой.
  • Тайм-ауты : Поскольку запросы Flex могут задерживаться в очереди, мы рекомендуем увеличить тайм-ауты на стороне клиента до 10 минут или более, чтобы избежать преждевременного разрыва соединения.

Настройте временные окна ожидания

Вы можете настроить тайм-ауты для каждого запроса как для REST API, так и для клиентских библиотек, а также глобальные тайм-ауты только при использовании клиентских библиотек.

Всегда следите за тем, чтобы время ожидания на стороне клиента покрывало предполагаемый временной интервал ожидания сервера (например, 600 секунд и более для очередей ожидания Flex). SDK ожидают значения времени ожидания в миллисекундах.

Тайм-ауты для каждого запроса

Python 

from google import genai

client = genai.Client()

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

# Example with streaming
try:
    response = client.models.generate_content_stream(
        model="gemini-3-flash-preview",
        contents=["List 5 ideas for a sci-fi movie."],
        config={
            "service_tier": "flex",
            "http_options": {"timeout": 60000}
        }
        # Per-request timeout for the streaming operation
    )
    for chunk in response:
        print(chunk.text, end="")

except Exception as e:
    print(f"An error occurred during streaming: {e}")

JavaScript 

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

 const client = new GoogleGenAI({});

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

     // Example with streaming
     try {
         const response = await client.models.generateContentStream({
             model: "gemini-3-flash-preview",
             contents: ["List 5 ideas for a sci-fi movie."],
             config: {
                 serviceTier: "flex",
                 httpOptions: {timeout: 60000}
             },
         });
         for await (const chunk of response.stream) {
             process.stdout.write(chunk.text());
         }
     } catch (e) {
         console.log(`An error occurred during streaming: ${e}`);
     }
 }

 await main();

Идти 

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "google.golang.org/api/iterator"
    "google.golang.org/genai"
)

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

    timeoutCtx, cancel := context.WithTimeout(ctx, 900*time.Second)
    defer cancel()

    _, err = client.Models.GenerateContent(
        timeoutCtx,
        "gemini-3-flash-preview",
        genai.Text("why is the sky blue?"),
        &genai.GenerateContentConfig{
            ServiceTier: "flex",
        },
    )
    if err != nil {
        fmt.Printf("Flex request failed: %v\n", err)
    }

    // Example with streaming
    streamTimeoutCtx, streamCancel := context.WithTimeout(ctx, 60*time.Second)
    defer streamCancel()

    iter := client.Models.GenerateContentStream(
        streamTimeoutCtx,
        "gemini-3-flash-preview",
        genai.Text("List 5 ideas for a sci-fi movie."),
        &genai.GenerateContentConfig{
            ServiceTier: "flex",
        },
    )
    for {
        response, err := iter.Next()
        if err == iterator.Done {
            break
        }
        if err != nil {
            fmt.Printf("An error occurred during streaming: %v\n", err)
            break
        }
        fmt.Print(response.Candidates[0].Content.Parts[0])
    }
}

ОТДЫХ

При выполнении REST-запросов вы можете управлять таймаутами, используя комбинацию HTTP-заголовков и параметров curl :

  • Заголовок X-Server-Timeout (тайм-аут на стороне сервера) : Этот заголовок указывает предпочтительную продолжительность тайм-аута (по умолчанию 600 секунд) для сервера API Gemini. Сервер попытается учесть это значение, но это не гарантируется. Значение должно быть указано в секундах.

  • --max-time в curl (тайм-аут на стороне клиента) : Опция curl --max-time <seconds> устанавливает жесткое ограничение на общее время (в секундах), в течение которого curl будет ждать завершения всей операции. Это мера предосторожности на стороне клиента. 

 # Set a server timeout hint of 120 seconds and a client-side curl timeout of 125 seconds.
 curl --max-time 125 \
   -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent" \
   -H "Content-Type: application/json" \
   -H "x-goog-api-key: YOUR_API_KEY" \
   -H "X-Server-Timeout: 120" \
   -d '{
   "contents": [{
     "parts":[{"text": "Summarize the latest research on quantum computing."}]
   }],
   "service_tier": "SERVICE_TIER_FLEX"
 }'

Глобальные тайм-ауты

Если вы хотите, чтобы для всех вызовов API, выполняемых через определенный экземпляр genai.Client (только для клиентских библиотек), устанавливалось время ожидания по умолчанию, вы можете настроить это при инициализации клиента с помощью http_options и genai.types.HttpOptions .

Python 

from google import genai

global_timeout_ms = 120000

client_with_global_timeout = genai.Client(
    http_options=types.HttpOptions(timeout=global_timeout_ms)
)

try:
    # Calling generate_content using global timeout...
    response = client_with_global_timeout.models.generate_content(
        model="gemini-3-flash-preview",
        contents="Summarize the history of AI development since 2000.",
        config={"service_tier": "flex"},
    )
    print(response.text)

    # A per-request timeout will *override* the global timeout for that specific call.
    shorter_timeout = 30000
    response = client_with_global_timeout.models.generate_content(
        model="gemini-3-flash-preview",
        contents="Provide a very brief definition of machine learning.",
        config={
            "service_tier": "flex",
            "http_options":{"timeout": shorter_timeout}
        }  # Overrides the global timeout
    )

    print(response.text)

except TimeoutError:
    print(
        f"A GenerateContent call timed out. Check if the global or per-request timeout was exceeded."
    )
except Exception as e:
    print(f"An error occurred: {e}")

JavaScript 

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

const globalTimeoutMs = 120000;

const clientWithGlobalTimeout = new GoogleGenAI({httpOptions: {timeout: globalTimeoutMs}});

async function main() {
    try {
        // Calling generate_content using global timeout...
        const response1 = await clientWithGlobalTimeout.models.generateContent({
            model: "gemini-3-flash-preview",
            contents: "Summarize the history of AI development since 2000.",
            config: { serviceTier: "flex" },
        });
        console.log(response1.text());

        // A per-request timeout will *override* the global timeout for that specific call.
        const shorterTimeout = 30000;
        const response2 = await clientWithGlobalTimeout.models.generateContent({
            model: "gemini-3-flash-preview",
            contents: "Provide a very brief definition of machine learning.",
            config: {
                serviceTier: "flex",
                httpOptions: {timeout: shorterTimeout}
            }  // Overrides the global timeout
        });

        console.log(response2.text());

    } catch (e) {
        if (e.name === 'TimeoutError' || e.message?.includes('timeout')) {
            console.log(
                "A GenerateContent call timed out. Check if the global or per-request timeout was exceeded."
            );
        } else {
            console.log(`An error occurred: ${e}`);
        }
    }
}

await main();

Идти 

 package main

 import (
     "context"
     "fmt"
     "log"
     "time"

     "google.golang.org/genai"
 )

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

     model := client.GenerativeModel("gemini-3-flash-preview")

     // Go uses context for timeouts, not client options.
     // Set a default timeout for requests.
     globalTimeout := 120 * time.Second
     fmt.Printf("Using default timeout of %v seconds.\n", globalTimeout.Seconds())

     fmt.Println("Calling generate_content (using default timeout)...")
     ctx1, cancel1 := context.WithTimeout(ctx, globalTimeout)
     defer cancel1()
     resp1, err := model.GenerateContent(ctx1, genai.Text("Summarize the history of AI development since 2000."), &genai.GenerateContentConfig{ServiceTier: "flex"})
     if err != nil {
         log.Printf("Request 1 failed: %v", err)
     } else {
         fmt.Println("GenerateContent 1 successful.")
         fmt.Println(resp1.Text())
     }

     // A different timeout can be used for other requests.
     shorterTimeout := 30 * time.Second
     fmt.Printf("\nCalling generate_content with a shorter timeout of %v seconds...\n", shorterTimeout.Seconds())
     ctx2, cancel2 := context.WithTimeout(ctx, shorterTimeout)
     defer cancel2()
     resp2, err := model.GenerateContent(ctx2, genai.Text("Provide a very brief definition of machine learning."), &genai.GenerateContentConfig{
         ServiceTier: "flex",
     })
     if err != nil {
         log.Printf("Request 2 failed: %v", err)
     } else {
         fmt.Println("GenerateContent 2 successful.")
         fmt.Println(resp2.Text())
     }
 }

Реализовать повторные попытки

Поскольку Flex допускает сброс и завершается с ошибкой 503, вот пример реализации логики повторных попыток для продолжения обработки неудачных запросов:

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.models.generate_content(
                model="gemini-3-flash-preview",
                contents="Analyze this batch statement.",
                config={"service_tier": "flex"},
            )
        except Exception as e:
            # Check for 503 Service Unavailable or 429 Rate Limits
      print(e.code)
            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.models.generate_content(
                    model="gemini-3-flash-preview",
                    contents="Analyze this batch statement."
                )

# Usage
response = call_with_retry()
print(response.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 response = await ai.models.generateContent({
         model: "gemini-3-flash-preview",
         contents: "Analyze this batch statement.",
         config: { serviceTier: 'flex' },
       });
       return response;
     } 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.models.generateContent({
           model: "gemini-3-flash-preview",
           contents: "Analyze this batch statement.",
         });
       }
     }
   }
 }

 async function main() {
     const response = await callWithRetry();
     console.log(response.text);
 }

 await main();

Идти 

 package main

 import (
     "context"
     "fmt"
     "log"
     "math"
     "time"

     "google.golang.org/genai"
 )

 func callWithRetry(ctx context.Context, client *genai.Client, maxRetries int, baseDelay time.Duration) (*genai.GenerateContentResponse, error) {
     modelName := "gemini-3-flash-preview"
     content := genai.Text("Analyze this batch statement.")
     flexConfig := &genai.GenerateContentConfig{
         ServiceTier: "flex",
     }

     for attempt := 0; attempt < maxRetries; attempt++ {
         log.Printf("Attempt %d: Calling Flex tier...", attempt+1)
         resp, err := client.Models.GenerateContent(ctx, modelName, content, flexConfig)
         if err == nil {
             return resp, nil
         }

         log.Printf("Attempt %d failed: %v", attempt+1, err)

         if attempt < maxRetries-1 {
             delay := time.Duration(float64(baseDelay) * math.Pow(2, float64(attempt)))
             log.Printf("Flex busy, retrying in %v...", delay)
             time.Sleep(delay)
         } else {
             log.Println("Flex exhausted, falling back to Standard...")
             return client.Models.GenerateContent(ctx, modelName, content)
         }
     }
     return nil, fmt.Errorf("retries exhausted") // Should not be reached
 }

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

     resp, err := callWithRetry(ctx, client, 3, 5*time.Second)
     if err != nil {
         log.Fatalf("Failed after retries: %v", err)
     }
     fmt.Println(resp.Text())
 }

Цены

Стоимость Flex Inference составляет 50% от стоимости стандартного API и рассчитывается за токен.

Поддерживаемые модели

Следующие модели поддерживают вывод Flex:

Модель Гибкий вывод
Предварительная версия Gemini 3.1 Flash-Lite ✔️
Gemini 3.1 Pro Preview ✔️
Предварительный просмотр Gemini 3 Flash ✔️
Предварительный просмотр изображения Gemini 3 Pro ✔️
Gemini 2.5 Pro ✔️
Вспышка Gemini 2.5 ✔️
Изображение со вспышкой Gemini 2.5 ✔️
Фонарь Gemini 2.5 Flash-Lite ✔️

Что дальше?

Узнайте больше о других возможностях Gemini в области вывода и оптимизации :