SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-06

Claude API மூலம் Python app உருவாக்குவது எப்படி?

Ubuntu 24.04 VPS-ல் Claude API-ஐப் பயன்படுத்தி log-களை விளக்கும் Python கருவியை உருவாக்குங்கள். API key பாதுகாப்பு, streaming, மற்றும் செலவு கட்டுப்பாடு முறைகளை இதில் கற்கலாம்.

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

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

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

Console-லிருந்து API key பெறுதல்

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

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

ஒரு project அல்லது server-க்கு மட்டும் பொருந்தும் வகையில் key-ஐ உருவாக்கவும். ஒரு key கசிந்தால் (நீண்ட கால அடிப்படையில் இது நிகழ வாய்ப்புள்ளது), மற்ற சேவைகளைப் பாதிக்காமல் அந்த ஒரு key-ஐ மட்டும் உங்களால் ரத்து செய்ய முடியும்.

key-ஐ .bashrc-ல் வைக்க வேண்டாம்

இயல்பாகவே பலரும் export ANTHROPIC_API_KEY=sk-ant-...-ஐ ~/.bashrc-ல் சேர்க்க முற்படுவார்கள். அதைச் செய்யாதீர்கள். இதில் மூன்று முக்கிய சிக்கல்கள் உள்ளன:

  • ஒவ்வொரு process-ம் இதை எடுத்துக்கொள்ளும். உங்கள் login shell-ல் export செய்யப்படும் environment variable, நீங்கள் தொடங்கும் அனைத்துக்கும் பரவும். இதில் web app, பிழை அறிக்கையில் (bug report) தற்செயலாக environment-ஐ dump செய்யும் crash reporter, மற்றும் யாரோ தவறுதலாக இயக்கி வைத்திருக்கும் phpinfo() பக்கம் என அனைத்தும் அடங்கும். இதனால், அந்த user இயக்கும் அனைத்துமே key-ஐ வெளிப்படுத்தும் அபாயத்திற்கு உள்ளாகிறது.
  • தட்டச்சு செய்யும் போது ~/.bash_history-ல் பதிவாகிவிடும். ஒருமுறை கைமுறையாக export கட்டளையை இயக்கினால், உங்கள் key plaintext கோப்பில் நிரந்தரமாகத் தங்கிவிடும். இது உங்கள் home directory-ன் அனைத்து backup-களிலும் நகலெடுக்கப்படும்.
  • systemd-க்கு இது தெரியாது. Services உங்கள் .bashrc-ஐ வாசிப்பதில்லை. எனவே, ஒரு script-ஐ unit-ஆக மாற்றும்போது இந்த முறை தோல்வியடையும். இது பெரும்பாலும் அதிகாலை 6 மணிக்கு மர்மமான 401 பிழையாக வெளிப்படும்.

Server-ல் இதற்கான சரியான முறை, 600 அனுமதிகளுடன் கூடிய பிரத்யேக 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 கோப்புகளில் சேமிக்காமல் இருக்க, editor-க்கு பதிலாக printf மூலம் tee-ஐ உருவாக்கவும். எப்படியிருப்பினும், ls -l /etc/claude-explain.env மூலம் அது -rw--------ஐ வாசிக்கிறதா என்பதையும், அதன் உரிமையாளர் root தானா என்பதையும் உறுதிப்படுத்தவும். Interactive shells ஒரு wrapper (கீழே உள்ளது) மூலம் ஒவ்வொரு முறையும் key-ஐப் பெறும். systemd, EnvironmentFile= மூலம் இதைப் பெறும். root பயனர் சலுகைகளைக் குறைப்பதற்கு முன்பே கோப்பை வாசித்துவிடுவதால், service user-க்கு அந்தக் கோப்பை வாசிக்கும் அனுமதி தேவையில்லை. இதனால் key குறியீட்டிலோ (code), git-லோ, ps வெளியீட்டிலோ அல்லது 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

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

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

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

claude-opus-4-8 என்ற சரியான model ID-ஐப் பயன்படுத்தவும். தற்போதைய தலைமுறை ID-களில் தேதி இருக்காது; தேதி suffix-ஐச் சேர்க்கச் சொல்லும் பழைய blog post-களின் வழிகாட்டுதலைப் பின்பற்ற வேண்டாம்; அது 404 பிழையைத் தரும், இதைப் பற்றி கீழே காணலாம்.

உண்மையான கருவி: விளக்கம்

இதோ முழுமையான நிரல், stdin உள்ளீடு, streamed diagnosis வெளியீடு, மற்றும் கையாளப்பட்ட பிழைகள்:

#!/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 வழியாக இயக்க வேண்டும் அல்லது உங்கள் admin பயனர் உறுப்பினராக உள்ள ஒரு group-க்கு அந்த env கோப்பை ஒதுக்க வேண்டும்; கோப்பின் அனுமதியை 644 எனத் தளர்வு செய்வதை விட, இதில் ஏதேனும் ஒன்றை கவனமாகத் தேர்ந்தெடுக்கவும்.)

ஏன் streaming. client.messages.stream முழு generation முடியும் வரை காத்திருக்காமல், tokens வரும்போதே அவற்றை அச்சிடுகிறது. இது நீண்ட வெளியீடுகளின் போது HTTP timeouts ஏற்படுவதைத் தவிர்க்கிறது; இதே காரணத்திற்காக, streaming அல்லாத அழைப்புகளில் மிக அதிகமான max_tokens மதிப்புகளை SDK நிராகரிக்கும். உங்களுக்குப் பிறகு முழுமையான object தேவைப்பட்டால், with block-க்குள் stream.get_final_message()-ஐ அழைக்கவும்.

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

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

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

max_tokens என்பது ஒவ்வொரு அழைப்பிற்கும் நீங்கள் நிர்ணயிக்கும் செலவு உச்சவரம்பு. Opus 4.8-ல், வெளியீட்டு டோக்கன்கள் (output tokens) உள்ளீட்டு விலையை விட ஐந்து மடங்கு அதிகம். max_tokens என்பது ஒரு மாடல் உருவாக்கக்கூடிய அதிகபட்ச வெளியீட்டு டோக்கன்களுக்கான கடுமையான வரம்பு. கட்டுப்பாடற்ற prompt-ஆல் நீங்கள் அனுமதித்த அளவைத் தாண்டி செலவு ஏற்படாது. பணியின் தேவைக்கேற்ப இதை அமைக்கவும்: log diagnosis-க்கு 1,500 டோக்கன்கள் போதுமானது; வகைப்படுத்தும் பணிக்கு (classification task) 100 டோக்கன்கள் போதும். stop_reason: "max_tokens" காரணமாகப் பதில்கள் பாதியிலேயே நின்றால், நீங்கள் நிர்ணயித்த அளவு மிகக் குறைவு என்று அர்த்தம்; அப்போது மட்டும் கவனமாக அளவை உயர்த்தவும்.

அனுப்புவதற்கு முன் டோக்கன்களை எண்ணுங்கள். உள்ளீட்டிற்கும் (input) கட்டணம் உண்டு, logs அளவில் பெரியவை. API-ல் டோக்கன்களை எண்ணுவதற்கு இலவச endpoint உள்ளது (இதற்குச் செய்தி உருவாக்கும் API-லிருந்து தனித்தனி 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-ஐத் தவறுதலாகக் கருவிக்கு அனுப்புவதைத் தவிர்க்க இதைப் பயன்படுத்தவும். இதற்கு tiktoken-ஐப் பயன்படுத்த வேண்டாம்; அது OpenAI-ன் tokenizer. அது Claude டோக்கன்களைச் சாதாரண உரையில் சுமார் 15–20% குறைவாகவும், code-ல் அதைவிட அதிகமாகவும் கணக்கிடும்.

பணிக்கு ஏற்ற மாடலைத் தேர்வு செய்யுங்கள். ஜூலை 2026 நிலவரப்படி, Opus 4.8 (claude-opus-4-8) ஒரு மில்லியன் உள்ளீட்டு டோக்கன்களுக்கு $5 மற்றும் வெளியீட்டு டோக்கன்களுக்கு $25 கட்டணம் வசூலிக்கிறது; Haiku 4.5 (claude-haiku-4-5) 200K context-உடன் $1/$5 கட்டணத்தில் கிடைக்கிறது; Sonnet 5 (claude-sonnet-5) $3/$15 என்ற இடைப்பட்ட விலையில் உள்ளது (ஆகஸ்ட் 31, 2026 வரை அறிமுக விலையாக $2/$10). சுருக்கமாகச் சொன்னால்: 2,000 டோக்கன் log பகுதி மற்றும் 500 டோக்கன் பதிலுக்கு Opus-ல் $0.0225-ம், Haiku-வில் $0.0045-ம் செலவாகும். வெளியீட்டின் தரத்தை உறுதிப்படுத்தும் வரை Opus-ல் தொடங்கவும், பின்னர் அதே prompt-களை Haiku-வில் முயற்சி செய்யவும். அதிக அளவுள்ள, எளிமையான மாற்றங்களுக்கு (simple transformations) ஐந்தில் ஒரு பங்கு விலையில் Haiku பெரும்பாலும் அதே தரத்தைத் தரும். பட்ஜெட்டில் எதையும் hard-code செய்வதற்கு முன், pricing பக்கத்தில் தற்போதைய விலைகளைச் சரிபார்க்கவும்.

காத்திருக்கக்கூடிய பணிகளுக்கு Batches-ஐப் பயன்படுத்தவும். Batches API கோரிக்கைகளை asynchronous முறையில் சாதாரண விலையில் 50% கட்டணத்தில் செயலாக்குகிறது. பெரும்பாலான batches ஒரு மணி நேரத்திற்குள் முடிந்துவிடும். இரவு நேர அறிக்கைகள் (nightly digests), backfills, bulk classification போன்ற மனிதர்கள் காத்திருக்கத் தேவையில்லாத பணிகளுக்கு இதைப் பயன்படுத்தவும்.

மீண்டும் மீண்டும் பயன்படுத்தப்படும் context-க்கு Prompt caching. ஒவ்வொரு அழைப்பிலும் அதே பெரிய 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 எழுதுவதற்கு உள்ளீட்டு விலையை விட சுமார் 1.25 மடங்கு செலவாகும், ஆனால் வாசிப்பதற்கு 0.1 மடங்கு மட்டுமே செலவாகும். 5 நிமிட TTL இருப்பதால், அந்த கால இடைவெளிக்குள் செய்யப்படும் இரண்டாவது அழைப்பிலேயே முதல் அழைப்பின் செலவு ஈடுசெய்யப்படும். இதில் இரண்டு கவனிக்க வேண்டியவை உள்ளன. Cache செய்யப்படும் prefix, ஒவ்வொரு மாடலுக்கும் நிர்ணயிக்கப்பட்ட குறைந்தபட்ச அளவைத் தாண்ட வேண்டும் (Opus-ல் சில ஆயிரம் டோக்கன்கள்). எனவே, சிறிய system prompt-கள் cache ஆகாது. மேலும், ஒரே மாதிரியான அழைப்புகளில் cache_read_input_tokens பூஜ்ஜியமாக இருந்தால், உங்கள் prefix-ல் ஒவ்வொரு முறையும் ஏதோ ஒன்று மாறுகிறது என்று அர்த்தம் (பொதுவாக timestamp-தான் இதற்குக் காரணம்).

எவை உள்ளீடாகக் கருதப்படும் என்பதை நினைவில் கொள்ளுங்கள். System prompts, tool definitions மற்றும் பலமுறை உரையாடும்போது (multi-turn conversations) ஒவ்வொரு முறையும் மீண்டும் அனுப்பப்படும் முழு வரலாறும் உள்ளீட்டு டோக்கன்களாகவே கணக்கிடப்படும். வரலாற்றைச் சுருக்காத (trim) chat loop-ன் செலவு quadratic முறையில் அதிகரிக்கும். உரையாடல் சார்ந்த எதையும் உருவாக்குவதற்கு முன், முழுமையான கணக்கீட்டு முறையைப் புரிந்துகொள்வது அவசியம்: Claude டோக்கன் பயன்பாடு மற்றும் கட்டணம் எவ்வாறு கணக்கிடப்படுகிறது.

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= எதைக் குறிக்கிறது என்பதைக் கவனியுங்கள்: root-க்குச் சொந்தமான, mode-600 அனுமதி கொண்ட கோப்பை, unprivileged explain பயனராக மாறுவதற்கு முன்பே systemd வாசித்துவிடும். இதனால், அந்தப் பயனர் key கோப்பை வாசிக்க முடியாவிட்டாலும், process-க்குத் தேவையான variable கிடைத்துவிடும். systemd-journal group, log-ஐ அணுகும் உரிமையை வழங்குகிறது. ஒரு manual systemctl start மூலம் சோதித்து, journalctl -u log-digest.service-ஐ வாசித்துப் பார்க்கவும்; தட்டச்சுப் பிழையைக் கண்டறிய 06:15 வரை காத்திருக்க வேண்டாம். இந்த முறை ஒரு shell pipeline-க்கு அப்பாற்பட்டு வளரும்போது, அதே key-in-env-file அணுகுமுறையை அதே server-ல் உள்ள Claude-powered n8n workflows-க்கும் நேரடியாகப் பயன்படுத்தலாம்.

தோல்வி முறைகள் மற்றும் நீங்கள் காணும் சரங்கள் (strings)

செயல்படும் 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= சரியான பாதையைச் சுட்டிக்காட்டுகிறதா என்று சரிபார்க்கவும். பிற காரணங்கள்: env கோப்பில் உள்ள மேற்கோள் குறிகள் (ANTHROPIC_API_KEY="sk-ant-...", systemd மேற்கோள் குறிகளை நீக்கிவிடும், ஆனால் உங்கள் shell wrapper-ன் . file அவற்றை மதிப்பில் அப்படியே வைத்திருக்கும்), இறுதியில் உள்ள தேவையற்ற இடைவெளிகள் (trailing whitespace), அல்லது கடந்த வாரம் Console-ல் நீங்கள் ரத்து செய்த key.

மாதிரி (model) பெயரில் உள்ள எழுத்துப் பிழையால் 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. இவற்றை மாதிரிகளின் ஆவணங்களிலிருந்து (models documentation) நகலெடுக்கவும்; நினைவிலிருந்தோ அல்லது பழைய tutorial-களிலிருந்தோ எடுக்க வேண்டாம்.

429 rate_limit_error. பிழை வகைச் சரம் (error type string) rate_limit_error ஆகும். பதில் செய்தியில் retry-after தலைப்பு (header) இருக்கும், அதில் காத்திருக்க வேண்டிய வினாடிகள் குறிப்பிடப்பட்டிருக்கும். நீங்கள் இந்த exception-ஐக் காண்பதற்கு முன்பே, SDK இரண்டு முறை backoff செய்து மீண்டும் முயன்றிருக்கும். எனவே, தொடர்ந்து 429 பிழை ஏற்பட்டால், உங்கள் பயன்பாடு அனுமதிக்கப்பட்ட அளவைத் தாண்டியுள்ளது என்று பொருள். பணிகளைத் தொகுப்பாக (batch) மாற்றவும் அல்லது கால இடைவெளியில் செய்யவும்; retry loop-ஐ வேகப்படுத்த வேண்டாம்.

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

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

FAQ

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

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

Claude API-க்கு இலவச அடுக்கு (free tier) உள்ளதா?

ஜூலை 2026 நிலவரப்படி, தொடர்ந்து பயன்படுத்தக்கூடிய இலவச அடுக்கு எதுவும் இல்லை. Anthropic-ன் விலை நிர்ணய ஆவணங்களின்படி, புதிய பயனர்களுக்கு API-ஐச் சோதிக்க ஒருமுறை மட்டும் பயன்படுத்தக்கூடிய சிறிய அளவிலான இலவச credits வழங்கப்படுகின்றன. பதிவு செய்யும் போது Console-ல் இதன் சரியான அளவு காட்டப்படும், அதன் பிறகு நீங்கள் கணக்கில் பணம் செலுத்த வேண்டும். ஒவ்வொரு கோரிக்கைக்கும் (request) செலவில்லாமல் இருக்க வேண்டும் என்பது உங்கள் நோக்கம் என்றால், அதற்குப் பதிலாக Ollama மூலம் open-weight model-ஐ self-host செய்து, tokens-க்கு பதிலாக RAM-ஐப் பயன்படுத்தலாம்.

server-ல் எனது API key-ஐ எவ்வாறு பாதுகாப்பாக வைத்திருப்பது?

குறியீட்டிலோ (code), git-லோ, .bashrc-லிருந்து export செய்தோ அல்லது history-ல் சேமிக்கப்படும் shell-லோ ஒருபோதும் API key-ஐ உள்ளிட வேண்டாம். root-க்குச் சொந்தமான கோப்பில் 600 அனுமதிகளுடன் அதைச் சேமிக்கவும். ஒவ்வொரு process-க்கும் அதைத் தனித்தனியாக ஏற்றவும். interactive பயன்பாட்டிற்கு ஒரு wrapper script-ஐப் பயன்படுத்தவும், systemd-க்கு EnvironmentFile=-ஐப் பயன்படுத்தவும். ஒவ்வொரு server-க்கும் அல்லது project-க்கும் ஒரு key-ஐ மட்டும் ஒதுக்கவும்; இதன் மூலம் ஒரு key கசிந்தால், முழு அமைப்பையும் பாதிக்காமல் அந்த ஒரு key-ஐ மட்டும் நீக்க முடியும். ஒருவேளை key ஏதேனும் paste site-லோ அல்லது git commit-லோ கசிந்துவிட்டால், உடனடியாக Console-ல் அதை revoke செய்யவும்; commit-ஐ நீக்குவது கசிவைத் தடுக்காது.

நான் எந்த Claude model-ஐ முதலில் பயன்படுத்தத் தொடங்க வேண்டும்?

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

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