Deduksioni Flex

Përshkrimi: Mëso se si të optimizosh kostot me nivelin e deduksionit 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ë trupin e kërkesës. Si parazgjedhje, kërkesat përdorin nivelin standard nëse kjo fushë lihet jashtë.

Python

from google import genai

client = genai.Client()

try:
    response = client.models.generate_content(
        model="gemini-3.8-flash",
        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.8-flash",
      contents: "Analyze this dataset for trends...",
      config: { serviceTier: "flex" },
    });
    console.log(response.text);
  } catch (e) {
    console.log(`Flex request failed: ${e}`);
  }
}

await main();

Go

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.8-flash",
        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())
}

QETËSI

curl -X POST "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.8-flash:generateContent?key=$GEMINI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "contents": [{
    "parts":[{"text": "Summarize the latest research on quantum computing."}]
  }],
  "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: Nuk ka nevojë të menaxhosh objektet e grupeve, ID-të e punëve ose anketat; 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ët e pritjes për çdo kërkesë për REST API dhe bibliotekat e klientit, si dhe kohët e pritjes globale vetëm kur përdor bibliotekat e klientit.

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()

try:
    response = client.models.generate_content(
        model="gemini-3.8-flash",
        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.8-flash",
        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.8-flash",
             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.8-flash",
             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();

Go

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.8-flash",
        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.8-flash",
        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])
    }
}

QETËSI

Kur bën telefonata REST, mund të kontrollosh kohët e pritjes duke përdorur një kombinim të titujve HTTP dhe opsioneve të curl:

  • Koka X-Server-Timeout (koha e pritjes në anën e serverit): Kjo kokë sugjeron një kohëzgjatje të preferuar të pritjes (parazgjedhja 600 sekonda) për serverin e Gemini API. Serveri do të përpiqet ta respektojë këtë, por nuk është e garantuar. Vlera duhet të jetë në sekonda.

  • --max-time në curl (Kohëzgjatja e pritjes në anën e klientit): Opsioni curl --max-time <seconds> vendos një kufi të rreptë për kohën totale (në sekonda) që curl do të presë që të përfundojë i gjithë operacioni. Kjo është një mbrojtje në anën e klientit.

 # 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.8-flash:generateContent?key=$GEMINI_API_KEY" \
   -H "Content-Type: application/json" \
   -H "X-Server-Timeout: 120" \
   -d '{
   "contents": [{
     "parts":[{"text": "Summarize the latest research on quantum computing."}]
   }],
   "service_tier": "flex"
 }'

Kohët e pritjes globale

Nëse dëshiron që të gjitha thirrjet e API-së të bëra nëpërmjet një instance specifike të genai.Client (vetëm bibliotekat e klientit) të kenë një kohë të parazgjedhur pritjeje, mund ta konfigurosh këtë kur inicializon klientin duke përdorur http_options dhe genai.types.HttpOptions.

Python

from google import genai
from google.genai import types

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.8-flash",
        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.8-flash",
        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.8-flash",
            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.8-flash",
            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();

Go

 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.8-flash")

     // 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())
     }
 }

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.models.generate_content(
                model="gemini-3.8-flash",
                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.8-flash",
                    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.8-flash",
         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.8-flash",
           contents: "Analyze this batch statement.",
         });
       }
     }
   }
 }

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

 await main();

Go

 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.8-flash"
     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())
 }

Ç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 ✔️
Pamja paraprake e imazheve të Gemini 3 Pro ✔️
Gemini 2.5 Pro ✔️
Gemini 2.5 Flash ✔️
Imazhi i Gemini 2.5 Flash ✔️
Gemini 2.5 Flash-Lite ✔️

Çfarë ka më pas

Lexo rreth opsioneve të tjera të përfundimit dhe optimizimit të Gemini: