Claude API ट्यूटोरियल शुरुआती के लिए: पूर्ण आरंभ गाइड

TL;DR: Claude API आपको Anthropic के AI मॉडल को अपने स्वयं के एप्लिकेशन में एकीकृत करने देता है। यह गाइड आपको शून्य से कार्यशील कोड तक ले जाता है — प्रमाणीकरण, आपकी पहली API कॉल, स्ट्रीमिंग प्रतिक्रियाएं, बातचीत प्रबंधन, उपकरण उपयोग, और उत्पादन सर्वोत्तम प्रथाओं को कवर करता है — पूरे समय कॉपी-पेस्ट Python और JavaScript उदाहरणों के साथ।

Claude API क्या है?

Claude API Anthropic का प्रोग्रामेटिक इंटरफेस है जो Claude के भाषा मॉडल को सीधे आपके एप्लिकेशन, स्क्रिप्ट, वर्कफ़्लो और उत्पादों में एकीकृत करने के लिए है। Claude.ai वेब इंटरफेस का उपयोग करने के बजाय, API आपको पूर्ण प्रोग्रामेटिक नियंत्रण देता है — आप टेक्स्ट भेजते हैं, आपको टेक्स्ट (या संरचित डेटा) वापस मिलता है, और आप निर्णय लेते हैं कि आपका एप्लिकेशन इसका उपयोग कैसे करेगा।

API सरल चैटबॉट से लेकर परिष्कृत मल्टी-एजेंट सिस्टम तक सब कुछ शक्ति प्रदान करता है। डेवलपर इसका उपयोग ग्राहक सेवा स्वचालन, दस्तावेज विश्लेषण पाइपलाइन, कोड जनरेशन उपकरण, सामग्री संशोधन प्रणाली, डेटा निष्कर्षण वर्कफ़्लो और बहुत कुछ बनाने के लिए करते हैं। कोई भी कार्य जो Claude ब्राउज़र में कर सकता है, वह API के माध्यम से कर सकता है — आपके स्वयं के उत्पाद के अंदर एम्बेड किया गया।

2026 तक, API तीन मुख्य मॉडल परिवारों तक पहुंच प्रदान करता है: Claude Opus 4.7 (सबसे सक्षम, 1M टोकन संदर्भ, जटिल तर्क के लिए आदर्श), Claude Sonnet 4.6 (संतुलित प्रदर्शन और गति, अधिकांश उत्पादन कार्यों के लिए सर्वश्रेष्ठ), और Claude Haiku 4.5 (सबसे तेज़ और सस्ता, उच्च-मात्रा, विलंबता-संवेदनशील कार्यों के लिए उत्तम)। प्रत्येक मॉडल एक एकल एकीकृत API एंडपॉइंट के माध्यम से उपलब्ध है जिसमें एक सुसंगत अनुरोध/प्रतिक्रिया प्रारूप है।

मूल्य निर्धारण टोकन-आधारित है — लगभग 750 शब्द लगभग 1,000 टोकन के बराबर है। इनपुट टोकन (जो आप भेजते हैं) और आउटपुट टोकन (जो Claude उत्पन्न करता है) अलग-अलग मूल्य निर्धारित हैं, इनपुट सस्ता है। एक विशिष्ट API कॉल 500 इनपुट टोकन का उपयोग कर सकता है और 300 आउटपुट टोकन उत्पन्न कर सकता है, जिसकी कीमत एक सेंट का एक अंश है। Claude API बड़े पैमाने पर उत्पादन कार्यों के लिए प्रति-सीट सदस्यता मूल्य निर्धारण की तुलना में काफी अधिक लागत-प्रभावी है।

यदि आप API लागतों के लिए प्रतिबद्ध होने से पहले Claude की क्षमताओं के साथ प्रयोग करना चाहते हैं, FreeClaude एक रेफरल प्रोग्राम के माध्यम से Claude Max x20 तक मुफ्त पहुंच प्रदान करता है जिसमें कोई क्रेडिट कार्ड की आवश्यकता नहीं है।

अपने पर्यावरण को सेट अप करना

किसी भी कोड को लिखने से पहले, आपको तीन चीजों की आवश्यकता है: एक Anthropic खाता, एक API कुंजी, और आपके प्रोजेक्ट में SDK स्थापित।

चरण 1: एक Anthropic खाता बनाएं

console.anthropic.com पर जाएं और साइन अप करें। नए खातों को प्रारंभिक परीक्षण के लिए एक छोटा क्रेडिट बैलेंस मिलता है — आमतौर पर सैकड़ों परीक्षण कॉल के लिए पर्याप्त। एक बार क्रेडिट समाप्त हो जाने के बाद, एक भुगतान विधि जोड़ें। API मूल्य निर्धारण कोई न्यूनतम प्रतिबद्धता के साथ भुगतान-जैसे-आप-जाते हैं है।

चरण 2: एक API कुंजी बनाएं

Anthropic कंसोल में, सेटिंग्स → API कुंजियाँ → कुंजी बनाएं पर नेविगेट करें। इसे एक वर्णनात्मक नाम दें (जैसे "dev-local")। कुंजी तुरंत कॉपी करें — यह केवल एक बार दिखाई जाती है। इसे पासवर्ड मैनेजर या AWS Secrets Manager जैसे सीक्रेट्स मैनेजर में स्टोर करें। कभी भी API कुंजी को सोर्स कोड में हार्डकोड न करें।

चरण 3: SDK स्थापित करें

Anthropic Python और TypeScript/JavaScript के लिए आधिकारिक SDK प्रदान करता है। दोनों सक्रिय रूप से बनाए रखे जाते हैं और नई मॉडल रिलीज़ के साथ सिंक रखे जाते हैं।

# Python
pip install anthropic

# Node.js / TypeScript
npm install @anthropic-ai/sdk

चरण 4: अपनी API कुंजी को एक पर्यावरण चर के रूप में सेट करें

SDK स्वचालित रूप से ANTHROPIC_API_KEY पर्यावरण चर को पढ़ता है:

export ANTHROPIC_API_KEY="sk-ant-..."

.env फ़ाइल का उपयोग करने वाले प्रोजेक्ट्स के लिए, python-dotenv (Python) या dotenv (Node) स्थापित करें और इसे स्टार्टअप पर लोड करें। .env को .gitignore में तुरंत जोड़ें — कभी भी साख को संस्करण नियंत्रण में कमिट न करें।

अपनी पहली API कॉल करना

अपने वातावरण के साथ सेट अप करने के बाद, यहाँ एक कार्यशील API कॉल करने के लिए न्यूनतम कोड है — Claude API विकास का "हैलो वर्ल्ड"।

Python

import anthropic

client = anthropic.Anthropic()

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Explain what an API is in two sentences."}
    ]
)

print(message.content[0].text)

JavaScript / Node.js

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

const message = await client.messages.create({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  messages: [
    { role: 'user', content: 'Explain what an API is in two sentences.' }
  ]
});

console.log(message.content[0].text);

मुख्य पैरामीटर को विभाजित करते हुए: model निर्दिष्ट करता है कि कौन सा Claude मॉडल उपयोग करना है। max_tokens प्रतिक्रिया की लंबाई को सीमित करता है — बहुत कम प्रतिक्रियाएं काट देता है, बहुत अधिक कुछ भी बर्बाद नहीं करता जब तक Claude उन टोकन का उपयोग नहीं करता। messages वार्तालाप बारी का एक सरणी है, प्रत्येक में एक role (user या assistant) और content।

प्रतिक्रिया ऑब्जेक्ट में सामग्री ब्लॉक की एक सरणी होती है। मानक पाठ प्रतिक्रियाओं के लिए, पाठ message.content[0].text में है। प्रतिक्रिया में उपयोग डेटा भी शामिल है: message.usage.input_tokens और message.usage.output_tokens — लागत की निगरानी के लिए पहले दिन से उपयोगी।

बहु-मोड़ वार्तालाप प्रबंधित करना

Claude API स्टेटलेस है — यह सर्वर पर वार्तालाप इतिहास संग्रहीत नहीं करता। आपके अनुप्रयोग को वार्तालाप ट्रैक करना चाहिए और प्रत्येक अनुरोध के साथ पूरा इतिहास भेजना चाहिए।

import anthropic

client = anthropic.Anthropic()
conversation = []

def chat(user_message):
    conversation.append({"role": "user", "content": user_message})
    response = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=1024,
        messages=conversation
    )
    assistant_message = response.content[0].text
    conversation.append({"role": "assistant", "content": assistant_message})
    return assistant_message

print(chat("My name is Alex and I'm learning Python."))
print(chat("What's a good first project for someone like me?"))
print(chat("How long will that take to build?"))

conversation सूची प्रत्येक मोड़ के साथ बढ़ती है, और पूरी सूची हर अनुरोध के साथ भेजी जाती है। Claude को पूरा संदर्भ प्राप्त होता है और वह पहले कही गई किसी भी चीज़ का संदर्भ दे सकता है। बहुत लंबे सत्रों के लिए, सारांश लागू करें: समय-समय पर Claude को वार्तालाप को सारांशित करने के लिए कहें, फिर संदर्भ विंडो सीमा के भीतर रहने के लिए इतिहास को उस सारांश से बदलें।

वास्तविक समय में प्रतिक्रियाएं स्ट्रीम करना

डिफ़ॉल्ट रूप से, API पूरी प्रतिक्रिया उत्पन्न होने तक प्रतीक्षा करता है इससे पहले कि यह इसे भेजे। स्ट्रीमिंग इसे हल करती है — आप टोकन को उत्पन्न होने के साथ ही प्राप्त करते हैं, टाइपराइटर प्रभाव को सक्षम करते हैं जो आप Claude.ai पर देखते हैं और माना जाने वाला प्रदर्शन में नाटकीय रूप से सुधार करते हैं।

Python स्ट्रीमिंग

import anthropic

client = anthropic.Anthropic()

with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Write a detailed explanation of machine learning."}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
print()

JavaScript स्ट्रीमिंग

const stream = await client.messages.stream({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Write a detailed explanation of machine learning.' }]
});

for await (const chunk of stream.textStream) {
  process.stdout.write(chunk);
}
console.log();

500-शब्द की प्रतिक्रिया उत्पन्न करने में लगभग 5–8 सेकंड लगते हैं। स्ट्रीमिंग के बिना, उपयोगकर्ता पूरे समय एक खाली स्क्रीन देखते हैं। स्ट्रीमिंग के साथ, वे पहले सेकंड के भीतर पढ़ना शुरू कर देते हैं। कुल पीढ़ी का समय समान है, लेकिन उपयोगकर्ता अनुभव रूपांतरित है। स्ट्रीमिंग किसी भी उपयोगकर्ता-सामना करने वाले अनुप्रयोग के लिए आवश्यक है।

टूल उपयोग और फ़ंक्शन कॉलिंग

टूल उपयोग Claude को बातचीत के दौरान बाहरी सिस्टम से डेटा का अनुरोध करने की अनुमति देता है — डेटाबेस, API, फ़ाइल सिस्टम — जिससे यह वास्तविक समय की जानकारी के साथ काम करने और दुनिया में कार्रवाই करने में सक्षम होता है।

import anthropic, json

client = anthropic.Anthropic()

tools = [{
    "name": "get_weather",
    "description": "Get current weather for a city",
    "input_schema": {
        "type": "object",
        "properties": {
            "city": {"type": "string", "description": "City name"},
            "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
        },
        "required": ["city"]
    }
}]

def get_weather(city, unit="celsius"):
    return {"temperature": 22, "condition": "sunny", "city": city}

messages = [{"role": "user", "content": "What's the weather in Paris?"}]
response = client.messages.create(
    model="claude-sonnet-4-6", max_tokens=1024, tools=tools, messages=messages
)

if response.stop_reason == "tool_use":
    tool_use = next(b for b in response.content if b.type == "tool_use")
    result = get_weather(**tool_use.input)
    messages.append({"role": "assistant", "content": response.content})
    messages.append({"role": "user", "content": [
        {"type": "tool_result", "tool_use_id": tool_use.id, "content": json.dumps(result)}
    ]})
    final = client.messages.create(
        model="claude-sonnet-4-6", max_tokens=1024, tools=tools, messages=messages
    )
    print(final.content[0].text)

टूल उपयोग डेटाबेस की क्वेरी करना, बाहरी API को कॉल करना, फ़ाइलों को पढ़ना और लिखना, कोड निष्पादित करना, और व्यावसायिक सिस्टम के साथ एकीकृत करना सक्षम बनाता है। Claude उपयोगकर्ता के अनुरोध और टूल के विवरण के आधार पर एक टूल को कब कॉल करना है यह तय करता है — विवरण पाठ महत्वपूर्ण है, क्योंकि Claude इसे पढ़कर प्रासंगिकता निर्धारित करता है।

सही Claude मॉडल का चयन

मॉडल का चयन लागत और गुणवत्ता दोनों को महत्वपूर्ण रूप से प्रभावित करता है। प्रत्येक मॉडल के पास विशिष्ट उपयोग के मामलों के लिए उपयुक्त एक अलग प्रदर्शन प्रोफ़ाइल है।

Claude Haiku 4.5 — सबसे तेज़ और सबसे सस्ता। सर्वश्रेष्ठ: वर्गीकरण, सरल प्रश्न और उत्तर, संयम, संरचित पाठ से डेटा निष्कर्षण, उच्च-मात्रा बैच प्रसंस्करण के लिए। छोटे आउटपुट के लिए 1 सेकंड से कम प्रतिक्रिया समय।

Claude Sonnet 4.6 — क्षमता और लागत का सर्वश्रेष्ठ संतुलन। संभालता है: जटिल लेखन, कोड जनरेशन, विस्तृत विश्लेषण, बहु-चरणीय तर्क, ग्राहक-सामना करने वाली चैट। अधिकांश उत्पादन अनुप्रयोगों के लिए सही डिफ़ॉल्ट — Opus गुणवत्ता के पास काफी कम लागत पर।

Claude Opus 4.7 — सबसे सक्षम, 1M टोकन संदर्भ। उपयोग: बहुत लंबे दस्तावेजों में अनुसंधान संश्लेषण, जटिल कोड आर्किटेक्चर, उच्च-दांव वाला लेखन, और ऐसे कार्य जहां आउटपुट गुणवत्ता लागत या विलंबता से अधिक महत्वपूर्ण है। Haiku की तुलना में लगभग 15x अधिक खर्च — उन कार्यों के लिए आरक्षित करें जिन्हें सच में इसकी आवश्यकता है।

एक व्यावहारिक उत्पादन रणनीति: सभी अनुरोधों के लिए Sonnet को डिफ़ॉल्ट करें, एक राउटिंग परत लागू करें जो जटिलता थ्रेसहोल्ड (प्रॉम्प्ट लंबाई, कार्य प्रकार, स्पष्ट उपयोगकर्ता अनुरोध) से ऊपर के अनुरोधों के लिए Opus में अपग्रेड करें। यह लागत को अनुकूलित करता है जबकि यह सुनिश्चित करता है कि गुणवत्ता जहां सबसे महत्वपूर्ण है वहां मौजूद है।

उत्पादन सर्वोत्तम प्रथाएं

घातीय बैकऑफ़ के साथ त्रुटियों को संभालें

import anthropic, time

client = anthropic.Anthropic()

def call_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.messages.create(
                model="claude-sonnet-4-6",
                max_tokens=1024,
                messages=messages
            )
        except anthropic.RateLimitError:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
        except anthropic.APIError as e:
            if e.status_code >= 500:
                time.sleep(1)
            else:
                raise

system पैरामीटर के माध्यम से सिस्टम प्रॉम्प्ट का उपयोग करें

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system="You are a concise technical assistant. Respond in plain text, no markdown unless explicitly asked. Keep answers under 200 words.",
    messages=[{"role": "user", "content": user_input}]
)

दिन एक से टोकन उपयोग को ट्रैक करें

प्रत्येक प्रतिक्रिया से usage.input_tokens और usage.output_tokens लॉग करें। यह आपको महंगे अनुरोधों की पहचान करने, प्रॉम्प्ट इंजेक्शन प्रयासों को पहचानने, और मासिक API व्यय को सटीक रूप से पूर्वानुमान करने देता है। टोकन निगरानी को शुरुआत से ही लागू करना बाद में रेट्रोफिट करने से बहुत आसान है।

दोहराए गए संदर्भ के लिए प्रॉम्प्ट कैशिंग सक्षम करें

उन कार्यों के लिए जहां एक बड़ी सिस्टम प्रॉम्प्ट या संदर्भ दस्तावेज़ को कई अनुरोधों में पुनः उपयोग किया जाता है, प्रासंगिक सामग्री ब्लॉक में "cache_control": {"type": "ephemeral"} जोड़कर प्रॉम्प्ट कैशिंग सक्षम करें। कैश किए गए टोकन समान सामग्री को बार-बार पुनः प्रोसेस करने की तुलना में काफी कम खर्च करते हैं — लंबी सिस्टम प्रॉम्प्ट वाले अनुप्रयोगों के लिए एक प्रमुख लागत बचत।

अनुप्रयोग स्तर पर दर सीमा हैंडलिंग लागू करें

पुनः प्रयास तर्क के साथ भी, लगातार उच्च-थ्रूपुट अनुप्रयोगों को कतार-आधारित दर सीमा प्रबंधन की आवश्यकता है। अपनी अनुप्रयोग परत में एक टोकन बाल्टी या स्लाइडिंग विंडो दर सीमा लागू करें ताकि आप पहले स्थान पर कभी API की दर सीमाओं को न मारें, बजाय अस्वीकार होने के बाद पूरी तरह से पुनः प्रयास तर्क पर निर्भर करने के।

अक्सर पूछे जाने वाले प्रश्न

क्या Claude API का उपयोग करने के लिए मुझे एक भुगतान योजना की आवश्यकता है?

नए Anthropic खातों को प्रारंभिक परीक्षण के लिए निःशुल्क क्रेडिट प्राप्त होते हैं। उन क्रेडिट से परे, API पे-ऐज़-यू-गो है — एक भुगतान विधि जोड़ें और केवल उसी के लिए भुगतान करें जो आप उपयोग करते हैं। API एक्सेस के लिए कोई आवश्यक मासिक सदस्यता नहीं है।

Claude API और Claude.ai के बीच क्या अंतर है?

Claude.ai उपभोक्ता वेब और मोबाइल इंटरफेस है। API डेवलपर्स के लिए है जो अपने स्वयं के अनुप्रयोग बना रहे हैं। उनके पास अलग बिलिंग है। यदि आप बिना कोड लिखे Claude चाहते हैं, तो FreeClaude रेफरल के माध्यम से मुफ्त Claude Max x20 एक्सेस प्रदान करता है।

मैं उन दस्तावेज़ों को कैसे हैंडल करूँ जो संदर्भ सीमाओं से अधिक हों?

संदर्भ विंडो के भीतर दस्तावेज़ों के लिए (Opus 4.7 के साथ 1M टोकन तक), संपूर्ण पाठ को प्रॉम्प्ट में शामिल करें। बड़े संग्रह के लिए, पुनः प्राप्ति-संवर्धित पीढ़ी (RAG) का उपयोग करें: दस्तावेज़ों को खंडित करें, उन्हें एक वेक्टर डेटाबेस के साथ एम्बेड करें, और प्रत्येक क्वेरी के लिए केवल प्रासंगिक अनुभाग पुनः प्राप्त करें।

क्या मैं वाणिज्यिक अनुप्रयोगों के लिए Claude API का उपयोग कर सकता हूँ?

हाँ। Anthropic की उपयोग नीति व्यावहारिक उपयोग को उनकी स्वीकार्य उपयोग दिशानिर्देशों के अधीन अनुमति देती है। आप Claude API द्वारा संचालित उत्पाद बना और बेच सकते हैं जब तक कि आपका अनुप्रयोग Anthropic की नीतियों और लागू कानूनों का अनुपालन करता है।

Claude API कौन सी प्रोग्रामिंग भाषाओं का समर्थन करता है?

Python और TypeScript/JavaScript के लिए आधिकारिक SDK मौजूद हैं। अंतर्निहित API एक मानक REST API है जिसमें JSON है, इसलिए कोई भी भाषा जो HTTP अनुरोध कर सकती है काम करती है — Ruby, Go, Java, PHP, Rust, और अन्य।

मैं प्रॉम्प्ट इंजेक्शन हमलों को कैसे रोकूँ?

रक्षा में शामिल हैं: XML टैग का उपयोग करके निर्देशों और उपयोगकर्ता सामग्री के बीच स्पष्ट पृथक्करण, उपयोगकर्ता इनपुट में विरोधाभासी सामग्री को अनदेखा करने के लिए सिस्टम प्रॉम्प्ट में स्पष्ट निर्देश, अप्रत्याशित प्रारूप परिवर्तन का पता लगाने के लिए आउटपुट सत्यापन, और विसंगतिपूर्ण पैटर्न का पता लगाने के लिए दर सीमा।

मुझे max_tokens को कैसे सेट करना चाहिए?

इसे अपेक्षित आउटपुट लंबाई और सुरक्षा मार्जिन के आधार पर सेट करें। चैटबॉट प्रतिक्रियाओं के लिए, 512–1024 आमतौर पर पर्याप्त है। दस्तावेज़ पीढ़ी के लिए, 4096 या अधिक। इसे बहुत कम सेट करने से प्रतिक्रिया काटी जाती है; इसे बहुत अधिक सेट करने से कोई अतिरिक्त लागत नहीं होती जब तक Claude वास्तव में उन टोकन का उपयोग नहीं करता।

API लागत को कम करने के सबसे प्रभावी तरीके क्या हैं?

सरल कार्यों के लिए Haiku का उपयोग करें, दोहराए जाने वाले संदर्भ के लिए प्रॉम्प्ट कैशिंग सक्षम करें, सिस्टम प्रॉम्प्ट को संक्षिप्त रखें, max_tokens को उचित रूप से सेट करें, अनुरोध डीडुपलिकेशन लागू करें, समान इनपुट के लिए API प्रतिक्रियाओं को कैश करें, और ऑफ-पीक घंटों के दौरान गैर-वास्तविक समय के कार्यभार को बैच करें।

आज ही बनाना शुरू करें

Claude API AI-संचालित अनुप्रयोगों के लिए वस्तुतः असीम संभावनाएँ खोलता है। इस गाइड में सरल उदाहरणों से शुरुआत करें, क्रमशः जटिलता जोड़ें — स्ट्रीमिंग, उपकरण उपयोग, बहु-बारी वार्तालाप — और आपके पास कुछ दिनों के भीतर एक उत्पादन-तैयार एकीकरण होगा। मुख्य बात यह है कि क्रमिक रूप से निर्माण करना, शुरुआत से ही टोकन उपयोग को मापना, और अपने प्रॉम्प्ट को विचारपूर्वक डिज़ाइन करना।

API ओवरहेड के बिना हाथों से Claude की खोज के लिए, FreeClaude की मुफ्त एक्सेस प्रोग्राम आपको Claude Max x20 क्षमताओं को सीधे परीक्षण करने देता है — प्रॉम्प्ट को तैयार और परीक्षण करने के लिए API कोड में जाने से पहले अमूल्य।

Claude API के साथ शुरुआती लोग जो सामान्य गलतियां करते हैं

Claude API के साथ दर्जनों परियोजनाओं में काम करने के बाद, ये वह गलतियां हैं जो लगातार नए डेवलपर्स को परेशान करती हैं। शुरुआत से ही इनसे बचना बाद में डिबगिंग के घंटों की बचत करता है।

stop_reason फ़ील्ड को संभालना नहीं

प्रत्येक API प्रतिक्रिया में एक stop_reason फ़ील्ड शामिल होता है। संभावित मान हैं end_turn (Claude स्वाभाविक रूप से समाप्त हुआ), max_tokens (प्रतिक्रिया काट दी गई), stop_sequence (एक स्टॉप अनुक्रम दिया गया), और tool_use (Claude एक उपकरण कॉल करना चाहता है)। कई शुरुआती केवल खुशहाल पथ को संभालते हैं और प्रतिक्रियाएं काटी हुई दिखाई देने पर आश्चर्यचकित होते हैं। हमेशा stop_reason की जांच करें और उत्पादन कोड में प्रत्येक स्थिति को स्पष्ट रूप से संभालें।

असिंक्रोनस एप्लिकेशन में सिंक्रोनस कॉल का उपयोग करना

Claude API में नेटवर्क विलंबता और उत्पादन समय एक सेकंड के तहत से लेकर दसियों सेकंड तक होता है। असिंक्रोनस फ्रेमवर्क (FastAPI, Express, Next.js) के साथ बनाए गए वेब एप्लिकेशन में, सिंक्रोनस API कॉल पर इवेंट लूप को ब्लॉक करना आपके संपूर्ण एप्लिकेशन के लिए अनुरोध हैंडलिंग को फ्रीज कर देता है। हमेशा असिंक्रोनस संदर्भ में असिंक्रोनस क्लाइंट का उपयोग करें: Python में anthropic.AsyncAnthropic(), या JavaScript में await-आधारित विधियां।

संदेश सरणी भूमिका क्रम को अनदेखा करना

संदेश सरणी को उपयोगकर्ता और सहायक भूमिकाओं के बीच वैकल्पिक होना चाहिए। दो लगातार उपयोगकर्ता संदेश या दो लगातार सहायक संदेश एक 400 त्रुटि का कारण बनेंगे। डेटाबेस से बातचीत का पुनर्निर्माण करते समय, भेजने से पहले हमेशा भूमिका वैकल्पिकता को मान्य करें। यदि आपको उपयोगकर्ता से कई जानकारी का प्रतिनिधित्व करने की आवश्यकता है, तो उन्हें एक ही उपयोगकर्ता संदेश में मिलाएं।

कोडबेस में हार्डकोडेड मॉडल नाम

Anthropic समय-समय पर मॉडल को अपडेट करता है और पुराने संस्करणों को हटाता है। कॉन्फ़िगरेशन फ़ाइल या पर्यावरण चर में मॉडल चयन को केंद्रीकृत करना मतलब है कि एक मॉडल संस्करण अपग्रेड एक-पंक्ति परिवर्तन है बजाय आपके पूरे कोडबेस में खोज-और-बदलने के।

टीमें Claude API के साथ क्या बना रही हैं

Claude API अनुप्रयोगों की एक बेहद विस्तृत श्रृंखला को शक्ति देता है। यह समझना कि अन्य टीमें क्या बनाती हैं, विचारों को जगाने में मदद करता है और बुनियादी चैटबॉट से परे जो संभव है उसके दायरे को दर्शाता है।

स्वचालित कोड समीक्षा प्रणाली — इंजीनियरिंग टीमें Claude को CI/CD पाइपलाइन में एकीकृत करती हैं ताकि मानव समीक्षा से पहले स्वचालित कोड समीक्षा की जा सके। Claude सुरक्षा कमजोरियों की जांच करता है, संभावित बग की पहचान करता है, कोड शैली की निरंतरता सुनिश्चित करता है, और परीक्षण कवरेज को याद दिलाता है। ये प्रणाली वरिष्ठ इंजीनियरों पर बोझ को कम करती हैं और उन मुद्दों को पकड़ती हैं जो उच्च-मात्रा PR कतारों में फिसल जाते हैं।

दस्तावेज़ बुद्धिमत्ता प्लेटफॉर्म — कानूनी, वित्तीय और अनुपालन टीमें ऐसे उपकरण बनाती हैं जो बड़ी मात्रा में दस्तावेज़ को संसाधित करते हैं — अनुबंध, नियामक फाइलिंग, अनुसंधान रिपोर्ट — और संरचित जानकारी निकालते हैं, मुख्य खंडों की पहचान करते हैं, मुद्दों को चिह्नित करते हैं, और सारांश उत्पन्न करते हैं। Claude की बड़ी संदर्भ खिड़की संरचित JSON आउटपुट के साथ मिलकर इस श्रेणी को विशेष रूप से मजबूत बनाती है।

ग्राहक संचार सहायक — समर्थन टीमें Claude को पहली-प्रतिक्रिया प्रणाली के रूप में तैनात करती हैं जो नियमित पूछताछ को स्वचालित रूप से संभालता है, मानव समीक्षा के लिए प्रतिक्रियाएं तैयार करता है, और जटिल मामलों को बढ़ाता है। कठोर नियम-आधारित बॉट्स के विपरीत, Claude यह संभालता है कि ग्राहक सवाल कैसे पूछते हैं इसमें प्राकृतिक भिन्नता।

व्यक्तिगत शिक्षा प्लेटफॉर्म — EdTech अनुप्रयोग Claude का उपयोग करके अनुकूली ट्यूटरिंग सिस्टम बनाते हैं जो प्रत्येक छात्र के विशिष्ट गलतफहमियों का जवाब देता है, सही कठिनाई पर अभ्यास समस्याएं उत्पन्न करता है, और जब तक छात्र समझ का प्रदर्शन नहीं करता, तब तक अवधारणाओं को कई तरीकों से समझाता है।

अनुसंधान और विश्लेषण पाइपलाइन — डेटा टीमें स्वचालित पाइपलाइन में Claude का उपयोग करती हैं जो विभिन्न स्रोतों से डेटा खींचता है, विश्लेषण उत्पन्न करता है, और संरचित रिपोर्ट तैयार करता है। कच्चे डेटा और कार्रवाई योग्य अंतर्दृष्टि के बीच के अंतर को बंद करने में Claude डेटा के बारे में तर्क देने और निष्कर्षों को सादे भाषा में समझाने की क्षमता।