Claude API वापरून VPS वर पहिले App कसे बनवायचे

तुम्ही काय तयार करत आहात

एक नवीन Ubuntu 24.04 VPS वर आधारित command-line tool, ज्यामध्ये तुम्ही error message किंवा log चा तुकडा pipe करू शकता आणि तुम्हाला साध्या इंग्रजीमध्ये निदान मिळेल: journalctl -u nginx -n 50 | explain. हे साधारणतः साठ ओळींचे Python कोड आहे. यामध्ये Claude API ॲप्लिकेशनसाठी आवश्यक असलेल्या सर्व गोष्टींचा सराव होतो — योग्यरित्या साठवलेली key, virtualenv, SDK च्या response shapes, streaming, typed exception chain आणि systemd unit जेणेकरून ते आपोआप चालू शकेल.

मी हा प्रकल्प मुद्दाम निवडला आहे. बहुतेक "first API app" ट्यूटोरियल्समध्ये तुम्हाला असा chatbot बनवला जातो जो तुम्ही पुन्हा कधीच उघडणार नाही. याउलट, log explainer पहिल्या दिवसापासूनच सर्व्हरवर उपयुक्त ठरतो. हे तुम्हाला दोन महत्त्वाच्या गोष्टी शिकवते ज्यामध्ये नवशिक्यांकडून चुका होतात: response object योग्यरित्या वाचणे आणि खर्च नियंत्रित करणे. API द्वारे होणारा खर्च token नुसार असतो आणि तुम्ही ठरवलेल्या मर्यादेव्यतिरिक्त इतर कोणताही ceiling नसतो, त्यामुळे खर्च नियंत्रण हा येथे एक महत्त्वाचा design input आहे — हीच शिस्त याच VPS वर tmux मध्ये Claude Code चालवताना देखील आवश्यक असते.

Console मधून API key मिळवा

API ॲक्सेस platform.claude.com या Anthropic Console मध्ये व्यवस्थापित केला जातो — साइन अप करा, त्यानंतर Settings → API Keys अंतर्गत की (key) तयार करा (डॉक्युमेंटेशन थेट platform.claude.com/settings/keys कडे निर्देश करते). ही की फक्त एकदाच दाखवली जाते, ती sk-ant- ने सुरू होते आणि पुन्हा प्राप्त करता येत नाही — ती लगेच कॉपी करा किंवा ती डिलीट करून पुन्हा तयार करा.

पेमेंटबद्दल: जुलै 2026 पर्यंत API साठी कोणताही चालू फ्री टियर (free tier) उपलब्ध नाही. Anthropic च्या प्राइसिंग डॉक्युमेंटेशननुसार, नवीन वापरकर्त्यांना चाचणीसाठी काही प्रमाणात मोफत क्रेडिट्स मिळतात; नेमकी रक्कम ही साइनअप करताना Console मध्ये जी दिसेल ती असेल, आणि ती संपल्यानंतर विनंत्या (requests) यशस्वी होण्यासाठी तुम्हाला खात्यात पैसे भरायचे लागतील. हे claude.ai सबस्क्रिप्शनपेक्षा वेगळे आहे — Pro किंवा Max प्लॅनमध्ये API क्रेडिट समाविष्ट नसते, आणि API key मुळे तुम्हाला चॅट ॲप मिळत नाही. जर तुम्ही सबस्क्रिप्शन आणि API मधील तुलना करत असाल, तर तो विषय वेगळा आहे: तुम्हाला प्रत्यक्षात कोणता Claude प्लॅन आवश्यक आहे.

की (key) फक्त एका विशिष्ट प्रोजेक्ट किंवा सर्व्हरपुरती मर्यादित (scoped) ठेवा. जेव्हा एखादी की लीक होते — आणि दीर्घकाळात तसे घडणारच आहे — तेव्हा तुमच्या इतर सर्व गोष्टी विस्कळीत न होता तुम्ही ती रद्द (revoke) करू शकाल याची खात्री करा.

.bashrc मधून key सुरक्षित ठेवा

export ANTHROPIC_API_KEY=sk-ant-... मध्ये ~/.bashrc वापरणे चुकीचे आहे. असे करू नका. याची तीन मुख्य कारणे आहेत:

• प्रत्येक process ला ते वारसाहक्काने मिळते. तुमच्या login shell मध्ये export केलेली environment variable सर्व गोष्टींमध्ये पसरते — जसे की web app, bug report मध्ये environment dump करणारा crash reporter, किंवा कोणातरी सुरू ठेवलेली phpinfo() page. यामुळे key ची exposure surface "या user ने चालवलेले सर्व काही" इतकी वाढते.
• ते ~/.bash_history मध्ये साठवले जाते. जर तुम्ही export command हाताने एकदा टाईप केली, तर तुमची key कायमस्वरूपी plaintext file मध्ये राहते आणि तुमच्या home directory च्या प्रत्येक backup मध्ये sync होते.
• systemd ला त्याची गरज असताना ती उपलब्ध नसते. Services तुमच्या .bashrc वाचत नाहीत, त्यामुळे जेव्हा तुम्ही script ला unit म्हणून वापरता, तेव्हा ही पद्धत अपयशी ठरते — सहसा सकाळी 6 वाजता mysterious 401 error च्या स्वरूपात.

server वर योग्य पद्धत म्हणजे 600 permissions असलेली एक समर्पित environment file वापरणे, जी फक्त आवश्यक असलेल्या process द्वारे लोड केली जाते:

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 वापरून ती -rw------- वाचते आणि root कडून owned आहे याची खात्री करा. Interactive shells ला wrapper (खालीलप्रमाणे) द्वारे प्रत्येक invocation वेळी key मिळते, आणि systemd ला ती EnvironmentFile= द्वारे मिळते — root privileges कमी करण्यापूर्वी फाईल वाचतो, त्यामुळे service user ला ती वाचण्याची गरज पडत नाही. key कधीही code मध्ये, git मध्ये, ps output मध्ये किंवा shell history मध्ये दिसत नाही.

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

Ubuntu 24.04 मध्ये Python 3.12 सोबत PEP 668 लागू केले आहे, त्यामुळे system interpreter विरुद्ध थेट 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 ची गरज नाही: /opt/explain/venv/bin/python थेट कॉल केल्यास नेहमी venv मधील packages वापरले जातात.

पहिली कॉल, आणि प्रतिसाद (response) योग्यरित्या वाचणे

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() मध्ये कोणतेही arguments न वापरल्यास की (key) environment मधून वाचली जाते — ती कधीही string literal म्हणून पास करू नका. दुसरे, response.content ही content blocks ची एक list आहे, string नाही. ती थेट print केल्यास तुम्हाला असा सामान्य आउटपुट मिळेल जो नवीन वापरकर्त्यांना दिसतो:

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

ही कोणतीही चूक (bug) नाही; ते त्या object चे repr आहे. प्रतिसादांमध्ये (responses) एकापेक्षा जास्त block types (text, tool calls, thinking) असू शकतात, म्हणून .text वापरण्यापूर्वी तुम्हाला iterate करून block.type == "text" तपासावे लागते. पहिल्याच दिवशी ही loop तयार करून घेतल्यास "it prints garbage" प्रकारचा गोंधळ कधीच होत नाही.

claude-opus-4-8 हा अचूक model ID वापरा. सध्याच्या पिढीचे (current-generation) IDs मध्ये तारीख नसते — date suffix जोडण्याची सवय (किंवा जुने blog posts) टाळा; तसे केल्यास 404 error येईल, ज्याबद्दल खाली माहिती दिली आहे.

प्रत्यक्ष साधन: स्पष्टीकरण

येथे संपूर्ण प्रोग्राम आहे — stdin इनपुट, स्ट्रीम केलेले निदान (diagnosis) आउटपुट आणि त्रुटींचे (errors) व्यवस्थापन:

#!/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) लोड करणारा एक 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 timeouts टाळता येतात — याच कारणामुळे SDK नॉन-स्ट्रीमिंग कॉल्सवर खूप मोठ्या max_tokens व्हॅल्यूज स्वीकारण्यास नकार देते. जर तुम्हाला नंतर पूर्ण ऑब्जेक्ट हवा असेल, तर with ब्लॉकच्या आत stream.get_final_message() कॉल करा.

अपवाद (exception) क्रम असा का आहे. SDK विशिष्ट प्रकारच्या exceptions देते, ज्यात सर्वात विशिष्ट अपवाद आधी येतो: RateLimitError हा 429 एरर आहे आणि त्यात retry-after हेडर असते जे तुम्हाला किती वेळ थांबायचे हे सांगते; APIStatusError इतर सर्व non-2xx रिस्पॉन्स कव्हर करते (सर्व्हर-साइड समस्यांसाठी e.status_code >= 500 तपासा); APIConnectionError म्हणजे विनंतीला (request) कोणताही प्रतिसाद मिळाला नाही. आणि retry loop तयार करण्यापूर्वी: SDK स्वतःच 429 आणि 5xx एरर्ससाठी आधीच retry करते, डिफॉल्टनुसार दोनदा exponential backoff सह (क्लायंटवर max_retries). तुमच्या except च्या रन होईपर्यंत, सर्व retries संपलेले असतात — त्यामुळे CLI मध्ये योग्य पाऊल म्हणजे एरर रिपोर्ट करून बाहेर पडणे, थांबून पुन्हा पुन्हा प्रयत्न करणे नव्हे.

Cost control

या विषयासाठी स्वतंत्र विभाग आवश्यक आहे, कारण तुम्ही कॉन्फिगर केलेल्या मर्यादेव्यतिरिक्त API मध्ये कोणतीही अंगभूत (built-in) मासिक मर्यादा नाही. येथे झालेली प्रत्येक चूक खर्च वाढवू शकते.

max_tokens ही तुमच्या प्रति-कॉल खर्चाची मर्यादा आहे. Output tokens महाग असतात — Opus 4.8 वर, हे input किमतीपेक्षा पाचपट जास्त आहेत — आणि max_tokens ही मॉडेल किती tokens तयार करू शकते याची कडक मर्यादा आहे. एखादा मोठा prompt मुळे तुम्ही ठरवलेल्या मर्यादेपेक्षा जास्त output खर्च होऊ शकत नाही. कामाच्या स्वरूपानुसार ही मर्यादा ठरवा: log diagnosis साठी 1,500 पुरेसे आहेत; classification task साठी 100 लागतात. जर stop_reason: "max_tokens" मुळे प्रतिसाद अर्धवट थांबत असतील, तर तुमची मर्यादा खूप कमी आहे — मोठी मर्यादा ठेवण्याऐवजी ती विचारपूर्वक वाढवा.

पाठवण्यापूर्वी मोजणी करा. Input साठी देखील पैसे लागतात आणि logs आकाराने मोठे असतात. API मध्ये एक counting endpoint आहे जे वापरण्यासाठी मोफत आहे (त्याच्या स्वतःच्या rate limits आहेत, ज्या message creation पासून वेगळ्या आहेत):

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

2 GB चा log चुकून टूलमधून पाठवण्यापासून वाचण्यासाठी याचा वापर करा. यासाठी tiktoken वापरू नका — ते OpenAI चे tokenizer आहे, आणि ते सामान्य मजकुरासाठी Claude tokens ची गणना साधारणपणे 15–20% कमी करते, आणि code साठी त्यापेक्षाही जास्त कमी करते.

निष्ठा (loyalty) न पाहता कामाच्या स्वरूपानुसार मॉडेल निवडा. July 2026 पर्यंत, Opus 4.8 (claude-opus-4-8) $5 per million input tokens आणि $25 per million output दराने चालते; Haiku 4.5 (claude-haiku-4-5) $1/$5 दराने 200K context सह उपलब्ध आहे; Sonnet 5 (claude-sonnet-5) $3/$15 दराने उपलब्ध आहे, आणि 31 August 2026 पर्यंत $2/$10 ही introductory किंमत आहे. उदाहरणार्थ: 500-token उत्तरासह 2,000-token चा log excerpt Opus वर सुमारे $0.0225 आणि Haiku वर $0.0045 खर्च होतो. आउटपुटची गुणवत्ता तपासत असताना Opus पासून सुरुवात करा, त्यानंतर तेच prompts Haiku वर वापरून पहा — मोठ्या प्रमाणात होणाऱ्या साध्या transformations साठी, पाचव्या किमतीत ते अनेकदा सारखेच परिणाम देते. बजेटमध्ये या किमती कायम करण्यापूर्वी pricing page वर सध्याचे आकडे तपासा.

ज्या गोष्टी थांबवता येतील त्यांच्यासाठी Batches वापरा. Batches API प्रमाणित किमतींच्या 50% दराने requests asynchronously प्रोसेस करते आणि बहुतेक batches एक तासाच्या आत पूर्ण होतात. रात्रीचे digests, backfills, bulk classification — ज्या कामासाठी मानवी प्रतिसादाची प्रतीक्षा करण्याची गरज नाही, ती सर्व कामे यासाठी वापरा.

पुन्हा वापरल्या जाणाऱ्या context साठी Prompt caching वापरा. जर प्रत्येक call मध्ये तोच मोठा system prompt किंवा runbook पुन्हा पाठवला जात असेल, तर त्याला cacheable म्हणून मार्क करा:

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

Cache writes साठी input किमतीपेक्षा सुमारे 1.25x खर्च येतो, आणि 5-minute TTL वर cache reads साठी सुमारे 0.1x खर्च येतो — त्यामुळे त्या वेळेत केलेला दुसरा call पहिल्या call च्या खर्चाची भरपाई करतो. दोन महत्त्वाच्या गोष्टी: cached prefix ला मॉडेलनुसार किमान मर्यादा पार करावी लागते — Opus वर काही हजार tokens — त्यामुळे छोटा system prompt कदाचित cache होणार नाही. आणि जर identical calls मध्ये cache_read_input_tokens शून्य राहत असेल, तर तुमच्या prefix मध्ये प्रत्येक request मध्ये काहीतरी बदलत आहे (timestamp हे याचे मुख्य कारण असते).

Input मध्ये काय येते हे लक्षात ठेवा. System prompts, tool definitions, आणि — multi-turn conversations मध्ये — तुम्ही प्रत्येक वेळी पुन्हा पाठवलेला संपूर्ण इतिहास (history) या सर्वांचे billing input tokens म्हणून केले जाते. ज्या chat loop मध्ये history कधीही कमी (trim) केली जात नाही, त्याचा खर्च वेगाने (quadratically) वाढतो. काहीही conversational बिल्ड करण्यापूर्वी संपूर्ण हिशोब समजून घेणे आवश्यक आहे: Claude token usage आणि billing कसे काम करते.

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 असलेली file वाचते, त्यामुळे process ला variable मिळते परंतु user ला key file वाचता येत नाही. systemd-journal group log access प्रदान करतो. manual systemctl start वापरून test करा आणि journalctl -u log-digest.service वाचा — typo शोधण्यासाठी 06:15 पर्यंत वाट पाहू नका. जेव्हा ही पद्धत shell pipeline पेक्षा मोठी होते, तेव्हा हीच env-file approach त्याच machine वरील Claude-powered n8n workflows मध्ये वापरता येते.

Failure modes, with the strings you will see

401 on a working key. ही exception अशी दिसते:

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

जर तुमची key shell मध्ये काम करत असेल पण service मध्ये 401 error येत असेल, तर service ला ती key मिळाली नाहीये — लक्षात ठेवा की systemd .bashrc वाचत नाही; EnvironmentFile= मध्ये योग्य path आहे की नाही ते तपासा. इतर कारणे: env file मध्ये quotes पेस्ट करणे (ANTHROPIC_API_KEY="sk-ant-..." — systemd quotes काढून टाकते, पण जर तुम्ही चुकीच्या पद्धतीने quotes वापरले असतील तर तुमच्या shell wrapper च्या . file मध्ये ते value मध्ये राहतात), trailing whitespace, किंवा तुम्ही गेल्या आठवड्यात Console मध्ये revoke केलेली key.

404 from a model typo. याचे सर्वात सामान्य कारण म्हणजे सध्याच्या model 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'}

Current-generation IDs जसे लिहिले आहेत तसेच अचूक असतात — claude-opus-4-8, claude-haiku-4-5, claude-sonnet-5. ते models documentation मधून कॉपी करा, कधीही लक्षातून किंवा जुन्या tutorial मधून घेऊ नका.

429 rate_limit_error. error type string rate_limit_error आहे आणि response मध्ये seconds दर्शवणारा retry-after header असतो. तुम्हाला exception दिसण्यापूर्वी SDK ने आधीच दोनदा backoff सह retry केले आहे, त्यामुळे सतत 429 error येत असेल तर तुमचा sustained rate तुमच्या tier पेक्षा जास्त आहे — कामाचे batch करा किंवा ते पसरवून करा, retry loop अधिक घट्ट करू नका.

It prints the object, not the text. Output [TextBlock(citations=None, text='...', type='text')] सारखे दिसते. तुम्ही blocks iterate करून जिथे block.type == "text" आहे तिथून .text वाचण्याऐवजी response.content print केले आहे. वरील प्रत्येक SDK example मध्ये हे योग्यरित्या केले आहे; तो loop कॉपी करा.

error: externally-managed-environment. तुम्ही Ubuntu 24.04 च्या system Python वर pip install चालवले आहे. venv वापरा — महत्त्वाच्या server वर कधीही --break-system-packages करू नका.

Truncated answers. response.stop_reason == "max_tokens" चा अर्थ असा आहे की model विचार प्रक्रिया पूर्ण करण्यापूर्वीच तुमच्या output cap ला पोहोचले आहे. हे अपेक्षित आहे; cap जाणीवपूर्वक वाढवा.

तुमचे पहिले app यशस्वीरित्या चालल्यानंतर, building an AI agent with Claude द्वारे तुम्ही त्याच API calls चा वापर करून tools वापरणारा agent तयार करू शकता.

FAQ

Claude API वापरण्यासाठी किती खर्च येईल?

अशा साधनासाठी खर्च खूपच कमी आहे. जुलै 2026 पर्यंत, Opus 4.8 साठी प्रति मिलियन इनपुट टोकन्स $5 आणि प्रति मिलियन आउटपुट $25 खर्च येतो. त्यामुळे सामान्य लॉग डायग्नोसिस (काही हजार इनपुट टोकन्स आणि काही शेकडा आउटपुट) यासाठी सुमारे दोन सेंट खर्च येईल. Haiku 4.5 ($1/$5) वापरल्यास हा खर्च अर्ध्या सेंटपेक्षाही कमी असेल. दररोजचे डायजेस्ट्स मिळवण्यासाठी एका महिन्याचा खर्च एका कॉफीपेक्षाही कमी आहे. मुख्य धोका प्रति-कॉल (per-call) किंमत नाही; तर अनबाउंडेड लूप्स आणि अनबाउंडेड max_tokens हा आहे. म्हणूनच या गाईडमध्ये या दोन्ही गोष्टी स्पष्टपणे सेट केल्या आहेत.

Claude API साठी काही फ्री टियर (free tier) आहे का?

जुलै 2026 पर्यंत कोणताही निरंतर फ्री टियर उपलब्ध नाही. Anthropic च्या प्राइसिंग डॉक्युमेंटेशननुसार, नवीन वापरकर्त्यांना API टेस्ट करण्यासाठी काही प्रमाणात फ्री क्रेडिट्स मिळतात — ही एकवेळची ट्रायल आहे आणि त्याचे नेमके प्रमाण साइनअप करताना Console मध्ये दिसते — त्यानंतर तुम्हाला खात्यात पैसे भरायचे लागतात. जर तुमचे ध्येय हाय-क्वालिटी मॉडेलऐवजी शून्य मार्जिनल कॉस्ट असेल, तर Ollama सह ओपन-वेट मॉडेल सेल्फ-होस्ट करणे हा एक पर्याय आहे, जिथे तुम्हाला टोकन्सऐवजी RAM साठी पैसे द्यावे लागतात.

सर्व्हरवर माझी API key सुरक्षित कशी ठेवायची?

कधीही कोडमध्ये, कधीही git मध्ये, कधीही .bashrc मधून एक्सपोर्ट करून किंवा हिस्ट्रीमध्ये राहतील अशा शेलमध्ये (shell) टाईप करून ती ठेवू नका. ती 600 परवान्यांसह (permissions) रूट-ओन्ड फाईलमध्ये ठेवा. ती प्रति-प्रोसेस लोड करा — इंटरअॅक्टिव्ह वापरासाठी wrapper script आणि systemd साठी EnvironmentFile= वापरा. प्रत्येक सर्व्हर किंवा प्रोजेक्टसाठी एक स्वतंत्र की (key) वापरा, जेणेकरून लीक झालेली की रिव्होक (revoke) करणे सोपे होईल. जर तुमची की कधीही पेस्ट साइट किंवा git कमिटमध्ये आढळली, तर ती लगेच Console मध्ये रिव्होक करा; कमिट डिलीट केल्याने ती लीक झाल्यापासून वाचत नाही.

मी कोणत्या Claude मॉडेलपासून सुरुवात करावी?

आउटपुटची गुणवत्ता पुरेशी आहे की नाही हे तपासण्यासाठी claude-opus-4-8 ने सुरुवात करा — तुम्हाला पूर्ण गुणवत्तेत कल्पनेचे मूल्यमापन करायचे आहे आणि कमी व्हॉल्यूमसाठी खर्चातील फरक केवळ काही सेंट्सचा आहे. एकदा प्रॉम्प्ट सेट झाला की, तुमचे प्रत्यक्ष इनपुट्स claude-haiku-4-5 वर पुन्हा रन करा; समरायझेशन, क्लासिफिकेशन आणि लॉग ट्रायजसाठी हे मॉडेल पाचव्या भागाच्या किमतीत तितकेच चांगले काम करते. मोजमाप (measurement) केल्यानंतर Haiku किंवा Sonnet वर स्विच करा, केवळ डिफॉल्टनुसार नाही.