> ## 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.

# एजेंट कुंजी

> एक ऐसी कुंजी बनाएँ जिसमें समय-सीमा हो, उन टूल के लिए जो प्रति अनुरोध एक समय-सीमा निर्धारित नहीं कर सकते।

अधिकांश टूल अपना स्वयं का अनुरोध बॉडी बनाते हैं। वे आपको `start_within` डालने के लिए कोई जगह नहीं देते, और इसके बिना हर अनुरोध [`400 missing_start_within`](/hi/errors#missing_start_within) लौटाता है।

एक एजेंट कुंजी इस समस्या का समाधान करती है। यह स्वयं समय-सीमा को धारण करती है, इसलिए टूल द्वारा किए गए प्रत्येक अनुरोध को इसके द्वारा रूट किया जाता है।

## कुंजी बनाएँ

1. [डैशबोर्ड](https://www.flexinference.com/dashboard) खोलें और **API** पर जाएँ, फिर **FlexInference keys** पर जाएँ।
2. **Create agent key** दबाएँ। साधारण **Create key** बटन बिना समय-सीमा वाली कुंजी बनाता है।
3. कुंजी का नाम दें। नाम वैकल्पिक है और केवल आपको इसे बाद में ढूँढने में मदद करता है।
4. समय-सीमा चुनें। **Flex race** पहले से चयनित आता है, और यही एजेंट कुंजियों के अस्तित्व का कारण है।
5. यदि आपने **Flex race** चुना है तो अवधि निर्धारित करें। 5 सेकंड से 10 मिनट तक कोई भी अवधि टाइप करें, या त्वरित चयन करें।
6. बनाएँ दबाएँ, फिर गुप्त कुंजी कॉपी करें। डैशबोर्ड इसे एक बार दिखाता है।

कुंजियों की सूची पर **Agent keys only** फ़िल्टर के साथ कुंजी को फिर से ढूँढें। पंक्ति पर एक पॉलिसी चिप दिखाती है कि इसमें क्या है।

## प्रत्येक समय-सीमा क्या करती है

| विकल्प        | वायर मान   | क्या होता है                                                                                         |
| ------------- | ---------- | ---------------------------------------------------------------------------------------------------- |
| **Flex race** | a duration | उस अवधि के लिए सस्ते टियर का प्रयास करता है, फिर स्टैंडर्ड पर वापस आ जाता है।                        |
| **Standard**  | `default`  | सामान्य टियर प्रदान करता है। हर मॉडल और हर रूट के साथ काम करता है।                                   |
| **Priority**  | `priority` | जल्दी शुरू होता है और अधिक लागत आती है। जब कोई व्यक्ति उत्तर का इंतजार कर रहा हो तो यह इसके लायक है। |
| **Auto**      | `auto`     | प्रदाता को चुनने देता है। Gemini मॉडल पर उपलब्ध नहीं है।                                             |

**Flex race** की लागत कम होती है और यह बाद में शुरू होता है। आप एक इंटरैक्टिव लूप में उस देरी को महसूस करते हैं, इसलिए एक टियर उस टूल के लिए उपयुक्त है जिसे आप बैठकर देखते हैं।

<Note>
  **Priority** और **Auto** को BYOK संगठन की आवश्यकता होती है। [Managed
  Keys](/hi/billing) इनमें से कोई भी टियर प्रदान नहीं करता है, इसलिए किसी भी प्रबंधित प्रदाता वाले संगठन को `400
      invalid_key_defaults` के साथ निर्माण के समय अस्वीकार कर दिया जाता है। यह अस्वीकृति
  अवधि के फ़ॉलबैक टियर को भी कवर करती है।
  वहाँ **Standard** या **Flex race** चुनें।
</Note>

## कुंजी क्या धारण करती है

एक कुंजी अधिकतम तीन फ़ील्ड संग्रहीत करती है।

* `start_within`: एक अवधि या एक टियर नाम। हमेशा सेट।
* `on_no_flex`: वह टियर जिस पर एक अवधि वापस आती है। डैशबोर्ड हमेशा `default` संग्रहीत करता है और कभी नहीं पूछता। केवल API आपको `priority` चुनने देता है।
* `retry`: 1 से 5 तक की `count`, वैकल्पिक `backoff` और `jitter` के साथ। जब तक आप इसके लिए नहीं पूछते, तब तक अनसेट।

जब तक आपके पास कोई कारण न हो, `retry` को अकेला छोड़ दें। अधिकांश एजेंट अपने आप पुनः प्रयास करते हैं, और दोनों स्टैक होते हैं। प्रत्येक क्लाइंट प्रयास तब एक पूर्ण सर्वर-साइड बजट खर्च करता है।

## अनुरोध हमेशा जीतता है

हम किसी भी अनुरोध में एक संग्रहीत फ़ील्ड भरते हैं जो इसके बिना आता है। हम अनुरोध द्वारा भेजे गए मान को कभी नहीं बदलते।

यह नियम तब भी लागू होता है जब भेजा गया मान गलत हो। एक स्पष्ट रूप से गलत `start_within` अभी भी `400 invalid_start_within` लौटाता है। एक कुंजी डिफ़ॉल्ट उस फ़ील्ड के लिए होता है जिसे आपने नहीं भेजा, न कि उस फ़ील्ड के लिए जिसे आपने गलत भेजा।

प्रत्येक प्रतिक्रिया जिसे हम भरते हैं, `x-flexinference-defaults-applied` के साथ आती है, जिसमें फ़ील्ड सूचीबद्ध होते हैं। एक अनुरोध जिसने अपनी स्वयं की समय-सीमा भेजी, उसे ऐसा कोई हेडर नहीं मिलता।

## एक कुंजी अवधि वहाँ वापस आती है जहाँ एक अनुरोध अवधि विफल हो जाती है

एक `claude-*` मॉडल पर अनुरोध बॉडी में एक अवधि Claude के सस्ते टियर के साथ प्रतिस्पर्धा करती है। तीन नियम इसे तय करते हैं: प्रबंधित कुंजी, कोई streaming नहीं, और तीन मिनट या अधिक। इनमें से किसी एक को तोड़ने पर अनुरोध विफल हो जाता है, और पहले के लिए [`400 flex_unsupported_for_anthropic`](/hi/errors#flex_unsupported_for_anthropic) मिलता है। [Claude durations need a longer window](/hi/deadline-routing) देखें।

कुंजी पर एक अवधि इसके बजाय वापस आती है। यह `on_no_flex` टियर चलाता है, इसलिए कुंजी के पास हमेशा एक उत्तर होता है। यह फ़ॉलबैक ही कारण है कि एक कुंजी कभी भी Claude के सस्ते टियर के साथ प्रतिस्पर्धा नहीं करती, चाहे वह प्रबंधित कुंजी पर हो या अन्यथा: समय-सीमा दौड़ पर विचार करने से पहले आपके टियर पर हल हो जाती है।

वह फ़ॉलबैक केवल मॉडल को कवर करता है। आपके अपने अनुरोध द्वारा बनाया गया कोई भी विरोध अभी भी विफल हो जाता है। एक क्लाउड रूट को पिन करने से ऐसा होता है, क्योंकि एक क्लाउड रूट केवल सामान्य टियर चलाता है। [`key_default_not_applicable`](/hi/errors#key_default_not_applicable) देखें।

## संपादित करें या रद्द करें

कुंजी पंक्ति पर समय-सीमा संपादित करें। लाइव ट्रैफ़िक इसे कुछ ही सेकंड में उठा लेता है, और आप वही कुंजी रखते हैं। कुछ भी पुनः आरंभ नहीं होता है और गुप्त कुंजी वही रहती है।

एक कुंजी को रद्द करने से उसके डिफ़ॉल्ट भी साफ़ हो जाते हैं।

## जहाँ एक एजेंट कुंजी लागू नहीं होती

एक टूल को हम तक पहुँचने के लिए एक बेस URL और एक key field की आवश्यकता होती है। एक उत्पाद जो केवल अपने विक्रेता की अपनी सदस्यता के विरुद्ध चलता है, उसके पास इनमें से कोई भी नहीं होता, इसलिए कोई भी कुंजी उस तक नहीं पहुँच सकती।

## प्रति-टूल गाइड

| टूल                                | यह जिस सतह को कॉल करता है |
| ---------------------------------- | ------------------------- |
| [Codex](/hi/coding-agents)         | प्रतिक्रियाएँ             |
| [Cursor](/hi/cursor)               | Chat Completions          |
| [Claude Code](/hi/claude-code)     | संदेश                     |
| [Claude Cowork](/hi/claude-cowork) | संदेश                     |
| [OpenCode](/hi/opencode)           | Chat Completions          |
| [OpenWork](/hi/openwork)           | Chat Completions          |
| [OpenScience](/hi/openscience)     | Chat Completions          |
| [OpenWorker](/hi/openworker)       | Chat Completions          |
| [OpenClaw](/hi/openclaw)           | Chat Completions          |

## समस्या निवारण और अक्सर पूछे जाने वाले प्रश्न

[Errors](/hi/errors) हमारे द्वारा लौटाई गई प्रत्येक अस्वीकृति को उसके वायर आकार, उसके कारण और समाधान के साथ बताता है। प्रत्येक प्रति-टूल गाइड उस क्लाइंट के लिए विशिष्ट लोगों को कवर करता है।

एक अस्वीकृति स्वयं एजेंट कुंजियों से संबंधित है।

**हर अनुरोध पर [`400 missing_start_within`](/hi/errors#missing_start_within)**। कुंजी में कोई समय-सीमा नहीं है, इसलिए यह **Create agent key** के बजाय **Create key** से आई है। **Create agent key** के साथ एक नई कुंजी बनाएँ और उसे बदल दें। डिफ़ॉल्ट के बिना बनाई गई कुंजी उन्हें बाद में प्राप्त नहीं कर सकती, इसलिए पंक्ति में एक जोड़ने के लिए कोई नियंत्रण नहीं होता है।

**क्या टूल को यह जानने की आवश्यकता है कि इसमें एक एजेंट कुंजी है?** नहीं। यह किसी भी कुंजी की तरह ही प्रमाणित होता है, और हर कुंजी `flex_live_` से शुरू होती है।

**क्या एक कुंजी एक टूल और मेरे अपने कोड दोनों को सेवा दे सकती है?** हाँ। आपका कोड `start_within` भेजता है और जीतता है। टूल कुछ भी नहीं भेजता है और कुंजी की समय-सीमा लेता है।

**इसकी लागत क्या है?** हम एजेंट द्वारा किए गए हर अनुरोध को चलाते हैं। आपकी अपनी प्रदाता कुंजी पर इसकी आपको यहाँ कोई लागत नहीं आती है, और आपका प्रदाता टोकन का बिल देता है। [Managed Keys](/hi/billing) पर प्रत्येक अनुरोध आपके शेष राशि से कटता है, इसलिए एक **Request volume** अलार्म सेट करें।

**एक लैपटॉप ने दर सीमा क्यों पार कर ली?** हम प्रति स्रोत IP पर सफल अनुरोधों को सीमित करते हैं, इसके पीछे की हर कुंजी पर। एक तेज़ लूप प्रति-कुंजी सीमा से पहले उस तक पहुँच जाता है। [`rate_limit_exceeded`](/hi/errors#rate_limit_exceeded) देखें।