OpenRouter: व्यावहारिक उदाहरणों के साथ एक गाइड

कई AI प्रदाताओं के API को मैनेज करना जल्द ही भारी लगने लगता है। हर प्रदाता की प्रमाणीकरण विधि, मूल्य निर्धारण मॉडल, और API विनिर्देशन अलग होते हैं। डेवलपर्स अलग-अलग मॉडलों तक पहुँचने के लिए OpenAI, Anthropic, Google, और अन्य प्लेटफ़ॉर्म के बीच स्विच करने में अनगिनत घंटे बर्बाद करते हैं।

OpenRouter इस जटिलता को एक एकीकृत API देकर सुलझाता है, जो आपको दर्जनों प्रदाताओं के 400+ मॉडलों से जोड़ता है। आप एक ही API कुंजी और समान इंटरफ़ेस के साथ GPT-5, Claude 4, Gemini 2.5 Pro और सैकड़ों अन्य मॉडलों तक पहुँच सकते हैं। प्लेटफ़ॉर्म पृष्ठभूमि में स्वचालित फ़ॉलबैक, लागत प्रबंधन, और प्रदाता रूटिंग संभालता है।

इस ट्यूटोरियल में, मैं OpenRouter के बारे में वह सब समझाऊँगा जो आपको जानना चाहिए—पहली API कॉल सेट करने से लेकर स्ट्रक्चर्ड आउटपुट जैसी उन्नत विशेषताएँ लागू करने तक। अंत तक, आप सीख जाएंगे कि ऐसे भरोसेमंद अनुप्रयोग कैसे बनाए जाएँ जो किसी एक प्रदाता पर निर्भर न हों।

OpenRouter क्या है?

OpenRouter एक एकीकृत API प्लेटफ़ॉर्म है जो आपको एक ही एंडपॉइंट के माध्यम से दर्जनों प्रदाताओं के 400+ AI मॉडलों तक पहुँच देता है। OpenAI, Anthropic, Google, Meta और अन्य के लिए अलग-अलग API कुंजियों को सँभालने के बजाय, आप उनकी पूरी मॉडल कैटलॉग तक पहुँचने के लिए एक ही कुंजी का उपयोग करते हैं।

यह प्लेटफ़ॉर्म एक बुद्धिमान राउटर की तरह काम करता है—जो प्रमाणीकरण, बिलिंग, और त्रुटि हैंडलिंग का ध्यान रखते हुए आपके अनुरोधों को सही प्रदाता तक भेजता है। यह तरीका कई सिरदर्दों को दूर करता है जो कई AI प्रदाताओं का उपयोग करने के साथ आते हैं।

OpenRouter किन समस्याओं का समाधान करता है

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

स्थिति तब और बिगड़ती है जब प्रदाता डाउन हो जाते हैं या रेट लिमिट लगा देते हैं। आपका ऐप टूट जाता है, और आप कुछ नहीं कर सकते सिवाय इंतज़ार करने के। ऊपर से, कौन-सा प्रदाता समान मॉडलों के लिए सबसे अच्छी कीमत देता है, यह समझने के लिए अलग-अलग प्लेटफ़ॉर्म पर लागतों को मैन्युअल रूप से ट्रैक करना पड़ता है।

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

OpenRouter इसे कैसे ठीक करता है

OpenRouter इन समस्याओं को आपस में जुड़े फीचर्स के सेट से हल करता है:

• एक API कुंजी 400+ मॉडलों के साथ काम करती है, सभी प्रमुख प्रदाताओं से
• जब आपकी पहली पसंद विफल हो, तो बैकअप प्रदाताओं पर स्वचालित स्विचिंग
• सभी मॉडलों की साइड-बाय-साइड कीमतें ताकि आप तुरंत लागत की तुलना कर सकें
• मौजूदा OpenAI कोड के साथ काम करता है — बस एंडपॉइंट URL बदलें
• रीयल-टाइम मॉनिटरिंग जो अनुरोधों को सबसे तेज उपलब्ध प्रदाता तक रूट करती है

ये सभी हिस्से मिलकर AI डेवलपमेंट को और सरल और भरोसेमंद बनाते हैं।

कौन OpenRouter का उपयोग करे?

इस एकीकृत दृष्टिकोण से अलग-अलग प्रकार के उपयोगकर्ताओं को लाभ मिलता है:

• डेवलपर्स बिना हर जगह खाते बनाए नए मॉडलों को आज़मा सकते हैं, जिससे प्रयोग तेज़ होता है
• एंटरप्राइज़ टीमें प्रदाताओं की विफलता पर स्वचालित बैकअप के ज़रिए आवश्यक अपटाइम पाती हैं
• बजट-सचेत उपयोगकर्ता बिना स्प्रेडशीट के गणित के, अपनी ज़रूरत के लिए सबसे सस्ता विकल्प ढूँढ़ सकते हैं
• शोधकर्ताओं को बिना खाता-सेटअप ओवरहेड के अत्याधुनिक मॉडलों तक तुरंत पहुँच मिलती है

अब जबकि आपको समझ आ गया है कि OpenRouter क्या लेकर आता है, आइए आपकी पहली API कॉल से सेटअप शुरू करें।

आवश्यक पूर्वतैयारी

OpenRouter में उतरने से पहले, आपके सिस्टम पर कुछ चीज़ें सेट होनी चाहिए। यह ट्यूटोरियल मान कर चलता है कि आप बेसिक Python प्रोग्रामिंग में सहज हैं और पहले APIs के साथ काम कर चुके हैं। विशेषज्ञ होना ज़रूरी नहीं, पर आपको HTTP अनुरोध बनाना और JSON प्रतिक्रियाएँ सँभालना जैसे सिद्धांत समझने चाहिए।

आपके सिस्टम पर Python 3.7 या बाद का संस्करण इंस्टॉल होना चाहिए। हम OpenRouter के API के साथ इंटरैक्ट करने के लिए openai Python पैकेज का उपयोग करेंगे, तथा python-dotenv का उपयोग सुरक्षित रूप से एनवायरनमेंट वैरिएबल सँभालने के लिए करेंगे। दोनों को आप इस तरह इंस्टॉल कर सकते हैं:

pip install requests openai python-dotenvसंचालित द्वारा

आपको OpenRouter खाता और API कुंजी भी चाहिए। मुफ्त खाता बनाने के लिए openrouter.ai पर जाएँ — आपको परीक्षण के लिए थोड़ी क्रेडिट राशि मिल जाएगी। लॉगिन के बाद, अपने अकाउंट सेटिंग्स में API Keys सेक्शन में जाएँ और नई कुंजी जनरेट करें।

API कुंजी मिलने के बाद, अपने प्रोजेक्ट डायरेक्टरी में एक .env फ़ाइल बनाएँ और अपनी कुंजी इस तरह जोड़ें:

OPENROUTER_API_KEY=your_api_key_hereसंचालित द्वारा

इससे आपकी API कुंजी सुरक्षित रहती है और कोड से बाहर रहती है। यदि आप परीक्षण से आगे OpenRouter का उपयोग करना चाहते हैं, तो आपको Credits पेज के माध्यम से अपने अकाउंट में क्रेडिट जोड़ने होंगे।

इन बुनियादी बातों के साथ, आप OpenRouter के माध्यम से अपनी पहली API कॉल करने के लिए तैयार हैं।

OpenRouter में अपनी पहली API कॉल करना

यदि आपने पहले OpenAI SDK का उपयोग किया है, तो OpenRouter के साथ शुरुआत करना बेहद आसान है। आप केवल कोड की एक पंक्ति बदलते हैं और अचानक अलग-अलग प्रदाताओं के सैकड़ों मॉडलों तक पहुँच मिल जाती है।

आपका पहला अनुरोध और सेटअप

आइए एक काम करने वाले उदाहरण से सीधे शुरू करें जो OpenRouter के दृष्टिकोण को दर्शाता है:

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
   base_url="https://openrouter.ai/api/v1",
   api_key=os.getenv("OPENROUTER_API_KEY"),
)

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "Write a haiku about debugging code at 2 AM"
       }
   ]
)

print(response.choices[0].message.content)संचालित द्वारा

Night hum, coffee cooled
cursor blinks, bug hides somewhere
I chase ghosts 'til dawnसंचालित द्वारा

जादू दो जगह होता है। पहला, base_url पैरामीटर आपके अनुरोधों को OpenAI के बजाय OpenRouter के सर्वर पर रीडायरेक्ट करता है। दूसरा, मॉडल का नाम provider/model-name फ़ॉर्मैट का अनुसरण करता है — openai/gpt-5-mini केवल gpt-5-mini के बजाय। यह OpenRouter को बताता है कि आप किस प्रदाता का संस्करण चाहते हैं, जबकि इंटरफ़ेस परिचित रहता है। यहाँ कुछ सामान्य मॉडल हैं जिन्हें आप ऊपर दिए उदाहरण में बिना किसी त्रुटि के प्लग-इन कर सकते हैं:

• google/gemini-2.0-flash-001
• google/gemini-2.5-pro
• mistralai/mistral-nemo
• deepseek/deepseek-r1-distill-qwen-32b

अब जब आपने देख लिया है कि अलग-अलग मॉडलों के साथ काम करना कितना आसान है, तो आप सोच रहे होंगे: अगर आपका चुना हुआ मॉडल उपलब्ध न हो तो क्या होता है? ऐसे अनुप्रयोग कैसे बनाएँ जो प्रदाताओं की समस्या होने पर भी विश्वसनीय बने रहें? यहीं OpenRouter की रूटिंग और रेज़िलिएंस विशेषताएँ काम आती हैं।

रेज़िलिएंस के लिए मॉडल रूटिंग

भरोसेमंद AI अनुप्रयोग बनाना अनपेक्षित परिस्थितियों के लिए तैयारी करना है। प्रदाता डाउनटाइम झेलते हैं, मॉडल रेट लिमिट पर पहुँचते हैं, और कभी-कभी कंटेंट मॉडरेशन आपके अनुरोधों को ब्लॉक कर देता है। मॉडल रूटिंग OpenRouter का समाधान है — यह आपके ऐप को सुचारु चलाने के लिए स्वचालित रूप से अलग-अलग मॉडलों के बीच स्विच करता है।

मैनुअल फ़ॉलबैक सेट करना

रेज़िलिएंस जोड़ने का सबसे सीधा तरीका है बैकअप मॉडल निर्दिष्ट करना। जब आपकी प्राथमिक पसंद विफल हो, OpenRouter क्रम में आपके विकल्पों को आज़माता है। extra_body पैरामीटर ये रूटिंग निर्देश OpenRouter के API तक भेजता है क्योंकि OpenAI SDK यह फ़ीचर देशी रूप से सपोर्ट नहीं करता:

response = client.chat.completions.create(
   model="moonshotai/kimi-k2",  # Primary choice
   messages=[
       {"role": "user", "content": "Explain quantum computing in simple terms"}
   ],
   extra_body={
       "models": ["anthropic/claude-sonnet-4", "deepseek/deepseek-r1"]
   }   
)

print(f"Response from: {response.model}")
print(response.choices[0].message.content)संचालित द्वारा

Response from: moonshotai/kimi-k2
Imagine a normal computer bit as a tiny light-switch that can only be OFF (0) or ON (1)...संचालित द्वारा

OpenRouter पहले Kimi-K2 आज़माता है। यदि वह अनुपलब्ध हो, रेट-लिमिटेड हो, या ब्लॉक हो, तो यह स्वतः Claude Sonnet 4 और फिर DeepSeek R1 को आज़माता है। response.model फ़ील्ड यह दिखाती है कि वास्तव में कौन-सा मॉडल उत्तर दे रहा है।

अधिकतम सुविधा के लिए ऑटो राउटर

जब आप मैनुअल फ़ॉलबैक समझ लेते हैं, तो ऑटो राउटर काफ़ी आकर्षक लगता है। यह मॉडल चयन और फ़ॉलबैक को अपने आप संभालता है, जो NotDiamond के इवैल्यूएशन सिस्टम से संचालित है:

response = client.chat.completions.create(
   model="openrouter/auto",
   messages=[
       {"role": "user", "content": "Debug this Python code in 3 sentences: def factorial(n): return n * factorial(n-1)"}
   ]
)

print(f"Auto router selected: {response.model}")
print(response.choices[0].message.content)संचालित द्वारा

Auto router selected: openai/chatgpt-4o-latest
The given code is missing a base case, which causes infinite recursion and eventually a RecursionError. To fix it, add a base case like `if n == 0: return 1` before the recursive call. Here's the corrected version:

\```python
def factorial(n):
   if n == 0:
       return 1
   return n * factorial(n - 1)
\```
संचालित द्वारा

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

प्रभावी फ़ॉलबैक रणनीतियाँ बनाना

सभी मॉडल एक-दूसरे के अच्छे बैकअप नहीं होते। किसी प्रदाता का डाउनटाइम उस कंपनी के सभी मॉडलों को प्रभावित कर सकता है, इसलिए अलग-अलग प्रदाताओं से फ़ॉलबैक चुनें। रेट लिमिट और लागत बहुत अलग-अलग होती हैं, इसलिए महंगे मॉडलों के साथ सस्ते विकल्पों की जोड़ी भी बनाएँ:

# Good fallback chain: different providers, decreasing cost
response = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=[
       {"role": "user", "content": "Your prompt here"}
   ],
   extra_body={
       "models": [
           "x-ai/grok-4",                  # Close performance
           "moonshotai/kimi-k2",           # Cheaper
           "deepseek/deepseek-r1:free"     # Free backup
       ]
   }   
)संचालित द्वारा

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

अपने फ़ॉलबैक चैन के लिए मॉडल ढूँढ़ना

मॉडल पेज आपको प्रदाता और क्षमताओं के अनुसार फ़िल्टर करने देता है ताकि आप अपनी चैन बना सकें। कई शक्तिशाली मॉडल, जैसे DeepSeek R1 और Kimi-K2, ओपन-सोर्स होने के कारण मुफ़्त हैं, और बेहतरीन फ़ॉलबैक बनते हैं। मुफ़्त मॉडलों की रेट लिमिट नए उपयोगकर्ताओं के लिए प्रति दिन 50 अनुरोध है, या यदि आपने 10 क्रेडिट खरीदे हैं तो प्रति दिन 1000 अनुरोध।

डायनेमिक अनुप्रयोगों के लिए, आप प्रोग्रामेटिक तरीक़े से मॉडल खोज सकते हैं:

def get_provider_models(api_key: str, provider: str) -> list[str]:
   r = requests.get(
       "https://openrouter.ai/api/v1/models",
       headers={"Authorization": f"Bearer {api_key}"}
   )
   return [m["id"] for m in r.json()["data"] if m["id"].startswith(provider)]

# Build fallbacks across providers
openai_models = get_provider_models(api_key, "openai/")
anthropic_models = get_provider_models(api_key, "anthropic/")संचालित द्वारा

यह तरीका आपको ऐसे मज़बूत फ़ॉलबैक चैन बनाने देता है जो नए मॉडल उपलब्ध होने पर अनुकूलित हो सकें।

रीयल-टाइम प्रतिक्रियाओं के लिए स्ट्रीमिंग

AI मॉडलों के साथ काम करते समय, विशेषकर लंबी प्रतिक्रियाओं के लिए, उपयोगकर्ता पूरी प्रतिक्रिया के इंतज़ार के बजाय धीरे-धीरे आउटपुट उभरता हुआ देखना पसंद करते हैं। स्ट्रीमिंग इसे हल करती है—जैसे-जैसे प्रतिक्रिया बनती है, वह हिस्सों में भेजी जाती है—जो ChatGPT के इंटरफ़ेस जैसी अधिक इंटरैक्टिव अनुभव देती है।

बेसिक स्ट्रीमिंग सेटअप

OpenRouter में स्ट्रीमिंग सेट करने के लिए, अपने अनुरोध में stream=True जोड़ें। प्रतिक्रिया एक इटरेटर बन जाती है जो मॉडल के जनरेट करते ही चंक्स देती है:

response = client.chat.completions.create(
   model="openai/gpt-5",
   messages=[
       {"role": "user", "content": "Write a detailed explanation of how neural networks learn"}
   ],
   stream=True
)

for chunk in response:
   if chunk.choices[0].delta.content is not None:
       print(chunk.choices[0].delta.content, end="")संचालित द्वारा

हर चंक में प्रतिक्रिया का एक छोटा हिस्सा होता है। delta.content फ़ील्ड नए टेक्स्ट फ़्रैगमेंट को रखती है, और हम उसे तुरंत बिना नई पंक्ति के प्रिंट करते हैं ताकि स्ट्रीमिंग प्रभाव बने। end="" पैरामीटर प्रिंट को चंक्स के बीच नई पंक्ति जोड़ने से रोकता है।

बेहतर स्ट्रीमिंग हैंडलर बनाना

प्रोडक्शन अनुप्रयोगों के लिए, आप स्ट्रीमिंग प्रक्रिया पर अधिक नियंत्रण चाहते हैं। यहाँ एक अधिक व्यापक हैंडलर है जो पूरी प्रतिक्रिया को मैनेज करता है:

def stream_response(model, messages, show_progress=True):
   response = client.chat.completions.create(
       model=model,
       messages=messages,
       stream=True
   )
  
   complete_response = ""
  
   for chunk in response:
       if chunk.choices[0].delta.content is not None:
           content = chunk.choices[0].delta.content
           complete_response += content
          
           if show_progress:
               print(content, end="", flush=True)
  
   if show_progress:
       print()  # Add final newline
  
   return complete_response

# Use it with different models
result = stream_response(
   "anthropic/claude-sonnet-4",
   [{"role": "user", "content": "Explain quantum entanglement like I'm 12 years old"}]
)संचालित द्वारा

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

स्ट्रीमिंग उपयोगकर्ता अनुभव को “इंतज़ार और उम्मीद” से “प्रगति देखना” में बदल देती है। इससे आपके AI अनुप्रयोग उपयोगकर्ताओं के लिए कहीं अधिक उत्तरदायी और आकर्षक महसूस होते हैं।

OpenRouter में रीजनिंग टोकन्स संभालना

कुछ AI मॉडल अंतिम उत्तर देने से पहले अपना “सोचने” का तरीका दिखा सकते हैं। ये रीजनिंग टोकन्स बताते हैं कि मॉडल जटिल समस्याओं को कैसे साधता है—ऐसी चरण-दर-चरण तर्क-शृंखला जो निष्कर्ष तक पहुँचती है। इस आंतरिक तर्क को समझना उत्तर सत्यापित करने, मॉडल के व्यवहार को डिबग करने, और अधिक भरोसेमंद अनुप्रयोग बनाने में मदद करता है।

रीजनिंग टोकन्स क्या हैं

रीजनिंग टोकन्स प्रतिक्रिया में मुख्य सामग्री से अलग एक reasoning फ़ील्ड में प्रकट होते हैं। अलग-अलग मॉडल इसे अलग तरह से सपोर्ट करते हैं—कुछ “effort” स्तरों का उपयोग करते हैं, तो कुछ टोकन बजट का। 

यह रहा एक सरल उदाहरण जो रीजनिंग को क्रिया में दिखाता है:

response = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=[
       {"role": "user", "content": "How many 'r's are in the word 'strrawberry'?"}
   ],
   max_tokens=2048,
   extra_body={
       "reasoning": {
           "max_tokens": 512
       }
   }
)

print("Final answer:")
print(response.choices[0].message.content)
print("\nReasoning process:")
print(response.choices[0].message.reasoning)संचालित द्वारा

Final answer:
To count the 'r's in 'strrawberry', I'll go through each letter:
...
There are **4** 'r's in the word 'strrawberry'.

Reasoning process:
...संचालित द्वारा

मॉडल अपना अंतिम उत्तर और उस तक पहुँचने वाली आंतरिक तर्क-श्रृंखला, दोनों दिखाएगा। यह दोहरा आउटपुट समझने में मदद करता है कि मॉडल ने समस्या को सही तरह से साधा या नहीं।

रीजनिंग की तीव्रता नियंत्रित करना

आप दो तरीकों से मॉडलों के रीजनिंग प्रयास को नियंत्रित कर सकते हैं। effort पैरामीटर OpenAI की o-सीरीज़ जैसे मॉडलों के साथ काम करता है और आपके max_tokens सेटिंग के आधार पर विशिष्ट टोकन प्रतिशत से मेल खाने वाले स्तरों का उपयोग करता है:

• उच्च प्रयास: रीजनिंग के लिए max_tokens का लगभग 80% उपयोग
• मध्यम प्रयास: रीजनिंग के लिए max_tokens का लगभग 50% उपयोग
• कम प्रयास: रीजनिंग के लिए max_tokens का लगभग 20% उपयोग

# High effort reasoning for complex problems
response = client.chat.completions.create(
   model="deepseek/deepseek-r1",
   messages=[
       {"role": "user", "content": "Solve this step by step: If a train travels 240 miles in 3 hours, then speeds up by 20 mph for the next 2 hours, how far does it travel total?"}
   ],
   max_tokens=4000,  # High effort will use ~3200 tokens for reasoning
   extra_body={
       "reasoning": {
           "effort": "high" 
       }
   }
)

print("Problem solution:")
print(response.choices[0].message.content)
print("\nStep-by-step reasoning:")
print(response.choices[0].message.reasoning)संचालित द्वारा

वे मॉडल जो सीधे टोकन आबंटन सपोर्ट करते हैं, जैसे Anthropic के मॉडल, उनके लिए आप सटीक रीजनिंग बजट निर्दिष्ट कर सकते हैं:

def get_reasoning_response(question, reasoning_budget=2000):
   response = client.chat.completions.create(
       model="anthropic/claude-sonnet-4",
       messages=[{"role": "user", "content": question}],
       max_tokens=10000,
       extra_body={
           "reasoning": {
               "max_tokens": reasoning_budget  # Exact token allocation
           }
       }
   )
   return response

# Compare different reasoning budgets
response = get_reasoning_response(
   "What's bigger: 9.9 or 9.11? Explain your reasoning carefully.",
   reasoning_budget=3000
)

print("Answer:", response.choices[0].message.content)
print("Detailed reasoning:", response.choices[0].message.reasoning)संचालित द्वारा

उच्च टोकन बजट सामान्यतः अधिक विस्तृत तर्क पैदा करते हैं, जबकि कम बजट तेज़ लेकिन कम विस्तार वाले विचार-क्रम देते हैं।

संवादों में रीजनिंग सुरक्षित रखना

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

# First message with reasoning
response = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=[
       {"role": "user", "content": "Should I invest in renewable energy stocks? Consider both risks and opportunities."}
   ],
   extra_body={
       "reasoning": {
           "max_tokens": 3000
       }
   }
)

# Build conversation history with reasoning preserved
messages = [
   {"role": "user", "content": "Should I invest in renewable energy stocks? Consider both risks and opportunities."},
   {
       "role": "assistant",
       "content": response.choices[0].message.content,
       "reasoning_details": response.choices[0].message.reasoning_details  # Preserve reasoning
   },
   {"role": "user", "content": "What about solar energy specifically? How does that change your analysis?"}
]

# Continue conversation with reasoning context
follow_up = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=messages,
   extra_body={
       "reasoning": {
           "max_tokens": 2000
       }
   }
)

print("Follow-up answer:")
print(follow_up.choices[0].message.content)
print("\nContinued reasoning:")
print(follow_up.choices[0].message.reasoning)संचालित द्वारा

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

लागत और बिलिंग संबंधी विचार

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

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

OpenRouter में मल्टीमोडल मॉडलों के साथ काम करना

अब तक आपने टेक्स्ट के साथ काम किया है, पर जब आपको छवियाँ या दस्तावेज़ विश्लेषित करने हों तो क्या करें? हो सकता है आप किसी चार्ट के बारे में सवाल पूछना चाहें, किसी PDF से जानकारी निकालनी हो, या किसी फ़ोटो में क्या हो रहा है इसका वर्णन चाहिए। यहीं मल्टीमोडल मॉडल काम आते हैं—वे एक ही अनुरोध में टेक्स्ट और दृश्य सामग्री दोनों को समझ सकते हैं।

मल्टीमोडल क्षमताओं को समझना

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

आप वही इंटरफ़ेस उपयोग करते हैं जो अब तक कर रहे थे—बस अपने दृश्य कंटेंट को शामिल करने के लिए एक अतिरिक्त attachments पैरामीटर के साथ। फ़ाइल अटैचमेंट OpenRouter के सभी मॉडलों के साथ काम करते हैं। भले ही कोई मॉडल PDF या छवियों को मूल रूप से सपोर्ट न करे, OpenRouter अंदरूनी तौर पर इन फ़ाइलों को पार्स करता है और सामग्री मॉडल को पास करता है।

छवियों के साथ काम करना

आप URLs या base64 एन्कोडिंग के ज़रिए अनुरोधों में छवियाँ शामिल कर सकते हैं। यदि आपकी छवि पहले से ऑनलाइन है, तो URL का तरीका सरल है:

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "What's happening in this image? Describe the scene in detail."
       }
   ],
   extra_body={
       "attachments": [
           {
               "type": "image/jpeg",
               "url": "https://example.com/photo.jpg"
           }
       ]
   }
)

print(response.choices[0].message.content)संचालित द्वारा

लोकल छवियों के लिए, आप base64 एन्कोडिंग का उपयोग कर सकते हैं:

import base64

def encode_image_to_base64(image_path):
   with open(image_path, "rb") as image_file:
       encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
   return encoded_string

# Analyze a local screenshot
encoded_image = encode_image_to_base64("screenshot.png")

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "This is a screenshot of a data dashboard. What insights can you extract from the charts and metrics shown?"
       }
   ],
   extra_body={
       "attachments": [
           {
               "type": "image/png",
               "data": encoded_image
           }
       ]
   }
)

print(response.choices[0].message.content)संचालित द्वारा

मॉडल वास्तविक छवि को देखकर वही विशेष अंतर्दृष्टियाँ देगा जो उसे दिखती हैं—सिर्फ़ सामान्य प्रतिक्रियाएँ नहीं।

PDF दस्तावेज़ प्रोसेस करना

PDF प्रोसेसिंग भी इसी तरह काम करती है, और दस्तावेज़ विश्लेषण के दरवाज़े खोलती है। आप रिपोर्ट्स पर सवाल पूछ सकते हैं, फ़ॉर्म का विश्लेषण कर सकते हैं, या जटिल दस्तावेज़ों से जानकारी निकाल सकते हैं:

def encode_pdf_to_base64(pdf_path):
   with open(pdf_path, "rb") as pdf_file:
       encoded_string = base64.b64encode(pdf_file.read()).decode('utf-8')
   return encoded_string

# Analyze a research paper
encoded_pdf = encode_pdf_to_base64("research_paper.pdf")

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "Summarize the key findings from this research paper. What are the main conclusions and methodology used?"
       }
   ],
   extra_body={
       "attachments": [
           {
               "type": "application/pdf",
               "data": encoded_pdf
           }
       ]
   }
)

print(response.choices[0].message.content)संचालित द्वारा

यह वित्तीय रिपोर्ट, शैक्षणिक पेपर, कॉन्ट्रैक्ट, या किसी भी PDF के लिए बेहतरीन काम करता है जहाँ आपको वास्तविक सामग्री का AI विश्लेषण चाहिए। यदि आपको छवियों की तुलना करनी हो या कई दस्तावेज़ एक साथ विश्लेषित करने हों, तो आप एक ही अनुरोध में कई अटैचमेंट भी शामिल कर सकते हैं।

लागत और मॉडल चयन

मल्टीमोडल अनुरोध, केवल-टेक्स्ट अनुरोधों की तुलना में अधिक महंगे होते हैं क्योंकि आप अतिरिक्त डेटा प्रकार प्रोसेस कर रहे होते हैं। छवियाँ और PDF अधिक कम्प्यूटेशनल शक्ति माँगते हैं, जो मूल्य निर्धारण में दिखता है। आप प्रत्येक मॉडल के विशेष मल्टीमोडल प्राइसिंग को मॉडल पेज पर देख सकते हैं।

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

स्ट्रक्चर्ड आउटपुट का उपयोग

वास्तविक अनुप्रयोग बनाते समय, आपको पूर्वानुमेय डेटा फ़ॉर्मैट चाहिए जिसे आपका कोड भरोसेमंद तरीके से पार्स कर सके। फ्री-फ़ॉर्म टेक्स्ट प्रतिक्रियाएँ चैट इंटरफ़ेस के लिए अच्छी हैं, लेकिन उन अनुप्रयोगों के लिए नहीं जहाँ विशिष्ट जानकारी निकालनी होती है। अनिश्चित टेक्स्ट पाने के बजाय जिसे आपको regex से पार्स करना पड़े या उम्मीद करनी पड़े कि मॉडल ने सही फ़ॉर्मैट किया है, स्ट्रक्चर्ड आउटपुट मॉडलों को बाध्य करता है कि वे गारंटीशुदा JSON लौटाएँ, ठीक उन्हीं फ़ील्ड्स और डेटा टाइप्स के साथ जिनकी आपको ज़रूरत है। इससे पार्सिंग त्रुटियाँ समाप्त होती हैं और आपका एप्लिकेशन कोड बहुत सरल हो जाता है।

स्ट्रक्चर्ड आउटपुट अनुरोधों की रचना

स्ट्रक्चर्ड आउटपुट के लिए response_format पैरामीटर का उपयोग होता है, जिसकी मूल संरचना इस तरह होती है:

"response_format": {
   "type": "json_schema",           # Always this for structured outputs
   "json_schema": {
       "name": "your_schema_name",  # Name for your schema
       "strict": True,              # Enforce strict compliance
       "schema": {
           # Your actual JSON schema definition goes here
       }
   }
}संचालित द्वारा

सेंटिमेंट विश्लेषण उदाहरण

आइए एक पूरा उदाहरण देखें जो टेक्स्ट से सेंटिमेंट निकालता है। इससे समझ आएगा कि स्ट्रक्चर्ड आउटपुट व्यवहार में कैसे काम करते हैं:

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {"role": "user", "content": "Analyze the sentiment: 'This movie was absolutely terrible!'"}
   ],
   extra_body={
       "response_format": {
           "type": "json_schema",
           "json_schema": {
               "name": "sentiment_analysis",
               "strict": True,
               "schema": {
                   "type": "object",
                   "properties": {
                       "sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"]},
                       "confidence": {"type": "number"}
                   },
                   "required": ["sentiment", "confidence"]
               }
           }
       }
   }
)

import json
result = json.loads(response.choices[0].message.content)
print(result)संचालित द्वारा

{'sentiment': 'negative', 'confidence': 0.98}संचालित द्वारा

इस स्कीमा में क्या हो रहा है:

• sentiment: एक स्ट्रिंग फ़ील्ड जिसे enum से तीन विशिष्ट मानों तक सीमित किया गया है। मॉडल "positive", "negative" या "neutral" के बाहर कुछ नहीं लौटा सकता
• confidence: मॉडल के विश्वसनीयता स्कोर के लिए एक संख्या फ़ील्ड
• required: दोनों फ़ील्ड प्रतिक्रिया में होना अनिवार्य है — मॉडल इन्हें छोड़ नहीं सकता
• strict: True: स्कीमा स्ट्रक्चर का कड़ाई से पालन कराता है

बिना स्ट्रक्चर्ड आउटपुट के, आपको “The sentiment is very negative with high confidence” या “Negative (95% sure)” जैसी प्रतिक्रियाएँ मिल सकती हैं। स्कीमा के साथ, आपको हमेशा पार्स करने योग्य JSON मिलता है जिसे आप तुरंत अपने कोड में उपयोग कर सकते हैं।

strict: True सेट करने से स्कीमा का कड़ा अनुपालन होता है—मॉडल आपकी संरचना से भटक नहीं सकता। required ऐरे यह बताता है कि किन फ़ील्ड्स का होना ज़रूरी है। आप मानों को सीमित करने के लिए enum का उपयोग कर सकते हैं, सूचियों के लिए array, और जटिल डेटा के लिए नेस्टेड object टाइप्स।

मॉडल संगतता

सभी मॉडल स्ट्रक्चर्ड आउटपुट सपोर्ट नहीं करते, लेकिन ज़्यादातर आधुनिक मॉडल करते हैं। आप मॉडल पेज पर संगतता जाँच सकते हैं। जब कोई मॉडल स्ट्रक्चर्ड आउटपुट को देशी रूप से सपोर्ट नहीं करता, तो अक्सर OpenRouter आंतरिक रूप से फ़ॉर्मैटिंग सँभाल लेता है।

स्ट्रक्चर्ड आउटपुट AI प्रतिक्रियाओं को अनिश्चित टेक्स्ट से बदल कर विश्वसनीय डेटा में बदल देते हैं, जिस पर आपके अनुप्रयोग भरोसा कर सकें। किसी भी प्रोडक्शन उपयोग-केस के लिए जहाँ आपको सुसंगत डेटा निष्कर्षण चाहिए, यह फ़ीचर अनिवार्य है।

निष्कर्ष

हमने OpenRouter के एकीकृत API के माध्यम से सैकड़ों AI मॉडलों तक पहुँचना सीखा—पहली रिक्वेस्ट करने से लेकर स्ट्रीमिंग, रीजनिंग टोकन्स, और स्ट्रक्चर्ड आउटपुट जैसी विशेषताएँ लागू करने तक।

प्लेटफ़ॉर्म के स्वचालित फ़ॉलबैक और मॉडल रूटिंग का मतलब है कि व्यक्तिगत प्रदाताओं में समस्या आने पर भी आपके अनुप्रयोग भरोसेमंद बने रहते हैं। उसी कोड पैटर्न के साथ, हम मॉडलों की तुलना कर सकते हैं, प्रदाताओं को बदल सकते हैं, और बिना कई API कुंजियाँ सँभाले हर कार्य के लिए सही विकल्प ढूँढ़ सकते हैं।

सरल अनुरोधों से प्रयोग शुरू करें और जैसे-जैसे ज़रूरतें बढ़ें, धीरे-धीरे और फ़ीचर्स आज़माएँ। अलग-अलग प्रकार के कार्यों के लिए अलग मॉडल टेस्ट करें — कुछ रचनात्मक लेखन में बेहतर होते हैं, जबकि कुछ डेटा विश्लेषण या तर्क-समस्या में अधिक सशक्त होते हैं।

यहाँ सीखी गई बातें आपको ऐसे AI अनुप्रयोग बनाने में सक्षम बनाती हैं जो किसी एक प्रदाता में लॉक नहीं हैं—ताकि नए मॉडल और क्षमताएँ उपलब्ध होने पर आप आसानी से अनुकूलित हो सकें।