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

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

కొత్త Ubuntu 24.04 VPSలో నడిచే ఒక command-line సాధనం ఇది. ఇందులో మీరు error message లేదా logలోని ఒక భాగాన్ని pipe చేస్తే, అది plain-English diagnosis ను తిరిగి ఇస్తుంది: journalctl -u nginx -n 50 | explain. ఈ సాధనం సుమారు అరవై lines Pythonతో ఉంటుంది. నిజమైన Claude API applicationకు అవసరమైన అంశాలన్నింటినీ ఇది ఆచరణలో చూపిస్తుంది: సరిగ్గా నిల్వ చేసిన key, virtualenv, SDK response shapes, streaming, typed exception chain, అలాగే మీరు జోక్యం చేసుకోకుండానే నడిచే systemd unit.

ఈ projectను నేను ఉద్దేశపూర్వకంగా ఎంచుకున్నాను. చాలా “మొదటి API app” tutorialsలో మీరు మళ్లీ ఎప్పుడూ తెరవని chatbotను నిర్మిస్తారు. Log explainer serverపై మొదటి రోజు నుంచే ఉపయోగపడుతుంది. అలాగే beginners సాధారణంగా చేసే రెండు తప్పులను ఇది తప్పనిసరిగా ఎదుర్కొనేలా చేస్తుంది: response objectను సరిగ్గా చదవడం, ఖర్చును నియంత్రించడం. API ప్రతి tokenకు billing చేస్తుంది. మీరు నిర్దేశించిన పరిమితులు తప్ప దీనికి మరే ceiling ఉండదు. అందువల్ల cost control ఇక్కడ తర్వాత ఆలోచించాల్సిన విషయం కాదు; ఇది design input. అదే క్రమశిక్షణను తరువాత ఈ VPSలోనే tmuxలో Claude Codeను నడిపేటప్పుడు కూడా పాటించాలి.

Console నుండి API key పొందండి

API access ను platform.claude.com లోని Anthropic Console ద్వారా నిర్వహిస్తారు. ముందుగా sign up చేసి, Settings → API Keys కింద key ను సృష్టించండి (docs నేరుగా platform.claude.com/settings/keys కు లింక్ చేస్తాయి). Key ఒక్కసారి మాత్రమే చూపబడుతుంది. ఇది sk-ant- తో ప్రారంభమవుతుంది. తరువాత దాన్ని మళ్లీ తిరిగి పొందలేరు. వెంటనే copy చేయండి. లేకపోతే దాన్ని delete చేసి కొత్త key ను జారీ చేయండి.

ఖర్చుల విషయానికి వస్తే, July 2026 నాటికి API కోసం నిరంతర free tier లేదు. పరీక్షించడానికి కొత్త users కు కొంత పరిమిత free credits లభిస్తాయని Anthropic pricing docs చెబుతున్నాయి. ఖచ్చితమైన మొత్తం signup సమయంలో Console చూపించే మొత్తమే. ఆ credits అయిపోయిన తరువాత requests విజయవంతం కావాలంటే account కు నిధులు జోడించాలి. ఇది claude.ai subscription కు వేరు. Pro లేదా Max plan లో API credit ఉండదు. అలాగే API key తో chat app కు access లభించదు. Subscription మరియు API మధ్య ఎంచుకోవాలనుకుంటే, ఆ trade-off వేరే అంశం: మీకు నిజంగా అవసరమైన Claude plan ఏది.

Key ను ఒకే project లేదా server కు పరిమితం చేసి సృష్టించండి. Key leak అయితే, తగినంత కాలం గడిచినప్పుడు అలాంటిది ఒకసారి జరుగుతుంది, మిగతా resources కు అంతరాయం కలగకుండా దాన్ని revoke చేయాలి.

.bashrc నుంచి key ను దూరంగా ఉంచండి

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

• ప్రతి process దాన్ని పొందుతుంది. మీ login shell లో export చేసిన environment variable, మీరు ప్రారంభించే ప్రతిదానికీ propagate అవుతుంది. అందులో web app, తన environment ను bug report లో సౌకర్యంగా dump చేసే crash reporter, ఎవరైనా enabled గా వదిలిన phpinfo() page కూడా ఉంటాయి. అందువల్ల key exposure surface “ఈ user ఎప్పుడైనా run చేసే ప్రతిదీ” అవుతుంది.
• దాన్ని టైప్ చేస్తే ~/.bash_history లో చేరుతుంది. export ను చేతితో ఒక్కసారి run చేసినా, మీ key plaintext file లో శాశ్వతంగా ఉంటుంది. అది మీ home directory యొక్క ప్రతి backup లోకీ sync అవుతుంది.
• systemd కి అవసరమైనప్పుడు అది అక్కడ ఉండదు. Services మీ .bashrc ను చదవవు. అందువల్ల script ను unit గా మార్చిన వెంటనే ఈ విధానం విఫలమవుతుంది. సాధారణంగా ఉదయం 6 గంటలకు కారణం తెలియని 401 error కనిపిస్తుంది.

Server పై సరైన విధానం, 600 permissions ఉన్న ప్రత్యేక 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

Key editor swap files లోకి వెళ్లకుండా ఉంచాలనుకుంటే editor బదులుగా printf నుంచి tee ను ఉపయోగించండి. ఏ విధానాన్ని ఎంచుకున్నా, అది -rw------- ను చదువుతోందని మరియు root యాజమాన్యంలో ఉందని ls -l /etc/claude-explain.env తో నిర్ధారించండి. Interactive shells కు key ప్రతి invocation సమయంలో wrapper ద్వారా లభిస్తుంది (కింద చూడండి). systemd కు అది EnvironmentFile= ద్వారా లభిస్తుంది. root privileges తగ్గించే ముందు file ను చదువుతుంది కాబట్టి service user కు దాన్ని చదివే access అవసరం ఉండదు. Key code లో, git లో, ps output లో లేదా shell history లో ఎక్కడా కనిపించదు.

venv లో SDK ను ఇన్‌స్టాల్ చేయండి

Ubuntu 24.04, PEP 668 అమలుతో Python 3.12 ను అందిస్తుంది. అందువల్ల system interpreter పై bare 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)

ఆ 12 పంక్తుల్లోని రెండు అంశాలు API యొక్క ప్రాథమిక విధానాన్ని స్పష్టంగా చూపిస్తాయి. మొదటిది, anthropic.Anthropic() ఎలాంటి arguments లేకుండా environment నుంచి key ను చదువుతుంది; దాన్ని string literal గా ఎప్పుడూ పంపవద్దు. రెండవది, response.content అనేది string కాదు; ఇది content blocks జాబితా. దాన్ని నేరుగా print చేస్తే మొదటిసారి ఉపయోగించేవారికి సాధారణంగా కనిపించే output వస్తుంది:

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

అది bug కాదు; అది object యొక్క repr. Responses లో text, tool calls, thinking వంటి అనేక block types ఉండవచ్చు. అందువల్ల iterate చేసి, .text ను ఉపయోగించే ముందు block.type == "text" ను తనిఖీ చేయాలి. ఈ loop ను మొదటి రోజే అమలు చేస్తే, “ఇది చెత్తను print చేస్తోంది” అనే మొత్తం రకమైన గందరగోళం ఎప్పటికీ ఎదురుకాదు.

ఖచ్చితమైన model ID claude-opus-4-8 ను ఉపయోగించండి. ప్రస్తుత తరం IDs లో date ఉండదు. Date suffix ను జోడించమని చెప్పే అలవాటును లేదా పాత blog post ను అనుసరించవద్దు; అలా చేస్తే 404 వస్తుంది. దీని గురించి క్రింద వివరించాం.

అసలు సాధనం: వివరణ

ఇది పూర్తి ప్రోగ్రామ్. ఇది stdin నుంచి ఇన్‌పుట్ తీసుకుని, diagnosis ను stream చేస్తుంది, errors ను నిర్వహిస్తుంది:

#!/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 గా save చేయండి. Interactive వినియోగం కోసం key ను load చేసే 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 ద్వారా run చేయాలి. లేదా env file కు మీ admin user చెందిన group ను ఇవ్వాలి. File permission ను 644 కు సడలించే బదులు, ఈ రెండింటిలో ఒకదాన్ని ఉద్దేశపూర్వకంగా ఎంచుకోండి.)

Streaming ఎందుకు. client.messages.stream పూర్తి generation పూర్తయ్యే వరకు మౌనంగా ఉండకుండా, tokens వచ్చిన వెంటనే print చేస్తుంది. దీని వల్ల ఎక్కువ output కోసం ఏర్పడే HTTP timeouts కూడా నివారించబడతాయి. అదే కారణంగా SDK non-streaming calls లో చాలా పెద్ద max_tokens values ను నిరాకరిస్తుంది. తరువాత assembled object అవసరమైతే, with block లో stream.get_final_message() ను call చేయండి.

Exception order ఎందుకు ఇలా ఉంది. SDK typed exceptions ను అత్యంత నిర్దిష్టమైనది ముందుగా raise చేస్తుంది. RateLimitError అనేది 429 error; ఇందులో ఎంతసేపు వేచి ఉండాలో తెలిపే retry-after header ఉంటుంది. ఇతర non-2xx responses ను APIStatusError నిర్వహిస్తుంది. Server-side సమస్యలను గుర్తించడానికి e.status_code >= 500 ను పరిశీలించండి. Request కు అసలు response రాకపోతే APIConnectionError వస్తుంది. Retry loop ను నిర్మించే ముందు ఇది గుర్తుంచుకోండి: SDK ఇప్పటికే 429 మరియు 5xx errors ను స్వయంగా retry చేస్తుంది. Default గా exponential backoff తో రెండుసార్లు retry చేస్తుంది (client పై max_retries). మీ except run అయ్యే సమయానికి retries పూర్తై ఉంటాయి. కాబట్టి CLI లో సరైన విధానం error ను report చేసి exit చేయడం. మళ్లీ sleep చేసి request పంపడం కాదు.

వ్యయ నియంత్రణ

APIలో మీరు configure చేసే పరిమితికి మించి built-in monthly cap లేదు. అందువల్ల ప్రతి పొరపాటు తెలియకుండానే ఖర్చును పెంచుతుంది. ఈ అంశానికి ప్రత్యేక section అవసరం.

max_tokens ప్రతి callకు ఖర్చు పరిమితి. Opus 4.8లో output tokens input price కంటే ఐదు రెట్లు ఖరీదైనవి. max_tokens మోడల్ ఉత్పత్తి చేయగల output tokens సంఖ్యకు hard capగా పనిచేస్తుంది. నియంత్రణ తప్పిన prompt వల్ల మీరు అనుమతించిన దానికంటే ఎక్కువ output ఖర్చు కాదు. పనిని బట్టి పరిమాణాన్ని నిర్ణయించండి: log diagnosisకు 1,500 సరిపోతుంది; classification taskకు 100 అవసరం కావచ్చు. stop_reason: "max_tokens" తో responses వాక్యం మధ్యలో ఆగితే పరిమితి చాలా తక్కువగా ఉంది. అప్పుడు దాన్ని ఉద్దేశపూర్వకంగా పెంచండి. ఎల్లప్పుడూ చాలా పెద్ద పరిమితిని defaultగా ఉపయోగించవద్దు.

పంపే ముందు tokens లెక్కించండి. Inputకు కూడా ఖర్చు ఉంటుంది. Logs పరిమాణంలో పెద్దవిగా ఉంటాయి. APIలో counting endpoint ఉంది. దాన్ని ఉచితంగా ఉపయోగించవచ్చు. దీనికి 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. దీనికి 200K context ఉంది. Sonnet 5 (claude-sonnet-5) ధర $3/$15తో మధ్యస్థంగా ఉంటుంది. August 31, 2026 వరకు introductory ధర $2/$10గా ఉంది. స్పష్టంగా చెప్పాలంటే, 2,000-token log excerptకు 500-token answer ఇచ్చినప్పుడు Opusపై ఖర్చు సుమారు $0.0225, Haikuపై $0.0045 ఉంటుంది. Output qualityను అంచనా వేస్తున్నప్పుడు Opusతో ప్రారంభించండి. తరువాత అదే promptsను Haikuపై పరీక్షించండి. అధిక పరిమాణంలో జరిగే సరళమైన transformationsకు ఇది తరచుగా దాదాపు అదే ఫలితాన్ని ఇస్తుంది, కానీ ఖర్చు ఐదో వంతు మాత్రమే. Budgetలో వీటిని hard-code చేసే ముందు pricing pageలో ప్రస్తుత ధరలను నిర్ధారించండి.

వాయిదా వేయగల పనులకు Batches ఉపయోగించండి. Batches API requestsను asynchronousగా process చేస్తుంది. Standard pricesలో 50%కే ఇది పనిచేస్తుంది. చాలా batches ఒక గంటలో పూర్తవుతాయి. Nightly digests, backfills, bulk classification, అలాగే ఎవరైనా ఫలితం కోసం వేచి ఉండాల్సిన అవసరం లేని పనులు అక్కడికి చెందుతాయి.

పునరావృత contextకు prompt caching ఉపయోగించండి. ప్రతి callలో అదే పెద్ద 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 writesకు input priceకు సుమారు 1.25x ఖర్చవుతుంది. Cache readsకు సుమారు 0.1x ఖర్చవుతుంది. TTL 5-minuteగా ఉంటుంది. అందువల్ల ఆ వ్యవధిలోని రెండో callకే మొదటి call ఖర్చు తిరిగి వస్తుంది. ఇక్కడ రెండు విషయాలు గమనించాలి. Cached prefix ప్రతి modelకు నిర్దేశించిన minimumను దాటాలి. Opusలో ఇది కొన్ని వేల tokens కావచ్చు. అందువల్ల చిన్న system prompt అసలు cache కాకపోవచ్చు. అలాగే identical callsలో cache_read_input_tokens సున్నాగానే ఉంటే, ప్రతి requestలో మీ prefixలో ఏదో మారుతోంది. సాధారణంగా timestamp దీనికి కారణమవుతుంది.

Inputగా ఏవి లెక్కించబడతాయో గుర్తుంచుకోండి. System prompts, tool definitions, అలాగే multi-turn conversationsలో ప్రతి turnకు మీరు మళ్లీ పంపే మొత్తం history—all ఇవి input tokensగా bill అవుతాయి. Historyను ఎప్పుడూ trim చేయని chat loopలో ఖర్చు quadraticగా పెరుగుతుంది. Conversational వ్యవస్థను నిర్మించే ముందు పూర్తి లెక్కింపు విధానాన్ని అర్థం చేసుకోవాలి: Claude token usage మరియు billing వాస్తవంగా ఎలా లెక్కించబడతాయి.

systemd కింద అమలు చేయండి

Environment file క్రమశిక్షణ వల్ల కలిగే ప్రయోజనం ఇది: ప్రతి ఉదయం నిన్నటి errors ను సంక్షిప్తంగా చూపించే 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 ఉన్న file ను privileges లేని explain user గా మారకముందే చదువుతుంది. అందువల్ల process కు variable లభిస్తుంది, కానీ ఆ user key file ను చదవలేడు. systemd-journal group log access ను అందిస్తుంది. Manual systemctl start తో పరీక్షించి journalctl -u log-digest.service ను చదవండి. Typo ఉందో తెలుసుకోవడానికి 06:15 వరకు వేచి ఉండకండి. ఈ విధానం shell pipeline పరిధిని దాటితే, అదే key-in-env-file విధానాన్ని అదే box లోని Claude ఆధారిత n8n workflows కు నేరుగా ఉపయోగించవచ్చు.

మీరు చూడగల error strings తో failure modes

పనిచేస్తున్న 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 చేసిన quotes (ANTHROPIC_API_KEY="sk-ant-..."; systemd ఆ quotes ను value నుంచి తొలగిస్తుంది, కానీ మీరు quotes ను అసాధారణంగా ఉపయోగిస్తే మీ 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'}

ప్రస్తుత తరం IDs, 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" ఉన్న వాటి నుంచి .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 లో కొన్ని వేల tokens input గా, కొన్ని వందల tokens output గా ఉంటాయి. అందువల్ల ఒక్కసారి చేసే ఖర్చు సుమారు రెండు cents ఉంటుంది. Haiku 4.5 ($1/$5) తో ఇది అర cent కంటే తక్కువ. ప్రతిరోజూ ఒక నెల పాటు digests రూపొందించినా, ఒక coffee ధర కంటే తక్కువే అవుతుంది. ప్రమాదం ఒక్కో call ధరలో లేదు. పరిమితిలేని loops మరియు పరిమితిలేని max_tokens సమస్య కావచ్చు. అందుకే ఈ guide లో రెండింటినీ స్పష్టంగా సెట్ చేస్తాము.

Claude API కు ఉచిత tier ఉందా?

July 2026 నాటికి నిరంతర free tier లేదు. Anthropic ధరల documentation ప్రకారం, కొత్త users కు API పరీక్షించడానికి కొంత ఉచిత credit లభిస్తుంది. ఇది ఒకసారి మాత్రమే లభించే trial. ఖచ్చితమైన మొత్తం signup సమయంలో Console లో చూపబడుతుంది. ఆ తరువాత account కు నిధులు సమకూర్చాలి. frontier quality అవసరం లేకుండా ప్రతి request కు marginal cost శూన్యంగా ఉండటం మీ లక్ష్యమైతే, ప్రత్యామ్నాయంగా Ollama తో open-weight model ను self-host చేయండి. అప్పుడు tokens కోసం కాకుండా RAM కోసం ఖర్చు చేస్తారు.

Server లో నా API key ను ఎలా సురక్షితంగా ఉంచాలి?

దాన్ని code లో ఎప్పుడూ ఉంచవద్దు. git లో ఎప్పుడూ ఉంచవద్దు. .bashrc నుంచి ఎప్పుడూ export చేయవద్దు. Shell history లో నిలిచిపోయే విధంగా shell లో ఎప్పుడూ type చేయవద్దు. దాన్ని root-owned file లో 600 permissions తో ఉంచండి. ప్రతి process కు అవసరమైనప్పుడు load చేయండి. Interactive use కోసం wrapper script ను, systemd కోసం EnvironmentFile= ను ఉపయోగించండి. ఒక leaked key ను revoke చేయడం సులభంగా ఉండేలా, ప్రతి server లేదా project కు ఒక ప్రత్యేక key ను scope చేయండి. Key ఎప్పుడైనా paste site లేదా git commit లోకి వెళ్లితే, వెంటనే Console లో revoke చేయండి. Commit ను delete చేసినంత మాత్రాన key leak ఆగదు.

ఏ Claude model తో ప్రారంభించాలి?

Outputs పై ఆధారపడి నిర్మించడం సరిపోతుందో అంచనా వేస్తున్నప్పుడు claude-opus-4-8 తో ప్రారంభించండి. మీరు ఆ ఆలోచనను పూర్తి quality తో అంచనా వేయాలి. Hobby స్థాయి usage లో ధర తేడా cents మాత్రమే ఉంటుంది. Prompt స్థిరపడిన తరువాత, మీ నిజమైన inputs ను claude-haiku-4-5 పై మళ్లీ run చేయండి. Summarization, classification మరియు log triage పనుల్లో ఇది తరచుగా ఐదో వంతు ధరకు దాదాపు అదే స్థాయి పనితీరును ఇస్తుంది. Default గా కాకుండా measurement ఆధారంగా Haiku లేదా Sonnet కు మారండి.