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 को Anthropic Console (platform.claude.com) में manage किया जाता है। साइन अप करें और फिर Settings → API Keys के अंतर्गत एक key बनाएँ (docs सीधे platform.claude.com/settings/keys पर लिंक करते हैं)। Key केवल एक बार दिखाई जाती है, यह sk-ant- से शुरू होती है, और इसे दोबारा प्राप्त नहीं किया जा सकता है। इसे तुरंत कॉपी करें या फिर डिलीट करके नई key जारी करें।

पैसे के बारे में: जुलाई 2026 तक API के लिए कोई निरंतर free tier उपलब्ध नहीं है। Anthropic के pricing docs के अनुसार, नए users को test करने के लिए थोड़ी मात्रा में free credits मिलते हैं। सटीक राशि वही है जो साइन अप के समय Console आपको दिखाता है, और एक बार यह समाप्त हो जाने पर, requests सफल होने से पहले आपको account में funds जमा करने होंगे। यह claude.ai subscription से अलग है; Pro या Max plan में API credit शामिल नहीं होता है, और API key आपको chat app का access नहीं देती है। यदि आप subscription और API के बीच तुलना कर रहे हैं, तो यह trade-off अपने आप में एक अलग विषय है: आपको वास्तव में किस Claude plan की आवश्यकता है।

Key को किसी एक project या server तक सीमित रखें। जब कोई key 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-4-8",
    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) का मुख्य हिस्सा हैं। पहला, बिना किसी आर्गुमेंट के anthropic.Anthropic() का उपयोग करना, जो की (key) को एनवायरनमेंट से पढ़ता है; इसे कभी भी स्ट्रिंग लिटरल के रूप में पास न करें। दूसरा, response.content एक कंटेंट ब्लॉक्स की सूची है, न कि कोई स्ट्रिंग। यदि आप इसे सीधे प्रिंट करेंगे, तो आपको पहली बार उपयोग करने वालों वाला क्लासिक आउटपुट मिलेगा:

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

यह कोई बग नहीं है; यह ऑब्जेक्ट का repr है। रिस्पॉन्स में कई ब्लॉक प्रकार (टेक्स्ट, टूल कॉल, थिंकिंग) हो सकते हैं, इसलिए आप लूप चलाएं और .text को एक्सेस करने से पहले block.type == "text" की जांच करें। पहले दिन ही इस लूप को सेट कर लें, तो "यह कचरा प्रिंट कर रहा है" जैसी उलझन कभी नहीं होगी।

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

वास्तविक टूल: व्याख्या

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

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

MODEL = "claude-opus-4-8"

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=1500,
            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 वैल्यू को अस्वीकार कर देगा। यदि आपको बाद में असेंबल किया हुआ ऑब्जेक्ट चाहिए, तो with ब्लॉक के अंदर stream.get_final_message() को कॉल करें।

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

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

यह विषय एक अलग अनुभाग का हकदार है क्योंकि API में आपके द्वारा कॉन्फ़िगर की गई सीमा के अलावा कोई इन-बिल्ट मासिक कैप नहीं है, और यहाँ की गई हर गलती चुपचाप लागत बढ़ाती है।

max_tokens आपकी प्रति-कॉल खर्च की सीमा है। आउटपुट टोकन महंगे होते हैं; Opus 4.8 पर, ये इनपुट मूल्य से पाँच गुना अधिक हैं, और max_tokens एक सख्त सीमा है कि मॉडल कितने टोकन उत्पन्न कर सकता है। एक अनियंत्रित प्रॉम्प्ट आपके द्वारा निर्धारित सीमा से अधिक आउटपुट लागत नहीं बढ़ा सकता। इसे कार्य के अनुसार आकार दें: लॉग डायग्नोसिस के लिए 1,500 पर्याप्त है; एक वर्गीकरण कार्य के लिए 100 की आवश्यकता होती है। यदि प्रतिक्रियाएँ stop_reason: "max_tokens" के साथ बीच में ही रुक जाती हैं, तो आपने इसे बहुत कम रखा है; इसे सोच-समझकर बढ़ाएँ, न कि डिफ़ॉल्ट रूप से बहुत बड़ा कर दें।

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

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

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

कार्य के अनुसार मॉडल चुनें, निष्ठा के अनुसार नहीं। जुलाई 2026 तक, Opus 4.8 (claude-opus-4-8) की कीमत $5 प्रति मिलियन इनपुट टोकन और $25 प्रति मिलियन आउटपुट टोकन है; Haiku 4.5 (claude-haiku-4-5) की कीमत 200K संदर्भ के साथ $1/$5 है; Sonnet 5 (claude-sonnet-5) इनके बीच में $3/$15 पर है, जिसमें 31 अगस्त, 2026 तक $2/$10 की प्रारंभिक कीमत है। स्पष्ट रूप से: 500-टोकन उत्तर के साथ 2,000-टोकन लॉग अंश की लागत Opus पर लगभग $0.0225 और Haiku पर $0.0045 आती है। जब आप आउटपुट गुणवत्ता का आकलन कर रहे हों तो Opus से शुरुआत करें, फिर उन्हीं प्रॉम्प्ट्स को Haiku पर आज़माएँ; उच्च-मात्रा, सरल परिवर्तनों के लिए यह अक्सर पाँचवें हिस्से की कीमत पर समान परिणाम देता है। बजट में इनमें से किसी को भी हार्ड-कोड करने से पहले मूल्य निर्धारण पृष्ठ पर वर्तमान संख्याओं को सत्यापित करें।

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

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

response = client.messages.create(
    model="claude-opus-4-8",
    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

कैश राइट्स की लागत इनपुट मूल्य का लगभग 1.25x है, और कैश रीड्स की 0.1x, 5-मिनट के TTL पर, इसलिए विंडो के भीतर दूसरी कॉल पहली कॉल की लागत को कवर कर लेती है। दो बातें ध्यान रखें। कैश किए गए प्रीफ़िक्स को प्रति-मॉडल न्यूनतम सीमा पार करनी चाहिए, Opus पर यह कुछ हजार टोकन है, इसलिए एक छोटा सिस्टम प्रॉम्प्ट चुपचाप कैश नहीं होगा। और यदि समान कॉल्स के दौरान 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 कर दिया था।

मॉडल के नाम में टाइपो के कारण 404 एरर। इसका सबसे सामान्य कारण वर्तमान मॉडल ID के साथ date-suffix जोड़ना है:

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

वर्तमान पीढ़ी की IDs बिल्कुल वैसे ही हैं जैसे लिखी गई हैं, जैसे claude-opus-4-8, claude-haiku-4-5, claude-sonnet-5। इन्हें models documentation से कॉपी करें, कभी भी याददाश्त या पुराने ट्यूटोरियल से न लिखें।

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

यह टेक्स्ट के बजाय ऑब्जेक्ट प्रिंट करता है। आउटपुट [TextBlock(citations=None, text='...', type='text')] जैसा दिखता है। आपने .text को उन ब्लॉक्स से पढ़ने और iterate करने के बजाय 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) पर पहुँच गया है। यह डिज़ाइन के अनुसार काम कर रहा है; जानबूझकर सीमा बढ़ाएं।

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

FAQ

Claude API को आज़माने की लागत कितनी है?

इस तरह के टूल के लिए यह बहुत कम है। जुलाई 2026 तक, Opus 4.8 की कीमत $5 प्रति दस लाख इनपुट टोकन और $25 प्रति दस लाख आउटपुट टोकन है। इसलिए, एक सामान्य लॉग डायग्नोसिस, जिसमें कुछ हजार टोकन इनपुट और कुछ सौ टोकन आउटपुट होते हैं, लगभग दो सेंट का पड़ता है। Haiku 4.5 ($1/$5) पर यह आधा सेंट से भी कम है। दैनिक डाइजेस्ट के एक महीने का खर्च एक कॉफी से भी कम है। जोखिम प्रति-कॉल कीमत में नहीं है; यह असीमित लूप और असीमित max_tokens में है, इसीलिए इस गाइड में दोनों को स्पष्ट रूप से सेट किया गया है।

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

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

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

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

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

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