Claude API का उपयोग करके Python app कैसे बनाएं

आप क्या बना रहे हैं

एक fresh Ubuntu 24.04 VPS पर एक command-line tool, जिसमें आप कोई error message या log का हिस्सा pipe करते हैं और आपको plain-English में diagnosis मिलता है: journalctl -u nginx -n 50 | explain। यह लगभग साठ lines का Python code है, और यह उन सभी चीजों का अभ्यास कराता है जिनकी एक वास्तविक Claude API application को आवश्यकता होती है: एक key जिसे सही तरीके से store किया गया है, एक virtualenv, SDK के response shapes, streaming, typed exception chain, और एक systemd unit ताकि यह आपके बिना चलता रहे।

मैंने जानबूझकर इस project को चुना है। अधिकांश "first API app" tutorials में आपसे एक ऐसा chatbot बनवाया जाता है जिसे आप दोबारा कभी नहीं खोलेंगे। एक log explainer सर्वर पर पहले दिन से ही उपयोगी साबित होता है, और यह आपको उन दो चीजों से गुजरने के लिए मजबूर करता है जिन्हें beginners वास्तव में गलत करते हैं: response object को सही ढंग से पढ़ना, और खर्च को नियंत्रित करना। API प्रति token billing करती है और आपके द्वारा set की गई सीमाओं के अलावा इसकी कोई ऊपरी सीमा नहीं है, इसलिए cost control यहाँ एक design input है, न कि बाद में सोचा जाने वाला विचार। यही अनुशासन तब भी मायने रखता है जब आप इसी VPS पर tmux में Claude Code चलाने की ओर बढ़ते हैं।

Console से API key प्राप्त करें

API access को platform.claude.com पर Anthropic Console में manage किया जाता है। sign up करें, फिर Settings → API Keys के अंतर्गत एक key बनाएँ (docs सीधे platform.claude.com/settings/keys पर लिंक करते हैं)। Console आपसे key का नाम रखने, expiration चुनने और उसे खुद से या service account से लिंक करने के लिए कहेगा; Anthropic production services और किसी भी shared उपयोग के लिए service account keys का सुझाव देता है। key केवल एक बार दिखाई जाती है, sk-ant- से शुरू होती है, और इसे दोबारा प्राप्त नहीं किया जा सकता है। इसे तुरंत copy करें या delete करके दोबारा जारी करें।

पैसे के बारे में: October 2026 तक API के लिए कोई ongoing free tier नहीं है। Anthropic के pricing docs के अनुसार नए users को test करने के लिए थोड़ी मात्रा में free credits मिलते हैं; सही मात्रा वही है जो signup के समय Console आपको दिखाता है, और एक बार यह खत्म हो जाने पर requests सफल होने से पहले आपको account में funds डालने होंगे। यह claude.ai subscription से अलग है, और API key आपको chat app का access नहीं देती है। Pro plan में API credit शामिल नहीं है, लेकिन Max और Team plans में यह शामिल है: October 2026 तक, Max 5x पर $100 प्रति माह और Max 20x पर $200 (Team में $20 प्रति Standard seat और $100 प्रति Premium seat, जो $500 पर capped है), जिसे claude.ai billing settings से Console organization को लिंक करके claim किया जाता है। unused credit प्रत्येक billing cycle के अंत में expire हो जाता है और यह Claude Code को cover नहीं करता है; विवरण Max और Team मासिक API credits कैसे काम करते हैं में हैं। यदि आप subscription बनाम API पर विचार कर रहे हैं, तो वह trade-off अपने आप में एक विषय है: आपको वास्तव में कौन सा Claude plan चाहिए।

key को एक project या server तक सीमित रखें। जब कोई key leak होती है, और लंबे समय में, कोई न कोई leak होगी ही, तो आप उसे अपने बाकी सभी संसाधनों को प्रभावित किए बिना revoke करना चाहेंगे।

Key को .bashrc से बाहर रखें

सहज प्रतिक्रिया export ANTHROPIC_API_KEY=sk-ant-... को ~/.bashrc में डालने की होती है। ऐसा न करें। इससे तीन अलग-अलग समस्याएँ पैदा होती हैं:

• हर process इसे inherit करती है। आपके login shell में export किया गया environment variable आपके द्वारा शुरू की गई हर चीज़ में फैल जाता है, जैसे web app, crash reporter जो अपनी environment को bug report में dump कर देता है, या वह phpinfo() पेज जिसे किसी ने गलती से enabled छोड़ दिया हो। key का exposure surface "इस user द्वारा चलाई जाने वाली हर चीज़" बन जाता है।
• इसे टाइप करने पर यह ~/.bash_history में दर्ज हो जाता है। यदि आप export command को एक बार भी हाथ से run करते हैं, तो आपकी key हमेशा के लिए एक plaintext file में रह जाती है और आपकी home directory के हर backup में sync हो जाती है।
• systemd को इसकी आवश्यकता होने पर यह वहाँ नहीं होता। Services आपकी .bashrc को नहीं पढ़ती हैं, इसलिए जब आप script को unit में बदलते हैं, तो यह तरीका विफल हो जाता है। आमतौर पर यह सुबह 6 बजे एक रहस्यमयी 401 error के रूप में सामने आता है।

सर्वर पर सही तरीका 600 permissions वाली एक समर्पित environment file का उपयोग करना है, जिसे केवल वही process load करे जिसे इसकी आवश्यकता है:

sudo mkdir -p /opt/explain
sudo install -m 600 -o root -g root /dev/null /etc/claude-explain.env
printf 'ANTHROPIC_API_KEY=sk-ant-YOUR-KEY-HERE\n' | sudo tee /etc/claude-explain.env >/dev/null

यदि आप key को editor की swap files से दूर रखना चाहते हैं, तो editor के बजाय printf से tee का उपयोग करें। किसी भी स्थिति में, ls -l /etc/claude-explain.env के साथ verify करें कि यह -rw------- को पढ़ता है और इसका owner root है। Interactive shells को wrapper (नीचे देखें) के माध्यम से प्रति-invocation key मिलती है, और systemd इसे EnvironmentFile= के माध्यम से प्राप्त करता है। root privileges छोड़ने से पहले file को पढ़ लेता है, इसलिए service user को इसे पढ़ने की अनुमति की आवश्यकता नहीं होती। key कभी भी code में, git में, ps output में, या shell history में दिखाई नहीं देती है।

venv में SDK इंस्टॉल करें

Ubuntu 24.04 में Python 3.12 के साथ PEP 668 लागू है, इसलिए सिस्टम इंटरप्रेटर पर सीधे pip install anthropic चलाने से error: externally-managed-environment त्रुटि आती है। यह त्रुटि OS के सही ढंग से काम करने का संकेत है, इसलिए virtualenv का उपयोग करें:

sudo apt update && sudo apt install -y python3-venv
sudo python3 -m venv /opt/explain/venv
sudo /opt/explain/venv/bin/pip install anthropic

सर्वर पर activation ceremony की आवश्यकता नहीं है: सीधे /opt/explain/venv/bin/python को कॉल करने से हमेशा venv के पैकेज का ही उपयोग होता है।

पहली कॉल, और रिस्पॉन्स को सही ढंग से पढ़ना

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY from the environment

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1000,
    messages=[{"role": "user", "content": "Explain what a systemd unit file is in three sentences."}],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

उन बारह लाइनों में दो चीजें API के मानसिक मॉडल (mental model) का मुख्य हिस्सा हैं। पहला, बिना किसी तर्क (argument) के anthropic.Anthropic() का उपयोग करना, जो एनवायरनमेंट से की (key) को पढ़ता है; इसे कभी भी स्ट्रिंग लिटरल के रूप में पास न करें। दूसरा, response.content एक कंटेंट ब्लॉक्स की सूची है, न कि कोई स्ट्रिंग। यदि आप इसे सीधे प्रिंट करेंगे, तो आपको पहली बार इस्तेमाल करने वालों वाला क्लासिक आउटपुट मिलेगा:

[TextBlock(citations=None, text='A systemd unit file is...', type='text')]

यह कोई बग नहीं है; यह ऑब्जेक्ट का repr है। रिस्पॉन्स में कई ब्लॉक प्रकार (टेक्स्ट, टूल कॉल, थिंकिंग) हो सकते हैं, इसलिए आपको .text को छूने से पहले लूप चलाना होगा और block.type == "text" की जांच करनी होगी। Opus 5.5 पर यह पहली कॉल से ही मायने रखता है: थिंकिंग हमेशा ऑन रहती है, इसलिए जब तक मॉडल किसी साधारण अनुरोध पर थिंकिंग को स्किप न करे, सूची एक thinking ब्लॉक के साथ शुरू होती है जिसका टेक्स्ट डिफ़ॉल्ट रूप से खाली होता है, और response.content[0].text आपका उत्तर नहीं होता है। पहले दिन ही उस लूप को सेटअप करें, तो "यह कचरा प्रिंट कर रहा है" जैसी उलझन कभी नहीं होगी।

सटीक मॉडल ID claude-opus-5-5 का उपयोग करें। 4.6 जनरेशन के बाद से, मॉडल ID बिना तारीख के होते हैं और यही बिना तारीख वाला ID ही पिन किया गया स्नैपशॉट है। इसलिए उस पुरानी आदत (या पुराने ब्लॉग पोस्ट) से बचें जो आपको वर्तमान मॉडल में तारीख का सफिक्स जोड़ने के लिए कहती है; ऐसा करने से 404 एरर आता है, जिसके बारे में नीचे बताया गया है। पुराने मॉडल इसके विपरीत काम करते हैं: Haiku 4.5 का कैनोनिकल ID दिनांकित claude-haiku-4-5-20251001 है।

वास्तविक टूल: स्पष्टीकरण

यहाँ पूरा प्रोग्राम है, stdin इनपुट लेता है, डायग्नोसिस को स्ट्रीम करता है, और एरर को हैंडल करता है:

#!/usr/bin/env python3
"""explain: pipe an error or log excerpt in, get a diagnosis out."""
import sys
import anthropic

MODEL = "claude-opus-5-5"

def main() -> int:
    text = sys.stdin.read().strip()
    if not text:
        print("usage: journalctl -u nginx -n 50 | explain", file=sys.stderr)
        return 1

    client = anthropic.Anthropic()
    try:
        with client.messages.stream(
            model=MODEL,
            max_tokens=4096,
            system=(
                "You are a senior Linux sysadmin. The user pipes you server "
                "logs or error output. Name the most likely cause outright, "
                "then give the commands to confirm and fix it. Be terse."
            ),
            messages=[{"role": "user", "content": text}],
        ) as stream:
            for chunk in stream.text_stream:
                print(chunk, end="", flush=True)
        print()
    except anthropic.RateLimitError as e:
        retry_after = e.response.headers.get("retry-after", "60")
        print(f"rate limited; retry in {retry_after}s", file=sys.stderr)
        return 2
    except anthropic.APIStatusError as e:
        print(f"API error {e.status_code}: {e.message}", file=sys.stderr)
        return 2
    except anthropic.APIConnectionError:
        print("network error reaching the API", file=sys.stderr)
        return 2
    return 0

if __name__ == "__main__":
    sys.exit(main())

इसे /opt/explain/explain.py के रूप में सेव करें, फिर एक रैपर जोड़ें जो इंटरैक्टिव उपयोग के लिए की (key) लोड करता है:

sudo tee /usr/local/bin/explain >/dev/null <<'EOF'
#!/bin/sh
set -a; . /etc/claude-explain.env; set +a
exec /opt/explain/venv/bin/python /opt/explain/explain.py "$@"
EOF
sudo chmod 755 /usr/local/bin/explain

(रैपर को sudo के माध्यम से चलना चाहिए या env फ़ाइल में एक ऐसा ग्रुप होना चाहिए जिससे आपका एडमिन यूजर संबंधित हो; फ़ाइल को 644 पर ढीला करने के बजाय जानबूझकर एक विकल्प चुनें।)

स्ट्रीमिंग क्यों। client.messages.stream टोकन को आने के साथ ही प्रिंट करता है, बजाय इसके कि पूरी जनरेशन के लिए चुपचाप बैठा रहे। यह लंबे आउटपुट पर HTTP टाइमआउट से बचाता है; SDK वास्तव में इसी कारण से नॉन-स्ट्रीमिंग कॉल्स पर बहुत बड़े max_tokens मानों को अस्वीकार कर देगा। text_stream केवल उत्तर का टेक्स्ट देता है, और Opus 5.5 पर डिफ़ॉल्ट थिंकिंग डिस्प्ले के साथ कोई भी थिंकिंग टेक्स्ट स्ट्रीम नहीं होता है, इसलिए आउटपुट साफ रहता है। यदि आपको बाद में असेंबल किया हुआ ऑब्जेक्ट चाहिए, तो with ब्लॉक के अंदर stream.get_final_message() को कॉल करें।

वह एक्सेप्शन ऑर्डर क्यों। SDK टाइप्ड एक्सेप्शन रेज़ करता है, सबसे विशिष्ट पहले: RateLimitError एक 429 है और इसमें एक retry-after हेडर होता है जो आपको बताता है कि कितनी देर प्रतीक्षा करनी है; APIStatusError अन्य नॉन-2xx रिस्पॉन्स को कवर करता है (सर्वर-साइड समस्या के लिए e.status_code >= 500 की जाँच करें); APIConnectionError का अर्थ है कि रिक्वेस्ट को कोई रिस्पॉन्स मिला ही नहीं। और इससे पहले कि आप रिट्राई लूप बनाएँ: SDK पहले से ही 429s और 5xx एरर को खुद रिट्राई करता है, डिफ़ॉल्ट रूप से एक्सपोनेंशियल बैकऑफ़ (क्लाइंट पर max_retries) के साथ दो बार। जब तक आपका except चलता है, तब तक रिट्राई समाप्त हो चुके होते हैं, इसलिए CLI में सही कदम रिपोर्ट करना और बाहर निकलना है, न कि स्लीप मोड में जाना और बार-बार रिक्वेस्ट भेजना।

लागत नियंत्रण

यह अनुभाग विशेष ध्यान देने योग्य है क्योंकि API में आपके द्वारा कॉन्फ़िगर की गई सीमा के अलावा कोई अंतर्निहित मासिक कैप (monthly cap) नहीं है, और यहाँ की गई हर गलती चुपचाप लागत बढ़ाती रहती है।

max_tokens आपकी प्रति-कॉल खर्च की सीमा है। आउटपुट टोकन महंगे होते हैं; Opus 5.5 पर, ये इनपुट मूल्य से पांच गुना अधिक हैं, और max_tokens एक हार्ड कैप है कि मॉडल कितने टोकन उत्पन्न कर सकता है। एक अनियंत्रित प्रॉम्प्ट आपके द्वारा निर्धारित सीमा से अधिक आउटपुट लागत नहीं ले सकता। 5.5 मॉडलों पर, यह कैप 'थिंकिंग' (thinking) पर भी लागू होता है: थिंकिंग टोकन max_tokens में गिने जाते हैं और आउटपुट के रूप में बिल किए जाते हैं, भले ही थिंकिंग टेक्स्ट आपको वापस न भेजा जाए। इसे कार्य के अनुसार निर्धारित करें: 4,096 टोकन एक संक्षिप्त लॉग डायग्नोसिस के लिए पर्याप्त हैं; एक वर्गीकरण कार्य (classification task) को बहुत कम की आवश्यकता होती है। यदि प्रतिक्रियाएं stop_reason: "max_tokens" के साथ बीच में ही रुक जाती हैं, तो आपने सीमा बहुत कम रखी है; इसे सोच-समझकर बढ़ाएं (या प्रयास सेटिंग को कम करें ताकि मॉडल कम सोचे), न कि डिफ़ॉल्ट रूप से बहुत बड़ा रखें।

भेजने से पहले गणना करें। इनपुट पर भी खर्च होता है, और लॉग बड़े हो सकते हैं। API में एक काउंटिंग एंडपॉइंट है जो उपयोग करने के लिए निःशुल्क है (इसकी अपनी दर सीमाएं हैं, जो संदेश निर्माण से अलग हैं):

count = client.messages.count_tokens(
    model="claude-opus-5-5",
    messages=[{"role": "user", "content": big_log_text}],
)
print(count.input_tokens)

इसका उपयोग गलती से 2 GB लॉग को टूल के माध्यम से भेजने से बचने के लिए करें, और वही मॉडल पास करें जिसे आप वास्तव में कॉल करेंगे: Claude 4.7 और बाद के मॉडल एक नए टोकेनाइज़र का उपयोग करते हैं जो पुराने Claude मॉडलों की तुलना में समान टेक्स्ट के लिए लगभग 30% अधिक टोकन उत्पन्न करते हैं। इसके लिए tiktoken का उपयोग न करें, वह OpenAI का टोकेनाइज़र है, Claude का नहीं, इसलिए इसकी गणना आपके बिल से मेल नहीं खाएगी।

कार्य के अनुसार मॉडल चुनें, निष्ठा के अनुसार नहीं। अक्टूबर 2026 तक, Opus 5.5 (claude-opus-5-5) की लागत $4 प्रति मिलियन इनपुट टोकन और $20 प्रति मिलियन आउटपुट है; Haiku 5.5 (claude-haiku-5-5) की लागत 100,000 टोकन तक के प्रॉम्प्ट के लिए $0.10/$0.50 (उससे ऊपर $0.50/$2.50) है, जिसमें 1M कॉन्टेक्स्ट मिलता है; Sonnet 5.5 (claude-sonnet-5-5) की लागत $2/$10 के बीच है। संक्षेप में: 500-टोकन उत्तर के साथ 2,000-टोकन लॉग अंश की लागत Opus पर लगभग $0.018 और Haiku पर $0.00045 होती है, साथ ही मॉडल द्वारा की गई कोई भी थिंकिंग, जो आउटपुट के रूप में बिल की जाती है। आउटपुट गुणवत्ता का आकलन करते समय Opus से शुरुआत करें, फिर उन्हीं प्रॉम्प्ट्स को Haiku पर आज़माएं; उच्च-मात्रा, सरल परिवर्तनों के लिए यह अक्सर प्रति-टोकन मूल्य के चालीसवें हिस्से पर समान परिणाम देता है। बजट में कुछ भी हार्ड-कोड करने से पहले मूल्य निर्धारण पृष्ठ पर वर्तमान संख्याओं को सत्यापित करें।

जो काम प्रतीक्षा कर सकते हैं, उनके लिए बैच का उपयोग करें। Batches API अनुरोधों को मानक कीमतों के 50% पर एसिंक्रोनस रूप से संसाधित करता है, और अधिकांश बैच एक घंटे के भीतर पूरे हो जाते हैं। रात्रिकालीन डाइजेस्ट, बैकफ़िल, बल्क वर्गीकरण, या ऐसा कोई भी काम जिसके लिए कोई व्यक्ति प्रतीक्षा नहीं कर रहा है, उसे यहीं रखा जाना चाहिए।

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

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1000,
    system=[{
        "type": "text",
        "text": RUNBOOK_TEXT,  # the same 30K tokens on every call
        "cache_control": {"type": "ephemeral"},
    }],
    messages=[{"role": "user", "content": question}],
)
print(response.usage.cache_read_input_tokens)  # non-zero from the second call on

कैश राइट्स की लागत 5-मिनट TTL पर इनपुट मूल्य का 1.25x है, और कैश रीड्स की लागत Opus 5.5 और Sonnet 5.5 पर 0.05x है (अधिकांश अन्य मॉडलों पर 0.1x), इसलिए विंडो के भीतर दूसरी कॉल पहले ही पहली कॉल की लागत वसूल कर लेती है। दो बातें ध्यान रखें। कैश किए गए प्रीफ़िक्स को प्रति-मॉडल न्यूनतम सीमा पार करनी चाहिए, Opus 5.5 पर 512 टोकन, इसलिए बहुत छोटा सिस्टम प्रॉम्प्ट बिल्कुल भी कैश नहीं होगा। और यदि समान कॉल्स के बीच cache_read_input_tokens शून्य रहता है, तो इसका मतलब है कि आपके प्रीफ़िक्स में हर अनुरोध पर कुछ बदल रहा है (आमतौर पर टाइमस्टैम्प इसका कारण होता है)।

याद रखें कि इनपुट के रूप में क्या गिना जाता है। सिस्टम प्रॉम्प्ट, टूल परिभाषाएं, और मल्टी-टर्न वार्तालापों में, वह पूरा इतिहास जिसे आप हर टर्न पर फिर से भेजते हैं, इनपुट टोकन के रूप में बिल किया जाता है। एक चैट लूप जो इतिहास को कभी ट्रिम नहीं करता है, लागत में द्विघातीय (quadratically) वृद्धि करता है। कुछ भी संवादात्मक बनाने से पहले पूरी अकाउंटिंग को समझना महत्वपूर्ण है: Claude टोकन उपयोग और बिलिंग वास्तव में कैसे जुड़ते हैं।

इसे systemd के अंतर्गत चलाएं

environment-file अनुशासन का लाभ: एक timer जो हर सुबह कल की त्रुटियों का सारांश देता है।

# /etc/systemd/system/log-digest.service
[Unit]
Description=Daily error-log digest via the Claude API

[Service]
Type=oneshot
User=explain
Group=systemd-journal
EnvironmentFile=/etc/claude-explain.env
ExecStart=/bin/sh -c 'journalctl -p err --since yesterday | /opt/explain/venv/bin/python /opt/explain/explain.py >> /var/log/log-digest.txt'

# /etc/systemd/system/log-digest.timer
[Unit]
Description=Run the log digest every morning

[Timer]
OnCalendar=06:15
Persistent=true

[Install]
WantedBy=timers.target

sudo useradd -r -s /usr/sbin/nologin explain
sudo touch /var/log/log-digest.txt && sudo chown explain /var/log/log-digest.txt
sudo systemctl daemon-reload
sudo systemctl enable --now log-digest.timer
sudo systemctl start log-digest.service   # test it once, right now

ध्यान दें कि EnvironmentFile= आपको क्या लाभ देता है: systemd unprivileged explain user पर स्विच करने से पहले root-owned, mode-600 फ़ाइल को पढ़ लेता है। इस प्रकार, process को variable मिल जाता है जबकि user key फ़ाइल को नहीं पढ़ सकता। systemd-journal group लॉग एक्सेस प्रदान करता है। एक manual systemctl start के साथ परीक्षण करें और journalctl -u log-digest.service पढ़ें, किसी typo का पता लगाने के लिए 06:15 तक प्रतीक्षा न करें। जब यह पैटर्न shell pipeline से बड़ा हो जाए, तो यही key-in-env-file दृष्टिकोण सीधे उसी बॉक्स पर Claude-संचालित n8n workflows में उपयोग किया जा सकता है।

विफलता के प्रकार और दिखने वाले स्ट्रिंग्स

काम कर रही key पर 401 एरर। एक्सेप्शन इस प्रकार है:

anthropic.AuthenticationError: Error code: 401 - {'type': 'error', 'error': {'type': 'authentication_error', 'message': 'invalid x-api-key'}, 'request_id': 'req_011CSHoEeqs5C35K2UUqR7Fy'}

यदि key आपके shell में काम करती है लेकिन सर्विस 401 एरर देती है, तो इसका मतलब है कि सर्विस को key प्राप्त नहीं हुई। याद रखें कि systemd .bashrc को नहीं पढ़ता है; जाँचें कि EnvironmentFile= सही path की ओर इशारा कर रहा है। अन्य कारण: env फाइल में पेस्ट किए गए quotes (ANTHROPIC_API_KEY="sk-ant-...", systemd quotes को हटा देता है, लेकिन आपके shell wrapper का . file उन्हें value में ही रखता है यदि आपने अजीब तरह से quote किया हो), trailing whitespace, कोई ऐसी key जिसे आपने पिछले सप्ताह Console में revoke कर दिया हो, या कोई ऐसी key जो आपके द्वारा निर्धारित expiration date तक पहुँच गई हो।

मॉडल के नाम में गलती के कारण 404 एरर। इसका सबसे आम कारण किसी ऐसे मॉडल ID के साथ date-suffix जोड़ना है जिसका कोई dated रूप नहीं है:

anthropic.NotFoundError: Error code: 404 - {'type': 'error', 'error': {'type': 'not_found_error', 'message': 'model: claude-opus-5-5-20260922'}, 'request_id': 'req_011CSJqymAvNw4bT3qmDdMbA'}

वर्तमान पीढ़ी के IDs बिल्कुल वैसे ही हैं जैसे लिखे गए हैं, जैसे claude-opus-5-5, claude-sonnet-5-5, claude-haiku-5-5, claude-fable-5-1। 4.6 पीढ़ी से पहले के मॉडल इसके अपवाद हैं: claude-haiku-4-5, dated ID claude-haiku-4-5-20251001 के लिए एक सुविधा-आधारित alias है, और दोनों रूप काम करते हैं। IDs को हमेशा models documentation से कॉपी करें, कभी भी याददाश्त या किसी पुराने ट्यूटोरियल से न लिखें।

429 rate_limit_error। एरर टाइप स्ट्रिंग rate_limit_error है और रिस्पॉन्स में retry-after हेडर होता है जिसमें प्रतीक्षा करने के लिए सेकंड की संख्या दी होती है। एक्सेप्शन दिखने से पहले SDK पहले ही backoff के साथ दो बार retry कर चुका होता है, इसलिए लगातार 429 एरर का मतलब है कि आपकी sustained rate वास्तव में आपके टियर से अधिक है। काम को batch करें या उसे फैलाएं, retry लूप को और सख्त न करें।

यह टेक्स्ट के बजाय ऑब्जेक्ट प्रिंट करता है। आउटपुट [TextBlock(citations=None, text='...', type='text')] जैसा दिखता है। आपने ब्लॉक्स को iterate करने और उन ब्लॉक्स से .text पढ़ने के बजाय response.content प्रिंट किया है जहाँ block.type == "text" है। ऊपर दिए गए सभी SDK उदाहरण इसे सही तरीके से करते हैं; लूप को कॉपी करें।

error: externally-managed-environment। आपने Ubuntu 24.04 के सिस्टम Python पर pip install चलाया है। venv का उपयोग करें, किसी ऐसे सर्वर पर कभी भी --break-system-packages न चलाएं जिसकी आपको परवाह है।

अधूरे उत्तर (Truncated answers)। response.stop_reason == "max_tokens" का मतलब है कि मॉडल आपके आउटपुट कैप (output cap) तक पहुँच गया है। यह डिज़ाइन के अनुसार काम कर रहा है; कैप को जानबूझकर बढ़ाएं, और याद रखें कि 5.5 मॉडल में 'thinking' उसी कैप से खर्च होती है।

एक बार जब आपका पहला ऐप काम करने लगे, तो Claude के साथ AI एजेंट बनाना उन API कॉल्स को एक ऐसे एजेंट में बदल देता है जो टूल्स का उपयोग करता है।

FAQ

Claude API को आज़माने का खर्च कितना है?

इस तरह के टूल के लिए यह वास्तव में बहुत कम है। अक्टूबर 2026 तक, Opus 5.5 की कीमत 4 डॉलर प्रति दस लाख इनपुट टोकन और 20 डॉलर प्रति दस लाख आउटपुट टोकन है। इसलिए, एक सामान्य लॉग डायग्नोसिस, जिसमें कुछ हजार टोकन इनपुट और कुछ सौ आउटपुट होते हैं, की कीमत थिंकिंग टोकन (जो आउटपुट के रूप में बिल होते हैं) से पहले लगभग दो सेंट होती है। Haiku 5.5 ($0.10/$0.50) पर यह एक सेंट के दसवें हिस्से से भी कम है। दैनिक डाइजेस्ट के एक महीने का खर्च एक कॉफी से भी कम है। जोखिम प्रति-कॉल कीमत नहीं है; बल्कि अनियंत्रित लूप और अनियंत्रित max_tokens हैं, इसीलिए इस गाइड में दोनों को स्पष्ट रूप से सेट किया गया है।

क्या Claude API के लिए कोई फ्री टियर है?

अक्टूबर 2026 तक कोई भी निरंतर फ्री टियर उपलब्ध नहीं है। Anthropic के प्राइसिंग डॉक्यूमेंटेशन के अनुसार, नए उपयोगकर्ताओं को API टेस्ट करने के लिए एक बार का छोटा फ्री क्रेडिट मिलता है। साइनअप के समय Console में सटीक राशि दिखाई जाती है, जिसके बाद आपको अकाउंट में फंड डालना होता है। Max और Team सब्सक्राइबर्स इसके अपवाद हैं: उनके प्लान में मासिक API क्रेडिट शामिल होते हैं, जिनका उल्लेख ऊपर किया गया है। यदि आपका लक्ष्य फ्रंटियर क्वालिटी के बजाय प्रति रिक्वेस्ट शून्य मार्जिनल कॉस्ट है, तो Ollama के साथ open-weight मॉडल को self-host करना और टोकन के बजाय RAM में भुगतान करना एक विकल्प है।

मैं सर्वर पर अपनी API key को सुरक्षित कैसे रखूँ?

इसे कभी भी कोड में न रखें, कभी भी git में न डालें, कभी भी .bashrc से एक्सपोर्ट न करें, और कभी भी ऐसी शेल में टाइप न करें जहाँ history इसे सेव कर ले। इसे root-owned फाइल में 600 अनुमतियों के साथ रखें, इसे प्रति-प्रोसेस लोड करें, इंटरैक्टिव उपयोग के लिए एक रैपर स्क्रिप्ट का उपयोग करें, systemd के लिए EnvironmentFile= का उपयोग करें, और प्रति सर्वर या प्रोजेक्ट एक ही key रखें ताकि लीक हुई key को रद्द करना एक छोटी सर्जरी हो, न कि पूरा अंग काटना। यदि key कभी भी किसी पेस्ट साइट या git कमिट पर चली जाए, तो उसे तुरंत Console में रद्द कर दें; कमिट डिलीट करने से वह लीक होने से नहीं बचती।

मुझे किस Claude मॉडल के साथ शुरुआत करनी चाहिए?

जब आप यह मूल्यांकन कर रहे हों कि क्या आउटपुट निर्माण के लिए पर्याप्त अच्छे हैं, तो claude-opus-5-5 के साथ शुरुआत करें। आप पूर्ण गुणवत्ता पर विचार को परखना चाहते हैं, और हॉबी वॉल्यूम पर लागत का अंतर केवल कुछ सेंट का होता है। एक बार प्रॉम्प्ट सेट हो जाने के बाद, अपने वास्तविक इनपुट को claude-haiku-5-5 पर चलाकर देखें; समराइजेशन, क्लासिफिकेशन और लॉग ट्राइएज के लिए यह अक्सर प्रति-टोकन कीमत के चालीसवें हिस्से पर पर्याप्त अच्छा होता है। Haiku या Sonnet पर जाने का निर्णय माप (measurement) के आधार पर लें, न कि डिफ़ॉल्ट रूप से।