आपकी पहली प्रोडक्शन API कॉल (लागत-सजग)

🟡मध्यम

एक खिलौना API कॉल सिर्फ़ एक लाइन की होती है। एक प्रोडक्शन कॉल त्रुटियों को संभालती है, आउटपुट स्ट्रीम करती है, लागत पर नज़र रखती है, और सीक्रेट्स को सुरक्षित रखती है। आइए इसे चरण-दर-चरण बनाएँ।

चरण 1 — कॉन्फ़िग से सीक्रेट्स और मॉडल

export ANTHROPIC_API_KEY="sk-ant-..."   # never in source control

मॉडल ID को कॉन्फ़िग में रखें, बिखरे हुए लिटरल्स में नहीं, ताकि माइग्रेशन आसान हो (क्यों)। इसे सोच-समझकर चुनें — मॉडल चुनना।

चरण 2 — एक लचीली, स्ट्रीम की गई कॉल

Python

import os, time, random, anthropic
client = anthropic.Anthropic()
MODEL = os.environ.get("CLAUDE_MODEL", "claude-sonnet-4-6")

def ask_stream(prompt, system=None, max_tokens=1024):
    for attempt in range(5):
        try:
            with client.messages.stream(
                model=MODEL, max_tokens=max_tokens,
                system=system or anthropic.NOT_GIVEN,
                messages=[{"role": "user", "content": prompt}],
            ) as stream:
                for text in stream.text_stream:
                    print(text, end="", flush=True)
                final = stream.get_final_message()
            print()
            usage = final.usage
            print(f"\n[tokens in/out: {usage.input_tokens}/{usage.output_tokens}]")
            return final
        except (anthropic.RateLimitError, anthropic.APIStatusError):
            if attempt == 4: raise
            time.sleep(min(2 ** attempt + random.random(), 30))

TypeScript

import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic();
const MODEL = process.env.CLAUDE_MODEL ?? "claude-sonnet-4-6";

export async function askStream(prompt: string, system?: string, maxTokens = 1024) {
  for (let attempt = 0; attempt < 5; attempt++) {
    try {
      const stream = client.messages.stream({ model: MODEL, max_tokens: maxTokens, system,
        messages: [{ role: "user", content: prompt }] });
      for await (const e of stream)
        if (e.type === "content_block_delta") process.stdout.write(e.delta.text ?? "");
      const final = await stream.finalMessage();
      console.error(`\n[tokens in/out: ${final.usage.input_tokens}/${final.usage.output_tokens}]`);
      return final;
    } catch (e: any) {
      if (attempt === 4 || ![429, 500, 529].includes(e?.status)) throw e;
      await new Promise(r => setTimeout(r, Math.min(2 ** attempt * 1000, 30000)));
    }
  }
}

चरण 3 — लागत का ध्यान रखें

• टोकन उपयोग लॉग करें (ऊपर) ताकि आप देख सकें कि हर कॉल की लागत क्या है।
• max_tokens और मॉडल को सही आकार दें; केंद्रित प्रॉम्प्ट से इनपुट को सीमित करें।
• दोहराए जाने वाले स्थिर प्रीफ़िक्स के लिए, प्रॉम्प्ट कैशिंग जोड़ें।
• देखें टोकन और मूल्य निर्धारण और लागत और लेटेंसी।

चरण 4 — विफलता के रास्तों को संभालें

• अस्थायी त्रुटियों (429/5xx) को बैकऑफ़ के साथ पुनः प्रयास करें (ऊपर); 400 को पुनः प्रयास न करें।
• इनकार को शालीनता से संभालें।
• किसी भी एजेंटिक चीज़ के लिए एक टाइमआउट और एक लागत/इटरेशन बजट सेट करें।

सत्यापित करें

इसे चलाएँ: आपको स्ट्रीम किया गया आउटपुट, एक टोकन-उपयोग लाइन, और यदि आप किसी त्रुटि को बलपूर्वक उत्पन्न करते हैं (जैसे, एक ग़लत की → साफ़ संदेश, क्रैश नहीं) तो शालीन व्यवहार दिखना चाहिए।

आगे

• त्रुटियाँ, रेट लिमिट और विश्वसनीयता
• प्रोडक्शन API स्निपेट्स
• API पर एजेंट बनाना