Grok Bot में Jev को कैसे जोड़ें: मेरा बनाया हुआ सबसे बेहतर एजेंट

Grok Bot हर यूज़र को एक क्लाउड कंप्यूटर देता है और बॉट्स को उस पर शेल (shell) चलाने देता है। ज़्यादातर लोग इसे टास्क पर लगाते हैं और देखते रहते हैं कि यह बार-बार वही गलती दोहरा रहा है।

तुम एक राउटर स्किल जोड़ो, उसे काम करने की इजाज़त देने से पहले एक हफ्ते तक सिर्फ लॉगिंग करते रहने दो, और हमेशा एक किल स्विच अपने पास रखो।

इसे सही तरीके से सेटअप कर लो, तो रीट्राई (retries) तुम्हें कुछ भी खर्च करवाने से पहले ही रुक जाएंगे।

यहाँ पूरा सेटअप दिया गया है 👇

आगे बढ़ने से पहले बता दूँ, मैं अपनी पूरी गाइड्स अपने Substack पर पब्लिश करता हूँ: https://zodchiii.substack.com/ 🧠

Jev जवाब में क्या लौटाता है

Jev, TypeSafe का System One मॉडल है। यह साधारण टेक्स्ट के बजाय एक टाइप्ड वैल्यू (typed value) में जवाब देता है, और इसके साथ तीन प्रिमिटिव्स आते हैं:

• Choice तुम्हारी बनाई हुई लिस्ट में से एक ऑप्शन चुनता है, और चॉइस, प्रोबेबिलिटीज़ और कॉन्फिडेंस लौटाता है
• Score किसी तय मानदंड (rubric) के आधार पर स्टेट को रेट करता है
• Noul बताता है कि कोई बात सच है या नहीं, 0 से 1 के बीच एक नंबर के रूप में

चूँकि जवाब एक वैल्यू के रूप में आता है, तुम उसे लॉग कर सकते हो, दो हफ्तों के फैसलों की आपस में तुलना कर सकते हो और उन्हें कल के ट्रैफिक पर फिर से चलाकर देख सकते हो।

कॉल कुछ इस तरह दिखती है:

1from typesafe_sdk import Choice, TypeSafeClient
2
3with TypeSafeClient(model="jev-latest") as client:   # TYPESAFE_API_KEY को पढ़ता है
4    r = client.system_one(
5        state=f"goal: {goal}\ntask: {task_type}\nlast error: {err} x{repeats}",
6        questions={
7            "action": Choice(
8                instructions="एजेंट को आगे क्या करना चाहिए",
9                criteria={
10                    "proceed": "कुछ भी यह नहीं बताता कि अगला स्टेप फेल होगा",
11                    "reuse_cache": "इसके लिए एक नया आर्टिफैक्ट पहले से मौजूद है",
12                    "stop_retry": "वही तरीका उसी तरह फेल हो गया",
13                    "research_capped": "पर्याप्त सोर्स पहले से ही जुटा लिए गए हैं",
14                    "ask_human": "यह स्टेप भेजता, पब्लिश करता, पेमेंट करता या डिलीट करता है",
15                },
16            )
17        },
18    )
19
20print(r.choices["action"].choice, r.choices["action"].confidence)

राउटर इन पाँच में से एक चुनता है और इसके अलावा कुछ भी जवाब देने का उसके पास कोई रास्ता नहीं है।

स्टेप 1: API की (key) हासिल करो

अपना TypeSafe डैशबोर्ड खोलो और एक API की बनाओ। इसे चैट से, रेपो (repo) से और ऐसी किसी भी स्किल से दूर रखो जिसे तुम शेयर करने वाले हो।

स्टेप 2: की को कंप्यूटर पर लाओ

मास्क्ड सीक्रेट रिक्वेस्ट फ्लो (masked secret request flow) का इस्तेमाल करो। की कभी भी चैट से होकर नहीं गुजरती।

इसे जोड़ने से पहले एक बात जान लो: तुम्हारा Grok Bot क्लाउड कंप्यूटर हर अकाउंट के लिए एक सिंगल मशीन है, और उस पर चलने वाला हर बॉट वही फाइलें, सेशन और लॉगिन देखता है। तुम वहाँ जो की रखोगे, वो उन सबको पढ़ने के लिए उपलब्ध होगी।

1मुझे तुम्हें TypeSafe के लिए एक API क्रेडेंशियल देना है। चैट का नहीं, मास्क्ड सीक्रेट
2रिक्वेस्ट फ्लो का इस्तेमाल करो। यह वैल्यू तुम्हारे कंप्यूटर पर एनवायरनमेंट वेरिएबल
3TYPESAFE_API_KEY के रूप में सेव होनी चाहिए, और यह तुम्हारी बनाई गई किसी भी फाइल,
4लॉग, स्किल या रेपो में नहीं दिखनी चाहिए। बस इतना कन्फर्म करो कि वेरिएबल सेट
5हो गया है और पढ़ने योग्य है, उसकी वैल्यू कभी मत बताओ।

स्टेप 3: SDK इंस्टॉल करो और उसका स्मोक टेस्ट करो

1अपने कंप्यूटर पर चलाओ:  pip install typesafe-sdk
2
3फिर /work/jev/smoke.py लिखो जो TypeSafeClient(model="jev-latest") खोले
4और एक Choice सवाल के साथ एक system_one कॉल भेजे। स्टेट:
5"goal: file a support ticket. task: routing. last error: none x0".
6क्राइटेरिया: billing, technical, sales.
7
8इसे चलाओ और मुझे रॉ रिस्पॉन्स ऑब्जेक्ट दिखाओ: चॉइस, प्रोबेबिलिटीज़
9और कॉन्फिडेंस। अगर TYPESAFE_API_KEY गायब है, तो रुक जाओ और मुझे बताओ,
10कुछ भी हार्डकोड मत करो।

आउटपुट में तुम्हें तीन चीज़ें देखनी हैं: तुम्हारी अपनी लिस्ट से आई एक वैल्यू, प्रोबेबिलिटी स्प्रेड, और एक कॉन्फिडेंस नंबर। अगर इनमें से कोई एक भी गायब है, तो समझो SDK किसी और चीज़ से बात कर रहा है।

स्टेप 4: राउटर बनाओ

1/work/jev/router.py पर एक राउटर मॉड्यूल बनाओ जिसमें एक फंक्शन हो:
2
3    route(goal: str, task_type: str, last_error: str, repeats: int) -> dict
4
5यह ठीक उन्हीं चार फील्ड्स को स्टेट के रूप में Jev को भेजता है, साथ में "action" नाम का एक Choice
6सवाल और ये क्राइटेरिया:
7
8  proceed          कुछ भी यह नहीं बताता कि अगला स्टेप फेल होगा
9  reuse_cache      इसके लिए एक नया आर्टिफैक्ट पहले से मौजूद है
10  stop_retry       वही तरीका उसी तरह फेल हो गया
11  research_capped  पर्याप्त सोर्स पहले से ही जुटा लिए गए हैं
12  ask_human        यह स्टेप भेजता, पब्लिश करता, पेमेंट करता या डिलीट करता है
13
14चॉइस, कॉन्फिडेंस और प्रोबेबिलिटीज़ लौटाओ। हर कॉल को टाइमस्टैम्प, चारों इनपुट और पूरे
15रिस्पॉन्स के साथ /work/jev/decisions.jsonl में जोड़ते जाओ। /work/jev/config.json से बिहेवियर पढ़ो जिसमें दो कीज़ हों:
16"enabled" और "mode" ("shadow" या "active")। डिफॉल्ट enabled false रखो।
17
18उन चार फील्ड्स के अलावा स्टेट में कोई प्रॉम्प्ट टेक्स्ट मत रखो। चलाने से पहले मुझे फाइल
19दिखाओ।

ये चार फील्ड्स ही वो पूरा स्टेट हैं जो Jev देखता है। उसे कभी तुम्हारा प्रॉम्प्ट, तुम्हारा रेपो या तुम्हारी बातचीत नहीं मिलती, इसलिए कॉल छोटी रहती है और लॉग पढ़ने में आसान।

स्टेप 5: स्किल जोड़ो

1jev-usage-router नाम की एक स्किल बनाओ।
2
3ट्रिगर: किसी भी ब्राउज़र सेशन से पहले, किसी भी रिसर्च पास से पहले, फेल हुए
4स्टेप के किसी भी रीट्राई से पहले, और कोई अतिरिक्त बॉट बनाने से पहले।
5
6स्टेप्स: /work/jev/router.py से route() कॉल करो जिसमें मौजूदा गोल,
7टास्क टाइप, पिछली एरर का टेक्स्ट और वह कितनी बार रिपीट हुई, ये सब हो।
8फिर एक्शन का पालन करो:
9
10  proceed          जैसा प्लान था वैसा ही जारी रखो
11  reuse_cache      मौजूदा आर्टिफैक्ट इस्तेमाल करो, काम छोड़ दो
12  stop_retry       इस तरीके को छोड़ो और बताओ क्यों
13  research_capped  5 सोर्स पर रुक जाओ और जो मिला है उसे लिखो
14  ask_human        रुक जाओ और मुझसे पूछो, खुद से आगे मत बढ़ो
15
16अप्रूवल बाउंड्री: ask_human को कभी ओवरराइड नहीं किया जाएगा, चाहे कॉन्फिडेंस कुछ भी हो।
17आउटपुट: रन रिपोर्ट में हर फैसले के लिए एक लाइन।

उस स्किल की असली कॉपी अपने सोर्स कंट्रोल में रखो। Grok Bot हर रूटीन के सिर्फ 20 सबसे हालिया रन रिकॉर्ड रखता है, इसलिए जो भी तुम्हारे लिए ज़रूरी हो, उसे होते ही अपने स्टोरेज में पुश कर दो।

स्टेप 6: इसे एक हफ्ते तक शैडो मोड में चलाओ

1/work/jev/config.json को {"enabled": true, "mode": "shadow"} पर सेट करो।
2
3शैडो मोड में, हर ट्रिगर पर राउटर को कॉल करो और फैसला लॉग करो, फिर
4उसे नज़रअंदाज़ करके वही करो जो तुम वैसे भी करते। अपने काम करने के तरीके में
5कुछ मत बदलो।
6
7हर दिन के अंत में /work/jev/report.md में जोड़ो: कितनी कॉल्स हुईं,
8एक्शन का बँटवारा कैसा रहा, औसत कॉन्फिडेंस क्या रहा, और हर वो मामला जहाँ लॉग किया गया
9एक्शन तुम्हारे असल काम से मेल नहीं खाता था।

शैडो मोड इसलिए होता है क्योंकि एक सस्ता जज गलत भी हो सकता है। जहाँ मेल नहीं खाता, वहाँ लॉग पढ़ो। अगर stop_retry ऐसे तरीके पर लग जाता जो चौथी कोशिश में काम कर जाता, तो तुम्हें उसके काम करने की छूट मिलने से पहले यह पता होना चाहिए।

एक हफ्ते का असली ट्रैफिक पढ़ने के लिए काफी है। इससे कम समय में सैंपल इतना छोटा रहेगा कि तुम्हें कुछ खास समझ नहीं आएगा।

स्टेप 7: एक्टिव मोड में जाओ, लेकिन किल स्विच बनाए रखो

1mode को "active" पर सेट करो। अब से फैसले को लॉग करने के बजाय उसका पालन करो।
2
3दो किल स्विच हमेशा मेरे पास उपलब्ध रहेंगे:
4  1. किसी भी मैसेज में "bypass jev", जो उस रन के लिए राउटर को नज़रअंदाज़ कर देगा
5  2. config.json में {"enabled": false}, जो इसे पूरी तरह बंद कर देगा
6
7ask_human अभी भी मेरे लिए रुकेगा। decisions.jsonl को बिल्कुल पहले की तरह लिखते रहो।

मोड बदलने के बाद भी लॉगिंग जारी रखो। यही लॉग तुम्हें बताएगा कि कौन सा राउटर तुम्हारे पैसे बचा रहा है और कौन सा चुपचाप वो काम रोक रहा है जो उसे पूरा करना चाहिए था।

सबसे पहले क्या राउट करें

उस एक रूटीन से शुरू करो जो बार-बार रीट्राई करता रहता है, और अपना बाकी सेटअप जैसा है वैसा ही रहने दो।

जिन रूटीन्स को सबसे पहले राउट करना फायदेमंद होता है, उनमें एक बात कॉमन होती है: एजेंट को पता ही नहीं होता कि उसे पहले से क्या पता है। वह डिस्क पर पड़ी फाइल के लिए ब्राउज़र फिर से खोलता है, जब पाँच सोर्स ने जवाब दे दिया हो तब चौदहवाँ सोर्स पढ़ता है, या तीसरी बार वही तरीका आजमाता है क्योंकि किसी ने उसे बताया ही नहीं कि दूसरी बार भी वही कारण फेल हुआ था।

कोई एक चुनो, उसे शैडो में चलाओ, और आगे बढ़ने से पहले लॉग पढ़ो।

इसकी लागत क्या है

Jev कॉल में चार छोटी फील्ड्स जाती हैं, इसलिए यह छोटी रहती है। हर कॉल तुम्हें कोई महँगा स्टेप छोड़ने का विकल्प देती है: ब्राउज़र सेशन, रिसर्च पास, एक्स्ट्रा बॉट, या रीट्राई।

किसी और के आँकड़ों पर भरोसा करने के बजाय — मेरे आँकड़ों सहित — इसे अपने ट्रैफिक पर नापो। फैसला लॉग करो, जो स्टेप छोड़ा उसे लॉग करो, और शैडो वाले हफ्ते की तुलना एक्टिव वाले हफ्ते से करो।

कुछ सीमाएँ जो याद रखनी चाहिए

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

तो आखिर में तुम्हारे हाथ क्या आता है?

Grok Bot सोचता है और काम करता है, Jev पाँच में से एक एक्शन का जवाब देता है, और जो कुछ भी वापस नहीं लिया जा सकता, उस पर आखिरी फैसला तुम्हारा होता है।

उस रूटीन से शुरू करो जो बार-बार उसी तरह फेल हो रहा है, उसे एक हफ्ते तक शैडो में चलाओ, फिर उसे एक्टिव कर दो।

पढ़ने के लिए शुक्रिया!

पूरी गाइड्स और इस सीरीज़ के बाकी हिस्से: https://zodchiii.substack.com/