SSD Nodes Learn
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-07-25

Claude API VPS Ubuntu 24.04 Python app tutorial

Ubuntu 24.04 VPS இல் Claude API key ஐ பாதுகாப்பாக அமைத்து, streaming மற்றும் typed error handling கொண்ட Python log-explainer உருவாக்க systemd unit வரை முழுமையான படிப்படியான வழிகாட்டி.

நீங்கள் உருவாக்கப் போவது என்ன

புதிதாக நிறுவப்பட்ட Ubuntu 24.04 VPS இல் இயங்கும் ஒரு command-line tool ஐ நீங்கள் உருவாக்கப் போகிறீர்கள். இதற்கு ஒரு பிழைச் செய்தி அல்லது log துண்டை நீங்கள் pipe மூலம் அனுப்புவீர்கள். பதிலாக எளிய ஆங்கிலத்தில் ஒரு காரணக் கண்டறிதலைப் பெறுவீர்கள்: journalctl -u nginx -n 50 | explain. இது சுமார் அறுபது வரிகள் கொண்ட Python நிரல். ஒரு உண்மையான Claude API பயன்பாட்டிற்குத் தேவையான அனைத்தையும் இது கொண்டுள்ளது — சரியான முறையில் சேமிக்கப்பட்ட ஒரு key, ஒரு virtualenv, SDK இன் response shapes, streaming, typed exception chain, மற்றும் உங்கள் தலையீடு இல்லாமல் இயங்குவதற்கான ஒரு systemd unit.

இந்த project ஐ நான் வேண்டுமென்றே தேர்ந்தெடுத்தேன். பெரும்பாலான "முதல் API app" பயிற்சிகள் உங்களை ஒரு chatbot உருவாக்கச் சொல்லும். ஆனால் அதை நீங்கள் மீண்டும் திறக்கமாட்டீர்கள். ஒரு log explainer முதல் நாளிலிருந்தே ஒரு server இல் தன் பயனைத் தருகிறது. மேலும் இது ஆரம்பநிலை பயனர்கள் உண்மையில் தவறாகச் செய்யும் இரண்டு விஷயங்களை உங்களுக்குக் கற்பிக்கிறது: response object ஐ சரியாகப் படிப்பது, மற்றும் செலவைக் கட்டுப்படுத்துவது. API ஒவ்வொரு token க்கும் கட்டணம் வசூலிக்கிறது. நீங்கள் அமைக்கும் வரம்புகளைத் தவிர வேறு எந்த உச்ச வரம்பும் இல்லை. எனவே இங்கு செலவுக் கட்டுப்பாடு ஒரு வடிவமைப்பு உள்ளீடாகும், பின்னர் சிந்திக்கும் விஷயம் அல்ல. இதே ஒழுக்கம் நீங்கள் இந்த VPS இல் tmux இல் Claude Code ஐ இயக்கத் தேவையான ஒழுக்கமாகும்.

கன்சோலில் இருந்து API key பெறுதல

API அணுகல் platform.claude.com இல் உள்ள Anthropic Console மூலம் நிர்வகிக்கப்படுகிறது — பதிவு செய்துகொள்ளுங்கள், பின்னர் Settings → API Keys கீழ் ஒரு key உருவாக்குங்கள் (ஆவணங்கள் நேரடியாக platform.claude.com/settings/keys க்கு இணைக்கின்றன). இந்த key ஒரு முறை மட்டுமே காட்டப்படும், sk-ant- உடன் தொடங்கும், மீண்டும் எடுக்க முடியாது — உடனே நகலெடுத்துக்கொள்ளுங்கள் அல்லது நீக்கிவிட்டு மீண்டும் உருவாக்குங்கள்.

பணம் பற்றி: ஜூலை 2026 நிலவரப்படி API க்கு நிரந்தர இலவச அடுக்கு இல்லை. Anthropic இன் விலைப்பட்டியல் ஆவணங்கள் புதிய பயனர்களுக்கு சோதனைக்கு சிறிய அளவு இலவச credits கிடைக்கும் எனக் கூறுகின்றன; துல்லியமான தொகை பதிவு செய்யும்போது Console காட்டுவதே, அது தீர்ந்ததும் கோரிக்கைகள் வெற்றிபெற முன்பு கணக்கில் பணம் சேர்க்க வேண்டும். இது claude.ai சந்தாவிலிருந்து தனித்தது — Pro அல்லது Max திட்டம் API credit ஐ உள்ளடக்காது, மேலும் ஒரு API key உங்களுக்கு chat செயலியைத் தராது. சந்தாவுக்கும் API க்கும் இடையே நீங்கள் யோசித்தால், அந்த பரிமாற்றம் ஒரு தனி தலைப்பு: உங்களுக்கு உண்மையில் தேவையான Claude திட்டம் எது.

ஒரு project அல்லது server க்கு மட்டும் வரம்பிற்குள் key ஐ உருவாக்குங்கள். ஒரு key கசிந்தால் — போதுமான நீண்ட காலக்கெடுவில், ஒன்று கசியும் — மற்ற அனைத்தையும் பாதிக்காமல் அதை ரத்து செய்ய வேண்டும்.

திறவுகோலை .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 கட்டாயத்தைக் கொண்டு வருகிறது. எனவே, கணினி 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-ன் தொகுப்புகளையே பயன்படுத்துகிறது.

முதல் அழைப்பு, மற்றும் பதிலைச் சரியாகப் படித்தல்

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() விசையை சூழலிலிருந்து படிக்கிறது — அதை எப்போதும் string literal-ஆக அனுப்ப வேண்டாம். இரண்டாவது, response.content என்பது ஒரு content blocks-இன் பட்டியல், string அல்ல. அதை நேரடியாக அச்சிட்டால் பழைய முதன்முறையாளர் வெளியீடு கிடைக்கிறது:

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

அது பிழை அல்ல; அது பொருளின் repr ஆகும். பதில்கள் பல block வகைகளைக் (உரை, tool calls, thinking) கொண்டிருக்கலாம், எனவே .text-ஐத் தொடுவதற்கு முன் நீங்கள் மறுசுழற்சி செய்து block.type == "text"-ஐச் சரிபார்க்கவும். இந்த மடக்கு வளையத்தை முதல் நாளிலேயே இணைத்துக்கொள்ளுங்கள்; "அது குப்பையை அச்சிடுகிறது" என்ற குழப்பத்தின் ஒரு முழு வகுப்பும் ஒருபோதும் நிகழாது.

சரியான model 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 எனச் சேமிக்கவும். பின்னர் இடையிலான பயன்பாட்டுக்கு 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 குறிப்பிட வேண்டியது உங்கள் admin user சேர்ந்திருக்கும் ஒரு group — file ஐ 644 ஆகத் தளர்த்துவதை விட இவற்றில் ஒன்றைத் தெரிவு செய்யவும்.)

வரிசையாக ஏன் வெளியிடுகிறது. client.messages.stream token களை வரும்போதே அச்சிடுகிறது; முழு உருவாக்கத்திற்கும் மௌனமாகக் காத்திருப்பதில்லை. நீண்ட output களில் HTTP timeout தவிர்க்கப்படுகிறது — அதே காரணத்திற்காக, non-streaming call களில் மிகப் பெரிய max_tokens மதிப்புகளை SDK ஏற்க மறுக்கும். பின்னர் ஒன்றிணைக்கப்பட்ட object தேவைப்பட்டால், with block க்குள் stream.get_final_message() ஐ அழைக்கவும்.

அந்த exception வரிசை ஏன். SDK வரிசைப்படுத்தப்பட்ட exception களை எழுப்புகிறது, மிகக் குறிப்பிட்டது முதலில்: RateLimitError என்பது 429 ஆகும்; எவ்வளவு காத்திருக்க வேண்டும் என்பதைத் தெரிவிக்கும் retry-after header ஐக் கொண்டிருக்கும்; APIStatusError மற்ற non-2xx பதில்களை உள்ளடக்கியது (server பக்க பிரச்சினைகளுக்கு e.status_code >= 500 ஐ சரிபார்க்கவும்); APIConnectionError என்பது கோரிக்கைக்கு எந்தப் பதிலும் கிடைக்கவில்லை என்று பொருள். நீங்கள் retry loop உருவாக்குவதற்கு முன்: SDK ஏற்கனவே 429 மற்றும் 5xx பிழைகளைத் தானாகவே retry செய்கிறது, exponential backoff உடன் இரண்டு முறை இயல்பாக (client இல் max_retries). உங்கள் except இயங்கும் போது, retry கள் தீர்ந்திருக்கும் — எனவே ஒரு CLI இல் சரியான செயல் பிழையைத் தெரிவித்து வெளியேறுவது, sleep செய்து தொடர்ந்து முயற்சிப்பது அல்ல.

செலவு கட்டுப்பாடு

இது தனி பிரிவு அவசியம். ஏனெனில் API-இல் நீங்கள் உள்ளமைக்கும் அளவுக்கு மேல் எந்த உள்ளமைக்கப்பட்ட மாதாந்திர வரம்பும் இல்லை. இங்கு நிகழும் ஒவ்வொரு தவறும் அறியாமல் பெருகிக்கொண்டே போகும்.

max_tokens என்பது உங்கள் ஒரு அழைப்புக்கான செலவு உச்ச வரம்பு. வெளியீட்டு டோக்கன்களே விலை உயர்ந்தவை — Opus 4.8-இல், உள்ளீட்டு விலையை விட ஐந்து மடங்கு அதிகம் — மேலும் max_tokens என்பது மாதிரி உருவாக்கக்கூடிய டோக்கன்களுக்கான கடுமையான வரம்பு. கட்டுப்பாடற்ற ஒரு prompt நீங்கள் அனுமதித்ததை விட அதிக வெளியீட்டை உருவாக்க முடியாது. அதை வேலைக்கு ஏற்ப அளவிடவும்: ஒரு பதிவு பகுப்பாய்வுக்கு 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 பதிவை தவறுதலாக கருவி வழியாக அனுப்புவதைத் தடுக்கவும். இதற்கு tiktoken ஐப் பயன்படுத்த வேண்டாம் — அது OpenAI-இன் tokenizer ஆகும். வழக்கமான உரையில் 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-இல் தொடங்கவும். பின்னர் அதே prompt-களை Haiku-இல் முயற்சிக்கவும் — அதிக அளவிலான, எளிய மாற்றங்களுக்கு இது பெரும்பாலும் விலையில் ஐந்தில் ஒரு பங்கில் வேறுபாடு தெரியாது. இவற்றில் ஏதேனும் ஒன்றை பட்ஜெட்டில் நிரந்தரமாக எழுதுவதற்கு முன், விலைப்பட்டியல் பக்கத்தில் தற்போதைய எண்களைச் சரிபார்க்கவும்.

காத்திருக்கக்கூடிய எதற்கும் Batches. Batches API கோரிக்கைகளை ஒரே நேரத்தில் இயல்பான விலையில் 50% ஆகச் செயல்படுத்துகிறது. பெரும்பாலான batches ஒரு மணி நேரத்திற்குள் முடிகின்றன. இரவுநேர சுருக்கங்கள், backfill-கள், மொத்த வகைப்படுத்தல் — மனிதன் காத்திருக்காத எதுவும் அங்கே சேர வேண்டும்.

மீண்டும் மீண்டும் வரும் சூழலுக்கு prompt தற்காலிக சேமிப்பு. ஒவ்வொரு அழைப்பும் அதே பெரிய 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

தற்காலிக சேமிப்பு எழுதுவது உள்ளீட்டு விலையில் ஏறக்குறைய 1.25x ஆகும். தற்காலிக சேமிப்பைப் படிப்பது ஏறக்குறைய 0.1x ஆகும். இது 5-நிமிட TTL அடிப்படையில் இருக்கும் — எனவே இந்த சாளரத்திற்குள் இரண்டாவது அழைப்பு முதல் அழைப்பின் செலவையே ஈடுசெய்துவிடும். இதில் இரண்டு சிக்கல்கள் உள்ளன. தற்காலிக சேமிக்கப்பட்ட prefix ஒரு மாதிரி-சார்ந்த குறைந்தபட்ச அளவைத் தாண்ட வேண்டும் — Opus-இல் சில ஆயிரக்கணக்கான டோக்கன்கள் — எனவே ஒரு குறுகிய system prompt அறியாமலேயே தற்காலிக சேமிப்பில் சேராது. மேலும் ஒரே மாதிரியான அழைப்புகளில் cache_read_input_tokens பூஜ்யமாகவே இருந்தால், உங்கள் prefix-இல் ஏதோ ஒன்று ஒவ்வொரு கோரிக்கையிலும் மாறுகிறது (வழக்கமான காரணம் ஒரு timestamp ஆகும்).

உள்ளீடாக என்ன கணக்கிடப்படுகிறது என்பதை நினைவில் கொள்ளவும். System prompt-கள், கருவி வரையறைகள், மற்றும் — பல-முறை உரையாடல்களில் — நீங்கள் ஒவ்வொரு முறையும் மீண்டும் அனுப்பும் முழு வரலாறும் உள்ளீட்டு டோக்கன்களாகவே பில் செய்யப்படுகின்றன. வரலாற்றை ஒருபோதும் சுருக்காத ஒரு அரட்டை சுழற்சி, செலவில் இருபடி வளர்கிறது. நீங்கள் எதையாக உரையாடல் தன்மையில் கட்டமைக்கிறீர்களோ, அதற்கு முன் முழு கணக்கீட்டைப் புரிந்துகொள்வது அவசியம்: Claude டோக்கன் பயன்பாடும் பில்லிங்கும் உண்மையில் எப்படி கூடுகின்றன.

systemd கீழ் இயக்கவும்

சுற்றுச்சூழல் கோப்பு ஒழுங்கின் பலன்: ஒவ்வொரு காலையிலும் நேற்றைய பிழைகளைச் சுருக்கிக் காட்டும் ஒரு 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 ஆனது root க்குச் சொந்தமான, mode-600 கோப்பை அனுமதியற்ற explain பயனருக்கு மாறுவதற்கு முன்பே படிக்கிறது. எனவே செயல்முறைக்கு மாறி கிடைக்கிறது, ஆனால் பயனரால் key கோப்பைப் படிக்க முடியாது. systemd-journal குழு log அணுகலை வழங்குகிறது. ஒரு கைமுறை systemctl start உடன் சோதித்து, journalctl -u log-digest.service ஐப் படிக்கவும் — ஒரு தட்டச்சுப் பிழையைக் கண்டறிய 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 தருகிறது என்றால், சேவை அதை ஒருபோதும் பெறவில்லை — systemd ஆனது .bashrc-ஐ படிக்காது என்பதை நினைவில் கொள்ளுங்கள்; EnvironmentFile= சரியான பாதையை சுட்டுகிறதா என சரிபாருங்கள். மற்ற காரணங்கள்: env கோப்பில் ஒட்டப்பட்ட மேற்கோள் குறிகள் (ANTHROPIC_API_KEY="sk-ant-..." — systemd மேற்கோள் குறிகளை வெளியே வைக்கிறது, ஆனால் நீங்கள் ஒட்டுமொத்தமாக மேற்கோளிட்டால் உங்கள் shell wrapper-ன் . file அவற்றை மதிப்பில் வைத்திருக்கும்), பின்னணி வெற்று இடம், அல்லது நீங்கள் கடந்த வாரம் Console-ல் ரத்து செய்த ஒரு key.

மாதிரி பெயர் தவறால் 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 header உள்ளது. நீங்கள் விதிவிலக்கை பார்ப்பதற்கு முன்பு SDK ஏற்கனவே backoff உடன் இரண்டு முறை மறுமுயற்சி செய்துவிட்டது, எனவே தொடர்ச்சியான 429-கள் உங்கள் நிலையான வேகம் உண்மையில் உங்கள் tier-ஐ விட அதிகம் என்பதை குறிக்கிறது — வேலையை batch செய்யுங்கள் அல்லது பரவலாக்குங்கள், மறுமுயற்சி சுழற்சியை இறுக்க வேண்டாம்.

அது உரையை அல்ல, object-ஐ அச்சிடுகிறது. வெளியீடு [TextBlock(citations=None, text='...', type='text')] போல் தெரிகிறது. நீங்கள் blocks-ஐ மறுசெய்து block.type == "text" உள்ளவற்றிலிருந்து .text-ஐ படிப்பதற்கு பதிலாக response.content-ஐ அச்சிட்டீர்கள். மேலே உள்ள ஒவ்வொரு SDK உதாரணமும் இதை சரியாக செய்கிறது; அந்த சுழற்சியை நகலெடுங்கள்.

error: externally-managed-environment. நீங்கள் Ubuntu 24.04-ன் system Python-க்கு எதிராக pip install இயக்கினீர்கள். venv-ஐ பயன்படுத்துங்கள் — உங்களுக்கு முக்கியமான சேவையகத்தில் ஒருபோதும் --break-system-packages செய்ய வேண்டாம்.

துண்டிக்கப்பட்ட பதில்கள். response.stop_reason == "max_tokens" என்பது மாதிரி உங்கள் வெளியீட்டு வரம்பை எண்ணத்தின் நடுவே அடைந்தது என்பதை குறிக்கிறது. வடிவமைக்கப்பட்டபடி செயல்படுகிறது; வரம்பை வேண்டுமென்றே உயர்த்துங்கள்.

உங்கள் முதல் செயலி வேலை செய்ததும், Claude-உடன் ஒரு AI agent-ஐ உருவாக்குதல் அதே API அழைப்புகளை கருவிகளை பயன்படுத்தும் ஒரு agent-ஆக மாற்றுகிறது.

FAQ

Claude API ஐ முயற்சிக்க எவ்வளவு செலவாகும்?

இது போன்ற ஒரு கருவிக்கு இது மிகக் குறைவு. ஜூலை 2026 நிலவரப்படி, Opus 4.8 ஒரு மில்லியன் உள்ளீட்டு tokenகளுக்கு $5 மற்றும் ஒரு மில்லியன் வெளியீட்டு tokenகளுக்கு $25 ஆகும். எனவே ஒரு வழக்கமான log பகுப்பாய்வு — சில ஆயிரம் tokenகள் உள்ளீடு, சில நூறு tokenகள் வெளியீடு — சுமார் இரண்டு சென்ட் ஆகும். Haiku 4.5 ($1/$5) இல் இது அரை சென்டுக்கும் குறைவு. தினசரி சுருக்கங்களை ஒரு மாதம் பெறுவதற்கான செலவு ஒரு காபிக்கும் குறைவு. ஆபத்து ஒரு அழைப்பின் விலை அல்ல; அது வரம்பற்ற மடக்குகள் மற்றும் வரம்பற்ற max_tokens ஆகும். எனவே இந்த வழிகாட்டியில் இரண்டும் வெளிப்படையாக அமைக்கப்படுகின்றன.

Claude API க்கு இலவச அடுக்கு உண்டா?

ஜூலை 2026 நிலவரப்படி தொடர்ச்சியான இலவச அடுக்கு இல்லை. Anthropic-ன் விலை நிர்ணய ஆவணம் கூறுவதாவது, புதிய பயனர்கள் API ஐ சோதிக்க சிறிய அளவு இலவச கடன்களைப் பெறுகிறார்கள் — இது ஒரு முறை சோதனை, சரியான தொகை பதிவு செய்யும்போது Console-ல் காட்டப்படும் — அதன் பிறகு நீங்கள் கணக்கில் பணம் சேர்க்க வேண்டும். உங்கள் நோக்கம் முன்னணி தரம் அல்லாமல் ஒரு கோரிக்கைக்கு பூஜ்ய கூடுதல் செலவு என்றால், மாற்று வழி Ollama உடன் ஒரு open-weight மாதிரியை தாங்களே ஹோஸ்ட் செய்வது ஆகும். இதில் tokenகளுக்கு பதிலாக RAM கட்டணமாக அமையும்.

சேவையகத்தில் எனது API key ஐ எவ்வாறு பாதுகாப்பாக வைப்பது?

குறியீட்டிற்குள் ஒருபோதும் இல்லை, git-ல் ஒருபோதும் இல்லை, .bashrc இலிருந்து ஒருபோதும் ஏற்றுமதி செய்ய வேண்டாம், வரலாற்றை சேமித்து வைக்கும் shell-ல் ஒருபோதும் தட்டச்சு செய்ய வேண்டாம். அதை root க்கு சொந்தமான கோப்பில் 600 அனுமதிகளுடன் வைக்கவும். ஒரு செயல்முறைக்கு ஏற்றவும் — ஊடாடும் பயன்பாட்டிற்கு ஒரு wrapper script, systemd க்கு EnvironmentFile= — மேலும் ஒரு சேவையகம் அல்லது திட்டத்திற்கு ஒரு key என வரையறுக்கவும். இதனால் கசிந்த key ஐ ரத்து செய்வது ஒரு அறுவை சிகிச்சையாக இருக்கும், ஒரு துண்டிப்பு அல்ல. key ஒருபோதும் ஒரு paste தளத்தில் அல்லது ஒரு git commit-ல் இடம்பெற்றால், Console-ல் உடனே அதை ரத்து செய்யவும்; commit ஐ நீக்கினால் கசிவு நீங்காது.

நான் எந்த Claude மாதிரியுடன் தொடங்க வேண்டும்?

வெளியீடுகள் கட்டமைக்க போதுமானதா என்று மதிப்பிடும்போது claude-opus-4-8 உடன் தொடங்கவும் — நீங்கள் யோசனையை முழு தரத்தில் மதிப்பிட வேண்டும், மேலும் பொழுதுபோக்கு அளவில் செலவு வித்தியாசம் சில சென்ட்களே. prompt ஐ உறுதிப்படுத்தியவுடன், உங்கள் உண்மையான உள்ளீடுகளை claude-haiku-4-5 இல் மீண்டும் இயக்கவும்; சுருக்கம், வகைப்படுத்தல் மற்றும் log பகுப்பாய்வுக்கு இது பெரும்பாலும் ஐந்தில் ஒரு பங்கு விலையில் சமமாக இருக்கும். Haiku அல்லது Sonnet க்கு அளவீட்டின் அடிப்படையில் மாறவும், இயல்பாக அல்ல.

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