समानांतर प्रश्न और speculative fan-out: एक ही अनुरोध में 13 प्रश्न
पिछले चरणरोज़मर्रा का उपयोग में पाँच तरीकों से प्रश्न पूछना सीखा था, लेकिन उदाहरण या तो सिंगल-प्रश्न अनुरोध थे या तीन-पाँच प्रश्नों तक सतही। इस पाठ में उन सबको एक ही अनुरोध में डालेंगे—Jev समानांतर प्रश्न: आधिकारिक वास्तविक परीक्षण, 13 प्रश्न एक अनुरोध में, एक-प्रश्न-एक-अनुरोध से 13 बार भेजने की तुलना मेंसस्ता 12.2 गुना, तेज़ 10.0 गुना, जवाब बिल्कुल एक जैसे।
दूसरी बात speculative fan-out (Speculative fan-out): जो प्रश्न "शायद चाहिए" उन्हें भी पहले से पूछ लें, जवाब आने पर कोड तय करे कि कौन सा उपयोग करना है। आधिकारिक Patterns दस्तावेज़ इसे चार आर्किटेक्चर पैटर्न में पहला स्थान देता है, और यही इस चरण के बाकी पाठों में बार-बार उपयोग होने वाली नींव है।
सीखने के बाद आप क्या कर सकते हैं
- एक ही Jev अनुरोध में कई प्रश्न समानांतर में पूछें: Choice / Score / Noul तीनों प्रश्न-प्रकार मिलाकर, आधिकारिक उदाहरण के 5 प्रश्न, 13 प्रश्न दोनों चलते हैं
- speculative fan-out के दोनों हिस्से लिखें: मॉडल एक बार में सबका जवाब देता है, कोड ब्रांच के अनुसार तय करता है कि कौन से जवाब पढ़ने हैं, कौन से अनदेखा करने हैं
- आधिकारिक 13 प्रश्न वाले वास्तविक परीक्षण को दोहराएं: 12.2 गुना सस्ता, 10.0 गुना तेज़, जवाब अपरिवर्तित (API key के बिना दोबारा चलाने की विधि सहित)
- वास्तविक निर्भरता पहचानें: "दूसरा अनुरोध भेजना ही पड़ेगा" के तीन आधिकारिक मापदंड बताएं, अब अनुरोध तोड़ने के लिए अंतर्ज्ञान पर निर्भर नहीं
आपकी मौजूदा समस्या
- मेरा टिकट triage क्रमिक अनुरोधों की श्रृंखला है: पहले श्रेणी पूछें, जवाब आने का इंतज़ार करें, bug हो तो गंभीरता पूछें, refund हो तो स्पष्ट रूप से माँगा गया है या नहीं पूछें…… एक टिकट में तीन-चार बार आगे-पीछे, विलंबता और बिल दोनों बढ़ते हैं
- सोचा था सारे प्रश्न एक साथ पूछ लूँ, पर डर लगा कि "ज़्यादा प्रश्नों से मॉडल भ्रमित हो जाएगा"—किसी तरह स्थिर किए जवाब, दो और प्रश्न जोड़ने से बदल तो नहीं जाएंगे?
- coding agent से बनवाया कोड हमेशा एक-प्रश्न-एक-अनुरोध वाला आता है, मैं सोचता रहा कि मेरा prompt गलत लिखा है
यह तरीका कब उपयोग करें
जब आपको चाहिए:
- एक ही सामग्री पर कई प्रश्न पूछना: टिकट triage, दस्तावेज़ अनुपालन जाँच, एक संदेश पर कई टैग लगाना
- जिनमें से कुछ प्रश्न "शायद उपयोग न हों"—वर्गीकरण का परिणाम आने के बाद ही पता चलता है कि कौन से जवाब प्रासंगिक हैं
- लागत और विलंबता नियंत्रित करना: सामग्री जितनी बड़ी, एक-प्रश्न-एक-अनुरोध उतना ही बेकार का खर्च
और आप नहीं चाहते:
- कुछ प्रश्नों के token बचाने के लिए अनुरोधों को श्रृंखला में तोड़ना, सामग्री N बार दोबारा भेजना
- "पहले कौन सा प्रश्न, जवाब मिलने पर कौन सा प्रश्न" वाला स्टेट मशीन बनाए रखना
- अंदाज़ा लगाना कि "प्रश्न जोड़ने से दूसरे जवाब भटकेंगे या नहीं"
🎒 शुरू करने से पहले की तैयारी
- पूरा किया कुशल वर्कफ़्लो: चार आर्किटेक्चर पैटर्न और coding agent का साथ: पता है कि इस पाठ का speculative fan-out चार पैटर्न में पहला है, आगे के पाठ इसी पर टिके हैं
- चला लियापहला अनुरोध:
.venvमेंtypesafe-sdkहै,TYPESAFE_API_KEYपर्यावरण चर में है - मोटे तौर पर याद है Choice, Score, Noul का लिखने का तरीका (भूल गए तो कोई बात नहीं, चरण 1 में पूरा कोड है)
मूल विचार
पहले आधिकारिक primitives दस्तावेज़ के तीन वाक्य याद रखें:
- समानांतर: अनुरोध का हर प्रश्न एक ही state पर समानांतर में मूल्यांकित होता है—प्रश्न जोड़ने से प्रतिक्रिया समय लगभग नहीं बदलता, केवल उन प्रश्नों के प्रश्न token अधिक खर्च होते हैं
- स्वतंत्र: एक प्रश्न का जवाब दूसरे प्रश्न का छिपा संदर्भ नहीं है—प्रश्न जोड़ने या हटाने से दूसरे जवाब नहीं बदलते
- state मुख्य भाग: सामग्री हर अनुरोध का सबसे बड़ा हिस्सा होती है—N सिंगल-प्रश्न अनुरोध सामग्री N बार दोबारा भेजते हैं, बैच पूछने पर केवल एक बार
speculative fan-out की आधिकारिक परिभाषा (TypeSafe fan-out पैटर्न पेज):
सिस्टम को चाहिए वे सभी प्रश्न एक ही अनुरोध में डालें—speculative प्रश्नों सहित—बाद में कोड तय करे कि कौन से प्रासंगिक हैं।
"शायद उपयोग न होने" वाले प्रश्न पहले से पूछने की हिम्मत क्यों? आधिकारिक व्याख्या: सभी प्रश्न समानांतर में मूल्यांकित होते हैं, प्रश्न जोड़ने का प्रतिक्रिया समय पर प्रभाव आमतौर पर बहुत कम होता है; एक ऐसा प्रश्न पूछना जो शायद न चाहिए, लगभग मुफ़्त है।
एक टिकट की पूरी triage प्रक्रिया ऐसी दिखती है (आधिकारिक उदाहरण की संरचना):
support ticket
│ एक अनुरोध: टिकट + 5 प्रश्न
▼
┌──────────────────────────────────────┐
│ category(Choice) │
│ bug_severity(Score) │ समानांतर मूल्यांकन
│ has_reproducible_steps(Noul) │ परस्पर स्वतंत्र
│ refund_requested(Noul) │
│ frustration(Score) │
└──────────────────────────────────────┘
│ एक प्रतिक्रिया: 5 जवाब
▼
आपका कोड: category के अनुसार ब्रांच
जो पढ़ना है पढ़ें, जो काम नहीं आते अनदेखा करेंदोनों तरीकों का अंतर:
| तुलना आयाम | एक-प्रश्न-एक-अनुरोध × 13 | एक अनुरोध में 13 प्रश्न |
|---|---|---|
| आगे-पीछे की संख्या | 13 बार | 1 बार |
| सामग्री token | 13 बार भुगतान | 1 बार भुगतान |
| प्रतिक्रिया समय | 13 खंडों की देरी जोड़ी जाती है | प्रश्न जोड़ने से लगभग कोई बदलाव नहीं |
| “शायद ज़रूरी न हो” वाले प्रश्न | पहले पिछले उत्तर का इंतज़ार करना पड़ता है, तभी पता चलता है कि पूछना है या नहीं | पहले से ही पूछ लें, ज़रूरत न हो तो नज़रअंदाज़ कर दें |
| उत्तर | वही (आधिकारिक परीक्षण) | वही (आधिकारिक परीक्षण) |
सामग्री कैसे दें, state में क्या रखें—यह देखने के लिए State स्थिति वाला पाठ; इस पाठ के सभी प्रश्न एक ही state से पूछे जाते हैं।
मेरे साथ करें
चरण 1: Jev समानांतर प्रश्न पूछने की पहली अनुभूति—5 प्रश्न एक ही अनुरोध में
क्यों: टिकट ट्राइएज आधिकारिक fan-out मोड पेज का उदाहरण परिदृश्य है। असली टिकट में अक्सर एक ही में कई तरह के मामले मिश्रित होते हैं; पहले वर्गीकृत करके फिर “आवश्यकतानुसार पूछने” पर कई बार आगे-पीछे करना पड़ता है; 5 प्रश्न एक ही बार में पूछ लें, एक ही अनुरोध में सब वापस पा लें।
यह आधिकारिक Playground उदाहरण का टिकट है—जानबूझकर मिश्रित: बार-बार शुल्क कटना + लॉगिन न होना + Apple Pay चाहना + अधैर्य। नया fanout_triage.py बनाएँ:
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
ticket = (
"Hi, I placed an order (#98423) last Thursday and was charged twice. "
"I also can't log in after the site update, and adding Apple Pay "
"would be really helpful. This is getting frustrating."
)
questions = {
"category": Choice(
instructions="Determine the broad category of this support ticket",
criteria={
"bug_report": "The user is reporting something that is broken or producing errors",
"billing": "Charges, invoices, refunds, subscriptions",
"feature_request": "The user is requesting new functionality",
"account": "Login, permissions, profile, security",
},
),
"bug_severity": Score(
instructions="How severe is the reported issue",
criteria=[
"Cosmetic; no impact to functionality",
"Broken or degraded feature; workaround exists",
"Blocking issue; no workaround exists",
],
),
"has_reproducible_steps": Noul(
instructions="The user describes specific steps to reproduce the issue"
),
"refund_requested": Noul(
instructions="The user is explicitly asking for a refund or credit"
),
"frustration": Score(
instructions="How frustrated the user appears",
criteria=[
"Calm, matter-of-fact",
"Frustrated but civil",
"Very angry",
],
),
}
with TypeSafeClient() as client:
response = client.system_one(state=ticket, questions=questions)
print(response.answers["category"].choice)
print(response.answers["bug_severity"].score)
print(response.answers["has_reproducible_steps"].noul)
print(response.answers["refund_requested"].noul)
print(response.answers["frustration"].score)टिकट का मूल पाठ, 5 प्रश्न, हर विकल्प का विवरण—सब आधिकारिक Playground उदाहरण का मूल पाठ है, एक शब्द भी नहीं बदला गया।
चलाएँ:
.venv/bin/python fanout_triage.pyआपको यह दिखना चाहिए: पाँच पंक्तियाँ उत्तर। पहली पंक्ति चार श्रेणियों में से एक है; दूसरी और पाँचवीं पंक्ति 0–2 का स्कोर है (दो स्तरों के बीच आ सकता है); तीसरी और चौथी पंक्ति 0–1 की प्रायिकता है। आधिकारिक रूप से इस मिश्रित टिकट के अपेक्षित आँकड़े जारी नहीं किए गए—सटीक आँकड़े आपके वास्तविक रिटर्न पर निर्भर करेंगे, लेकिन 5 उत्तर निश्चित रूप सेएक साथएक ही प्रतिक्रिया में आएँगे।
इनमें से सट्टा प्रश्नों पर ध्यान दें: bug_severity, has_reproducible_steps केवल तब काम आते हैं जब category bug_report हो; refund_requested केवल billing होने पर काम आता है। आधिकारिक NOTE की व्याख्या: सब पहले से पूछ लें, क्योंकि प्रश्न जोड़ने का प्रतिक्रिया समय पर बहुत कम प्रभाव पड़ता है; अगर टिकट अंत में feature request निकला, तो bug severity का परिणाम अप्रासंगिक है, कोड पथ उसे सीधे नज़रअंदाज़ कर देता है।
- एक अनुरोध में 5 उत्तर मिलते हैं, कोड में कोई लूप नहीं, दूसरा कॉल नहीं
चरण 2: कोड से रूटिंग—सट्टे वाले उत्तर जिन्हें नज़रअंदाज़ करना है, कर दें
क्यों: सट्टा fan-out का दूसरा आधा हिस्सा कोड में होता है। मॉडल 5 उत्तर सब वापस दे देता है; “इस पथ पर कौन से उत्तर मान्य हैं” यह आपका if/else तय करता है।
आधिकारिक fan-out मोड पेज का रूटिंग कोड (triage.py जैसा है; हैंडलर फ़ंक्शन आधिकारिक प्लेसहोल्डर नाम हैं, अपने बिज़नेस लॉजिक से बदलें):
category = response.answers["category"]
bug_severity = response.answers["bug_severity"]
bug_repro = response.answers["has_reproducible_steps"]
refund = response.answers["refund_requested"]
frustration = response.answers["frustration"]
if category.choice == "bug_report":
if bug_severity.score > 1.5 and bug_repro.noul > 0.6:
escalate_to_engineering(ticket_id, severity="high")
else:
add_to_bug_backlog(ticket_id)
elif category.choice == "billing":
if refund.noul > 0.7:
route_to_billing_with_flag(ticket_id, refund_likely=True)
else:
route_to_billing(ticket_id)
elif category.choice == "feature_request":
log_feature_request(ticket_id)
# Frustration is useful regardless of category
if frustration.score > 1.5:
flag_for_priority_response(ticket_id)थ्रेशोल्ड तालिका:
| शाखा | गेटिंग शर्त | क्रिया (प्लेसहोल्डर फ़ंक्शन) |
|---|---|---|
| bug_report | severity > 1.5 और repro > 0.6 | इंजीनियरिंग टीम को एस्केलेट |
| bug_report (शेष) | — | bug बैकलॉग में डालें |
| billing | refund > 0.7 | बिलिंग टीम को भेजें और टैग लगाएँ |
| billing (शेष) | — | बिलिंग टीम को भेजें |
| feature_request | — | फ़ीचर अनुरोध दर्ज करें |
| कोई भी श्रेणी | frustration > 1.5 | प्राथमिक प्रतिक्रिया |
तीन बातें पढ़ें:
- कुछ उत्तर पढ़े ही नहीं जाते। category billing में पड़ने पर,
bug_severityका उत्तर कोई नहीं देखता—पूछ लिया, काम न आया, नुकसान भी नहीं, यही सट्टा है - frustration किसी if/elif में नहीं जाता। आधिकारिक टिप्पणी के मूल शब्द: Frustration is useful regardless of category (किसी भी श्रेणी में उपयोगी)—यह सभी शाखाओं के बाहर अलग से एक द्वार है
- पूरा डिसीज़न ट्री केवल एक कॉल में। आधिकारिक सारांश: सट्टा प्रश्न अप्रासंगिक होने पर नज़रअंदाज़ होता है, प्रासंगिक होने पर एक आगे-पीछे बचाता है
आपको यह दिखना चाहिए: category जिस विकल्प में पड़ेगा, कोड उसी शाखा में जाएगा, बाकी शाखाएँ नहीं चलेंगी। केवल प्रवाह देखना हो तो प्लेसहोल्डर फ़ंक्शन को print("escalate") जैसा बना दें। आधिकारिक रूप से इस टिकट का अपेक्षित रूटिंग परिणाम भी जारी नहीं किया गया।
- मैं बता सकता हूँ कि किन दो प्रश्नों के उत्तर billing शाखा में पढ़े नहीं जाते (उत्तर: bug_severity, has_reproducible_steps)
चरण 3: आधिकारिक 13 प्रश्न परीक्षण को दोहराएँ—12.2 गुना सस्ता, 10.0 गुना तेज़
क्यों: “प्रश्न जोड़ने से प्रतिक्रिया समय लगभग नहीं बढ़ता, उत्तर एक-दूसरे को प्रभावित नहीं करते” केवल दावे पर नहीं रहना चाहिए। आधिकारिक Parallel questions cookbook ने एक तुलनात्मक प्रयोग किया, इस चरण में उसकी सेटिंग और परिणाम देखें, और API key के बिना दोबारा चलाने का तरीका दें।
प्रयोग सेटअप:
- सामग्री: GDPR की विकिपीडिया प्रविष्टि, निश्चित संशोधन 1363040264, मापा गया 53,777 अक्षर (लगभग 5.4 万 — यानी लगभग 54 हज़ार)
- 13 प्रश्न: 8 Noul + 2 Choice + 3 Score, कम्प्लायंस टीम द्वारा जाँची जाने वाली 13 बातों को कवर करते हैं
- दो तरीकों से भेजना, हर तरीका 5 बार: एक अनुरोध में 13 प्रश्न बनाम एक प्रश्न प्रति अनुरोध 13 बार; औसत (कोई शिफ़्ट है या नहीं) और स्टैंडर्ड डेविएशन (शोर बढ़ा है या नहीं) की तुलना
- मॉडल jev-1.12, कीमत $0.042/Mtok इनपुट, आउटपुट $0 (2026-09 समयबिंदु)
13 प्रश्न कैसे दिखते हैं? तीन उदाहरण:
| प्रश्न ID | प्रकार | क्या पूछता है |
|---|---|---|
| breach_72h | Noul | क्या व्यक्तिगत डेटा उल्लंघन को नियामक को 72 घंटों के भीतर रिपोर्ट करना अनिवार्य है? |
| instrument_type | Choice | GDPR यूरोपीय संघ के किस प्रकार का कानूनी उपकरण है? (Regulation / Directive / Treaty / Recommendation) |
| compliance_burden | Score | GDPR संगठनों पर कितना भारी कम्प्लायंस बोझ डालता है? (5 स्तरीय पैमाना) |
परिणाम 1: बैच हो या न हो, जवाब नहीं बदलते। 13 प्रश्नों में से 11 (2 Choice + 3 Score + 8 Noul के 6 प्रश्न) 5 दोहरावों में हर बार पूरी तरह समान रहे, दोनों भेजने के तरीकों का स्टैंडर्ड विचलन 0.0 था; बाकी breach_72h और criminal_penalties में थोड़ा रन-टू-रन नॉइज़ था, और नॉइज़ की सीमा के भीतर दोनों तरीकों के माध्य समान रहे। आधिकारिक निष्कर्ष: नॉइज़ समस्या की अपनी विशेषता है, बैचिंग ने उसे नहीं जोड़ा—बैचिंग न तो जवाबों को खिसकाती है, न ही वैरिएंस बढ़ाती है।
परिणाम 2: लागत और समय में 12.2x / 10.0x का अंतर।
| भेजने का तरीका | कॉल की संख्या | लागत | कुल समय |
|---|---|---|---|
| एक अनुरोध में 13 प्रश्न | 1 | $0.000497 | 0.27s |
| 13 अनुरोध, एक प्रश्न प्रति अनुरोध | 13 | $0.006090 | 2.71s |
आधिकारिक स्पष्टीकरण: सिंगल-प्रश्न तरीका 53,777 कैरेक्टर वाली एंट्री को 13 बार दोबारा भेजता है, जबकि बैच पूछने में केवल एक बार जाता है। तालिका का कुल समय 13 सिंगल-प्रश्न लेटेंसियों को जोड़कर बना है (मान लिया गया है कि एक के बाद एक चलते हैं); समानांतर में भेजने से समय का अंतर घट सकता है, लेकिन 13x की token लागत वैसी ही रहती है। दस्तावेज़ जितना बड़ा, बचत उतनी ही 13x के पूरे आंकड़े के करीब।
दोबारा चलाना (API key के बिना):
pip install ipython 'cooksafe>=0.2.0,<0.3.0'फिर आधिकारिक examples रिपॉजिटरी से json_cache.json डाउनलोड करें (github.com/typesafe-ai/typesafe-public-examples/tree/main/cookbooks/parallel_questions), इसे रनिंग डायरेक्टरी में रखें, और cookbook पेज की स्क्रिप्ट के अनुसार चलाएँ।
आपको यह दिखना चाहिए: परिणाम 1 और परिणाम 2 के आंकड़े जस के तस पुनः प्रस्तुत हों—कैश बिल्कुल वही कॉल रिप्ले करता है जो आधिकारिक रूप से मापे गए थे; json_cache.json को हटाने पर ही दोबारा असली रन होता है।
एक छोटा जाल: स्क्रिप्ट शुरू होते समय TYPESAFE_API_KEY एनवायरनमेंट वेरिएबल पढ़ती है, और क्लाइंट के पास key न होने पर सीधे एरर देती है। रिप्ले से पहले एक प्लेसहोल्डर वैल्यू सेट कर दें (जैसे export TYPESAFE_API_KEY=dummy)—कैश हिट वाले कॉल असल में अनुरोध नहीं भेजते, प्लेसहोल्डर key का कोई उपयोग नहीं होता।
💡 जब दो दस्तावेज़ों के आंकड़े आपस में टकराएँ, cookbook को ही मान्य मानें
primitives.md उसी प्रयोग का हवाला देते हुए 11.5x सस्ता और 9.6x तेज़ लिखता है; cookbook का मूल पाठ 12.2x / 10.0x है। इस साइट पर हमेशा cookbook का मूल पाठ अपनाया गया है (12.2x / 10.0x)।
- मैं आधिकारिक माप के तीन निष्कर्ष बता सकता/सकती हूँ: जवाब अपरिवर्तित, 12.2x सस्ता, 10.0x तेज़
चरण 4: असली निर्भरता पहचानना—दूसरा अनुरोध कब भेजना चाहिए
क्यों: Jev समानांतर प्रश्नों की एक कठोर सीमा है: एक ही अनुरोध के प्रश्न एक-दूसरे से स्वतंत्र होते हैं, एक जवाब दूसरे प्रश्न का संदर्भ नहीं बन सकता। तो वह कोड जो «पहले श्रेणी पूछो, जवाब मिलने पर तय करो कि अगला प्रश्न क्या हो»—क्या उसे सच में दो अनुरोधों में तोड़ना चाहिए?
आधिकारिक मानदंड केवल एक है: कोड को पहला जवाब मिले बिना दूसरा अनुरोध बनाना संभव न हो। ठोस रूप में तीन स्थितियाँ:
- जवाब का उपयोग state में और डेटा खींचने के लिए करना हो (जवाब तय करता है कि कहाँ से क्या लेना है)
- जवाब से तय करना हो कि state में क्या-क्या रहेगा
- जवाब से अगले प्रश्न के विकल्प चुनने हों
इन तीनों के बाहर: पहले अनुरोध में ही मिला लें, और जवाब आने पर कोड में जोड़ दें। आधिकारिक मूल शब्द: दो अनुरोध अपवाद हैं, नियम नहीं।
आधिकारिक «असली निर्भरता» के तीन उदाहरण (सभी cookbook से):
| Cookbook | दूसरा अनुरोध क्यों अनिवार्य है |
|---|---|
| Skill suggestion | पहले स्किल कैटलॉग को रैंक करो, शीर्ष तीन की पूरी सामग्री लाओ, फिर बेहतर साक्ष्यों के मुकाबले दोबारा मूल्यांकन करो—रैंकिंग मिले बिना पता ही नहीं कि कौन-सी तीन लानी हैं |
| Structure recovery | पहले पूछो कि हर लाइन-ब्रेक वाक्य काटता है या नहीं, जवाबों के आधार पर पंक्तियों को ब्लॉक में जोड़ो—ब्लॉक पहले अनुरोध के जवाब से पहले अस्तित्व में ही नहीं होते |
| Hierarchical classification | हर स्तर के Choice का जवाब तय करता है कि अगले स्तर के अनुरोध में कौन-से विकल्प दिए जाएँगे |
आखिरी एक मात्रात्मक सवाल—एक बार में आखिर कितने प्रश्न समा सकते हैं?
प्रश्नों की संख्या की कोई ऊपरी सीमा नहीं है। सीमा आकार में है: प्रति अनुरोध 64k, प्रति प्रश्न 32k (दोनों में state शामिल), विवरण के लिए देखेंमॉडल और मूल्य
प्रश्न आम तौर पर state से छोटे होते हैं, दोनों सीमाओं का बड़ा हिस्सा state ही है
वाकई न समाएँ: कई अनुरोधों में तोड़ दें जोएक ही state साझा करें
मेरा हर «दूसरा अनुरोध» तीन मानदंडों में से किसी एक से मेल खाता है, न कि «बाद में पूछना सुरक्षित लगता है» जैसी भावना से
चेकपॉइंट ✅
- एक ही अनुरोध में तीनों प्रश्न-प्रकार मिलाकर चलाना, 5 जवाब ID से अलग-अलग वापस मिलना
- मेरे राउटिंग कोड में «जवाब मिल गया लेकिन पढ़ा नहीं जा रहा» वाली शाखा है
- आधिकारिक माप बता सकता/सकती हूँ: 13 प्रश्न, 12.2x सस्ता, 10.0x तेज़, जवाब अपरिवर्तित
- असली निर्भरता के तीन मानदंड बता सकता/सकती हूँ: state में डेटा खींचना / state की संरचना तय करना / अगले प्रश्न के विकल्प चुनना
- जानता/जानती हूँ कि प्रश्नों की संख्या की कोई ऊपरी सीमा नहीं, सीमा 64k / 32k दो कॉन्टेक्स्ट हैं
खाड़े में गिरने की चेतावनी
❌ एक प्रश्न प्रति अनुरोध (coding agent का सबसे बड़ा प्रभावित क्षेत्र)
आधिकारिक primitives दस्तावेज़ के TIP के मूल शब्द: coding agents इंसानों से ज़्यादा आसानी से «एक प्रश्न प्रति अनुरोध» की आदत में गिरते हैं। TypeSafe Agent Skill इसे खास तौर पर सुधारता है—agent को हर अनुरोध में बहुत सारे प्रश्न रखने के लिए कहता है, जिनमें वे प्रश्न भी शामिल हैं जो केवल कुछ इनपुट के लिए अर्थ रखते हैं।
सही तरीका: एक ही state के सभी प्रश्न एक ही अनुरोध में मिला दें। agent के लिखे कोड की समीक्षा करते समय अगर for लूप में एक बार में एक प्रश्न भेजते दिखे, तो यही बीमारी है।
❌ «शायद काम आएँ» वाले प्रश्नों को दूसरे अनुरोध के लिए छोड़ना
लक्षण: पहले category पूछो, जवाब आने दो, फिर severity / refund वाला अनुरोध भेजो। आधिकारिक smart-home demo इस रास्ते को सीधे «गलत तरीका» कहता है (the wrong way: sequential API calls)—यह प्रश्नों की संख्या न्यूनतम करने के लिए अनुकूलित है, नतीजा एक बैच प्रश्न से कहीं ज़्यादा धीमा और महँगा।
सही तरीका: अटकल-आधारित प्रश्न पहले से पूछ लो। दो प्रश्न बढ़ाना लगभग मुफ़्त है (केवल दो प्रश्नों के token), जबकि बचाया गया एक राउंड-ट्रिप असली पैसा है।
❌ एक instructions में पूरी श्रृंखला के निर्णय ठूँसना
«इस टिकट का विश्लेषण करो और सबसे अच्छा उपचार तय करो» अच्छा प्रश्न नहीं है—System One मॉडल तेज़ और केंद्रित निर्णयों के लिए अनुकूलित है, अच्छा प्रश्न वह है जिस पर कोई विशेषज्ञ एक सेकंड में निर्णय ले सके। जब निर्णय कई कारकों पर निर्भर हो: एक कारक प्रति प्रश्न, और जवाब कोड में भारित रूप से मिलाएँ—यही संयुक्त स्कोरिंग पाठ की मुख्य डिश है।
❌ प्रश्न जोड़ने से डरना, कि «ट्यून किए हुए जवाब भटक जाएँगे»
आधिकारिक माप ने इस बिंदु का खास जवाब दिया: 13 प्रश्नों के जवाब दोनों तरीकों में समान रहे (चरण 3); हर प्रश्न स्वतंत्र रूप से मूल्यांकित होता है, प्रश्न जोड़ने-हटाने से दूसरे जवाब नहीं बदलते। डरना चाहिए प्रश्न की अस्पष्टता से, प्रश्नों की संख्या से नहीं।
उन्नत तकनीकें (वैकल्पिक)
स्पेकुलेटिव फैन-आउट का पूरा प्रोडक्ट रूप देखें। आधिकारिक smart-home demo (वीडियो सहित) पूरे तरीके को आपके सामने चलाकर दिखाता है: एक वाक्य — "पूरे घर की लाइटें बंद कर दो" — जिसके पीछे सवालों की एक लंबी श्रृंखला है: अनुरोध की श्रेणी, लक्ष्य डोमेन, डिवाइस का प्रकार, डिवाइस पर किया जाने वाला कार्रवाई…… इनमें से "लाइट पर क्या कार्रवाई करनी है" यह सवाल तब पहले से ही पूछ लिया जाता है, जब आपको अभी पता ही नहीं होता कि उपयोगकर्ता वाकई लाइट को निर्देश दे रहा है या नहीं। demo यह भी दिखाता है कि TypeSafe और LLM का मेल कैसे चलता है: कंपोजिट अनुरोध का पता चलने पर LLM से उसे एटॉमिक कमांड में तोड़ा जाता है, और आम बातचीत में वापस डायलॉग LLM पर चला जाता है — आधिकारिक कथन के अनुसार, TypeSafe का यह कदम LLM की तुलना में बहुत तेज़ है और पूरे सिस्टम में जो लेटेंसी जोड़ता है वह नगण्य है।
सवाल लिखने से पहले how-to मैनुअल का नंबर 6 एक बार देख लें। आधिकारिक how-to-build-with-system-one मैनुअल「बहुत सारे सवाल पूछो」(Ask a lot of questions) को「हर डॉलर में इंटेलिजेंस」को अधिकतम करने का तरीका बताता है: सवाल समानांतर में मूल्यांकन होते हैं, कोड सिग्नल को कंबाइन करता है, कोई सीरियल राउंड-ट्रिप नहीं जोड़ी जाती।
कोडिंग agent को खुद बदलने दें। अगर आपका agent हमेशा एक सवाल-एक अनुरोध लिखता है, तो TypeSafe Agent Skill इंस्टॉल करें (Claude Code के साथ मिलकर डेवलप करने वाले पाठ में विस्तार से समझाया गया है): इंस्टॉल के बाद, agent द्वारा जनरेट किया गया कॉल कोड खुद-ब-खुद सवालों को अनुरोध में बैच में भरेगा, जिसमें स्पेकुलेटिव वाले भी शामिल हैं।
इस पाठ का सारांश
✅ Jev समानांतर प्रश्न = एक ही state के सभी सवाल एक अनुरोध में: तीन तरह के सवाल मिलाकर भरे जाते हैं, समानांतर में स्वतंत्र मूल्यांकन होते हैं, सवाल जोड़ने से रिस्पॉन्स टाइम लगभग नहीं बढ़ता।
✅ स्पेकुलेटिव फैन-आउट =「शायद ज़रूरी पड़ें」वाले सवाल भी पहले से पूछ लिए जाते हैं; मॉडल सबका जवाब देता है, कोड ब्रांच के आधार पर तय करता है कि कौन-से पढ़ने हैं, कौन-से नज़रअंदाज़ करने हैं।
✅ आधिकारिक वास्तविक परीक्षण का समर्थन: 13 सवालों वाला GDPR नियामक ब्रीफ, एक अनुरोध बनाम 13 अनुरोध — 12.2 गुना सस्ता, 10.0 गुना तेज़, जवाब वही रहते हैं।
✅ सच्ची निर्भरता हो तभी दूसरा अनुरोध भेजें: state में डेटा लाना / state की संरचना तय करना / अगले सवाल के विकल्प चुनना — इन तीन मानदंडों के अलावा बाकी सब बहाने हैं।
✅ संख्या की कोई ऊपरी सीमा नहीं, साइज़ की सीमा है: 64k per-request / 32k per-question; समा न जाए तो कुछ अनुरोध एक ही state साझा कर लें।
मुख्य तथ्यों की त्वरित सूची:
| विषय | मान | स्रोत |
|---|---|---|
| 13 सवालों का वास्तविक परीक्षण | 12.2x सस्ता, 10.0x तेज़, जवाब वही | docs/cookbooks/parallel_questions.md |
| लागत / समय | $0.000497 / 0.27s (बैच) बनाम $0.006090 / 2.71s (13 बार) | वही |
| 13 सवालों की संरचना | 8 Noul + 2 Choice + 3 Score, हर भेजने के तरीके को 5 बार चलाया गया | वही |
| GDPR प्रविष्टि | 53,777 अक्षर, निश्चित संशोधन संस्करण 1363040264 | वही |
| टिकट ट्राइएज 5 सवाल | category (Choice), bug_severity (Score), has_reproducible_steps (Noul), refund_requested (Noul), frustration (Score) | docs/patterns/fan-out.md |
| राउटिंग थ्रेशोल्ड | severity > 1.5 और repro > 0.6 पर एस्केलेट; refund > 0.7 पर टैग; frustration > 1.5 पर प्राथमिक रिस्पॉन्स | वही |
| कॉन्टेक्स्ट सीमा | 64k per-request / 32k per-question, सवालों की संख्या की कोई ऊपरी सीमा नहीं | docs/models.md, docs/primitives.md |
नोट: primitives.md वास्तविक परीक्षण का हवाला देते समय 11.5x / 9.6x लिखता है, cookbook के मूल पाठ 12.2x / 10.0x को ही मान्य मानें।
अगले पाठ की झलक
एक अनुरोध से जवाबों का एक बैच मिलने के बाद, अगला विषय है「जवाबों का उपयोग कैसे करें」: अगला पाठ स्मार्ट राउटिंग: इंटेंट क्लासिफिकेशन के साथ कॉन्फिडेंस गेटिंग।
आप सीखेंगे:
- Choice से इंटेंट क्लासिफाई करना, Score से जटिलता आँकना, एक ही अनुरोध में समानांतर रूप से दोनों पाना
- ऑटोमेशन को ब्रेक लगाना: confidence थ्रेशोल्ड से कम हो तो पहले मानव को भेजें, थ्रेशोल्ड पार होने पर फिर डिस्पैच करें
- थ्रेशोल्ड जोखिम के साथ स्केल करता है: बैलेंस देखने पर 0.6 पर छोड़ दें, ट्रांसफर मंज़ूर करने के लिए 0.85 या उससे ऊपर चाहिए