PricingLoginStart free
Claude Architect · पाठ

पूरा इतिहास आवश्यक है

हर अनुरोध में पूरी बातचीत शामिल होती है।

पाठ 1, कुल 4 में से13 चरण

पूरा इतिहास आवश्यक है, CoddyKit पर Claude Architect का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह Claude Architect सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Claude Architect पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

Model कोई state नहीं रखता

Claude API के बारे में सबसे महत्वपूर्ण तथ्य यह है: model stateless है। Requests के बीच उसे कुछ याद नहीं रहता। Anthropic की ओर कोई छिपी हुई session नहीं होती जिसमें आपके पिछले turns सुरक्षित हों।

जब भी आप API को call करते हैं, messages array में पूरी conversation history भेजते हैं। यदि कोई तथ्य उस array में नहीं है, तो model उसे नहीं जानता — भले ही तीस सेकंड पहले उसने आपको वही तथ्य बताया हो।

Claude Certified Architect के रूप में इस बात को आत्मसात करने से आप हर multi-turn system, agentic loop और multi-agent handoff को design करने का तरीका बदल देते हैं।

Request की बनावट

Claude API request में fields का एक निश्चित समूह होता है। हर turn में आप जिन fields का उपयोग करेंगे, वे हैं:

  • model — किस Claude model को call करना है
  • max_tokens — output का बजट
  • system — system prompt (निर्देश, persona, नियम)
  • messages — role/content objects के array के रूप में पूरी conversation history
  • tools और tool_choice — वैकल्पिक tool definitions और चयन नियंत्रण

ध्यान दें कि यहाँ क्या NOT है: किसी भी प्रकार का conversation ID या session token। State पूरी तरह उसी चीज़ में रहती है जिसे आप दोबारा भेजते हैं।

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    system="You are a concise travel assistant.",
    messages=[
        {"role": "user", "content": "I want to visit Japan in spring."}
    ],
)

History array बनाना

Conversation जारी रखने के लिए आप किसी session को 'reply' नहीं करते — model के पिछले उत्तर और नए user turn को उसी messages list में append करते हैं, फिर पूरी list दोबारा भेजते हैं।

तरीका यह है: पिछले turn की messages लें, assistant का response जोड़ें, नया user message जोड़ें और फिर call करें। हर exchange के साथ array बढ़ता जाता है।

messages = [
    {"role": "user", "content": "I want to visit Japan in spring."},
    {"role": "assistant", "content": "Great — cherry blossom season peaks in early April."},
    {"role": "user", "content": "What about the weather then?"},
]

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    messages=messages,  # full history, every turn
)

यदि आप भूल जाएँ तो क्या होता है

मान लीजिए कि आप केवल नवीनतम user message — "What about the weather then?" — भेजते हैं और पहले के turns हटा देते हैं। Model को बिल्कुल पता नहीं होगा कि 'then' किसके लिए है या Japan का कभी उल्लेख हुआ था।

वह या तो clarification माँगेगा या कोई context गढ़ लेगा। यह 'the bot forgot what we were talking about' जैसी समस्याओं का सबसे सामान्य कारण है। इसका समाधान कभी कोई prompt trick नहीं होता — पूरी history को दोबारा भेजना ही समाधान है।

Tool results भी history का हिस्सा हैं

History में केवल user और assistant का text नहीं होता। जब model किसी tool को call करता है, तो conversation संरचित turns के साथ आगे बढ़ती है:

  • tool_use block वाला assistant turn
  • मिलते-जुलते tool_result वाला user turn

आपको tool result को messages में वापस append करके सब कुछ दोबारा भेजना होगा। Model tool का output केवल इसलिए 'देख' पाता है क्योंकि अब वह आपके आगे ले जाए जाने वाले history का हिस्सा है।

messages.append({"role": "assistant", "content": response.content})  # has tool_use
messages.append({
    "role": "user",
    "content": [{
        "type": "tool_result",
        "tool_use_id": tool_use_id,
        "content": "Tokyo, April: ~15C, mild, occasional rain.",
    }],
})

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=tools,
    messages=messages,  # history now includes the tool_result
)

Agentic loop history को साथ लेकर चलता है

इसीलिए agentic loop इस तरह काम करता है। हर iteration में request भेजें, stop_reason देखें, और यदि वह tool_use हो, तो tools चलाएँ, results को history में append करें और फिर loop चलाएँ — जब तक कि stop_reason end_turn न हो जाए।

यह loop मूल रूप से history जमा करने वाला loop है। इसे stop_reason पर समाप्त करें, text में 'done' जैसे शब्द खोजकर NEVER। iteration cap सुरक्षा-जाल है, प्राथमिक stop mechanism नहीं।

while True:
    response = client.messages.create(
        model="claude-sonnet-4-5", max_tokens=1024,
        tools=tools, messages=messages,
    )
    if response.stop_reason == "tool_use":
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": run_tools(response)})
        continue  # resend the FULL grown history
    break  # end_turn -> done

Subagents history प्राप्त नहीं करते

यह multi-agent व्यवस्था का सामान्य जाल है। hub-and-spoke system में coordinator, Task calls के ज़रिए subagents को काम सौंपता है। लेकिन subagent को नई conversation मिलती है — उसे coordinator की message history NOT मिलती।

यदि subagent को customer का ID, order number या कोई पिछली finding चाहिए, तो coordinator को उसे subagent के prompt के भीतर स्पष्ट रूप से भेजना होगा। विरासत में history मिलने की धारणा निश्चित विफलता है: subagent बिना संदर्भ के काम करता है।

Context स्पष्ट रूप से भेजना

क्योंकि state साझा नहीं होती, coordinator के काम में हर delegation के लिए सही context तैयार करना भी शामिल है। Subagent को काम करने के लिए जितना आवश्यक हो उतना ही दें — उससे अधिक नहीं (least privilege का सिद्धांत context पर भी लागू होता है)।

एक response में कई Task calls parallel चलती हैं और हर call अपने-आप में पूर्ण brief होती है। हर subagent prompt को पूर्ण, स्वतंत्र request मानें।

subagent_prompt = f"""
You are researching flight options.
Context (you have no other history):
- Destination: Tokyo, Japan
- Travel window: early April 2026
- Origin: Istanbul (IST)
Return the 3 cheapest round-trip options with dates and prices.
"""
# Coordinator allowedTools must include "Task".
# Subagent starts with a blank message history -> context must be inline.

History बढ़ती है — और लागत भी

सब कुछ दोबारा भेजने का एक परिणाम है: हर turn पूरी history को फिर से tokenize करता है। लंबी conversations का अर्थ है बड़ी, धीमी और महँगी requests, और अंततः context window भर जाती है।

Architect-स्तर के reliability कार्य में इस वृद्धि को fidelity खोए बिना संभालना शामिल है:

  • Append करने से पहले विस्तृत tool output को केवल प्रासंगिक fields तक सीमित करें।
  • क्रमिक सार-संक्षेपण पुराने turns को संक्षिप्त करता है — लेकिन सावधान रहें: इससे numbers, percentages और dates अस्पष्ट हो जाते हैं।

लेन-देन संबंधी तथ्यों को ज्यों का त्यों रखें

अस्पष्ट summaries का समाधान है: order IDs, amounts, dates और verified identities जैसे ठोस तथ्यों को एक अलग 'case facts' block में ज्यों का त्यों रखें, summary के बाहर। बातचीत का सार दें, numbers का कभी नहीं।

lost-in-the-middle का भी ध्यान रखें: models context की शुरुआत और अंत पर सबसे अधिक ध्यान देते हैं। सबसे महत्वपूर्ण facts और वर्तमान instruction ऐसी जगह रखें जहाँ वे दिखाई दें, न कि लंबी history के बीच दबे रहें।

messages = [
    {"role": "user", "content":
        "CASE FACTS (verbatim):\n"
        "- Order #A-4471, total $129.00, placed 2026-03-02\n"
        "- Customer verified: ID CUST-8830\n\n"
        "CONVERSATION SUMMARY:\n"
        "Customer reported a late delivery and requested options."
    },
    {"role": "user", "content": "Now: can you process a partial refund?"},
]

Sessions फिर शुरू होती हैं — Tool results पुराने हो सकते हैं

Claude Code sessions के बीच history को सुरक्षित रखता है: --resume <name> किसी नामित session को जारी रखता है और fork_session किसी साझा बिंदु से शाखा बनाता है। यह सुविधाजनक है — लेकिन परीक्षा के लिए याद रखने योग्य सावधानी है।

यदि codebase तब से बदल चुका हो, तो फिर शुरू की गई session के tool results पुराने हो सकते हैं। पुरानी history को आगे ले जाना हमेशा सही नहीं होता; कभी-कभी साफ़, संरचित summary के साथ शुरू की गई नई session, पुराने context को दोहराने से बेहतर होती है।

# Continue a prior named session (history reloaded)
claude --resume refactor-auth

# Branch from a shared point without polluting the original
# fork_session -> new line of exploration from the same base

त्वरित जाँच: भुलक्कड़ subagent

यह एक ऐसा परिदृश्य है जो इस lesson के मूल निर्णय की जाँच करता है।

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: पूरी history आवश्यक है

परीक्षा और वास्तविक systems के लिए इन बातों को पक्का याद रखें:

  • Model stateless है; हर request में पूरी messages history होनी चाहिए।
  • Tool calls history बढ़ाती हैं — हर tool_result को append करें और सब कुछ दोबारा भेजें।
  • Agentic loop history जमा करने वाला loop है; parsed text पर नहीं, stop_reason पर रुकें।
  • Subagents coordinator की history प्राप्त NOT करते — हर prompt में सारा context स्पष्ट रूप से भेजें।
  • History बढ़ती है: विस्तृत tool output सीमित करें, पुराने turns का सारांश बनाएँ, लेकिन लेन-देन संबंधी facts ज्यों के त्यों रखें और lost-in-the-middle का ध्यान रखें।
  • फिर शुरू की गई sessions में पुराने tool results आ सकते हैं — कभी-कभी साफ़ summary वाली नई session बेहतर होती है।
शुरुआत निःशुल्क

एआई शिक्षक के साथ Python सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
26
पाठ
104
निःशुल्क सीखना शुरू करेंपूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “पूरा इतिहास आवश्यक है” पाठ निःशुल्क है?

हाँ — Claude Architect अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “पूरा इतिहास आवश्यक है” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। Claude Architect पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“पूरा इतिहास आवश्यक है” में मैं क्या सीखूँगा?

हर अनुरोध में पूरी बातचीत शामिल होती है। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Claude Architect का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या Claude Architect शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Claude Architect शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“पूरा इतिहास आवश्यक है” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Claude Architect पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Claude Architect पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. पूरा इतिहास आवश्यक है
  2. क्रमिक सारांश के जोखिम
  3. बीच में खो जाने का प्रभाव
  4. केस-तथ्य ब्लॉक और आउटपुट छोटा करना
← Claude Architect पर वापस जाएँ