Claude API ट्यूटोरियल: VPS पर पहला ऐप बनाएँ

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

एक नए Ubuntu 24.04 VPS पर चलने वाला कमांड-लाइन टूल, जिसमें आप कोई एरर मैसेज या लॉग का टुकड़ा pipe करते हैं और बदले में सीधी-सादी भाषा में उसका निदान पाते हैं: journalctl -u nginx -n 50 | explain। यह कोई साठ लाइन का Python है, और असली Claude API एप्लिकेशन को जो कुछ चाहिए, सब आज़मा लेता है: ठीक से सहेजी गई एक कुंजी, एक virtualenv, SDK के रिस्पॉन्स का ढाँचा, स्ट्रीमिंग, टाइप्ड एक्सेप्शन की शृंखला, और एक systemd यूनिट ताकि यह आपके बिना भी चलता रहे।

यह प्रोजेक्ट मैंने जान-बूझकर चुना है। “पहला API ऐप” वाले ज़्यादातर ट्यूटोरियल आपसे एक चैटबॉट बनवाते हैं, जिसे आप दोबारा कभी नहीं खोलेंगे। एक लॉग एक्सप्लेनर सर्वर पर पहले ही दिन से अपनी क़ीमत वसूल कर देता है, और आपको उन दो चीज़ों से गुज़ारता है जिनमें शुरुआती लोग सचमुच चूकते हैं: रिस्पॉन्स ऑब्जेक्ट को सही तरीक़े से पढ़ना, और ख़र्च पर क़ाबू रखना। API टोकन के हिसाब से पैसे लेता है, और आपकी तय की गई सीमाओं के अलावा उस पर कोई छत नहीं है। इसलिए यहाँ लागत नियंत्रण डिज़ाइन का हिस्सा है, बाद में जोड़ी जाने वाली चीज़ नहीं। यही अनुशासन आगे भी काम आता है, जब आप इसी VPS पर tmux में Claude Code चलाना शुरू करते हैं।

Console से API कुंजी लें

API का एक्सेस Anthropic Console से चलता है, जो platform.claude.com पर है। साइन अप करें, फिर Settings → API Keys में जाकर एक कुंजी बनाएँ (दस्तावेज़ सीधे platform.claude.com/settings/keys पर ले जाते हैं)। कुंजी सिर्फ़ एक बार दिखती है, sk-ant- से शुरू होती है, और दोबारा नहीं मिलती। उसे तुरंत कॉपी करें, वरना उसे डिलीट करके नई जारी करनी पड़ेगी।

पैसे की बात: जुलाई 2026 तक API के लिए कोई लगातार चलने वाला फ़्री टियर नहीं है। Anthropic के प्राइसिंग दस्तावेज़ कहते हैं कि नए यूज़र्स को आज़माने के लिए थोड़े-से मुफ़्त क्रेडिट मिलते हैं; रक़म कितनी है, यह साइन अप के समय Console ही आपको दिखाता है, और वह ख़त्म होते ही, जब तक अकाउंट में पैसे न डालें, कोई रिक्वेस्ट कामयाब नहीं होगी। यह claude.ai के सब्सक्रिप्शन से अलग चीज़ है: Pro या Max प्लान में API क्रेडिट शामिल नहीं होता, और API कुंजी से चैट ऐप नहीं मिलता। सब्सक्रिप्शन और API में से किसे चुनें, यह तय कर रहे हों, तो वह अपने आप में एक अलग विषय है: आपको असल में कौन-सा Claude प्लान चाहिए।

कुंजी एक ही प्रोजेक्ट या सर्वर के दायरे में बनाएँ। कोई कुंजी देर-सबेर लीक होगी ही, और उस वक़्त आप उसे रद्द करना चाहेंगे, बिना अपनी बाक़ी हर चीज़ तोड़े।

कुंजी को .bashrc से बाहर रखें

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

• हर प्रोसेस को वह विरासत में मिलती है। आपके login शेल में export किया गया एनवायरनमेंट वेरिएबल उस हर चीज़ तक पहुँचता है जिसे आप शुरू करते हैं: वेब ऐप, वह क्रैश रिपोर्टर जो मददगार बनकर अपना पूरा एनवायरनमेंट बग रिपोर्ट में उड़ेल देता है, वह phpinfo() पेज जिसे कोई चालू छोड़ गया था। कुंजी के उजागर होने का दायरा बढ़कर “जो कुछ भी यह यूज़र कभी चलाता है” जितना हो जाता है।
• उसे टाइप करना ~/.bash_history में दर्ज हो जाता है। एक बार हाथ से export चला दें, और आपकी कुंजी हमेशा के लिए सादे टेक्स्ट (plaintext) की एक फ़ाइल में बैठ जाती है, और आपकी होम डायरेक्टरी के हर बैकअप में सिंक होती रहती है।
• systemd को जब वह चाहिए, तब वह वहाँ होती ही नहीं। सर्विसें आपकी .bashrc नहीं पढ़तीं, इसलिए यह तरीक़ा ठीक उसी वक़्त नाकाम होता है जब आप स्क्रिप्ट को systemd यूनिट में बदलते हैं। आमतौर पर सुबह 6 बजे एक रहस्यमय 401 की शक्ल में।

सर्वर पर सही तरीक़ा यह है: 600 परमिशन वाली एक समर्पित एनवायरनमेंट फ़ाइल, जिसे सिर्फ़ वही प्रोसेस लोड करे जिसे उसकी ज़रूरत है:

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

कुंजी को एडिटर की swap फ़ाइलों से दूर रखना हो, तो एडिटर के बजाय printf से tee इस्तेमाल करें। तरीक़ा जो भी हो, ls -l /etc/claude-explain.env से जाँच लें कि वह -rw------- दिखाती है और उसका मालिक root है। इंटरैक्टिव शेल को कुंजी हर बार एक wrapper के ज़रिए मिलती है (नीचे देखें), और systemd को EnvironmentFile= के ज़रिए: root विशेषाधिकार छोड़ने से पहले फ़ाइल पढ़ लेता है, इसलिए सर्विस यूज़र को उस पर read एक्सेस की ज़रूरत ही नहीं पड़ती। कुंजी न कोड में आती है, न git में, न ps के आउटपुट में, न शेल हिस्ट्री में।

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

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

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

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

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

मॉडल ID ठीक claude-opus-4-8 ही इस्तेमाल करें। मौजूदा पीढ़ी की ID में कोई तारीख़ नहीं होती। आदतन, या किसी पुरानी ब्लॉग पोस्ट के कहने पर, तारीख़ का suffix जोड़ने से बचें; उससे 404 मिलता है, जिसकी बात नीचे है।

असली टूल: explain

यह रहा पूरा प्रोग्राम, 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 के नाम से सहेजें, फिर एक wrapper जोड़ें जो इंटरैक्टिव इस्तेमाल के लिए कुंजी लोड करे:

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

(या तो wrapper को sudo से चलाना होगा, या env फ़ाइल पर ऐसा कोई ग्रुप देना होगा जिसमें आपका admin यूज़र शामिल है। फ़ाइल को 644 करके ढीला छोड़ने के बजाय इनमें से एक सोच-समझकर चुनें।)

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

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

लागत पर क़ाबू

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

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

भेजने से पहले गिनें। इनपुट पर भी पैसे लगते हैं, और लॉग भारी-भरकम होते हैं। API में गिनती के लिए एक endpoint है, जिसका इस्तेमाल मुफ़्त है (उसकी अपनी रेट लिमिट हैं, मैसेज बनाने वाली सीमाओं से अलग):

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

इसे इसी बचाव के तौर पर लगाएँ कि ग़लती से 2 GB का लॉग टूल में pipe न हो जाए। इसके लिए 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 की क़ीमत पर। ठोस उदाहरण: 2,000 टोकन के लॉग अंश और 500 टोकन के जवाब की लागत Opus पर क़रीब $0.0225 और Haiku पर $0.0045 बैठती है। जब तक आप आउटपुट की गुणवत्ता आँक रहे हों, Opus से शुरू करें, फिर वही प्रॉम्प्ट Haiku पर आज़माएँ: बड़ी मात्रा वाले सीधे-सादे रूपांतरणों में अक्सर फ़र्क़ पकड़ में नहीं आता, और दाम पाँचवाँ हिस्सा होता है। इनमें से कुछ भी बजट में पक्का लिखने से पहले मौजूदा आँकड़े प्राइसिंग पेज पर जाँच लें।

जो काम रुक सकता है, उसे Batches पर डालें। 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.25 गुना है, कैश से पढ़ने की क़रीब 0.1 गुना, और TTL 5 मिनट का। यानी इसी विंडो के भीतर की गई दूसरी कॉल ही पहली की क़ीमत चुका देती है। दो पेच हैं। कैश होने वाले prefix को हर मॉडल के लिए तय एक न्यूनतम आकार पार करना पड़ता है, Opus पर कुछ हज़ार टोकन, इसलिए छोटा सिस्टम प्रॉम्प्ट चुपचाप कैश होता ही नहीं। और अगर एक जैसी कॉल पर भी cache_read_input_tokens शून्य ही रहता है, तो आपके prefix में हर रिक्वेस्ट पर कुछ बदल रहा है (आमतौर पर कोई timestamp)।

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

इसे systemd के तहत चलाएँ

एनवायरनमेंट फ़ाइल वाले अनुशासन का फल यह रहा: एक टाइमर, जो हर सुबह पिछले दिन के एरर का सार बना देता है।

# /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, root के मालिकाना हक़ वाली उस mode-600 फ़ाइल को बिना विशेषाधिकार वाले explain यूज़र में बदलने से पहले पढ़ लेता है, इसलिए प्रोसेस को वेरिएबल मिल जाता है जबकि यूज़र कुंजी वाली फ़ाइल पढ़ नहीं सकता। systemd-journal ग्रुप लॉग तक पहुँच देता है। हाथ से systemctl start चलाकर टेस्ट करें और journalctl -u log-digest.service पढ़ें। किसी टाइपो का पता लगाने के लिए 06:15 का इंतज़ार न करें। जब यह तरीक़ा शेल पाइपलाइन से बड़ा हो जाए, तो कुंजी को env फ़ाइल में रखने वाला यही तरीक़ा उसी मशीन पर चलने वाले Claude से चलने वाले n8n वर्कफ़्लो में भी ज्यों का त्यों काम आता है।

फ़ेल्योर मोड, और वे स्ट्रिंग जो आपको दिखेंगी

काम करती हुई कुंजी पर 401। एक्सेप्शन ऐसा दिखता है:

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

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

मॉडल के नाम की टाइपो से आया 404। इसका सबसे आम रूप यही है कि मौजूदा मॉडल ID के पीछे तारीख़ का suffix जोड़ दिया जाए:

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

मौजूदा पीढ़ी की ID ठीक वैसी ही हैं जैसी लिखी हैं: claude-opus-4-8, claude-haiku-4-5, claude-sonnet-5। इन्हें मॉडल दस्तावेज़ों से कॉपी करें, याददाश्त या किसी पुराने ट्यूटोरियल से कभी नहीं।

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

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

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

कटे हुए जवाब। response.stop_reason == "max_tokens" का मतलब है कि मॉडल बीच सोच में आपकी आउटपुट सीमा से टकरा गया। यह वैसे ही काम कर रहा है जैसा तय है; सीमा सोच-समझकर बढ़ाएँ।

पहला ऐप चलने लगे, तो 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 से कोई ओपन-वेट मॉडल सेल्फ़-होस्ट करें और टोकन के बजाय RAM में क़ीमत चुकाएँ।

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

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

शुरुआत किस Claude मॉडल से करूँ?

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