Përfundim fleksibël

API-ja Gemini Flex është një nivel nxjerrjeje përfundimesh që ofron një ulje të kostos prej 50% krahasuar me tarifat standarde, në këmbim të latencës së ndryshueshme dhe disponueshmërisë së përpjekjes më të mirë. Është projektuar për ngarkesa pune tolerante ndaj latencës që kërkojnë përpunim sinkron, por nuk kanë nevojë për performancën në kohë reale të API-së standarde.

Si të përdorni Flex

Për të përdorur nivelin Flex, specifikoni 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 

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

Shko 

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

PUSHTIM 

"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"
}'

Si funksionon përfundimi fleksibël

Inferenca Gemini Flex mbush hendekun midis API-t standard dhe përpunimin brenda 24 orëve të API-t Batch . Ai përdor kapacitetin llogaritës jashtë orarit të pikut, "të shpërdorueshëm", për të ofruar një zgjidhje me kosto efektive për detyrat në sfond dhe rrjedhat e punës sekuenciale.

Karakteristikë Përkul Prioritet Standard Grumbull
Çmimet 50% zbritje 75-100% më shumë se Standardi Çmimi i plotë 50% zbritje
Latencia Minuta (objektivi 1–15 minuta) I ulët (Sekonda) Sekonda në minuta Deri në 24 orë
Besueshmëria Përpjekja më e mirë (e shpërndarshme) I lartë (i pathyeshëm) I lartë / Mesatar-i lartë I lartë (për rendiment)
Ndërfaqja Sinkron Sinkron Sinkron Asinkron

Përfitimet kryesore

  • Efikasitet kostoje : Kursime të konsiderueshme për vlerësime jo-prodhuese, agjentë sfondi dhe pasurim të të dhënave.
  • Fërkim i ulët : Nuk ka nevojë të menaxhoni objekte batch, ID të punës ose sondazhe; thjesht shtoni një parametër të vetëm në kërkesat tuaja ekzistuese.
  • Rrjedhat e punës sinkrone : Ideale për zinxhirët API të njëpasnjëshëm ku kërkesa tjetër varet nga rezultati i asaj të mëparshmes, duke e bërë atë më fleksibël sesa Batch për rrjedhat e punës agjentike.

Rastet e përdorimit

  • Vlerësime jashtë linje : Ekzekutimi i testeve të regresionit ose tabelave të renditjes "LLM-as-a-judge".
  • Agjentë në sfond : Detyra të njëpasnjëshme si përditësimet e CRM-së, ndërtimi i profileve ose moderimi i përmbajtjes ku minutat e vonesës janë të pranueshme.
  • Hulumtim me buxhet të kufizuar : Eksperimente akademike që kërkojnë vëllim të lartë tokenësh me një buxhet të kufizuar.

Limitet e tarifave

Trafiku i përfundimit fleksibël llogaritet në kufijtë tuaj të përgjithshëm të normës ; ai nuk ofron kufij të zgjeruar të normës si Batch API .

Kapacitet i shpërdorueshëm

Trafiku fleksibël trajtohet me përparësi më të ulët. Nëse ka një rritje të trafikut standard, kërkesat fleksibël mund të parandalohen ose të nxirren jashtë funksionit për të siguruar kapacitetin për përdoruesit me përparësi të lartë. Nëse po kërkoni përfundim me përparësi të lartë, kontrolloni përfundimin e përparësisë.

Kodet e gabimit

Kur kapaciteti Flex nuk është i disponueshëm ose sistemi është i mbingarkuar, API do të kthejë kodet standarde të gabimit:

  • Shërbimi 503 i Padisponueshëm : Sistemi është aktualisht i mbingarkuar.
  • 429 Shumë kërkesa : Kufizime shpejtësie ose shterim i burimeve.

Përgjegjësia e klientit

  • Pa mundësi rezervë nga ana e serverit : Për të parandaluar tarifa të papritura, sistemi nuk do ta përditësojë automatikisht një kërkesë Flex në nivelin Standard nëse kapaciteti Flex është i plotë.
  • Ripërpjekjet : Duhet të implementoni logjikën tuaj të ripërpjekjes në anën e klientit me tërheqje eksponenciale.
  • Afatet e pritjes : Meqenëse kërkesat Flex mund të qëndrojnë në radhë, ne rekomandojmë rritjen e afateve 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ë skadimit

Mund të konfiguroni kohëzgjatjet për çdo kërkesë për API-n REST dhe bibliotekat e klientit, si dhe kohëzgjatjet globale vetëm kur përdorni bibliotekat e klientit.

Sigurohuni gjithmonë që koha e pritjes në anën e klientit të mbulojë dritaren e synuar të durimit të serverit (p.sh., 600 sekonda+ për radhë pritjeje fleksibël). SDK-të presin vlera të kohës së pritjes në milisekonda.

Afatet kohore për kërkesë

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

Shko 

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])
    }
}

PUSHTIM

Kur bëni thirrje REST, mund të kontrolloni skadimet e kohës duke përdorur një kombinim të header-ave HTTP dhe opsioneve curl :

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

  • --max-time in curl (Kohëzgjatja e pritjes në anën e klientit) : Opsioni curl --max-time <seconds> vendos një kufi të caktuar për kohën totale (në sekonda) që curl do të presë që të përfundojë i gjithë operacioni. Ky ë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-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"
 }'

Afatet globale

Nëse dëshironi që të gjitha thirrjet API të bëra përmes një instance specifike genai.Client (vetëm bibliotekat e klientëve) të kenë një kohëzgjatje të paracaktuar, mund ta konfiguroni këtë kur inicializoni klientin duke përdorur http_options dhe 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();

Shko 

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

Zbatoni ripërpjekjet

Meqenëse Flex është i shpërdorueshëm dhe dështon me gabime 503, ja një shembull i implementimit 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-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();

Shko 

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

Çmimet

Përfundimi Flex ka një çmim prej 50% të API-t standard dhe faturohet për token.

Modelet e mbështetura

Modelet e mëposhtme mbështesin përfundimin Flex:

Model Përfundim fleksibël
Pamje paraprake e Gemini 3.1 Flash-Lite ✔️
Pamje paraprake e Gemini 3.1 Pro ✔️
Pamje paraprake e shpejtë e Gemini 3 ✔️
Pamje paraprake e imazhit të Gemini 3 Pro ✔️
Gemini 2.5 Pro ✔️
Binjakët 2.5 Flash ✔️
Imazh Flash i Gemini 2.5 ✔️
Gemini 2.5 Flash-Lite ✔️

Çfarë vjen më pas

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