Flex inference
Gemini Flex API, अनुमान लगाने वाला टियर है. इसमें स्टैंडर्ड दरों की तुलना में 50% कम कीमत लगती है. हालांकि, इसमें जवाब मिलने में लगने वाला समय अलग-अलग हो सकता है. साथ ही, यह सबसे अच्छे तरीके से उपलब्ध होता है. इसे ऐसे वर्कलोड के लिए डिज़ाइन किया गया है जिनमें इंतज़ार का समय कम होता है. साथ ही, जिनमें सिंक्रोनस प्रोसेसिंग की ज़रूरत होती है, लेकिन स्टैंडर्ड एपीआई की रीयल-टाइम परफ़ॉर्मेंस की ज़रूरत नहीं होती.
Flex का इस्तेमाल कैसे करें
Flex टियर का इस्तेमाल करने के लिए, अपने अनुरोध में service_tier को flex के तौर पर सेट करें. इस फ़ील्ड को शामिल न करने पर, अनुरोधों के लिए डिफ़ॉल्ट रूप से स्टैंडर्ड टियर का इस्तेमाल किया जाता है.
Python
from google import genai
client = genai.Client()
try:
interaction = client.interactions.create(
model="gemini-3-flash-preview",
input="Analyze this dataset for trends...",
service_tier='flex'
)
print(interaction.steps[-1].content[0].text)
except Exception as e:
print(f"Flex request failed: {e}")
JavaScript
import { GoogleGenAI } from '@google/genai';
const client = new GoogleGenAI({});
async function main() {
try {
const interaction = await client.interactions.create({
model: 'gemini-3-flash-preview',
input: 'Analyze this dataset for trends...',
serviceTier: 'flex'
});
console.log(interaction.steps.at(-1).content[0].text);
} catch (e) {
console.log(`Flex request failed: ${e}`);
}
}
await main();
REST
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-flash-preview",
"input": "Analyze this dataset for trends...",
"service_tier": "flex"
}'
फ़्लेक्स इन्फ़रेंस कैसे काम करता है
Gemini Flex inference, स्टैंडर्ड एपीआई और Batch API के 24 घंटे के टर्नअराउंड के बीच के अंतर को कम करता है. यह ऑफ़-पीक समय में, "शेड की जा सकने वाली" कंप्यूट क्षमता का इस्तेमाल करता है. इससे बैकग्राउंड टास्क और क्रमवार वर्कफ़्लो के लिए, कम लागत वाला समाधान मिलता है.
| सुविधा | Flex | प्राथमिकता | स्टैंडर्ड | बैच |
|---|---|---|---|---|
| कीमत | 50% की छूट | स्टैंडर्ड से 75 से 100% ज़्यादा | फ़ुल टिकट | 50% की छूट |
| लेटेंसी | मिनट (1 से 15 मिनट का टारगेट) | कम (सेकंड) | सेकंड से मिनट | 24 घंटे तक |
| भरोसेमंद होना | सबसे अच्छी कोशिश (शेड किया जा सकता है) | ज़्यादा (नहीं बदले जा सकने वाले) | ज़्यादा / सामान्य से ज़्यादा | ज़्यादा (थ्रूपुट के लिए) |
| इंटरफ़ेस | सिंक्रोनस | सिंक्रोनस | सिंक्रोनस | एसिंक्रोनस |
मुख्य फ़ायदे
- लागत कम होना: इससे नॉन-प्रोडक्शन इवैल, बैकग्राउंड एजेंट, और डेटा को बेहतर बनाने में काफ़ी बचत होती है.
- आसानी से लागू करना: अपने मौजूदा अनुरोधों में बस एक पैरामीटर जोड़ें.
- सिंक्रोनस वर्कफ़्लो: यह क्रम से एपीआई कॉल करने के लिए सबसे सही है. इसमें अगला अनुरोध, पिछले अनुरोध के आउटपुट पर निर्भर करता है. इसलिए, यह एजेंटिक वर्कफ़्लो के लिए बैच से ज़्यादा फ़्लेक्सिबल होता है.
उपयोग के उदाहरण
- ऑफ़लाइन आकलन: "एलएलएम-एज़-अ-जज" रिग्रेशन टेस्ट या लीडरबोर्ड चलाना.
- बैकग्राउंड एजेंट: ऐसे टास्क जो क्रम से किए जाते हैं, जैसे कि सीआरएम अपडेट करना, प्रोफ़ाइल बनाना या कॉन्टेंट की निगरानी करना. इनमें कुछ मिनट की देरी स्वीकार की जा सकती है.
- बजट की कमी वाली रिसर्च: ऐसे शैक्षणिक एक्सपेरिमेंट जिनके लिए सीमित बजट में ज़्यादा टोकन की ज़रूरत होती है.
तय सीमाएं
फ़्लेक्स इन्फ़्रेंस ट्रैफ़िक को, दर से जुड़ी सामान्य सीमाओं में गिना जाता है. इसमें Batch API की तरह, दर से जुड़ी ज़्यादा सीमाएं नहीं मिलती हैं.
शेड की जा सकने वाली क्षमता
फ़्लेक्स ट्रैफ़िक को कम प्राथमिकता दी जाती है. अगर स्टैंडर्ड ट्रैफ़िक में अचानक बढ़ोतरी होती है, तो हो सकता है कि Flex के अनुरोधों को पहले से ही रोक दिया जाए या उन्हें हटा दिया जाए. ऐसा इसलिए किया जाता है, ताकि ज़्यादा प्राथमिकता वाले उपयोगकर्ताओं के लिए क्षमता बनी रहे. अगर आपको ज़्यादा प्राथमिकता वाली इनफ़रेंस की सुविधा चाहिए, तो प्राथमिकता के आधार पर इनफ़रेंस लेख पढ़ें
गड़बड़ी के कोड
जब फ़्लेक्स क्षमता उपलब्ध नहीं होती है या सिस्टम पर ज़्यादा लोड होता है, तो एपीआई गड़बड़ी के स्टैंडर्ड कोड दिखाएगा:
- 503 कोड वाली गड़बड़ी: सेवा उपलब्ध नहीं है: फ़िलहाल, सिस्टम पर काफ़ी ज़्यादा लोड है.
- 429 कई बार अनुरोध किया गया: अनुरोधों की संख्या तय सीमा से ज़्यादा हो गई है या संसाधन खत्म हो गए हैं.
क्लाइंट की ज़िम्मेदारी
- सर्वर साइड फ़ॉलबैक नहीं: अचानक लगने वाले शुल्क से बचने के लिए, अगर Flex की क्षमता पूरी हो जाती है, तो सिस्टम Flex के अनुरोध को स्टैंडर्ड टियर में अपने-आप अपग्रेड नहीं करेगा.
- फिर से कोशिश करना: आपको क्लाइंट-साइड पर, फिर से कोशिश करने का अपना लॉजिक लागू करना होगा. इसके लिए, एक्स्पोनेंशियल बैकऑफ़ का इस्तेमाल करें.
- टाइमआउट: Flex के अनुरोधों को एक कतार में रखा जा सकता है. इसलिए, हमारा सुझाव है कि क्लाइंट-साइड टाइमआउट को 10 मिनट या उससे ज़्यादा बढ़ाएं, ताकि कनेक्शन समय से पहले बंद न हो.
टाइम आउट विंडो में बदलाव करना
REST API और क्लाइंट लाइब्रेरी के लिए, हर अनुरोध के हिसाब से टाइमआउट कॉन्फ़िगर किए जा सकते हैं. हमेशा पक्का करें कि क्लाइंट-साइड टाइमआउट, सर्वर के इंतज़ार की तय अवधि को कवर करता हो. उदाहरण के लिए, फ़्लेक्स की इंतज़ार की कतारों के लिए 600 सेकंड से ज़्यादा. एसडीके, टाइम आउट की वैल्यू मिलीसेकंड में लेते हैं.
हर अनुरोध के लिए समयसीमाएं
Python
from google import genai
client = genai.Client()
try:
interaction = client.interactions.create(
model="gemini-3-flash-preview",
input="why is the sky blue?",
service_tier="flex",
http_options={"timeout": 900000}
)
except Exception as e:
print(f"Flex request failed: {e}")
JavaScript
import { GoogleGenAI } from '@google/genai';
const client = new GoogleGenAI({});
async function main() {
try {
const interaction = await client.interactions.create({
model: "gemini-3-flash-preview",
input: "why is the sky blue?",
serviceTier: "flex",
httpOptions: {timeout: 900000}
});
} catch (e) {
console.log(`Flex request failed: ${e}`);
}
}
await main();
फिर से कोशिश करने की सुविधा लागू करना
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.interactions.create(
model="gemini-3-flash-preview",
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:
# Fallback to standard on last strike (Optional)
print("Flex exhausted, falling back to Standard...")
return client.interactions.create(
model="gemini-3-flash-preview",
input="Analyze this batch statement."
)
# Usage
interaction = call_with_retry()
print(interaction.steps[-1].content[0].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-flash-preview",
input: "Analyze this batch statement.",
serviceTier: '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-flash-preview",
input: "Analyze this batch statement.",
});
}
}
}
}
async function main() {
const interaction = await callWithRetry();
console.log(interaction.steps.at(-1).content[0].text);
}
await main();
कीमत
फ़्लेक्स इन्फ़रेंस की कीमत, स्टैंडर्ड एपीआई की कीमत का 50% होती है. इसका बिल हर टोकन के हिसाब से भेजा जाता है.
इन मॉडल के साथ काम करता है
इन मॉडल के साथ फ़्लेक्स इन्फ़रेंस की सुविधा काम करती है:
| मॉडल | Flex inference |
|---|---|
| Gemini 3.1 Flash-Lite | ✔️ |
| Gemini 3.1 Flash-Lite की झलक | ✔️ |
| Gemini 3.1 Pro की झलक | ✔️ |
| Gemini 3 Flash की झलक | ✔️ |
| Gemini 2.5 Pro | ✔️ |
| Gemini 2.5 Flash | ✔️ |
| Gemini 2.5 Flash-Lite | ✔️ |
आगे क्या करना है
- बहुत कम इंतज़ार के समय के लिए, प्राथमिकता के आधार पर अनुमान लगाना.
- टोकन: टोकन के बारे में जानें.