Claude API ట్యుటోరియల్: VPS పై మీ మొదటి యాప్

మీరు నిర్మించేది ఏమిటి

కొత్త Ubuntu 24.04 VPS పై ఒక కమాండ్-లైన్ సాధనం. దీనికి మీరు ఒక ఎర్రర్ సందేశం లేదా లాగ్ భాగాన్ని పైప్ చేస్తే, మీకు సరళమైన ఇంగ్లీషు విశ్లేషణ లభిస్తుంది: journalctl -u nginx -n 50 | explain. ఇది దాదాపు అరవై లైన్ల Python కోడ్. ఒక నిజమైన Claude API అప్లికేషన్‌కు కావలసిన ప్రతిదీ ఇందులో ఉంటుంది — సరైన రీతిలో నిల్వ చేయబడిన కీ, ఒక virtualenv, SDK యొక్క రెస్పాన్స్ ఆకృతులు, స్ట్రీమింగ్, టైప్ చేయబడిన ఎక్సెప్షన్ చైన్, మరియు మీ ప్రమేయం లేకుండా అది నడిచేలా చేసే ఒక systemd యూనిట్.

ఈ ప్రాజెక్ట్‌ను నేను ఉద్దేశపూర్వకంగా ఎంచుకున్నాను. చాలా "మొదటి API యాప్" ట్యుటోరియల్స్ మీకు మళ్లీ తెరిచి చూడని ఒక చాట్‌బాట్‌ను నిర్మించమని చెబుతాయి. ఒక లాగ్ విశ్లేషకం మొదటి రోజు నుండే సర్వర్‌పై తన ఉపయోగాన్ని నిరూపిస్తుంది. అలాగే, ప్రారంభకులు నిజంగా తప్పు చేసే రెండు పనుల ద్వారా మిమ్మల్ని ఇది నడిపిస్తుంది: రెస్పాన్స్ ఆబ్జెక్ట్‌ను సరిగ్గా చదవడం, మరియు ఖర్చును నియంత్రించడం. మీరు పెట్టే పరిమితులు తప్ప టోకెన్‌కు ఈ API బిల్లు వేస్తుంది, పై పరిమితి ఏమీ లేదు. కాబట్టి ఇక్కడ ఖర్చు నియంత్రణ ఒక డిజైన్ ఇన్‌పుట్, ఆలస్యంగా ఆలోచించే అంశం కాదు — మీరు ఈ VPS పై tmux లో Claude Code ను నడపడం అనే స్థాయికి చేరుకున్నప్పుడు అవసరమయ్యే అదే క్రమశిక్షణ ఇక్కడ కూడా ముఖ్యం.

కన్సోల్ నుండి API కీని పొందండి

API యాక్సెస్‌ను platform.claude.com వద్ద ఉన్న Anthropic కన్సోల్‌లో నిర్వహిస్తారు — సైన్ అప్ చేసి, తర్వాత Settings → API Keys కింద ఒక కీని సృష్టించండి (డాక్స్ నేరుగా platform.claude.com/settings/keys‌కి లింక్ చేస్తాయి). ఆ కీ ఒకేసారి చూపబడుతుంది, sk-ant-‌తో ప్రారంభమవుతుంది, మళ్లీ పొందలేరు — వెంటనే కాపీ చేయండి లేదా తొలగించి తిరిగి జారీ చేయండి.

డబ్బు గురించి: జూలై 2026 నాటికి API కోసం ఎటువంటి కొనసాగుతున్న ఉచిత స్థాయి లేదు. Anthropic ధరల డాక్స్ ప్రకారం కొత్త వినియోగదారులు పరీక్షించడానికి కొంచెం ఉచిత క్రెడిట్‌లను పొందుతారు; సైన్ అప్ సమయంలో కన్సోల్ మీకు చూపే దానికే అసలు మొత్తం, అది అయిపోయిన తర్వాత అభ్యర్థనలు విజయవంతం కావడానికి ముందు మీరు ఖాతాకు నిధులు అందించాలి. ఇది claude.ai సబ్‌స్క్రిప్షన్‌కు వేరు — Pro లేదా Max ప్లాన్‌లో API క్రెడిట్ ఉండదు, మరియు API కీ మీకు చాట్ యాప్‌ను ఇవ్వదు. మీరు సబ్‌స్క్రిప్షన్‌ను APIతో పోలుస్తుంటే, ఆ సర్దుబాటు ఒక ప్రత్యేక అంశం: మీకు నిజంగా అవసరమైన క్లాడ్ ప్లాన్ ఏది.

ఒక ప్రాజెక్ట్ లేదా సర్వర్‌కు పరిమితం చేసి కీని సృష్టించండి. ఒక కీ లీక్ అయినప్పుడు — మరియు సరిపోనంత సుదీర్ఘ కాలంలో, ఒకటి అవుతుంది — మీరు సొంతం చేసుకున్న మరోదేనినీ పాడుచేయకుండా దాన్ని ఉపసంహరించుకోవాలనుకుంటారు.

కీని .bashrc లో ఉంచవద్దు

అనువాద చర్య export ANTHROPIC_API_KEY=sk-ant-... ను ~/.bashrc లో ఉంచడం. అలా చేయవద్దు. మూడు వేర్వేరు సమస్యలున్నాయి:

• ప్రతి ప్రక్రియ దాన్ని వారసత్వంగా పొందుతుంది. మీ లాగిన్ షెల్‌లో ఎక్స్‌పోర్ట్ చేసిన పర్యావరణ వేరియబుల్, మీరు ప్రారంభించే ప్రతిదానికీ వ్యాపిస్తుంది — వెబ్ యాప్, బగ్ రిపోర్ట్‌లో తన పర్యావరణాన్ని సహాయకంగా డంప్ చేసే క్రాష్ రిపోర్టర్, ఎవరో ఎనేబుల్ చేసి వదిలేసిన phpinfo() పేజీ. కీ బహిర్గత ఉపరితలం "ఈ వినియోగదారు రన్ చేసే ప్రతిది" అని మారిపోతుంది.
• టైప్ చేయడం దాన్ని ~/.bash_history లోకి చేరుస్తుంది. ఎక్స్‌పోర్ట్‌ను ఒకసారి మాన్యువల్‌గా రన్ చేస్తే మీ కీ శాశ్వతంగా ఒక ప్లెయిన్‌టెక్స్ట్ ఫైల్‌లో ఉంటుంది, మరియు మీ హోమ్ డైరెక్టరీ యొక్క ప్రతి బ్యాకప్‌కు సింక్ అవుతుంది.
• systemd కు అవసరమైనప్పుడు అది అక్కడ ఉండదు. సర్వీస్‌లు మీ .bashrc ను చదవవు, కాబట్టి మీరు స్క్రిప్ట్‌ను యూనిట్‌గా ప్రమోట్ చేసినప్పుడు ఈ ప్యాటర్న్ విఫలమవుతుంది — సాధారణంగా ఉదయం 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

కీని ఎడిటర్ స్వాప్ ఫైళ్ల బయట ఉంచాలనుకుంటే printf నుండి tee ఉపయోగించండి, ఎడిటర్ కాదు; ఏ విధంగానైనా, ls -l /etc/claude-explain.env తో ఇది -rw------- ను చదువుతుందని మరియు root యజమానిత్వంలో ఉందని ధృవీకరించుకోండి. ఇంటరాక్టివ్ షెల్‌లు ఒక రాపర్ (కింద) ద్వారా ప్రతి-కాల్‌కు కీని పొందుతాయి, మరియు systemd దాన్ని EnvironmentFile= ద్వారా పొందుతుంది — root అధికారాలను వదులుకునే ముందు ఫైల్‌ను చదువుతుంది, కాబట్టి సర్వీస్ వినియోగదారుకు దానికి రీడ్ యాక్సెస్ అవసరం ఉండదు. కీ ఎప్పుడూ కోడ్‌లో, git లో, ps అవుట్‌పుట్‌లో, లేదా షెల్ హిస్టరీలో కనిపించదు.

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

సర్వర్‌పై యాక్టివేషన్ అవసరం లేదు: /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 ని ఉపయోగించే ముందు పునరావృతం చేసి block.type == "text" ని తనిఖీ చేయండి. మొదటి రోజునే ఆ లూప్‌ని జోడించండి, అప్పుడు "అది చెత్తను ప్రింట్ చేస్తోంది" అనే గందరగోళం ఒకటి కూడా తలెత్తదు.

సరైన మోడల్ ID claude-opus-4-8 ని ఉపయోగించండి. ప్రస్తుత తరం IDలకు తేదీ ఉండదు — తేదీ సఫిక్స్‌ని జోడించమని చెప్పే మీ అలవాటును (లేదా పాత బ్లాగ్ పోస్ట్‌ను) నిరోధించండి; అలా చేస్తే 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 గా సేవ్ చేయండి, తర్వాత ఇంటరాక్టివ్ వినియోగం కోసం కీని లోడ్ చేసే ఒక ర్యాపర్ జోడించండి:

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 టైమౌట్‌లను నివారిస్తుంది — సరిగ్గా అదే కారణం వల్ల నాన్-స్ట్రీమింగ్ కాల్‌లలో చాలా పెద్ద max_tokens విలువలను SDK వాస్తవానికి తిరస్కరిస్తుంది. తర్వాత మీకు అసెంబుల్ చేసిన ఆబ్జెక్ట్ అవసరం అయితే, with బ్లాక్ లోపల stream.get_final_message() ని కాల్ చేయండి.

ఆ ఎక్సెప్షన్ క్రమం ఎందుకు. SDK టైప్ చేయబడిన ఎక్సెప్షన్‌లను అత్యంత నిర్దిష్టమైనది ముందుగా పెంచుతుంది: RateLimitError అనేది 429 మరియు ఎంతసేపు వేచి ఉండాలో చెప్పే retry-after హెడర్‌ను కలిగి ఉంటుంది; APIStatusError ఇతర నాన్-2xx రెస్పాన్స్‌లను కవర్ చేస్తుంది (సర్వర్-సైడ్ సమస్య కోసం e.status_code >= 500 ని చెక్ చేయండి); APIConnectionError అంటే అభ్యర్థనకు ఎలాంటి రెస్పాన్స్ రాలేదు. మరియు మీరు రీట్రై లూప్‌ను రూపొందించడానికి ముందు: 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 ధరతో. స్పష్టంగా చెప్పాలంటే: 2,000-టోకెన్ లాగ్ సందర్భం 500-టోకెన్ సమాధానంతో 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 సున్నాగానే ఉంటే, మీ ప్రిఫిక్స్‌లో ఏదో ఒకటి ప్రతి అభ్యర్థనలో మారుతోంది (టైమ్‌స్టాంప్ సాధారణ కారణం).

ఇన్‌పుట్‌గా ఏది లెక్కకు వస్తుందో గుర్తుంచుకోండి. సిస్టమ్ ప్రాంప్ట్‌లు, టూల్ నిర్వచనాలు, మరియు — బహుళ-మలుపు సంభాషణల్లో — మీరు ప్రతి మలుపులో మళ్లీ పంపే మొత్తం చరిత్ర అన్నీ ఇన్‌పుట్ టోకెన్‌లుగా బిల్ చేయబడతాయి. చరిత్రను ఎప్పుడూ కత్తిరించని చాట్ లూప్ ఖర్చులో చతుర్భుజాకారంగా పెరుగుతుంది. సంభాషణాత్మకంగా ఏదైనా నిర్మించే ముందు పూర్తి లెక్కను అర్థం చేసుకోవడం విలువైనది: 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 అనునది రూట్ యాజమాన్యంలోని, mode-600 ఫైలును అనుభవహీన లేని explain యూజర్‌కు దిగమ్రింగే ముందు చదువుతుంది, కాబట్టి ప్రాసెస్‌కు వేరియబుల్ లభిస్తుంది, అదే సమయంలో యూజర్ ఆ కీ ఫైలును చదవలేరు. systemd-journal గ్రూప్ లాగ్ యాక్సెస్‌ను మంజూరు చేస్తుంది. మాన్యువల్ systemctl startతో పరీక్షించి, journalctl -u log-digest.serviceను చదవండి — ఒక టైపో కోసం 06:15 వరకు వేచి చూడకండి. ఈ ప్యాటర్న్ షెల్ పైప్‌లైన్ పరిధిని దాటినప్పుడు, ఎన్విరాన్మెంట్ ఫైలులో కీ ఉంచడం అనే అదే విధానం అదే సర్వర్‌లోని 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= సరైన పాత్‌ను సూచిస్తుందో కాదో తనిఖీ చేయండి. ఇతర కారణాలు: env ఫైలులోకి అతికించబడిన కోట్స్ (ANTHROPIC_API_KEY="sk-ant-..." — systemd కోట్స్‌ను విలువ నుండి తీసివేస్తుంది, కానీ మీ షెల్ రాపర్ యొక్క . file మీరు విచిత్రంగా కోట్ చేసిఉంటే వాటిని విలువలో ఉంచుతుంది), ట్రైలింగ్ వైట్‌స్పేస్, లేదా మీరు గత వారం కన్సోల్‌లో రద్దుచేసిన కీ.

మోడల్ టైపో వల్ల 404. దీనికి అత్యంత సాధారణ కారణం, ప్రస్తుత మోడల్ IDకి తేదీ ప్రత్యయం జోడించడం:

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 ఇప్పటికే బ్యాకాఫ్‌తో రెండుసార్లు రీట్రై చేసి ఉంటుంది, కాబట్టి నిరంతర 429లు అంటే మీ నిలకడైన రేట్ నిజంగా మీ టైర్‌ను మించిపోతోంది — పనిని బ్యాచ్ చేయండి లేదా విస్తరించండి, రీట్రై లూప్‌ను టైట్ చేయకండి.

అది టెక్స్ట్ కాకుండా ఆబ్జెక్ట్‌ను ప్రింట్ చేస్తుంది. అవుట్‌పుట్ [TextBlock(citations=None, text='...', type='text')] లా కనిపిస్తుంది. మీరు బ్లాక్‌లను ఇటరేట్ చేసి block.type == "text" అయిన వాటి నుండి .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 నుండి ఎక్స్‌పోర్ట్ చేయదు, ఎప్పుడూ హిస్టరీ దాన్ని నిలుపుకునే షెల్‌లో టైప్ చేయదు. దాన్ని 600 అనుమతులతో root-యాజమాన్య ఫైల్‌లో ఉంచండి, ప్రతి ప్రక్రియకు లోడ్ చేయండి — ఇంటరాక్టివ్ వినియోగానికి ఒక రాపర్ స్క్రిప్ట్, systemd కోసం EnvironmentFile= — మరియు ప్రతి సర్వర్ లేదా ప్రాజెక్ట్‌కు ఒక కీ సెట్ చేయండి తద్వారా లీకైన కీని రద్దు చేయడం ఒక శస్త్రచికిత్స, కానీ అంగవిచ్ఛేదన కాదు. కీ ఎప్పుడైనా పేస్ట్ సైట్ లేదా git కమిట్‌ను తాకితే, Consoleలో వెంటనే దాన్ని రద్దు చేయండి; కమిట్‌ను తొలగించడం దాన్ని అన్-లీక్ చేయదు.

నేను ఏ Claude మోడల్‌తో ప్రారంభించాలి?

అవుట్‌పుట్‌లు మీద నిర్మించడానికి సరిపోతాయో లేదో మూల్యాంకనం చేసేటప్పుడు claude-opus-4-8తో ప్రారంభించండి — మీరు ఆలోచనను పూర్తి నాణ్యత వద్ద అంచనా వేయాలి, మరియు హాబీ వాల్యూమ్ వద్ద ధరల తేడా కొన్ని సెంట్లు మాత్రమే. ప్రాంప్ట్ స్థిరపడిన తర్వాత, మీ నిజమైన ఇన్‌పుట్‌లను claude-haiku-4-5 మీద మళ్లీ రన్ చేయండి; సారాంశం, వర్గీకరణ, మరియు లాగ్ ట్రయేజ్ కోసం ఇది తరచుగా ఐదవ వంతు ధరకే అంతే మంచిది. Haiku లేదా Sonnetకు కొలమానం ద్వారా మారండి, అప్రమేయంగా కాదు.