Deduksioni Flex

Gemini Flex API është një nivel përfundimtar që ofron një ulje të kostos me 50% në krahasim me tarifat standarde, në këmbim të vonesës së ndryshueshme dhe disponueshmërisë me përpjekjen më të mirë. Është projektuar për ngarkesa pune që janë tolerante ndaj vonesave që kërkojnë përpunim sinkron, por që nuk kanë nevojë për performancën në kohë reale të API-së standarde.

Si të përdorësh Flex

Për të përdorur nivelin Flex, specifiko service_tier si flex në kërkesën tënde. Si parazgjedhje, kërkesat përdorin nivelin standard nëse kjo fushë hiqet.

Python

from google import genai

client = genai.Client()

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

JavaScript

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

const client = new GoogleGenAI({});

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

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ServiceTier;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;

Client client = new Client();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.of("Analyze this dataset for trends..."))
        .serviceTier(ServiceTier.FLEX)
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

System.out.println(interaction.outputText().orElse(""));

Go

package main

import (
    "context"
    "fmt"
    "log"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

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

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model:       interactions.Model("gemini-3.8-flash"),
            Input:       interactions.NewInteractionsInput("Analyze this dataset for trends..."),
            ServiceTier: interactions.ServiceTierFlex.ToPointer(),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    if res.Interaction.OutputText != nil {
        fmt.Println(*res.Interaction.OutputText)
    }
}

QETËSI

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

Si funksionon deduksioni Flex

Deduksioni i Gemini Flex krijon urën lidhëse mes API-së standarde dhe kohës së përgjigjes prej 24 orësh të Batch API. Ai përdor kapacitetin llogaritës të periudhave jo të pikut dhe të "ndërprerë" për të ofruar një zgjidhje me kosto efektive për detyrat në sfond dhe flukset e punës sekuenciale.

Veçoria Tregim force Me përparësi Standard Paketë
Çmimet 50% zbritje 75-100% më shumë se standarde Çmimi i plotë 50% zbritje
Vonesa Minuta (objektivi 1-15 min.) E ulët (sekonda) Sekonda në minuta Deri në 24 orë
Besueshmëria Me përpjekjen më të mirë (i heqshëm) E lartë (jo e heqshme) E lartë / mesatarisht e lartë E lartë (për rendiment)
Ndërfaqja Sinkron Sinkron Sinkron Josinkron

Përfitimet kryesore

  • Efikasiteti i kostos: Kursime të konsiderueshme për vlerësimet jo të prodhimit, agjentët në sfond dhe pasurimin e të dhënave.
  • Fërkimi i ulët: Thjesht shto një parametër të vetëm në kërkesat e tua ekzistuese.
  • Flukset e punës sinkrone: Ideale për zinxhirët e API-ve sekuenciale ku kërkesa e radhës varet nga rezultati i asaj të mëparshmes, duke e bërë atë më fleksibël se "Paketa" për flukset e punës agjentike.

Rastet e përdorimit

  • Vlerësimet offline: Ekzekutimi i testeve të regresionit ose tabelave të klasifikimit "LLM-si-gjykatës".
  • Agjentët në sfond: Detyrat në sekuencë si përditësimet e CRM-së, krijimi i profileve ose moderimi i përmbajtjeve ku pranohen disa minuta vonesë.
  • Kërkime me buxhet të kufizuar: Eksperimente akademike që kërkojnë vëllim të madh token-ësh me buxhet të kufizuar.

Kufijtë e normës

Trafiku i përfundimeve të Flex llogaritet në kufijtë e përgjithshëm të normës; ai nuk ofron kufij të zgjeruar të normës si Batch API.

Kapaciteti i transferueshëm

Trafiku i Flex trajtohet me përparësi më të ulët. Nëse ka një rritje të trafikut standard, kërkesat e Flex mund të parandalohen ose të hiqen për të siguruar kapacitetin për përdoruesit me përparësi të lartë. Nëse po kërkon për përfundime me përparësi të lartë, kontrollo Përfundimet me përparësi

Kodet e gabimeve

Kur kapaciteti i Flex nuk ofrohet ose sistemi është i mbingarkuar, API-ja do të kthejë kode standarde gabimi:

  • 503 Shërbimi nuk ofrohet: Sistemi është aktualisht në nivelin maksimal të kapacitetit.
  • 429 Shumë kërkesa: Kufijtë e normës ose shterimi i burimeve.

Përgjegjësia e klientit

  • Nuk ka kalim në modalitetin rezervë në anën e serverit: Për të parandaluar tarifat e papritura, sistemi nuk do ta kalojë automatikisht një kërkesë të Flex në nivelin Standard nëse kapaciteti i Flex është i plotë.
  • Riprovat: Duhet të zbatosh logjikën tënde të riprovës në anën e klientit me zbritje eksponenciale.
  • Kohët e pritjes: Meqenëse kërkesat e Flex mund të qëndrojnë në një radhë, ne rekomandojmë rritjen e kohëve të pritjes në anën e klientit në 10 minuta ose më shumë për të shmangur mbylljen e parakohshme të lidhjes.

Rregullo dritaret e kohës së pritjes

Mund të konfigurosh kohëzgjatjet e pritjes për çdo kërkesë për REST API dhe bibliotekat kliente. Sigurohu gjithmonë që koha e pritjes në anën e klientit të mbulojë periudhën e synuar të pritjes të serverit (p.sh. 600 sekonda e lart për radhët e pritjes të Flex). SDK-të presin vlera të kohës së pritjes në milisekonda.

Kohët e pritjes për çdo kërkesë

Python

from google import genai

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

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

JavaScript

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

const client = new GoogleGenAI({});

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

await main();

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ServiceTier;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;
import com.google.genai.types.HttpOptions;

Client client =
    Client.builder()
        .httpOptions(HttpOptions.builder().timeout(900000).build())
        .build();

CreateModelInteraction params =
    CreateModelInteraction.builder()
        .model(Model.of("gemini-3.8-flash"))
        .input(InteractionsInput.of("why is the sky blue?"))
        .serviceTier(ServiceTier.FLEX)
        .build();

Interaction interaction =
    client.interactions.create(CreateInteractionRequestBody.of(params)).interaction().get();

Go

package main

import (
    "context"
    "log"
    "time"

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

func main() {
    ctx := context.Background()
    client, err := genai.NewClient(ctx, &genai.ClientConfig{
        HTTPOptions: genai.HTTPOptions{
            Timeout: genai.Ptr(15 * time.Minute),
        },
    })
    if err != nil {
        log.Fatal(err)
    }

    res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
        Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
            Model:       interactions.Model("gemini-3.8-flash"),
            Input:       interactions.NewInteractionsInput("why is the sky blue?"),
            ServiceTier: interactions.ServiceTierFlex.ToPointer(),
        }),
    })
    if err != nil {
        log.Fatal(err)
    }
    _ = res
}

Zbato riprovimet

Duke qenë se Flex është i heqshëm dhe dështon me gabime 503, ja një shembull i zbatimit opsional të logjikës së riprovimit për të vazhduar me kërkesat e dështuara:

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.8-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.8-flash",
                    input="Analyze this batch statement."
                )

interaction = call_with_retry()
print(interaction.output_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.8-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.8-flash",
          input: "Analyze this batch statement.",
        });
      }
    }
  }
}

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

await main();

Java

import com.google.genai.Client;
import com.google.genai.gaos.models.interactions.CreateModelInteraction;
import com.google.genai.gaos.models.interactions.Interaction;
import com.google.genai.gaos.models.interactions.InteractionsInput;
import com.google.genai.gaos.models.interactions.Model;
import com.google.genai.gaos.models.interactions.ServiceTier;
import com.google.genai.gaos.models.operations.CreateInteractionRequestBody;

Client client = new Client();

int maxRetries = 3;
int baseDelay = 5;
Interaction interaction = null;

for (int attempt = 0; attempt < maxRetries; attempt++) {
  try {
    CreateModelInteraction flexParams =
        CreateModelInteraction.builder()
            .model(Model.of("gemini-3.8-flash"))
            .input(InteractionsInput.of("Analyze this batch statement."))
            .serviceTier(ServiceTier.FLEX)
            .build();
    interaction =
        client.interactions.create(CreateInteractionRequestBody.of(flexParams)).interaction().get();
    break;
  } catch (Exception e) {
    if (attempt < maxRetries - 1) {
      int delay = baseDelay * (1 << attempt); // Exponential Backoff
      System.out.println("Flex busy, retrying in " + delay + "s...");
      Thread.sleep(delay * 1000L);
    } else {
      System.out.println("Flex exhausted, falling back to Standard...");
      CreateModelInteraction standardParams =
          CreateModelInteraction.builder()
              .model(Model.of("gemini-3.8-flash"))
              .input(InteractionsInput.of("Analyze this batch statement."))
              .build();
      interaction =
          client
              .interactions
              .create(CreateInteractionRequestBody.of(standardParams))
              .interaction()
              .get();
    }
  }
}

if (interaction != null) {
  System.out.println(interaction.outputText().orElse(""));
}

Go

package main

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

    "google.golang.org/genai"
    "google.golang.org/genai/interactions/models/interactions"
    "google.golang.org/genai/interactions/models/operations"
)

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

    maxRetries := 3
    baseDelay := 5
    var interaction *interactions.Interaction

    for attempt := 0; attempt < maxRetries; attempt++ {
        res, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
            Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
                Model:       interactions.Model("gemini-3.8-flash"),
                Input:       interactions.NewInteractionsInput("Analyze this batch statement."),
                ServiceTier: interactions.ServiceTierFlex.ToPointer(),
            }),
        })
        if err == nil {
            interaction = res.Interaction
            break
        }

        if attempt < maxRetries-1 {
            delay := baseDelay * (1 << attempt) // Exponential Backoff
            fmt.Printf("Flex busy, retrying in %ds...\n", delay)
            time.Sleep(time.Duration(delay) * time.Second)
        } else {
            fmt.Println("Flex exhausted, falling back to Standard...")
            stdRes, err := client.Interactions.Create(ctx, operations.CreateInteractionRequest{
                Body: operations.NewCreateInteractionRequestBody(interactions.CreateModelInteraction{
                    Model: interactions.Model("gemini-3.8-flash"),
                    Input: interactions.NewInteractionsInput("Analyze this batch statement."),
                }),
            })
            if err != nil {
                log.Fatal(err)
            }
            interaction = stdRes.Interaction
        }
    }

    if interaction != nil && interaction.OutputText != nil {
        fmt.Println(*interaction.OutputText)
    }
}

Çmimet

Konkludimi fleksibël ka çmimin 50% të API-së standarde dhe faturohet për çdo kod.

Modelet e mbështetura

Modelet e mëposhtme mbështesin deduktimin Flex:

Modeli Deduksioni Flex
Gemini 3.8 Flash ✔️
Gemini 3.6 Flash ✔️
Gemini 3.5 Flash-Lite ✔️
Gemini 3.1 Flash-Lite ✔️
Versioni paraprak i Gemini 3.1 Pro ✔️
Pamja paraprake e Gemini 3 Flash ✔️
Gemini 2.5 Pro ✔️
Gemini 2.5 Flash ✔️
Gemini 2.5 Flash-Lite ✔️

Çfarë ka më pas