चैट कम्प्लीशन

हर टेक्स्ट मॉडल के लिए OpenAI का Chat Completions API: वही रिक्वेस्ट और रिस्पॉन्स, वही स्ट्रीमिंग, वही SDK।

रिक्वेस्ट

जवाब

{
  "id": "chatcmpl-AbC123...",
  "object": "chat.completion",
  "created": 1790870400,
  "model": "claude-opus-5-5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Here's the summary..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1204,
    "completion_tokens": 312,
    "total_tokens": 1516,
    "prompt_tokens_details": { "cached_tokens": 1024 },
    "completion_tokens_details": { "reasoning_tokens": 128 }
  }
}

• model वह मॉडल है जिसने जवाब दिया। यह वही मॉडल होता है जिसे आपने चुना था, जब तक कि स्मार्ट राउटिंग ने किसी वैकल्पिक मॉडल से जवाब न दिलाया हो।
• रीजनिंग मॉडल मैसेज में reasoning_content जोड़ सकते हैं: इसमें मॉडल की सोच होती है, अगर वह इसे साझा करता है।
• आपसे usage के लिए शुल्क लिया जाता है। cached_tokens वे इनपुट टोकन हैं जो मॉडल के प्रॉम्प्ट कैश से पढ़े गए हैं। जिन मॉडल में कैश की अलग दर होती है, उनमें इन्हीं दरों पर शुल्क लगता है।

हर रिस्पॉन्स में ये हेडर भी होते हैं:

स्ट्रीमिंग

stream: true के साथ, जवाब OpenAI के चंक फ़ॉर्मैट में सर्वर से भेजे गए इवेंट के रूप में आता है और data: [DONE] पर खत्म होता है। हर SDK इन्हें आपके लिए पढ़ता है।

import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
stream = client.chat.completions.create(
    model="claude-sonnet-5-5",
    messages=[
      {
        "role": "user",
        "content": "Write a limerick about databases."
      }
    ],
    stream=True,
    stream_options={
      "include_usage": True
    },
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

• मॉडल का पहला टोकन बनने तक कोई जवाब नहीं भेजा जाता, इसलिए दोबारा कोशिश करना या दूसरे रास्ते पर स्विच करना आपको दिखाई नहीं देता।
• जिन अंतरालों में कोई डेटा नहीं आता (जब मॉडल चरणों के बीच सोच रहा होता है), उनमें हर 15 सेकंड पर SSE कमेंट लाइनें (: keep-alive) भेजी जाती हैं। क्लाइंट इन्हें अनदेखा करते हैं; ये प्रॉक्सी को कनेक्शन बंद करने से रोकती हैं। अगर पहले टोकन में 20 सेकंड से ज़्यादा लगें (लंबा प्रॉम्प्ट होने या अटके हुए रास्ते की जगह दूसरा रास्ता चुने जाने के कारण), तो स्ट्रीम उसी समय खुल जाती है: आपके इंतज़ार के दौरान हेडर और कीप-अलाइव कमेंट आते रहते हैं। अगला रास्ता आज़माने से पहले हर रास्ते को शुरू होने के लिए 3 मिनट तक मिलते हैं (रीजनिंग का प्रयास ज़्यादा होने पर 5), इसलिए अपने क्लाइंट का टाइमआउट 10 मिनट पर सेट करें।
• पहले टोकन से पहले खुली स्ट्रीम में x-zurelay-model सिर्फ़ तभी होता है जब कोई दूसरा मॉडल जवाब नहीं दे सकता (स्मार्ट राउटिंग बंद हो)। स्ट्रीम खुलने के बाद कोई गड़बड़ी होने पर, एरर स्टेटस की जगह स्ट्रीम में एरर इवेंट आता है (एरर बॉडी वाले ही ढाँचे में)।
• include_usage के साथ, [DONE] से पहले वाले आखिरी चंक में खाली choices सूची और usage होता है।

टूल कॉलिंग

tools में फ़ंक्शन का विवरण दें; जब मॉडल को कोई फ़ंक्शन चाहिए होता है, तो वह टेक्स्ट की जगह tool_calls के साथ जवाब देता है। फ़ंक्शन चलाएँ, कॉल के ID के साथ नतीजा tool मैसेज के रूप में वापस भेजें, और मॉडल आगे बढ़ेगा।

import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
response = client.chat.completions.create(
    model="gpt-6-sol",
    messages=[
      {
        "role": "user",
        "content": "What's the weather in Lisbon right now?"
      }
    ],
    tools=[
      {
        "type": "function",
        "function": {
          "name": "get_weather",
          "description": "Current weather for a city",
          "parameters": {
            "type": "object",
            "properties": {
              "city": {
                "type": "string"
              }
            },
            "required": [
              "city"
            ]
          }
        }
      }
    ],
)
print(response.choices[0].message.content)

स्ट्रक्चर्ड आउटपुट

response_format के ज़रिए JSON माँगें। json_schema इसका समर्थन करने वाले मॉडल से आपके स्कीमा का पालन करवाता है; json_object किसी भी मान्य JSON के लिए कहता है (अपने प्रॉम्प्ट में भी यह बताएँ)।

import os
from openai import OpenAI
client = OpenAI(
    base_url="https://api.zurelay.com/v1",
    api_key=os.environ["ZURELAY_API_KEY"],
)
response = client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[
      {
        "role": "user",
        "content": "Extract the people: 'Ana met Ben and Chloe in Porto.'"
      }
    ],
    response_format={
      "type": "json_schema",
      "json_schema": {
        "name": "people",
        "schema": {
          "type": "object",
          "properties": {
            "names": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          },
          "required": [
            "names"
          ]
        }
      }
    },
)
print(response.choices[0].message.content)

रीजनिंग

रीजनिंग मॉडल जवाब देने से पहले सोचते हैं। सोच की गहराई के बदले लगने वाले समय और लागत को नियंत्रित करने के लिए reasoning_effort सेट करें: ऊँचे स्तर पर मॉडल ज़्यादा देर सोचता है, ज़्यादा समय लेता है और ज़्यादा आउटपुट टोकन इस्तेमाल करता है। हर मॉडल अपनी लैब के दस्तावेज़ों में दिए गए स्तर स्वीकार करता है, none (बिना सोचे) से लेकर minimal, low, medium, high और xhigh (बहुत ऊँचा) होते हुए max तक; नीचे की तालिका में ये दिए गए हैं। इसे न भेजने पर मॉडल अपना डिफ़ॉल्ट स्तर इस्तेमाल करता है। यह किसी भी OpenAI SDK के साथ एक जैसा काम करता है, और आप डैशबोर्ड के प्लेग्राउंड में हर स्तर आज़मा सकते हैं।

from openai import OpenAI
client = OpenAI(base_url="https://api.zurelay.com/v1", api_key="YOUR_ZURELAY_KEY")
response = client.chat.completions.create(
    model="zurelay-auto",
    reasoning_effort="high",
    messages=[{"role": "user", "content": "How many primes are there below 1,000?"}],
)
message = response.choices[0].message
print(getattr(message, "reasoning_content", None))  # the thinking, when the model shares it
print(message.content)

जो मॉडल अपनी सोच साझा करते हैं, उनमें यह जवाब के साथ message.reasoning_content में लौटती है (स्ट्रीमिंग के दौरान delta.reasoning_content में); कुछ मॉडल इस फ़ील्ड को reasoning कहते हैं। इसका शुल्क आउटपुट टोकन के रूप में लगता है और यह हमेशा completion_tokens का हिस्सा होती है; जब मॉडल इसकी जानकारी देता है, तो completion_tokens_details.reasoning_tokens इसे अलग से गिनता है। रीजनिंग का प्रयास ज़्यादा होने पर जवाब शुरू होने में कई मिनट लग सकते हैं, इसलिए अपने क्लाइंट के लिए पर्याप्त लंबा टाइमआउट रखें (विश्वसनीयता और टाइमआउट देखें)।

हर मॉडल के स्तर

हर लैब के अपने दस्तावेज़ों के अनुसार। अगर मॉडल किसी स्तर को स्वीकार नहीं करता, तो वह अपने सबसे नज़दीकी समर्थित स्तर पर चलता है (दो स्तर बराबर नज़दीक हों, तो नीचे वाला; और सोचना सिर्फ़ none भेजने पर बंद होता है), इसलिए एक ही अनुरोध हर मॉडल पर काम करता है, स्मार्ट राउटिंग के साथ भी। x-zurelay-reasoning-effort रिस्पॉन्स हेडर बताता है कि कौन-सा स्तर चला। स्तर के नाम के अलावा कोई और शब्द भेजने पर अनुरोध 400 के साथ अस्वीकार होता है, जिसमें मॉडल के स्तरों की सूची होती है।

Claude की सोच

इस एंडपॉइंट पर, Claude दूसरे मॉडल की तरह reasoning_effort स्वीकार करता है: low, medium, high, xhigh या max (Opus 4.6 में xhigh नहीं है)। Anthropic के अपने फ़ॉर्मैट में, Claude चुने गए स्तर पर परिस्थिति के हिसाब से सोचता है: thinking: { type: "adaptive", display: "summarized" } को output_config: { effort: "xhigh" } के साथ भेजें और सोच वाले ब्लॉक पढ़ें। Anthropic Messages देखें।