द्वारे Matt Connor 2026-07-15 · अपडेटेड 2026-08-07

Claude API Tutorial: Ubuntu VPS वर Python App

Q: Server वर माझी API key सुरक्षित कशी ठेवू?

API key code मध्ये कधीही ठेवू नका. ती git मध्ये ठेवू नका. .bashrc मधून ती export करू नका. Shell history मध्ये ती जतन होईल अशा प्रकारे shell मध्ये type करू नका. ती root-owned file मध्ये 600 permissions सह ठेवा. प्रत्येक process साठी ती load करा. Interactive वापरासाठी wrapper script वापरा आणि systemd साठी EnvironmentFile= वापरा. तसेच प्रत्येक server किंवा project साठी स्वतंत्र key वापरा. त्यामुळे leaked key revoke करणे नियंत्रित पद्धतीने करता येते. एखादी key paste site किंवा git commit मध्ये गेली असेल, तर ती Console मध्ये त्वरित revoke करा. Commit delete केल्याने key पुन्हा गुप्त होत नाही.

Q: मी कोणत्या Claude model पासून सुरुवात करावी?

तुम्ही outputs पुरेसे चांगले आहेत का हे तपासत असताना claude-opus-4-8 पासून सुरुवात करा. त्यामुळे कल्पनेचे मूल्यमापन पूर्ण quality वर करता येते. Hobby volume मध्ये किमतीतील फरक cents मध्ये असतो. Prompt निश्चित झाल्यानंतर तुमचे वास्तविक inputs claude-haiku-4-5 वर पुन्हा चालवा. Summarization, classification आणि log triage साठी तो अनेकदा एक-पंचमांश किमतीत जवळपास तितकाच चांगला असतो. Haiku किंवा Sonnet कडे default ने नव्हे, तर मोजलेल्या परिणामांच्या आधारे बदला.

Ubuntu 24.04 VPS वर Claude API key सुरक्षित करा आणि सुमारे 60 ओळींचे Python log-explainer तयार करा. streaming, typed errors आणि खर्च नियंत्रण शिका.

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

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

मी हा प्रकल्प जाणीवपूर्वक निवडला आहे. बहुतेक "first API app" tutorial मध्ये तुम्ही पुन्हा कधीही न उघडणारा chatbot तयार करता. Log explainer पहिल्याच दिवसापासून server वर उपयुक्त ठरतो. तसेच सुरुवातीच्या वापरकर्त्यांकडून होणाऱ्या दोन सामान्य चुका तो स्पष्टपणे समोर आणतो: response object योग्य प्रकारे वाचणे आणि खर्च नियंत्रित करणे. API प्रत्येक token साठी billing करते. तुम्ही ठरवलेल्या मर्यादांखेरीज त्यावर दुसरी कोणतीही कमाल मर्यादा नसते. त्यामुळे येथे cost control हा नंतरचा विचार नसून design input आहे. पुढे याच VPS वर tmux मध्ये Claude Code चालवताना देखील हीच शिस्त महत्त्वाची ठरते.

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

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

पैशांबाबत: July 2026 पर्यंत API साठी कायमस्वरूपी free tier उपलब्ध नाही. Anthropic च्या pricing docs नुसार, नवीन users ना चाचणीसाठी थोडे free credits मिळतात. अचूक रक्कम signup वेळी Console मध्ये दाखवली जाते. हे credits संपल्यानंतर requests यशस्वी होण्यासाठी account मध्ये निधी जमा करावा लागतो. हे claude.ai subscription पेक्षा वेगळे आहे. Pro किंवा Max plan मध्ये API credit समाविष्ट नसतो. API key मुळे chat app चा access मिळत नाही. Subscription आणि API यांपैकी निवड करताना हा स्वतंत्र विचाराचा विषय आहे: तुम्हाला प्रत्यक्षात कोणता Claude plan आवश्यक आहे.

ही key एका project किंवा server पुरती मर्यादित ठेवा. एखादी key leak झाल्यावर, आणि पुरेसा वेळ दिल्यास अशी घटना घडणारच असल्याने, तुमच्या इतर सर्व साधनांवर परिणाम न करता ती 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 चालवला की तुमचा key plaintext file मध्ये कायमचा राहतो आणि तुमच्या home directory च्या प्रत्येक backup मध्ये sync होतो.
systemd ला गरज असताना तो उपलब्ध नसतो. Services तुमचे .bashrc वाचत नाहीत. त्यामुळे script ला unit मध्ये रूपांतरित केल्यावर ही पद्धत नेमकी अपयशी ठरते. सहसा सकाळी 6 वाजता अनाकलनीय 401 दिसतो.

Server वर योग्य पद्धत म्हणजे 600 permissions असलेली dedicated 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

Editor च्या swap files मध्ये key जाऊ नये असे वाटत असल्यास editor ऐवजी printf मधून tee वापरा. कोणतीही पद्धत वापरली तरी ls -l /etc/claude-explain.env ने ती -rw------- वाचते आणि तिचा मालक 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 मध्ये PEP 668 enforcement सह Python 3.12 उपलब्ध असते. त्यामुळे 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 नेहमी वापरले जातात.

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

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

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

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

अचूक model ID claude-opus-4-8 वापरा. सध्याच्या पिढीतील IDs मध्ये date नसते. date suffix जोडण्याची सवय किंवा जुन्या blog post मधील सूचना टाळा; तसे केल्यास 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 म्हणून जतन करा. त्यानंतर interactive वापरासाठी 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 file अशा group कडे असावी ज्याचा तुमचा admin user सदस्य आहे. फाइलची परवानगी 644 करून सुरक्षा कमी करण्याऐवजी यापैकी एक पर्याय जाणीवपूर्वक निवडा.)

प्रवाह का वापरायचा. client.messages.stream tokens उपलब्ध होताच ते छापतो. त्यामुळे संपूर्ण generation पूर्ण होईपर्यंत प्रक्रिया शांत बसत नाही. तसेच मोठ्या output मुळे होणारे HTTP timeouts टाळता येतात. याच कारणामुळे SDK non-streaming calls मध्ये अतिशय मोठ्या max_tokens values नाकारतो. नंतर assembled object आवश्यक असल्यास, with block मध्ये stream.get_final_message() कॉल करा.

त्या exception क्रमाचे कारण. SDK typed exceptions निर्माण करते आणि सर्वाधिक specific exception आधी तपासली जाते: RateLimitError हा 429 error आहे आणि त्यामध्ये किती वेळ प्रतीक्षा करावी हे सांगणारा retry-after header असतो; APIStatusError इतर non-2xx responses हाताळतो (server-side समस्या आहे का हे e.status_code >= 500 तपासा); APIConnectionError म्हणजे request ला कोणताही response मिळालाच नाही. Retry loop तयार करण्यापूर्वी हे लक्षात ठेवा: SDK 429s आणि 5xx errors साठी स्वतःच retry करते. exponential backoff सह ते default ने दोनदा retry करते (client वर max_retries). तुमचा except चालू होईपर्यंत retries पूर्ण झालेल्या असतात. त्यामुळे CLI मध्ये योग्य कृती म्हणजे त्रुटी नोंदवून बाहेर पडणे; प्रतीक्षा करून पुन्हा पुन्हा request पाठवणे नाही.

खर्चाचे नियंत्रण

या विषयासाठी स्वतंत्र विभाग आवश्यक आहे, कारण तुम्ही configure केलेल्या मर्यादेपलीकडे API मध्ये अंगभूत मासिक cap नाही. त्यामुळे येथील प्रत्येक चूक नकळत एकत्रित खर्च वाढवत जाते.

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

पाठवण्यापूर्वी संख्या मोजा. Input साठीही शुल्क आकारले जाते आणि logs मोठे असतात. API मध्ये tokens मोजण्यासाठी endpoint आहे. तो विनामूल्य वापरता येतो. त्याच्या rate limits स्वतंत्र आहेत आणि message creation च्या rate limits पेक्षा वेगळ्या आहेत:

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

चुकून 2 GB log या tool मधून पाठवला जाणार नाही, यासाठी त्याचा वापर करा. यासाठी tiktoken वापरू नका. ते OpenAI चे tokenizer आहे आणि सामान्य text मध्ये Claude tokens ची संख्या साधारण 15–20% ने कमी मोजते; code साठी ही तफावत आणखी जास्त असते.

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

ज्या कामासाठी प्रतीक्षा चालू शकते त्यासाठी Batches वापरा. Batches API requests asynchronous पद्धतीने process करते आणि standard prices च्या 50% शुल्कात काम करते. बहुतेक batches एका तासात पूर्ण होतात. Nightly digests, backfills, bulk classification आणि human च्या प्रतीक्षेची गरज नसलेली कोणतीही कामे तेथे पाठवा.

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

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 price च्या सुमारे 1.25 पट, तर cache reads साठी सुमारे 0.1 पट शुल्क आकारले जाते. TTL 5-minute असल्यामुळे, या कालावधीत केलेली दुसरी call पहिल्याच call चा खर्च भरून काढते. येथे दोन गोष्टी लक्षात ठेवा. Cached prefix ने प्रत्येक model साठीची किमान token मर्यादा पूर्ण केली पाहिजे. Opus साठी ही मर्यादा काही हजार tokens असते. त्यामुळे short system prompt मुळे caching मूकपणे लागू होणार नाही. तसेच identical calls मध्ये cache_read_input_tokens सतत zero राहत असेल, तर प्रत्येक request मध्ये prefix मधील काहीतरी बदलत आहे. Timestamp हे त्याचे सर्वसाधारण कारण आहे.

Input म्हणून काय मोजले जाते ते लक्षात ठेवा. System prompts, tool definitions आणि multi-turn conversations मध्ये प्रत्येक turn वेळी पुन्हा पाठवले जाणारे संपूर्ण history हे सर्व input tokens म्हणून billed केले जातात. History कधीही trim न करणाऱ्या chat loop चा खर्च quadratically वाढतो. Conversational काहीही build करण्यापूर्वी संपूर्ण accounting समजून घेणे महत्त्वाचे आहे: 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 अनधिकृत explain वापरकर्त्याकडे प्रक्रिया सोपवण्यापूर्वी root-owned, mode-600 फाइल वाचतो. त्यामुळे प्रक्रियेला variable मिळतो, पण त्या वापरकर्त्याला key file वाचता येत नाही. systemd-journal group मुळे log वाचण्याची परवानगी मिळते. Manual systemctl start वापरून चाचणी करा आणि journalctl -u log-digest.service वाचा. Typo शोधण्यासाठी 06:15 पर्यंत थांबू नका. ही पद्धत shell pipeline पेक्षा मोठी झाल्यावर, तीच key-in-env-file पद्धत त्याच मशीनवरील Claude-सक्षम n8n workflows मध्ये थेट वापरता येते.

अपयशाच्या स्थिती आणि दिसणारे संदेश

कार्यरत key वर 401. Exception असा दिसतो:

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

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

model मधील typo मुळे 404. सध्याच्या 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'}

सध्याच्या generation मधील ID जशा लिहिल्या आहेत तशाच अचूक असतात: claude-opus-4-8, claude-haiku-4-5, claude-sonnet-5. त्या models documentation मधून copy करा. त्या स्मरणावर किंवा जुन्या tutorial मधून घेऊ नका.

429 rate_limit_error. Error type string rate_limit_error आहे आणि response मध्ये प्रतीक्षा करण्यासाठी लागणाऱ्या seconds सह retry-after header असतो. Exception दिसण्यापूर्वी SDK ने backoff सह दोनदा retry केलेले असते. त्यामुळे सातत्याने येणाऱ्या 429 errors चा अर्थ तुमचा sustained rate तुमच्या tier च्या मर्यादेपेक्षा खरोखर जास्त आहे. काम batch करा किंवा ते अधिक कालावधीत पसरवा. Retry loop अधिक घट्ट करू नका.

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

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

उत्तर truncated आहे. response.stop_reason == "max_tokens" याचा अर्थ model तुमच्या output cap पर्यंत पोहोचले आणि विचाराच्या मध्यभागी थांबले. हे अपेक्षित वर्तन आहे; cap जाणीवपूर्वक वाढवा.

तुमचे पहिले app कार्यरत झाल्यावर, Claude सह AI agent तयार करणे याच API calls चे रूपांतर tools वापरणाऱ्या agent मध्ये करते.

FAQ

Claude API वापरून पाहण्याचा खर्च किती आहे?

यासारख्या साधनासाठी हा खर्च खरोखरच कमी आहे. July 2026 नुसार, Opus 4.8 ची किंमत प्रति million input tokens $5 आणि प्रति million output tokens $25 आहे. त्यामुळे सामान्य log diagnosis मध्ये काही thousand tokens input आणि काही hundred tokens output असल्यास खर्च सुमारे दोन cents येतो. Haiku 4.5 ($1/$5) वापरल्यास हा खर्च अर्ध्या cent पेक्षाही कमी असतो. दररोज एक digest तयार करण्याचा महिन्याचा खर्च एका coffee पेक्षा कमी असतो. धोका प्रत्येक call च्या किमतीत नाही; तो मर्यादा नसलेल्या loops आणि मर्यादा नसलेल्या max_tokens मध्ये आहे. म्हणून या दोन्ही गोष्टी या मार्गदर्शकामध्ये स्पष्टपणे सेट केल्या आहेत.

Claude API साठी विनामूल्य tier आहे का?

July 2026 नुसार सतत उपलब्ध असलेला free tier नाही. Anthropic च्या pricing documentation नुसार, नवीन users ना API ची चाचणी घेण्यासाठी थोडे free credits मिळतात. हा one-time trial असतो. नेमकी रक्कम signup वेळी Console मध्ये दाखवली जाते. त्यानंतर account मध्ये निधी जमा करावा लागतो. तुमचे उद्दिष्ट frontier quality ऐवजी प्रत्येक request साठी शून्य marginal cost ठेवणे असेल, तर पर्याय म्हणून Ollama वापरून open-weight model self-host करा आणि tokens ऐवजी RAM साठी खर्च करा.

Server वर माझी API key सुरक्षित कशी ठेवू?

API key code मध्ये कधीही ठेवू नका. ती git मध्ये ठेवू नका. .bashrc मधून ती export करू नका. Shell history मध्ये ती जतन होईल अशा प्रकारे shell मध्ये type करू नका. ती root-owned file मध्ये 600 permissions सह ठेवा. प्रत्येक process साठी ती load करा. Interactive वापरासाठी wrapper script वापरा आणि systemd साठी EnvironmentFile= वापरा. तसेच प्रत्येक server किंवा project साठी स्वतंत्र key वापरा. त्यामुळे leaked key revoke करणे नियंत्रित पद्धतीने करता येते. एखादी key paste site किंवा git commit मध्ये गेली असेल, तर ती Console मध्ये त्वरित revoke करा. Commit delete केल्याने key पुन्हा गुप्त होत नाही.

मी कोणत्या Claude model पासून सुरुवात करावी?

तुम्ही outputs पुरेसे चांगले आहेत का हे तपासत असताना claude-opus-4-8 पासून सुरुवात करा. त्यामुळे कल्पनेचे मूल्यमापन पूर्ण quality वर करता येते. Hobby volume मध्ये किमतीतील फरक cents मध्ये असतो. Prompt निश्चित झाल्यानंतर तुमचे वास्तविक inputs claude-haiku-4-5 वर पुन्हा चालवा. Summarization, classification आणि log triage साठी तो अनेकदा एक-पंचमांश किमतीत जवळपास तितकाच चांगला असतो. Haiku किंवा Sonnet कडे default ने नव्हे, तर मोजलेल्या परिणामांच्या आधारे बदला.

#claude-api #python #ai #vps #anthropic