GPT‑6 फ़ैमिली के लिए एक मॉडल गाइड

GPT‑6 हमारे अब तक के सबसे एडवांस्ड मॉडल्स का सेट है⁠ और आपको अलग-अलग तरह के कामों के लिए मॉडल चुनने का विकल्प देता है.

चाहे आप किसी आइडिया को काम करने वाले प्रोटोटाइप में बदल रहे हों, कोई फ़ीचर बना और टेस्ट कर रहे हों, या कोड रिपॉज़िटरी, डेटाबेस और एक्सटर्नल API में कई स्टेप वाले वर्कफ़्लो को मैनेज कर रहे हों, यह गाइड बताती है कि GPT‑6 मॉडल कैसे चुनें, उसे सही निर्देश कैसे दें, लंबे समय तक चलने वाले काम को कैसे मैनेज करें और प्रोडक्शन के लिए कैसे तैयारी करें.

• प्रोडक्शन में असरदार तरीके से चलाएँ. संदर्भ और लागत को मैनेज करने के लिए कैशिंग⁠(एक नई विंडो में खुलेगा) और कम्पैक्शन⁠(एक नई विंडो में खुलेगा) का इस्तेमाल करें. टास्क की सफ़लता और लेटेंसी को मापें, और मॉनिटरिंग और डेटा कंट्रोल के लिए प्लान बनाएँ.

• अपने वर्कलोड के हिसाब से मॉडल चुनें. टास्क के लिए सही मॉडल, रीज़निंग की कोशिश⁠(एक नई विंडो में खुलेगा) और स्पीड चुनकर क्षमता, लागत और लेटेंसी के बीच संतुलन बनाएँ.

• अपने प्रॉम्प्ट और स्किल्स को एडजस्ट करें. प्रॉम्प्ट, स्किल्स और रिपॉज़िटरी के निर्देशों में एकरूपता बनाए रखें कि मॉडल को क्या डिलीवर करना है, वह क्या काम खुद कर सकता है, और किस काम को पूरा माना जाएगा.

• लंबे समय तक चलने वाले काम को सही दिशा में रखें. अपडेट और व्यक्तिगत काम को संभालने के लिए दिशा-निर्देश⁠(एक नई विंडो में खुलेगा), एसिंक्रोनस टूल्स⁠(एक नई विंडो में खुलेगा) और काम सौंपने⁠(एक नई विंडो में खुलेगा) का इस्तेमाल करें. स्पष्ट तौर पर तय करें कि मॉडल को कब इनपुट मांगना चाहिए.

डिप्लॉय करने से पहले, आपको कई तरह की जाँच और बेहतरीन तरीके लागू करने होंगे.

• एफ़िशिएन्सी का ध्यान रखें. उन संदर्भों को हटा दें जिनकी टास्क को ज़रूरत नहीं है⁠(एक नई विंडो में खुलेगा), लेकिन ज़रूरी सबूतों को बनाए रखें. जहाँ आपका ऐप्लिकेशन इसे सपोर्ट करता है, वहाँ व्यक्तिगत टास्क एक साथ चलाएँ⁠(एक नई विंडो में खुलेगा) ताकि एक धीमा स्टेप दूसरे असंबंधित काम को न रोके.

• बार-बार होने वाले काम के लिए प्रॉम्प्ट कैशिंग⁠(एक नई विंडो में खुलेगा) के ज़रिए शेयर किए गए संदर्भ का दोबारा इस्तेमाल करें. मॉडल के आधार पर, कैश किए गए इनपुट टोकन की लागत बिना कैश किए गए इनपुट टोकन की तुलना में 95% तक कम⁠(एक नई विंडो में खुलेगा) होती है. टास्क की जानकारी बदलने से पहले स्थिर निर्देश और रेफ़रेंस मटीरियल रखें, और टूल की परिभाषाओं को एक जैसा बनाए रखें. कैशिंग डैशबोर्ड⁠(एक नई विंडो में खुलेगा) और डायग्नोस्टिक्स गाइड⁠(एक नई विंडो में खुलेगा) आपको यह देखने में मदद करते हैं कि दोबारा इस्तेमाल कहाँ काम नहीं कर रहा है. पूरे वर्कफ़्लो की लागत का अनुमान लगाते समय कैश में लिखने और लंबे संदर्भ की लागू दरें भी शामिल करें.

• लंबी बातचीत के लिए, कम्पैक्शन⁠(एक नई विंडो में खुलेगा) संदर्भ का साइज़ कम करता है, साथ ही बातचीत जारी रखने के लिए ज़रूरी स्थिति को भी बनाए रखता है.

• तय करें कि आप व्यवहार की निगरानी⁠(एक नई विंडो में खुलेगा) कैसे करेंगे और अपने ऐप्लिकेशन के लिए डेटा कंट्रोल⁠(एक नई विंडो में खुलेगा) को कैसे रिव्यू करेंगे.

• डिप्लॉय करने से पहले टेस्ट करें: कुछ ख़ास टास्क चलाकर देखें और टास्क की सफ़लता, लेटेंसी और हर सफ़ल टास्क की लागत को मापें. हमारी API डिप्लॉयमेंट चेकलिस्ट⁠(एक नई विंडो में खुलेगा) देखें.

मॉडल के चुनाव और रीज़निंग लेवल को इंटेलिजेंस और कीमत के बीच संतुलन तय करने का तरीका समझें.

• मॉडल:

  • GPT‑6 Astra⁠(एक नई विंडो में खुलेगा), सबसे मुश्किल रीज़निंग वाले काम के लिए, जहाँ बहुत ज़्यादा इंटेलिजेंस की ज़रूरत होती है.

  • GPT‑6.1 Sol⁠(एक नई विंडो में खुलेगा) मुश्किल कोडिंग, रिसर्च और कंप्यूटर के इस्तेमाल के लिए.

  • GPT‑6 Luna⁠(एक नई विंडो में खुलेगा) बड़े पैमाने पर ख़ास टास्क और रोज़ाना के बार-बार होने वाले काम के लिए है, जिनका लक्ष्य स्पष्ट हो; जैसे कि इनवॉइस से जानकारी निकालना, अनुरोधों को कैटेगराइज़ करना या व्यवस्थित समरी तैयार करना.

टास्क के लिए सबसे अच्छे मॉडल का मूल्यांकन करते समय, हर मॉडल की कीमत की तुलना करें⁠(एक नई विंडो में खुलेगा).

• रीज़निंग लेवल: API में, यह चुनें कि मॉडल किसी टास्क पर कितनी मेहनत करेगा.

  • कम: रोज़मर्रा के टास्क, जैसे जानकारी निकालना या छोटे-मोटे बदलाव करना.

  • मीडियम: ऐसा काम जिसमें समझ-बूझ की ज़रूरत हो, जैसे किसी फ़ीचर को प्लान करना या विकल्पों की तुलना करना.

  • हाई: मुश्किल डिबगिंग, गहरा एनालिसिस या ध्यान से रिव्यू.

  • एक्स्ट्रा हाई / मैक्स: जब 'हाई' काफ़ी न हो, तो जहाँ सपोर्टेड हो वहाँ इसे टेस्ट करें; और इसे तभी बनाए रखें जब इससे होने वाला सुधार, इसमें लगने वाले अतिरिक्त समय और लागत को यह सही ठहराता हो.

API में, आप कैश को बरकरार रखते हुए बातचीत के बीच में ही रीज़निंग की कोशिश को बदल⁠(एक नई विंडो में खुलेगा) सकते हैं.

Codex में, उस मॉडल के लिए डिफ़ॉल्ट रीज़निंग लेवल से शुरुआत करें, फिर आसान टास्क के लिए इसे कम करें या ज़्यादा गहराई से एनालिसिस करने के लिए इसे बढ़ाएँ.

• स्पीड:

  • API में, जवाब मिलने का समय मायने रखता हो, तो फ़ास्ट मोड⁠(एक नई विंडो में खुलेगा) चुनें—जैसे चैट ऐप या कोडिंग टूल में. इससे स्टैंडर्ड प्रोसेसिंग के मुकाबले ज़्यादा प्रति-टोकन लागत पर जवाब जल्दी मिलते हैं और उनके समय में कम उतार-चढ़ाव होता है.

  • Codex और API में, Ultrafast⁠(एक नई विंडो में खुलेगा) का इस्तेमाल तब करें जब तेज़ रिस्पॉन्स के लिए ज़्यादा कीमत चुकाना सही हो, जैसे कि तेज़ी से कोडिंग करने के दौरान. यह रीज़निंग की कोशिश से अलग, टोकन जेनरेशन की रफ़्तार को बढ़ाता है. GPT‑6 Astra के लिए उपलब्ध⁠(एक नई विंडो में खुलेगा).

एक स्पष्ट असाइनमेंट से शुरुआत करें: आपको क्या नतीजा चाहिए, यह किसके लिए है, इससे जुड़े उपयुक्त संदर्भ और सीमाएँ क्या हैं, और काम पूरा कब माना जाएगा. इसके बाद, अपने निर्देशों को बेहतर बनाने के लिए इन चार चीज़ों को रिव्यू करें, जिन्हें GPT‑6 Astra के लिए स्किल्स और प्रॉम्प्ट्स पर नए सिरे से सोचने⁠(एक नई विंडो में खुलेगा) से लिया गया है:

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

• अपने AGENTS.md को अपडेट करें: बताएँ कि ख़ास डॉक्यूमेंट और टेस्ट कब उपयुक्त हैं, और सुरक्षित रूटीन वर्कफ़्लो को स्पष्ट तौर पर ऑथोराइज़ करें, जैसे कि डिस्पोज़ेबल डेटा के साथ लोकल टेस्ट चलाना और प्रोडक्शन एक्सेस न होना.

• फ़ैसले की सीमाएँ तय करें: बताएँ कि कौन-से काम व्यक्तिगत तौर से हो सकते हैं और किसके लिए मंज़ूरी चाहिए; "हमेशा पूछने" वाले आम नियमों की जगह स्पष्ट सीमाएँ तय करें.

• लगातार काम करने के बारे में स्पष्ट निर्देश दें: तय करें कि "काम पूरा होने" का क्या मतलब है—इसमें बदलाव लागू करना, उसे चलाना, नतीजों की जाँच करना और कमियों को ठीक करना शामिल है—और उन फ़ैसलों की पहचान करें जिनके लिए आपके रिव्यू की ज़रूरत है.

अतिरिक्त मार्गदर्शन के लिए, रीज़निंग के सबसे अच्छे तरीकों⁠(एक नई विंडो में खुलेगा) को देखें.

चाहे आप Codex में काम कर रहे हों या API का इस्तेमाल करके कुछ बना रहे हों, यह स्पष्ट करें कि मॉडल कौन-से फ़ैसले ले सकता है, उसे कब इनपुट मांगना चाहिए और एक उपयोगी जवाब कैसा होना चाहिए.

मॉडल को इतना निर्देश दें कि काम बिना रुके चलता रहे और ज़रूरी फ़ैसलों के लिए अंदाज़ा न लगाना पड़े. उसे बताएँ कि वह कौन से फ़ैसले ले सकता है और कब आपसे राय लेनी है⁠(एक नई विंडो में खुलेगा); उदाहरण के लिए, वह तय कर सकता है कि समरी को कैसे व्यवस्थित किया जाए, लेकिन प्रोजेक्ट का दायरा बदलने से पहले उसे आपसे पूछना चाहिए. बताएँ कि एक उपयोगी जवाब कैसा होना चाहिए⁠(एक नई विंडो में खुलेगा); उदाहरण के लिए, आसान भाषा, आपके ऑडियंस के हिसाब से तकनीकी जानकारी, और एक छोटा सा सारांश जिसमें बताया गया हो कि क्या बदला गया, क्या चेक किया गया, और किस चीज़ पर अभी भी ध्यान देने की ज़रूरत है.

GPT‑6 मॉडल फ़ैमिली के साथ, अब आप ऐसे टास्क कर सकते हैं जिनमें घंटों या दिनों का समय लगता है. लंबे समय तक चलने वाले टास्क में एजेंट को बेहतर ढंग से मैनेज करने के लिए इन फ़ीचर का इस्तेमाल करें.

API में, लंबे समय तक चलने वाले टास्क को जारी रखने के लिए स्टीयरिंग, एसिंक्रोनस टूल और साथ में चलने वाले काम का इस्तेमाल करें.

• काम के दौरान निर्देश अपडेट करें: टर्न के बीच दिशा-निर्देशन⁠(एक नई विंडो में खुलेगा) की मदद से, मॉडल के काम करते समय आप Responses WebSocket API⁠(एक नई विंडो में खुलेगा) के ज़रिए सुधार भेज सकते हैं. अपडेट कतार में लग जाते हैं; वे चल रहे टूल को कैंसल नहीं करते और न ही पूरे हो चुके काम को वापस पहले जैसा करते हैं.

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

• व्यक्तिगत सब-टास्क सौंपें: GPT‑6.1 Sol रिस्पॉन्स API में मल्टी-एजेंट वर्कफ़्लो⁠(एक नई विंडो में खुलेगा) को सपोर्ट करता है. यह सब-एजेंट्स को व्यक्तिगत काम (जैसे कोडबेस के अलग-अलग हिस्सों की जाँच करना) सौंप सकता है और उनके नतीजों को मिलाकर एक फ़ाइनल रिस्पॉन्स तैयार कर सकता है. मल्टी-एजेंट सुविधा फ़िलहाल बीटा में है.

लंबे समय तक चलने वाले टास्क से ऐसे फ़ैसले सामने आ सकते हैं जिनकी उम्मीद आपने शायद शुरुआती प्रॉम्प्ट में न की हो. काम को सही दिशा में बनाए रखने के लिए स्पष्ट और सही दिशा देने का इस्तेमाल करें.

• काम आगे बढ़ने के साथ-साथ सवालों के जवाब दें: GPT‑6 Astra के साथ, Codex काम करते समय सफ़ाई मांग सकता है⁠(एक नई विंडो में खुलेगा). अगले स्टेप पर असर डालने वाले सवालों को हल करें और बताएँ कि आपके फ़ैसला लेने के दौरान कौन-सा व्यक्तिगत काम जारी रह सकता है. अगर आप कहीं जा रहे हैं, तो Codex को बताएँ कि कौन-से काम जारी रखे जा सकते हैं और कब उसे आपके जवाब का इंतज़ार करना चाहिए.

• ज़रूरतों में बदलाव होने पर काम की दिशा बदलें: एक्टिव टास्क को दिशा दें⁠(एक नई विंडो में खुलेगा) नई जानकारी के साथ, यह समझाते हुए कि क्या बदलना चाहिए और क्या वैसा ही रहना चाहिए. इससे ऐसे तरीके पर ज़्यादा समय ख़र्च करने से बचने में मदद मिलती है जो अब आपकी ज़रूरतों को पूरा नहीं करता है.

कंप्यूटर का इस्तेमाल⁠(एक नई विंडो में खुलेगा) GPT‑6 Astra, GPT‑6.1 Sol और GPT‑6 Luna को सीधे वेबसाइट और डेस्कटॉप ऐप्स के साथ इंटरैक्ट करने देता है, यहाँ तक कि उन ऐप्स के साथ भी जिनमें API नहीं है. उदाहरण के लिए, आप मॉडल से किसी बग की जाँच करने, कोड ठीक करने और यह देखने के लिए कि सुधार काम कर रहा है या नहीं, ब्राउज़र में अपना प्रोडक्ट खोलने के लिए कह सकते हैं.

हर स्टेप को पूरा करने का सबसे आसान और भरोसेमंद तरीका चुनें:

• जब कोई API या कनेक्टेड टूल सीधे काम कर सकता हो, तो उसका इस्तेमाल करें.

• जब मॉडल को आपके लिए स्क्रीन पढ़नी हो, बटन क्लिक करने हों या कोई फ़ॉर्म भरना हो, तो कंप्यूटर के इस्तेमाल वाले फ़ीचर का उपयोग करें.

अगर आप अपने ऐप में कंप्यूटर का इस्तेमाल करने की सुविधा बना रहे हैं, तो मॉडल को ऐसा टूल दें जो ब्राउज़र या डेस्कटॉप को कंट्रोल करने के लिए कोड चला सके. Playwright ब्राउज़र के साथ काम करता है⁠(एक नई विंडो में खुलेगा); PyAutoGUI डेस्कटॉप ऐप्स के साथ काम करता है.