डेवलपर्स के लिए OpenAI API: एक संगत एंडपॉइंट का उपयोग करें

संक्षिप्त संस्करण

विकासकों के लिए openai api पर अधिकांश गाइड एक विक्रेता और एक बिल मानती हैं। हालाँकि, वायर फॉर्मेट केवल HTTPS पर JSON है, और क्लाइंट कोड, फ्रेमवर्क और उपकरण किसी भी सर्वर से बात कर सकते हैं जो इसे लागू करता है। यह साइट एक ऐसे सर्वर की मेजबान करती है। आप अपना SDK रखते हैं, बेस URL बदलते हैं, इस साइट से एक कुंजी डालते हैं, और मॉडल को uncensored पर सेट करते हैं।

यह एक सामान्य एप्लिकेशन के लिए पूरी माइग्रेशन है। यहाँ चेकलिस्ट है, और पृष्ठ का शेष भाग प्रत्येक चरण को भरता है।

1. एक खाता बनाएँ और API कुंजी पृष्ठ पर ट्रायल क्रेडिट क्लेम करें।
2. बेस URL को https://api.openaigatewayapi.com/v1 पर सेट करें।
3. कुंजी को Authorization: Bearer <key> के रूप में भेजें। जब आप api_key पास करते हैं तो SDK इसे आपके लिए करते हैं।
4. हर अनुरोध में मॉडल ID के रूप में uncensored का उपयोग करें।
5. HTTP 429 को एक छोटे पुन: प्रयास के साथ हैंडल करें, जैसा कि अंत के निकट दिखाया गया है।

दो एंडपॉइंट मौजूद हैं: POST /v1/chat/completions और GET /v1/models। सेवा केवल टेक्स्ट के लिए है। इसमें इमेज या ऑडियो जनरेशन, एम्बेडिंग्स और फाइन-ट्यूनिंग नहीं है, इसलिए यदि आपकी एप्लिकेशन उनका उपयोग करती है, तो उसे एक अलग प्रोवाइडर की आवश्यकता होगी।

curl के साथ कनेक्शन जाँचें

अपने एप्लिकेशन को बदलने से पहले, पुष्टि करें कि कुंजी काम कर रही है। मॉडल एंडपॉइंट सबसे सस्ता परीक्षण है, क्योंकि इसमें कोई टोकन जनरेट नहीं होता।

Copyexport API_KEY="paste-your-key-here"

curl https://api.openaigatewayapi.com/v1/models \
  -H "Authorization: Bearer $API_KEY" | grep -o uncensored

grep यदि सूची में हो तो मॉडल ID uncensored प्रिंट करता है; पूर्ण JSON सूची देखने के लिए grep हटा दें। यदि आपको 401 मिलता है, तो कुंजी गलत है या Bearer प्रीफिक्स छूट गया है। अब एक वास्तविक अनुरोध भेजें:

Copycurl https://api.openaigatewayapi.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise technical assistant."},
      {"role": "user", "content": "Explain idempotency keys in two sentences."}
    ],
    "temperature": 0.4
  }'

प्रतिक्रिया में सामान्य choices और usage ऑब्जेक्ट्स होते हैं। इसमें लॉग करने योग्य हेडर भी शामिल हैं: सपोर्ट प्रश्नों के लिए X-Request-Id, आपके शेष क्रेडिट के लिए X-Balance-USD, और वे दो X-RateLimit-Limit-* हेडर जो आपके अनुरोध और समानांतर अनुरोध सीमाओं को दर्शाते हैं।

आधिकारिक openai पैकेज के साथ Python

Python में आपको केवल क्लाइंट कंस्ट्रक्टर को बदलना है। उसके बाद का कोड वही है जो आपके पास पहले से है।

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You write short, accurate release notes."},
        {"role": "user", "content": "Summarise: added retry logic, fixed timeout bug."},
    ],
    temperature=0.5,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

वास्तविक कोड में कुंजी को एक एनवायरनमेंट वेरिएबल से पढ़ें। सैंपल में इसे केवल स्निपेट को छोटा रखने के लिए हार्डकोड किया गया है। max_tokens यहाँ वैकल्पिक है; यदि आप इसे छोड़ देते हैं, तो कंप्लीशन 100,000-टोकन विंडो के बचे हुए हिस्से का उपयोग कर सकता है (प्रॉम्प्ट और कंप्लीशन मिलकर)। इसे सेट करना रनअवे जनरेशन पर लागत को सीमित करने का एक सस्ता तरीका है।

स्ट्रीमिंग

स्ट्रीमिंग सर्वर-सेंट इवेंट्स (SSE) और उसी stream=True फ्लैग का उपयोग करती है जिसे आप जानते हैं। उपयोग की संख्या स्ट्रीम के अंत में आती है, इसलिए आखिरी चंक में खाली choices सूची हो सकती है।

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "List five edge cases for a date parser."}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\ntokens:", chunk.usage.total_tokens)

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

Node.js उदाहरण

Node SDK एक ही सेटिंग्स को अलग नामों के तहत लेता है।

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.openaigatewayapi.com/v1",
  apiKey: process.env.GATEWAY_KEY,
});

const completion = await client.chat.completions.create({
  model: "uncensored",
  messages: [
    { role: "user", content: "Write a regex that matches ISO 8601 dates, and explain it." },
  ],
  temperature: 0.3,
});

console.log(completion.choices[0].message.content);

यदि आप किसी फ्रेमवर्क का उपयोग कर रहे हैं जिसकी अपना OpenAI इंटीग्रेशन है, तो सेटिंग्स में base URL, API base या endpoint नाम का फ़ील्ड खोजें। वहां उसी URL को पेस्ट करना आमतौर पर काफी होता है। चैट फ्रंट-एंड्स, एजेंट फ्रेमवर्क्स और एडिटर प्लगइन्स ज्यादातर इसी पैटर्न का पालन करते हैं। temperature, top_p, stop, seed जैसे सैंपलिंग पैरामीटर और फ्रीक्वेंसी व प्रेजेंस पेनल्टी मॉडल को पास की जाती हैं।

टूल कॉलिंग और JSON मोड

दो फीचर्स तय करते हैं कि क्या कोई मॉडल एक वास्तविक एप्लिकेशन में फिट बैठता है: आपके फ़ंक्शन्स को कॉल करना और डेटा लौटाना जिसे आप पार्स कर सकें। दोनों का समर्थन किया जाता है।

टूल कॉलिंग

आप tools के साथ टूल्स घोषित करते हैं, वैकल्पिक रूप से tool_choice के साथ एक चयन फोर्स करते हैं, और role: "tool" के साथ संदेशों के रूप में परिणाम वापस भेजते हैं। स्ट्रीम किए गए प्रतिक्रियाएं tool_calls को टुकड़ों में डिलीवर करती हैं, जैसे कि स्टैंडर्ड फॉर्मेट में होता है।

Copyimport json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its ID.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "shipped"}  # your real lookup here
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

किसी भी एक्शन से पहले तर्कों की सत्यापन करें। मॉडल अधिकांश समय आपके स्कीमा से मेल खाने वाला JSON उत्पन्न करता है, हर बार नहीं, इसलिए call.function.arguments को किसी भी अन्य अविश्वसनीय इनपुट की तरह मानें।

JSON मोड

एक्सट्रैक्शन और क्लासिफिकेशन जॉब्स के लिए, एक JSON ऑब्जेक्ट मांगें और प्रॉम्प्ट में भी बताएं। निर्देशों में JSON का उल्लेख करने से केवल फ्लैग पर निर्भर रहने की तुलना में बेहतर परिणाम मिलते हैं।

Copyfrom openai import OpenAI
import json

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"sentiment\": string, \"topics\": [string]}."},
        {"role": "user", "content": "The docs are clear but the rate limits caught me off guard."},
    ],
)
data = json.loads(resp.choices[0].message.content)
print(data)

सीमाएँ, त्रुटियाँ और पुन: प्रयास

पूर्ण कुंजी 8 अनुरोधों को एक साथ चलाने और प्रति मिनट 300 अनुरोधों की अनुमति देती है। ट्रायल कुंजी 2 अनुरोधों को एक साथ चलाने और प्रति मिनट 60 की अनुमति देती है। अधिकतम अनुरोध बॉडी 8 MB है। सीमा से आगे बढ़ने पर आपको HTTP 429 मिलता है, और त्रुटि कोड बताता है कि वह कौन सी सीमा थी।

त्रुटि कोड	अर्थ	क्या करना है
rate_limited	प्रति मिनट बहुत सारे अनुरोध	प्रोड्यूसर को धीमा करें या काम को मिनट में फैलाएं
concurrency	एक साथ बहुत सारे अनुरोध	अपने वर्कर काउंट को 8 या उससे कम करें, या ट्रायल कुंजी पर 2
429 के साथ Retry-After: 5	अस्थायी ओवरलोड	दिए गए सेकंड तक प्रतीक्षा करें और फिर से कोशिश करें

SDK पहले से ही कुछ विफलताओं के लिए रीट्राई करते हैं। 429 के लिए अपना हैंडलिंग जोड़ें ताकि एक बर्स्ट बैच जॉब को क्रैश न करे:

Copyimport time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
    max_retries=0,
)

def ask(prompt, attempts=5):
    for i in range(attempts):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            wait = float(e.response.headers.get("retry-after", 2 ** i))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है, इसलिए एक रीट्राई लूप आपकी बिल को दोगुना नहीं करता है। एक सेमाफोर जो आपके कन्करेंसी लिमिट के आकार का हो, एसिंक कोड में कैप के नीचे रहने का सबसे साफ तरीका है।

मौजूदा ऐप को स्थानांतरित करना

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

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.openaigatewayapi.com/v1"),
    api_key=os.environ["LLM_API_KEY"],
)
MODEL = os.environ.get("LLM_MODEL", "uncensored")

def complete(messages, **kw):
    return client.chat.completions.create(model=MODEL, messages=messages, **kw)

फिर एक छोटी माइग्रेशन प्रक्रिया के माध्यम से काम करें:

1. अपने मौजूदा प्रॉम्प्ट सेट को नए एंडपॉइंट पर चलाएं और आउटपुट को स्वयं पढ़ें। स्वचालित जाँच फॉर्मेट में खराबी को पकड़ती है, टोन को नहीं।
2. यह जाँच करें कि JSON पार्स करने वाला कोड response_format सेट होने पर भी काम कर रहा है, और ऑब्जेक्ट के आसपास की अवांछित टेक्स्ट को हटाने वाला एक फॉलबैक रखें।
3. usage से वास्तविक टोकन गिनती मापें, क्योंकि एक अलग मॉडल टेक्स्ट को अलग तरीके से टोकन में बदलता है और आपकी पुरानी अनुमान गलत हो सकती है।
4. अपने वर्कर पूल को 8 या उससे कम पर सेट करें ताकि समानांतर अनुरोध सीमा लोड के तहत विफल होने वाला पहला कारक न बने।
5. ट्रैफ़िक के एक छोटे हिस्से को रिलीज करें, 429 रेट और एरर लॉग की निगरानी करें, फिर विस्तार करें।

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

स्विच करने से पहले जानने योग्य बातें

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

एक बहुरूपी मॉडल प्लेटफॉर्म से तीन व्यावहारिक अंतरों को ध्यान में रखकर योजना बनाएं:

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

प्रॉम्प्ट प्रशिक्षण के लिए उपयोग नहीं किए जाते। पूर्ण पैरामीटर सूची के लिए API दस्तावेज़ देखें। यदि आप खर्च का अनुमान लगा रहे हैं, तो मूल्य निर्धारण पृष्ठ प्रति टोकन दरें सूचीबद्ध करता है: 1M इनपुट टोकन के लिए $0.15 और 1M आउटपुट टोकन के लिए $0.50, प्रीपेड क्रेडिट से बिल किए जाते हैं, बिना सदस्यता के। टॉप-अप $20 से $500 तक चलते हैं और क्रेडिट समाप्त नहीं होता है। यदि आप कई सेवाओं के सामने एक प्रॉक्सी परत का वजन कर रहे हैं, तो LLM गेटवे पृष्ठ कवर करता है कि वह अतिरिक्त घटक कब फायदेमंद होता है।

अधिक गाइड

• साधारण शब्दों में OpenAI Gateway API की व्याख्या
• OpenAI Gateway API मूल्य निर्धारण: वास्तविक लागत उदाहरण
• LLM गेटवे: लागत बनाम जटिलता विश्लेषण