Flex inference

Gemini Flex API, अनुमान लगाने के लिए एक ऐसा टियर है जो स्टैंडर्ड दरों की तुलना में 50% कम लागत पर उपलब्ध है. हालांकि, इसमें लेटेंसी अलग-अलग हो सकती है और उपलब्धता की कोई गारंटी नहीं होती. इसे ऐसे वर्कलोड के लिए डिज़ाइन किया गया है जिनमें सिंक्रोनस प्रोसेसिंग की ज़रूरत होती है, लेकिन स्टैंडर्ड एपीआई की तरह रीयल-टाइम परफ़ॉर्मेंस की ज़रूरत नहीं होती.

Flex का इस्तेमाल करना

Flex टियर का इस्तेमाल करने के लिए, अपने अनुरोध में service_tier को flex के तौर पर तय करें. डिफ़ॉल्ट रूप से, अगर इस फ़ील्ड को छोड़ दिया जाता है, तो अनुरोधों के लिए स्टैंडर्ड टियर का इस्तेमाल किया जाता है.

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-3.5-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.5-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.5-flash",
      "input": "Analyze this dataset for trends...",
      "service_tier": "flex"
  }'

Flex से अनुमान लगाने की सुविधा कैसे काम करती है

Gemini Flex से अनुमान लगाने की सुविधा, स्टैंडर्ड एपीआई और Batch API के 24 घंटे के टर्नअराउंड के बीच के अंतर को कम करती है. यह सुविधा, ऑफ़-पीक के दौरान "शेड किए जा सकने वाले" कंप्यूट क्षमता का इस्तेमाल करती है. इससे बैकग्राउंड टास्क और सीक्वेंशियल वर्कफ़्लो के लिए, लागत के हिसाब से बेहतर समाधान मिलता है.

मुख्य फ़ायदे

• लागत के हिसाब से बेहतर: प्रोडक्शन के अलावा अन्य कामों के लिए, बैकग्राउंड एजेंट, और डेटा को बेहतर बनाने के लिए, लागत में काफ़ी बचत होती है.
• आसानी से इस्तेमाल किया जा सकता है: मौजूदा अनुरोधों में सिर्फ़ एक पैरामीटर जोड़ें.
• सिंक्रोनस वर्कफ़्लो: यह सीक्वेंशियल एपीआई चेन के लिए सबसे सही है. इसमें अगला अनुरोध, पिछले अनुरोध के आउटपुट पर निर्भर करता है. इसलिए, एजेंटिक वर्कफ़्लो के लिए, यह बैच की तुलना में ज़्यादा फ़्लेक्सिबल है.

इस्तेमाल के उदाहरण

• ऑफ़लाइन आकलन: "एलएलएम-एज़-अ-जज" रिग्रेशन टेस्ट या लीडरबोर्ड चलाना.
• बैकग्राउंड एजेंट: सीक्वेंशियल टास्क, जैसे कि सीआरएम अपडेट, प्रोफ़ाइल बनाना या कॉन्टेंट मॉडरेट करना. इनमें कुछ मिनट की देरी स्वीकार की जा सकती है.
• बजट की सीमा में रिसर्च: ऐसे ऐकेडमिक एक्सपेरिमेंट जिनमें सीमित बजट में ज़्यादा टोकन की ज़रूरत होती है.

अनुरोध करने की सीमाएं

Flex से अनुमान लगाने के लिए किए गए ट्रैफ़िक को, अनुरोध करने की सामान्य सीमाओं में गिना जाता है. इसमें बैच एपीआई की तरह, अनुरोध करने की ज़्यादा सीमाएं नहीं मिलती हैं.

शेड की जा सकने वाली क्षमता

Flex के ट्रैफ़िक को कम प्राथमिकता दी जाती है. अगर स्टैंडर्ड ट्रैफ़िक में बढ़ोतरी होती है, तो ज़्यादा प्राथमिकता वाले उपयोगकर्ताओं के लिए क्षमता पक्का करने के लिए, Flex के अनुरोधों को रोका या हटाया जा सकता है. अगर आपको ज़्यादा प्राथमिकता वाले अनुमान की ज़रूरत है, तो ज़्यादा प्राथमिकता वाले अनुमान की सुविधा देखें

गड़बड़ी के कोड

अगर Flex की क्षमता उपलब्ध नहीं है या सिस्टम में ज़्यादा ट्रैफ़िक है, तो एपीआई, गड़बड़ी के स्टैंडर्ड कोड दिखाएगा:

• 503 कोड वाली गड़बड़ी: सेवा उपलब्ध नहीं है: इस्तेमाल करने की मौजूदा सीमा पूरी हो गई है.
• 429 कई बार अनुरोध किया गया: अनुरोध करने की सीमाएं पूरी हो गई हैं या संसाधन खत्म हो गए हैं.

क्लाइंट की ज़िम्मेदारी

• सर्वर साइड फ़ेलओवर की सुविधा उपलब्ध नहीं है: अनचाहे शुल्क से बचने के लिए, अगर Flex की क्षमता पूरी हो जाती है, तो सिस्टम, Flex के अनुरोध को स्टैंडर्ड टियर में अपने-आप अपग्रेड नहीं करेगा.
• फिर से कोशिश करना: आपको क्लाइंट साइड पर, फिर से कोशिश करने का लॉजिक लागू करना होगा. इसमें एक्सपोनेन्शियल बैकऑफ़ का इस्तेमाल किया जाता है.
• टाइम आउट: ऐसा हो सकता है कि Flex के अनुरोध, क्यू में हों. इसलिए, हम क्लाइंट साइड पर टाइम आउट को 10 मिनट या उससे ज़्यादा करने का सुझाव देते हैं, ताकि कनेक्शन समय से पहले बंद न हो.

टाइम आउट विंडो को अडजस्ट करना

आपके पास REST API और क्लाइंट लाइब्रेरी के लिए, हर अनुरोध के हिसाब से टाइम आउट कॉन्फ़िगर करने का विकल्प होता है. हमेशा पक्का करें कि क्लाइंट साइड पर टाइम आउट, सर्वर की इंतज़ार करने की तय सीमा के हिसाब से हो. उदाहरण के लिए, Flex की इंतज़ार करने वाली क्यू के लिए 600 सेकंड से ज़्यादा. एसडीके, टाइम आउट की वैल्यू को मिलीसेकंड में स्वीकार करते हैं.

हर अनुरोध के हिसाब से टाइम आउट

from google import genai

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

interaction = client.interactions.create(
    model="gemini-3.5-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.5-flash",
        input: "why is the sky blue?",
        service_tier: "flex",
    }, {timeout: 900000});
}

await main();

फिर से कोशिश करने की सुविधा लागू करना

Flex को शेड किया जा सकता है और इसमें 503 कोड वाली गड़बड़ियां आ सकती हैं. इसलिए, यहां फ़ेल हुए अनुरोधों को जारी रखने के लिए, फिर से कोशिश करने का लॉजिक लागू करने का एक उदाहरण दिया गया है:

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

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

await main();

कीमत

Flex से अनुमान लगाने की सुविधा की कीमत, स्टैंडर्ड एपीआई की कीमत का 50% होती है. इसके लिए, हर टोकन के हिसाब से बिल भेजा जाता है.

काम करने वाले मॉडल

इन मॉडल के साथ, Flex से अनुमान लगाने की सुविधा काम करती है:

आगे क्या करना है

• लाइव स्ट्रीमिंग करने और उसके दिखने के बीच इंतज़ार का समय बहुत कम रखने के लिए, ज़्यादा प्राथमिकता वाले अनुमान की सुविधा.
• टोकन: टोकन के बारे में जानकारी.