> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flexinference.com/llms.txt
> Use this file to discover all available pages before exploring further.
# समर्थित मॉडल
> वे मॉडल जिन्हें FlexInference रूट करता है, और वे इनपुट जिन्हें वे स्वीकार करते हैं।
FlexInference **OpenAI**, **Google Gemini**, और **Anthropic** मॉडल उपनामों को रूट करता है। मॉडल को उसके **उपनाम** (उदाहरण के लिए `gpt-5.5` या `gemini-3.5-flash`) से पास करें, न कि किसी पुरानी स्नैपशॉट से।
`start_within` को उस अधिकतम समय पर सेट करें जब तक आप अनुरोध के शुरू होने का इंतजार करेंगे। सरफेस प्लानर केवल नीचे सूचीबद्ध flex-सक्षम OpenAI और Gemini मॉडल पर flex रेस चलाता है: यह उस बजट के मुकाबले सस्ते प्रोवाइडर flex टियर को आज़माता है, फिर यदि flex समय पर शुरू नहीं होता है तो स्टैंडर्ड टियर पर चला जाता है। पूरी कार्यप्रणाली के लिए [flex रेसिंग कैसे काम करती है](/hi/deadline-routing) देखें।
गैर-अवधि वाले अनुरोधों के लिए, FlexInference उन प्रोवाइडर टियर पर किसी भी मॉडल को प्रॉक्सी करता है जिन्हें वह सपोर्ट करता है। Gemini में कोई `auto` टियर नहीं है, इसलिए Gemini मॉडल पर `auto` `400 auto_unsupported_for_gemini` लौटाता है।
## Flex-सक्षम मॉडल
### OpenAI
`gpt-5.6`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`
`gpt-5.5`, `gpt-5.5-pro`
`gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`, `gpt-5.4-pro`
`gpt-5.2`
`gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-5.1`
`o3`, `o4-mini`
### Gemini
`gemini-3.5-flash`, `gemini-3.1-pro-preview`, `gemini-3.1-flash-lite`
`gemini-3-flash-preview`
`gemini-2.5-pro`, `gemini-2.5-flash`, `gemini-2.5-flash-lite`
इस अनुमति-सूची के बाहर किसी OpenAI या Gemini मॉडल पर अवधि `start_within` flex रेस नहीं चलाता है। FlexInference `400 flex_model_not_capable` लौटाता है। flex का उपयोग करने के लिए सूचीबद्ध मॉडल चुनें। flex रेस को छोड़ने के लिए, अवधि के बजाय एक टियर वैल्यू भेजें: `default`, `priority`, या, जहाँ समर्थित हो, `auto`। FlexInference समर्थित टियर अनुरोधों को प्रोवाइडर को प्रॉक्सी करता है। Gemini के लिए, `default` Gemini के **standard** टियर से मैप करता है, और `auto` `400 auto_unsupported_for_gemini` लौटाता है।
## Anthropic (Claude)
Claude मॉडल Anthropic को रूट करते हैं और **केवल प्रॉक्सी** होते हैं। वे `default`, `priority`, और `auto` को सपोर्ट करते हैं, लेकिन flex रेस को नहीं। `claude-*` मॉडल पर अवधि `start_within` `400 flex_unsupported_for_anthropic` लौटाता है, क्योंकि Anthropic में कोई flex टियर नहीं है।
`default` Anthropic के **standard\_only** सर्विस टियर से मैप करता है। `auto` Anthropic को चुनने देता है। `priority` सर्वोत्तम प्रयास है और `auto` से मैप करता है, क्योंकि Anthropic एक शाब्दिक प्रायोरिटी टियर को अस्वीकार करता है।
Anthropic को अपस्ट्रीम `max_tokens` की आवश्यकता होती है। जब आप एक आउटपुट-टोकन फ़ील्ड सेट करते हैं तो FlexInference उसे आगे बढ़ाता है और जब आप इसे छोड़ देते हैं तो डिफ़ॉल्ट को संश्लेषित नहीं करता है, इसलिए Anthropic गुम सीमाओं के लिए अपना स्वयं का अनुरोध त्रुटि लौटाता है।
`claude-opus-4-8`, `claude-opus-4-7`, `claude-opus-4-6`, `claude-opus-4-5`,
`claude-opus-4-1`
`claude-sonnet-5`, `claude-sonnet-4-6`, `claude-sonnet-4-5`
`claude-haiku-4-5`
`claude-fable-5`
Claude हर समर्थित कॉलर फॉर्मेट के माध्यम से काम करता है: `/v1/responses`, `/v1/chat/completions`, `/v1/interactions`, और Anthropic-नेटिव [`/v1/messages`](/hi/sdks)। FlexInference प्रत्येक को Anthropic के Messages API में अनुवादित करता है। Anthropic सेवा किए गए टियर का निर्णय लेता है। एक `standard_only` अनुरोध प्रतिक्रिया पर `"service_tier": "standard"` के रूप में रिपोर्ट किया जाता है।
## प्रोवाइडर रूटिंग
एक वैकल्पिक क्रमबद्ध `provider` array उस रूट को पिन करता है जिसे आपका अनुरोध लेता है। एलिमेंट 0 प्राथमिक रूट और एकमात्र flex गेट है; एलिमेंट 1 से n तक समान-मॉडल फ़ॉलबैक चेन हैं, जिन्हें अस्थायी रूप से रूट विफल होने पर क्रम में आज़माया जाता है। `provider` को छोड़ दें और FlexInference मॉडल के नेटिव डायरेक्ट रूट का उपयोग करता है, ठीक पहले की तरह। array को आपके मॉडल के नेटिव रूट पर सेट करना एक रूटिंग नो-ऑप है जो उसी व्यवहार को स्पष्ट रूप से पिन करता है।
`google`, `openai`, और `anthropic` **डायरेक्ट रूट** हैं। `vertex` (Gemini) और `bedrock` (Claude) **क्लाउड रूट** हैं जो एक अलग प्रोवाइडर पर समान मॉडल को सेवा देते हैं: `bedrock` Amazon Bedrock (Bedrock Converse) के माध्यम से `claude-*` को सेवा देता है, और `vertex` Google Vertex AI (Vertex generateContent) के माध्यम से `gemini-*` को सेवा देता है। एक प्रोवाइडर फ़ॉलबैक केवल रूट को बदलता है: यह कभी भी मॉडल या टियर को नहीं बदलता है, और एक फ़ॉलबैक एंट्री हमेशा एक सादा स्टैंडर्ड कॉल होती है, कभी भी flex रेस नहीं।
### आपके द्वारा नामित प्रत्येक रूट को उसकी key की आवश्यकता होती है
एक चेन एक घोषणा है कि आपने इसमें हर रूट को कॉन्फ़िगर किया है। प्रत्येक रूट अपनी स्वयं की BYOK key का उपयोग करता है: `openai` आपकी OpenAI key का उपयोग करता है, `google` आपकी Gemini key का, `anthropic` आपकी Anthropic key का, `vertex` आपकी Vertex express key का, और `bedrock` आपकी Bedrock key और क्षेत्र का। रूट का नाम देने से पहले उन्हें डैशबोर्ड में Settings -> API keys के तहत जोड़ें।
एक गुम key एक कॉन्फ़िगरेशन त्रुटि है, न कि एक अस्थायी विफलता, इसलिए यह अगले रूट पर नहीं जाती है। FlexInference उस रूट के लिए `400 no_..._key` कोड के साथ अनुरोध को अस्वीकार करता है जिसकी key गुम है, किसी भी अपस्ट्रीम कॉल से पहले और किसी भी बिल योग्य कार्य से पहले। Bedrock key के बिना `["bedrock","anthropic"]` [`400 no_bedrock_key`](/hi/errors#no_bedrock_key) लौटाता है, भले ही आपकी Anthropic key मौजूद हो और मॉडल को सेवा दे सकती हो। यहां फ़ॉलबैक करने से अनकॉन्फ़िगर किया गया रूट छिप जाएगा और आपको चुपचाप एक ऐसे प्रोवाइडर पर सेवा मिलेगी जिसका आप उपयोग करना नहीं चाहते थे, इसलिए FlexInference इसके बजाय आपको बताता है। गुम key जोड़ें, या उस रूट को चेन से हटा दें।
फ़ॉलबैक अस्थायी अपस्ट्रीम विफलताओं और कुछ नहीं को कवर करता है: एक `429`, एक `5xx`, एक कनेक्शन त्रुटि, या एक टाइमआउट, प्रत्येक को प्रतिक्रिया प्रतिबद्ध होने से पहले पकड़ा जाता है। एक रूट को अग्रिम रूप से अस्वीकार किए जाने वाली हर चीज़, जिसमें एक गुम key, एक मॉडल जिसे रूट सेवा नहीं दे सकता, और एक गलत चेन शामिल है, आपके द्वारा ठीक करने का अनुरोध है और `400` लौटाता है।
प्रत्येक रूट एक मॉडल परिवार को सेवा देता है, इसलिए एक चेन जो एक ऐसे रूट को पिन करती है जो आपके मॉडल को सेवा नहीं दे सकता है, [`400 provider_model_mismatch`](/hi/errors#provider_model_mismatch) लौटाता है। `openai` GPT और o-सीरीज़ मॉडल को सेवा देता है, `google` और `vertex` Gemini को सेवा देते हैं, और `anthropic` और `bedrock` Claude को सेवा देते हैं।
| मॉडल | नेटिव डायरेक्ट रूट | क्लाउड रूट | उदाहरण वैध array | Flex रेस? |
| --------------------- | ------------------ | ---------- | ------------------------------------------------------------------------------------ | -------------------------------------------------------------- |
| `claude-*` | `anthropic` | `bedrock` | `["anthropic"]`, `["bedrock"]`, `["anthropic","bedrock"]`, `["bedrock","anthropic"]` | नहीं, Claude में कोई flex टियर नहीं है |
| Flex-सक्षम `gemini-*` | `google` | `vertex` | `["google"]`, `["vertex"]`, `["google","vertex"]`, `["vertex","google"]` | केवल तभी जब एलिमेंट 0 `google` हो और `start_within` एक अवधि हो |
| नॉन-flex `gemini-*` | `google` | `vertex` | ऊपर जैसा ही | नहीं, flex अनुमति-सूची में नहीं है |
| Flex-सक्षम `gpt-*` | `openai` | none | `["openai"]` | केवल तभी जब एलिमेंट 0 `openai` हो और `start_within` एक अवधि हो |
| नॉन-flex `gpt-*` | `openai` | none | `["openai"]` | नहीं, flex अनुमति-सूची में नहीं है |
एकल-एलिमेंट क्लाउड-फर्स्ट चेन जैसे `["vertex"]` या `["bedrock"]` उस क्लाउड प्रोवाइडर के लिए एक वैध नो-flex डायरेक्ट रूट है। एलिमेंट 0 के रूप में क्लाउड रूट के साथ एक अवधि `start_within` [`400 flex_unsupported_on_cloud`](/hi/errors#flex_unsupported_on_cloud) लौटाता है, क्योंकि क्लाउड रूट में रेस के लिए कोई flex टियर नहीं होता है; इसके बजाय एक टियर वैल्यू (`default`, `priority`, या `auto`) भेजें। एक गलत array (एक अज्ञात नाम, एक डुप्लिकेट, एक खाली array, या तीन से अधिक प्रविष्टियाँ) [`400 invalid_provider_chain`](/hi/errors#invalid_provider_chain) लौटाता है।
### Bedrock पर Claude: ग्लोबल रूटिंग, opus-4-1, और एक्सेस ग्रांट
`bedrock` रूट Amazon के क्रॉस-रीजन इन्फरेंस प्रोफाइल के माध्यम से Claude को सेवा देता है। FlexInference इसे **ग्लोबल-फर्स्ट** रूट करता है: Bedrock पर सेवा देने वाला हर `claude-*` मॉडल एक ग्लोबल इन्फरेंस प्रोफाइल के माध्यम से संबोधित किया जाता है, इसलिए यह किसी भी AWS क्षेत्र से सेवा देता है, भले ही आपके संगठन की Bedrock key कहाँ सेट हो। एक परिणाम डेटा-रेजिडेंसी ट्रेडऑफ है जिसे जानना महत्वपूर्ण है: एक ग्लोबल प्रोफाइल प्रत्येक अनुरोध को सभी समर्थित AWS क्षेत्रों में रूट करता है, इसलिए यह गारंटी नहीं है कि एक अनुरोध आपके अपने क्षेत्र में चलेगा। ग्लोबल-फर्स्ट के तहत कोई भी रूट किसी विशिष्ट AWS क्षेत्र में प्रोसेसिंग की गारंटी नहीं देता है, और `anthropic` डायरेक्ट रूट एक इन-रीजन विकल्प नहीं है: यह Anthropic के अपने इंफ्रास्ट्रक्चर तक पहुँचता है, न कि आपके AWS अकाउंट तक। यदि इन-रीजन प्रोसेसिंग एक आवश्यकता है, तो एक रीजन-पिन किया गया Bedrock प्रोफाइल (`us.` या `eu.`, आपकी Bedrock key के क्षेत्र से मेल खाता हुआ) प्रति-संगठन डेटा-रेजिडेंसी नीति के माध्यम से अनुरोध पर उपलब्ध है।
`claude-opus-4-1` एकमात्र अपवाद है जो **`bedrock` रूट पर बिल्कुल भी नहीं है**। Amazon इसे केवल US में प्रकाशित करता है, और हर US क्षेत्र में भी नहीं, इसलिए आंशिक क्षेत्र carve-out ले जाने के बजाय FlexInference इसे केवल `anthropic` डायरेक्ट रूट पर सेवा देता है; इसके लिए एक `["bedrock"]` चेन हर क्षेत्र में [`400 bedrock_model_unavailable`](/hi/errors#bedrock_model_unavailable) लौटाता है। यह हमेशा `anthropic` डायरेक्ट रूट पर उपलब्ध होता है, इसलिए `provider` को छोड़ दें या किसी भी क्षेत्र से इस तक पहुँचने के लिए `["anthropic"]` भेजें।
अलग से, एक मॉडल विश्व स्तर पर सेवा दे सकता है और फिर भी आपके AWS अकाउंट के लिए बंद रह सकता है जब तक आप Amazon Bedrock कंसोल में इस तक पहुँच का अनुरोध नहीं करते। जब Bedrock के पास मॉडल होता है लेकिन आपके AWS अकाउंट को यह प्रदान नहीं किया गया होता है, तो आपको [`403 bedrock_model_access_denied`](/hi/errors#bedrock_model_access_denied) मिलता है, जो मॉडल का नाम बताता है और Bedrock ने क्या कहा उसे उद्धृत करता है। (दूसरा मामला, [`400 bedrock_model_unavailable`](/hi/errors#bedrock_model_unavailable) एक ऐसे मॉडल के लिए जिसके लिए Bedrock कोई प्रोफाइल प्रकाशित नहीं करता है, अब प्रभावी रूप से केवल `claude-opus-4-1` पर लागू होता है, क्योंकि हर दूसरे सेवा दिए गए मॉडल का एक ग्लोबल प्रोफाइल होता है।)
दोनों में से कोई भी आपकी Bedrock key के साथ समस्या नहीं है, और एक काम करने वाली key काम करती रहती है: दोनों त्रुटियों का मतलब मॉडल है, क्रेडेंशियल नहीं। न ही कोई चेन में अगले रूट पर जाता है, क्योंकि आपके द्वारा नामित एक रूट वह रूट है जिसे आपने सेट अप करने की उम्मीद की है। इसके बजाय मॉडल को `anthropic` रूट पर भेजें, या इसे AWS अकाउंट को प्रदान करें।
### Bedrock पर नवीनतम Claude मॉडल को एक बार के अकाउंट सेटअप की आवश्यकता होती है
पांच Claude मॉडल `bedrock` रूट पर सेवा देते हैं जब AWS अकाउंट में सामान्य **Model access** ग्रांट होता है: `claude-haiku-4-5`, `claude-sonnet-4-6`, `claude-sonnet-4-5`, `claude-opus-4-6`, और `claude-opus-4-5`।
चार सबसे नए मॉडल - `claude-sonnet-5`, `claude-fable-5`, `claude-opus-4-8`, और `claude-opus-4-7` - को Bedrock द्वारा सेवा देने से पहले AWS अकाउंट पर दो अतिरिक्त एक बार के चरणों की आवश्यकता होती है। Amazon Bedrock कंसोल **Model access** ग्रांट अकेले उन्हें सक्षम नहीं करता है। दोनों को प्रति AWS अकाउंट एक बार चलाएं, एक एडमिनिस्ट्रेटर के AWS क्रेडेंशियल का उपयोग करके (आपकी Bedrock इन्फरेंस key का नहीं)।
**चरण 1 - अकाउंट को प्रोवाइडर डेटा शेयरिंग में ऑप्ट-इन करें।** इस चरण में कोई कंसोल UI नहीं है, इसलिए इसे AWS CLI से चलाना होगा:
```bash theme={null}
aws bedrock put-account-data-retention --mode provider_data_share
```
**चरण 2 - मॉडल समझौते को स्वीकार करें** इनमें से प्रत्येक मॉडल के लिए जिसे आप कॉल करने की योजना बना रहे हैं (इसे प्रति मॉडल एक बार चलाएं):
```bash theme={null}
aws bedrock create-foundation-model-agreement
```
जब तक दोनों पूरे नहीं हो जाते, इन चार मॉडलों में से किसी एक के लिए एक `bedrock` अनुरोध [`403 bedrock_model_access_denied`](/hi/errors#bedrock_model_access_denied) लौटाता है। यह एक Amazon Bedrock अकाउंट की आवश्यकता है, न कि FlexInference की, इसलिए यह वही है चाहे आप FlexInference के माध्यम से Bedrock तक पहुँचें या सीधे। `claude-opus-4-1` अप्रभावित है क्योंकि इसे `bedrock` रूट पर बिल्कुल भी सेवा नहीं दी जाती है; इसे `anthropic` रूट पर पहुँचें।
`vertex` और `bedrock` क्लाउड रूट आज सेवा देते हैं। `bedrock` Amazon Bedrock के माध्यम से `claude-*`
को सेवा देता है और `vertex` Google Vertex AI के माध्यम से `gemini-*` को सेवा देता है, हमेशा वही मॉडल जो आपने मांगा था।
प्रत्येक क्लाउड रूट को उस क्लाउड की अपनी key डैशबोर्ड में जोड़ने की आवश्यकता होती है: `vertex` के लिए एक Vertex express key (`AQ.` उपसर्ग), `bedrock` के लिए एक Bedrock bearer key (`ABSK` उपसर्ग) और क्षेत्र। क्लाउड रूट केवल स्टैंडर्ड टियर पर चलते हैं, बिना flex रेस के। दोनों क्लाउड रूट टेक्स्ट, इमेज और फाइलें ले जाते हैं: एक रिमोट `https` इमेज या फाइल URL सर्वर-साइड से प्राप्त किया जाता है और उनके लिए इनलाइन किया जाता है (नीचे [Inputs](#inputs) देखें)।
## रूट के अनुसार क्षमताएं
तालिका प्रति-रूट त्वरित हाँ/नहीं है। प्रत्येक रूट टेक्स्ट, स्ट्रीमिंग, फ़ंक्शन कॉलिंग, इमेज, फाइलें (PDF सहित), और थिंकिंग/रीजनिंग को सेवा देता है; बेसलाइन के नीचे की पंक्तियाँ वे हैं जहाँ रूट भिन्न होते हैं। `openai`, `anthropic`, और `google` डायरेक्ट रूट हैं; `vertex` और `bedrock` क्लाउड रूट हैं।
| क्षमता | OpenAI (`openai`) | Anthropic (`anthropic`) | Gemini (`google`) | Vertex (`vertex`) | Bedrock (`bedrock`) |
| ----------------------------------------- | ----------------- | ----------------------- | ----------------- | ----------------- | ------------------- |
| टेक्स्ट, स्ट्रीमिंग, फ़ंक्शन कॉलिंग | हाँ | हाँ | हाँ | हाँ | हाँ |
| इमेज और फाइलें (PDF सहित) | हाँ | हाँ | हाँ | हाँ | हाँ |
| थिंकिंग / रीजनिंग | हाँ | हाँ | हाँ | हाँ | हाँ\* |
| वेब सर्च | हाँ | हाँ | हाँ | हाँ | नहीं |
| साइटेशन (`url_citation`) | हाँ | हाँ | हाँ | हाँ | नहीं |
| संरचित आउटपुट (`json_schema`) | हाँ | हाँ | हाँ | हाँ | नहीं |
| `json_object` आउटपुट फॉर्मेट | हाँ | नहीं | हाँ | हाँ | नहीं |
| स्ट्रिक्ट स्कीमा (`text.format.strict`) | हाँ | नहीं | नहीं | नहीं | नहीं |
| `code_execution` / `url_context` (Gemini) | नहीं | नहीं | हाँ | हाँ | नहीं |
\*Bedrock थिंकिंग चलाता है, लेकिन रीजनिंग टोकन को आउटपुट काउंट में शामिल करता है और कोई अलग रीजनिंग-टोकन कुल रिपोर्ट नहीं करता है; Vertex रीजनिंग टोकन रिपोर्ट करता है।
एक `No` एक ज़ोरदार `400 unsupported_parameter` है, न कि एक शांत ड्रॉप। एक ऐसे रूट पर `web_search`, एक `json_schema` संरचित आउटपुट, या `text.format.strict: true` भेजें जो इसे सपोर्ट नहीं करता है और FlexInference अनुरोध को अस्वीकार करता है और फ़ील्ड का नाम बताता है। वेब सर्च या संरचित आउटपुट को किसी भी डायरेक्ट रूट या `vertex` पर रूट करें, और स्ट्रिक्ट स्कीमा अनुरूपता को `openai` पर रूट करें।
## Flex परिणाम और त्रुटियाँ
सफल प्रतिक्रियाओं पर `x-flexinference-flex-*` हेडर flex परिणामों की रिपोर्ट करते हैं। वैलिडेशन त्रुटियाँ अभी भी सामान्य त्रुटि बॉडी का उपयोग करती हैं। पूर्ण त्रुटि आकार और Flex परिणाम हेडर के लिए [त्रुटियाँ पृष्ठ](/hi/errors) देखें।
* `flex_model_not_capable` का मतलब है कि आपने flex अनुमति-सूची के बाहर किसी OpenAI या Gemini मॉडल को अवधि `start_within` भेजा है। एक टियर वैल्यू का उपयोग करें या एक flex-सक्षम मॉडल चुनें।
* `auto_unsupported_for_gemini` का मतलब है कि आपने एक Gemini मॉडल पर `auto` मांगा है, जिसमें कोई `auto` टियर नहीं है। Gemini के स्टैंडर्ड टियर के लिए `default` का उपयोग करें।
* `flex_unsupported_for_anthropic` का मतलब है कि आपने एक `claude-*` मॉडल को अवधि `start_within` भेजा है। Claude के लिए `default`, `priority`, या `auto` का उपयोग करें।
## इनपुट
ये रूट OpenAI-संगत इनपुट स्वीकार करते हैं:
* **टेक्स्ट**: सिस्टम, डेवलपर, यूजर, और असिस्टेंट मैसेज।
* **इमेज**: इमेज URL या base64 डेटा URL पास करें। Base64 डेटा URL सबसे विश्वसनीय हैं। Bedrock और Vertex रूट के लिए, जिन्हें इनलाइन बाइट्स की आवश्यकता होती है, एक रिमोट `https` इमेज URL सर्वर-साइड से डाउनलोड किया जाता है और आपके लिए इनलाइन किया जाता है, SSRF-सुरक्षा जांचों के पीछे (केवल https, कोई निजी या मेटाडेटा होस्ट नहीं, एक आकार सीमा, और png/jpeg/gif/webp के लिए एक मैजिक-बाइट टाइप चेक); एक URL जो एक जांच में विफल रहता है, `400 unsupported_parameter` लौटाता है बजाय चुपचाप छोड़े जाने के।
* **फाइलें**: PDF और अन्य फाइल इनपुट जिन्हें Responses API स्वीकार करता है। रिमोट `https` PDF URL को उन्हीं जांचों के तहत Bedrock और Vertex के लिए डाउनलोड और इनलाइन किया जाता है।
आउटपुट टेक्स्ट होते हैं, जिसमें टूल कॉल, संरचित आउटपुट और रीजनिंग शामिल हैं। स्ट्रीमिंग हर मॉडल पर काम करती है। Gemini पर, `reasoning.effort` प्रति-मॉडल `thinking_level` से मैप करता है और उस मॉडल द्वारा समर्थित रेंज तक सीमित हो सकता है।
नेटिव प्रोवाइडर पैरामीटर केवल तभी पास होते हैं जब मॉडल उस प्रोवाइडर से संबंधित होता है। एंडपॉइंट-विशिष्ट पासथ्रू नियमों के लिए [SDKs](/hi/sdks) देखें।
ऊपर दी गई [क्षमता मैट्रिक्स](#capabilities-by-route) प्रति-रूट हाँ/नहीं है; यह नोट बताता है कि साझा क्षमताएं प्रत्येक प्रोवाइडर पर कैसे मैप होती हैं। वेब सर्च के लिए, एक Responses `web_search` टूल भेजें; Gemini इसे `google_search` से मैप करता है और Anthropic अपने `web_search_20250305` टूल से। जो भी प्रोवाइडर अनुरोध को सेवा देता है, `web_search` (और Gemini का `url_context`) अपने स्रोतों को मैसेज आउटपुट पर कैनोनिकल `url_citation` एनोटेशन के रूप में लौटाता है, ताकि आप रूट की परवाह किए बिना साइटेशन को उसी तरह पढ़ें। संरचित आउटपुट (`json_schema` के साथ `text.format`) Gemini के `response_format` और Anthropic के `output_config` से मैप करते हैं; `json_object` Gemini पर मैप करता है लेकिन Anthropic पर नहीं। `strict` फ्लैग केवल OpenAI पर सम्मानित किया जाता है। Gemini, Vertex, और Anthropic प्रतिक्रिया स्कीमा आकार का सम्मान करते हैं लेकिन सख्त अनुरूपता की गारंटी नहीं दे सकते, इसलिए `text.format.strict: true` वहां चुपचाप अनदेखा किए जाने के बजाय `400 unsupported_parameter` लौटाता है; इसे लागू करने के लिए `strict` को छोड़ दें या OpenAI पर रूट करें। Gemini अतिरिक्त रूप से `code_execution` और `url_context` टूल और `top_k` को स्वीकार करता है। फाइलों को base64 डेटा URL के रूप में पास करें; Gemini पर PDF सबसे विश्वसनीय हैं।
FlexInference OpenAI और Gemini से नए flex-सक्षम मॉडल जोड़ता है जैसे ही प्रोवाइडर उन्हें शिप करते हैं। यदि कोई मॉडल जिसकी आप उम्मीद कर रहे हैं वह गुम है, तो जांचें कि आप उसके उपनाम का उपयोग कर रहे हैं और प्रोवाइडर उसके लिए एक flex टियर प्रदान करता है।