ஆல் Matt Connor 2026-07-15 · புதுப்பிக்கப்பட்டது 2026-08-07

Ubuntu VPS-ல் Claude API பயன்படுத்துவது எப்படி?

Ubuntu 24.04 VPS-ல் Claude API மூலம் Python log-explainer உருவாக்குவது எப்படி? 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-ஐ விளக்கும் கருவி, server-ல் முதல் நாளிலிருந்தே பயனுள்ளதாக இருக்கும். இது ஆரம்ப நிலையில் உள்ளவர்கள் தவறு செய்யும் இரண்டு முக்கியமான விஷயங்களைக் கற்றுக்கொள்ள உதவுகிறது: response object-ஐச் சரியாக வாசிப்பது மற்றும் செலவைக் கட்டுப்படுத்துவது. API-ன் கட்டணம் token அடிப்படையில் வசூலிக்கப்படுகிறது. நீங்கள் நிர்ணயிக்கும் வரம்பைத் தவிர வேறு உச்சவரம்பு எதுவும் இல்லை. எனவே, செலவுக் கட்டுப்பாடு என்பது இங்கே ஒரு கூடுதல் அம்சம் அல்ல, அது வடிவமைப்பின் ஒரு முக்கிய அங்கமாகும். இதே ஒழுக்கமுறைதான், நீங்கள் இதே 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- என்று தொடங்கும். இதை மீண்டும் பெற முடியாது என்பதால், உடனடியாக நகலெடுக்கவும் அல்லது நீக்கிவிட்டு புதியதாக உருவாக்கவும்.

கட்டணம் குறித்து: ஜூலை 2026 நிலவரப்படி, API-க்கு என்று தொடர்ந்து இலவச அடுக்கு (free tier) எதுவும் இல்லை. Anthropic-ன் விலை நிர்ணய ஆவணங்களின்படி, புதிய பயனர்களுக்குச் சோதித்துப் பார்ப்பதற்காகச் சிறிய அளவிலான இலவச credits வழங்கப்படும்; பதிவு செய்யும் போது Console-ல் காட்டப்படும் தொகையே துல்லியமானது. அந்த credits தீர்ந்த பிறகு, கோரிக்கைகள் (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) சூழலைத் தானாகவே பதிவேற்றும் 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, privileges-ஐக் குறைப்பதற்கு முன்பே இந்தக் கோப்பை வாசித்துவிடும், எனவே service user-க்கு இந்தக் கோப்பை வாசிக்கும் அனுமதி தேவையில்லை. key ஒருபோதும் code-ல், git-ல், ps வெளியீட்டில் அல்லது shell history-ல் இடம்பெறாது.

venv-ல் SDK-ஐ நிறுவுதல்

Ubuntu 24.04, PEP 668 அமலாக்கத்துடன் 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

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

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

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

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

The actual tool: explain

Here is the full program, stdin in, streamed diagnosis out, errors handled:

#!/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())

Save it as /opt/explain/explain.py, then add a wrapper that loads the key for interactive use:

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

(The wrapper needs to run via sudo or the env file needs a group your admin user belongs to, pick one deliberately rather than loosening the file to 644.)

Why streaming. client.messages.stream prints tokens as they arrive instead of sitting silent for the full generation, and it sidesteps HTTP timeouts on long outputs, the SDK will actually refuse very large max_tokens values on non-streaming calls for exactly that reason. If you need the assembled object afterwards, call stream.get_final_message() inside the with block.

Why that exception order. The SDK raises typed exceptions, most-specific first: RateLimitError is a 429 and carries a retry-after header telling you how long to wait; APIStatusError covers other non-2xx responses (check e.status_code >= 500 for server-side trouble); APIConnectionError means the request never got a response at all. And before you build a retry loop: the SDK already retries 429s and 5xx errors itself, twice by default with exponential backoff (max_retries on the client). By the time your except runs, the retries are spent, so the right move in a CLI is to report and exit, not to sleep and hammer.

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

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

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

அனுப்புவதற்கு முன் கணக்கிடுங்கள். உள்ளீட்டிற்கும் (input) கட்டணம் உண்டு, logs அளவில் பெரியவை. API-ல் இதற்கென இலவசமாகப் பயன்படுத்தக்கூடிய counting 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-வில் முயற்சி செய்யவும். அதிக அளவிலான எளிய மாற்றங்களுக்கு, ஐந்தில் ஒரு பங்கு விலையில் Haiku பெரும்பாலும் அதே தரத்தைத் தரும். பட்ஜெட்டில் இதைக் குறிப்பிடுவதற்கு முன், pricing பக்கத்தில் தற்போதைய விலையைச் சரிபார்க்கவும்.

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

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

எவை உள்ளீடாகக் கருதப்படும் என்பதை நினைவில் கொள்ளுங்கள். System prompts, tool definitions மற்றும் பலமுறை உரையாடும்போது நீங்கள் மீண்டும் அனுப்பும் முழு வரலாறும் உள்ளீட்டு டோக்கன்களாகவே கணக்கிடப்படும். வரலாற்றைச் சுருக்காத chat loop-ன் செலவு வர்க்க முறையில் (quadratically) அதிகரிக்கும். எதையும் உருவாக்கும் முன் முழுமையான கணக்கீட்டு முறையைப் புரிந்துகொள்வது அவசியம்: 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= உங்களுக்கு என்ன பயனைத் தருகிறது என்பதைக் கவனியுங்கள்: systemd, root-க்குச் சொந்தமான mode-600 கோப்பை, explain பயனராக மாறுவதற்கு முன்பே வாசித்துவிடும். இதனால், அந்தப் பயனர் 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-க்கு நேரடியாகப் பயன்படுத்தலாம்.

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

செயல்படும் 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 பிழை. தற்போதைய model 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 ஆவணத்திலிருந்து நகலெடுக்கவும், நினைவிலிருந்து அல்லது பழைய tutorial-லிருந்து எடுக்க வேண்டாம்.

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

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

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

பாதியில் நின்ற பதில்கள். 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) பயன்படுத்தினால் அரை சென்ட்டிற்கும் குறைவாகவே செலவாகும். ஒரு மாதத்திற்கான தினசரி சுருக்கங்கள் (daily digests) ஒரு காபி விலையை விடக் குறைவு. ஒருமுறை அழைப்பதற்கான (per-call) விலை ஆபத்தானது அல்ல; மாறாக, முடிவில்லாத 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-ல் தட்டச்சு செய்யாதீர்கள். இதை root-க்கு சொந்தமான கோப்பில் 600 அனுமதிகளுடன் சேமிக்கவும். ஒவ்வொரு process-க்கும் தனித்தனியாக ஏற்றவும், interactive பயன்பாட்டிற்கு wrapper script-ஐப் பயன்படுத்தவும், systemd-க்கு EnvironmentFile=-ஐப் பயன்படுத்தவும். ஒவ்வொரு server அல்லது project-க்கும் தனித்தனி key-ஐப் பயன்படுத்துங்கள்; இதன் மூலம் ஒரு key கசிந்தால், முழு அமைப்பையும் பாதிக்காமல் அந்த குறிப்பிட்ட key-ஐ மட்டும் நீக்க முடியும். ஒரு key paste தளத்திலோ அல்லது git commit-லோ கசிந்துவிட்டால், உடனடியாக Console-ல் அதை revoke செய்யுங்கள்; commit-ஐ நீக்குவது மட்டும் கசிவைத் தடுக்காது.

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

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

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