HI ▾

openaiapiproxy.comपायथन में OpenAI API प्रॉक्सी: सेटअप और उदाहरण

पायथन में OpenAI API प्रॉक्सी: सेटअप और उदाहरण

openai API प्रॉक्सी Python प्रोजेक्ट के लिए, आप आधिकारिक openai पैकेज रखते हैं और दो कंस्ट्रक्टर तर्क बदलते हैं: base_url और api_key। इस पृष्ठ का शेष भाग स्ट्रीमिंग, एसिंक, टूल्स, रेट्राइज़ और बजट कवर करता है।

अपडेट किया गया

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

मुख्य बिंदु

  • openai इंस्टॉल करें, फिर OpenAI(base_url=..., api_key=...) मॉडल को uncensored सेट करके बनाएं।
  • स्ट्रीमिंग, JSON मोड और टूल कॉलिंग मानक पैरामीटर का उपयोग करती है, और async वैसे ही काम करता है।
  • सेमाफोर के साथ कॉन्करेंसी को 8 तक सीमित करें और SDK को 429 प्रतिक्रियाओं के लिए रीट्राई करने दें।
  • रिस्पॉन्स हेडर से X-Balance-USD पढ़ें ताकि आप अपने क्रेडिट की निगरानी कोड से कर सकें।

न्यूनतम कार्य उदाहरण

यहाँ सबसे छोटा उपयोगी openai api प्रॉक्सी Python सेटअप है। इसमें Python 3.9 या उससे नया, API कुंजी पेज से एक कुंजी, pip install openai से पैकेज इंस्टॉल और UNCENSORED_API_KEY के रूप में कुंजी एक्सपोर्ट की गई है।

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.openaiapiproxy.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Give me a one-line product tagline for a hiking app."}],
    temperature=0.8,
    max_tokens=60,
)

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

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

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

आने वाले टोकन को स्ट्रीम करना

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

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Tell a two-paragraph ghost story."}],
    stream=True,
)

usage = None
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):
        usage = chunk.usage
print()
if usage:
    print("tokens:", usage.prompt_tokens, usage.completion_tokens)

एक ऑपरेशनल विवरण: एक स्ट्रीमिंग कॉल आपके कॉन्करेंसी स्लॉट में से एक को तब तक ओक्युप करती है जब तक स्ट्रीम खत्म न हो जाए। यदि आपका कोड लूप से जल्दी बाहर निकलता है, तो स्लॉट को फ्री करने के लिए स्ट्रीम को बंद करें (stream.close())।

एक वेब ऐप आमतौर पर इस लूप को एक जनरेटर में लपेटता है और प्रत्येक टुकड़े को ब्राउज़र को फॉरवर्ड करता है। FastAPI के साथ, इसका मतलब है एक StreamingResponse लौटना जो टेक्स्ट पार्ट्स को यील्ड करता है। उस डिज़ाइन में कुंजी सर्वर पर रखें। ब्राउज़र आपकी रूट से बात करता है, और आपकी रूट API से बात करती है, इसलिए कुंजी क्लाइंट कोड के लिए कभी एक्सपोज्ड नहीं होती।

एसिंक क्लाइंट और नियंत्रित कन्करेंसी

एक फुल कुंजी एक साथ 8 अनुरोध और प्रति मिनट 300 की अनुमति देती है। एक ट्रायल कुंजी 2 और 60 की अनुमति देती है। यदि आप asyncio.gather के साथ 200 कोरूटीन फायर ऑफ करते हैं, तो आपको 429 त्रुटियाँ मिलेंगी जिनका कोड concurrency है। एक सेमाफोर इसे होने से पहले ठीक कर देता है।

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=4)
gate = asyncio.Semaphore(8)

async def ask(prompt: str) -> str:
    async with gate:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=200,
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Write a title for chapter {i} of a sea adventure." for i in range(1, 41)]
    results = await asyncio.gather(*(ask(p) for p in prompts))
    for t in results:
        print(t)

asyncio.run(main())

जब आप ट्रायल कुंजी पर हों तो सेमाफोर का साइज़ 2 का उपयोग करें। SDK डिफ़ॉल्ट रूप से बैकऑफ़ के साथ 429 प्रतिक्रियाओं को रीट्राई करता है, और max_retries प्रयासों की संख्या बढ़ाता है। अस्थायी ओवरलोड के लिए सेवा 429 को Retry-After: 5 के साथ उत्तर देती है, जिसे SDK मानता है।

एक सेमाफोर केवल एक प्रोसेस के अंदर चल रहे अनुरोधों को ही सीमित करता है। यदि आप कई वर्कर्स चलाते हैं, तो सीमा को उनके बीच बाँटें: एक फुल कुंजी के साथ, चार वर्कर्स को प्रत्येक 2 का सेमाफोर उपयोग करना चाहिए। प्रति मिनट 300 की सीमा सभी के लिए साझा है, इसलिए एक स्थिर दर वाली कतार बड़ी ऑफ़लाइन जॉब्स के लिए बर्स्ट से बेहतर है। 8 MB बॉडी लिमिट चैट के लिए दुर्लभ रूप से चिंता का विषय है, लेकिन यह हर अनुरोध पर लागू होती है।

JSON मोड और टूल कॉल्स

दोनों सामान्य पैरामीटर के माध्यम से काम करते हैं। JSON मोड के लिए, response_format सेट करें और प्रॉम्प्ट में JSON का अनुरोध करें।

import json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

r = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Return JSON with keys name, mood and hook."},
        {"role": "user", "content": "Invent a tavern keeper for a fantasy game."},
    ],
)
npc = json.loads(r.choices[0].message.content)
print(npc["name"])

टूल कॉलिंग को एक अतिरिक्त कदम की आवश्यकता है: आप फ़ंक्शन को स्वयं निष्पादित करते हैं और आउटपुट को एक tool मैसेज के रूप में लौटाते हैं।

import json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

tools = [{
    "type": "function",
    "function": {
        "name": "roll_dice",
        "description": "Roll a die with the given number of sides.",
        "parameters": {
            "type": "object",
            "properties": {"sides": {"type": "integer"}},
            "required": ["sides"],
        },
    },
}]

messages = [{"role": "user", "content": "Roll a twenty-sided die for me."}]
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]
    sides = json.loads(call.function.arguments)["sides"]
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": "14"})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

यहाँ पासे के लिए लौटाया गया मान संक्षेप के लिए हार्ड-कोडेड है। असली कोड में, sides के साथ अपनी फ़ंक्शन को कॉल करें और उसके परिणाम को भेजें।

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

त्रुटियाँ, रेट्राइज़ और कन्वर्सेशन हिस्ट्री

SDK टाइप्ड एक्ससेप्शन फेंकता है, जिससे एरर हैंडलिंग छोटी हो जाती है। एक 429 openai.RateLimitError फेंकता है, एक नेटवर्क फेल्योर openai.APIConnectionError फेंकता है, और अन्य गैर-सफल स्टेटस openai.APIStatusError फेंकते हैं। SDK पहले ही रीट्राई कर चुका होता है जब आप पहली त्रुटि देखते हैं, इसलिए आपके कोड तक वह कॉल पहुंचती है जिसने बार-बार फेल किया है।

import time
import openai
from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY", max_retries=2)

def chat(messages, attempts=4):
    delay = 2.0
    for n in range(attempts):
        try:
            r = client.chat.completions.create(model="uncensored", messages=messages)
            return r.choices[0].message.content
        except openai.RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", delay))
            time.sleep(wait)
            delay *= 2
        except openai.APIConnectionError:
            time.sleep(delay)
            delay *= 2
    raise RuntimeError("gave up after repeated failures")

print(chat([{"role": "user", "content": "Name a color."}]))

कोड Retry-After पढ़ता है जब सेवा इसे भेजती है, जो अस्थायी ओवरलोड पर होता है (मूल्य 5 सेकंड है)। जब हेडर गायब होता है, तो यह अपने आप के शेड्यूल पर बैकऑफ़ करता है। ध्यान दें कि लूप हर त्रुटि को कैच नहीं करता: एक खराब रिक्वेस्ट रीट्राई पर बेहतर नहीं होगा, इसलिए इसे प्रपगेट होने दें।

कन्वर्सेशन हिस्ट्री स्टेट का दूसरा हिस्सा है। API इसे आपके लिए स्टोर नहीं करता, इसलिए मैसेज की सूची की मालिक आपकी प्रोग्राम है। एक सरल नीति जो अच्छी तरह काम करती है: सिस्टम मैसेज रखें, आखिरी N टर्न्स रखें, और जब कुल आकार एक ऐसे आकार से बढ़ जाता है जिसे आप चुनते हैं, तो मॉडल से सबसे पुराने हिस्से को एक छोटे मैसेज में सारांशित करने के लिए कहें।

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

def compact(history, keep=6):
    system, rest = history[0], history[1:]
    if len(rest) <= keep:
        return history
    old, recent = rest[:-keep], rest[-keep:]
    text = "\n".join(m["role"] + ": " + m["content"] for m in old)
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": "Summarize this conversation in 120 words:\n" + text}],
        max_tokens=250,
    )
    summary = {"role": "system", "content": "Earlier in this conversation: " + r.choices[0].message.content}
    return [system, summary] + recent

समरियाइज़ में टोकन भी खर्च होते हैं, लेकिन वे स्वयं को भुगतान करते हैं: एक कन्वर्सेशन जो अन्यथा हर टर्न पर 20,000 टोकन रिसेंड करता, अब केवल कुछ हजार में घट जाता है।

बैलेंस और रिक्वेस्ट आईडी पढ़ना

प्रत्येक प्रतिक्रिया में X-Request-Id और X-Balance-USD शामिल हैं। SDK डिफ़ॉल्ट रूप से हेडर छुपा देता है, लेकिन with_raw_response उन्हें प्रकट करता है और आपको पार्स किया गया ऑब्जेक्ट भी प्रदान करता है।

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("X-Request-Id"))
print("balance USD:", raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

प्रत्येक विफलता के साथ अनुरोध ID लॉग करें। यदि आपको सहायता पृष्ठ के माध्यम से टीम से संपर्क करने की आवश्यकता है, तो वह ID सीधे उस कॉल की ओर इशारा करता है।

बैलेंस हेडर लॉगिंग से परे भी उपयोगी है। एक शेड्यूल्ड जॉब प्रत्येक बैच के बाद इसे पढ़ सकता है और क्रेडिट एक थ्रेशोल्ड से कम होने पर रुक सकता है जिसे आप सेट करते हैं, या आपको एक संदेश भेज सकता है ताकि आप उपयोगकर्ताओं को महसूस होने से पहले टॉप-अप कर सकें। क्रेडिट कभी समाप्त नहीं होता, इसलिए इसे खर्च करने का कोई दबाव नहीं है। टॉप-अप $20 से $500 तक पूर्ण राशि में होते हैं, इसलिए आप बड़ी राशि में रिफिल कर सकते हैं यदि आप ऐसा ही पसंद करते हैं।

SDK के बिना: requests या httpx

यदि आप निर्भरता से बचना पसंद करते हैं, तो API एक साधारण HTTP क्लाइंट के लिए पर्याप्त सरल है।

import requests

r = requests.post(
    "https://api.openaiapiproxy.com/v1/chat/completions",
    headers={"Authorization": "Bearer YOUR_KEY"},
    json={
        "model": "uncensored",
        "messages": [{"role": "user", "content": "Name three sea shanty topics."}],
    },
    timeout=120,
)
r.raise_for_status()
print(r.json()["choices"][0]["message"]["content"])

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

स्ट्रीमिंग के लिए वही दृष्टिकोण काम करता है। JSON बॉडी में "stream": true जोड़ें, requests.post में stream=True पास करें और प्रतिक्रिया को iter_lines() के साथ पढ़ें। प्रत्येक इवेंट पंक्ति data: के साथ शुरू होती है, जिसके बाद JSON आता है, और स्ट्रीम data: [DONE] मार्कर के साथ समाप्त होती है। इसे हाथ से पार्स करना एक अच्छा शिक्षाप्रद अभ्यास है, हालांकि उत्पादन कोड के लिए SDK कम एज केस के साथ ऐसा करता है, जैसे कि आंशिक लाइनें और पुनः कनेक्शन।

अपने Python कोड के अंदर बजटिंग

resp.usage में टोकन गणना आपको प्रत्येक कॉल के लिए खर्च की गणना करने देती है। कीमत $0.15 प्रति 1M इनपुट टोकन और $0.50 प्रति 1M आउटपुट टोकन है।

from openai import OpenAI

client = OpenAI(base_url="https://api.openaiapiproxy.com/v1", api_key="YOUR_KEY")

def cost_usd(prompt_tokens: int, completion_tokens: int) -> float:
    return prompt_tokens * 0.15 / 1_000_000 + completion_tokens * 0.50 / 1_000_000

r = client.chat.completions.create(model="uncensored", messages=[{"role": "user", "content": "Hi"}])
print(cost_usd(r.usage.prompt_tokens, r.usage.completion_tokens))
print(cost_usd(1_000_000, 200_000))  # 0.25

दूसरी लाइन को हाथ से जांचने पर: 1M इनपुट टोकन की लागत $0.15 है और 200,000 आउटपुट टोकन की लागत 0.2 x $0.50 = $0.10 है, जिससे $0.25 बनता है। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है, इसलिए आपको उन्हें घटाने की आवश्यकता नहीं है। टॉप-अप $20 से शुरू होते हैं, और मूल्य पृष्ठ पर $50, $100 और $200 पर बोनस सूचीबद्ध हैं।

पूर्ण पैरामीटर सूची और त्रुटि कोड के लिए, दस्तावेज़ देखें।

अपने जॉब में एक चालू कुल राशि रखें ताकि एक लूप आपकी योजना से अधिक न खर्च कर सके। 50,000 छोटे टेक्स्ट को वर्गीकृत करने वाला एक बैच जॉब, जिसमें प्रत्येक के लिए 400 इनपुट टोकन और 20 आउटपुट टोकन हैं, 20M इनपुट टोकन और 1M आउटपुट टोकन का उपयोग करता है। इसकी लागत 20 x $0.15 + 1 x $0.50 = $3.50 है। यदि आपका काउंटर बताता है कि जॉब उसकी दोगुनी पर है, तो कुछ लूप हो रहा है।

प्रश्न और उत्तर

क्या मुझे एक विशेष Python पैकेज की आवश्यकता है?

नहीं। आधिकारिक openai पैकेज ही पर्याप्त है। क्लाइंट पर base_url और api_key सेट करें और मॉडल नाम uncensored का उपयोग करें।

क्या async क्लाइंट काम करता है?

हाँ। AsyncOpenAI समान तर्क लेता है। एक पूर्ण कुंजी पर समानांतर अनुरोधों की संख्या को 8 अनुरोधों तक सीमित करें, या एक ट्रायल कुंजी पर 2।

मैं कोड से अपना शेष क्रेडिट कैसे देखूं?

X-Balance-USD प्रतिक्रिया हेडर पढ़ें। openai पैकेज में, with_raw_response का उपयोग करें और फिर raw.headers पढ़ें।

429 त्रुटि पर क्या होता है?

त्रुटि कोड rate_limited या concurrency आपको बताता है कि आपने कौन सी सीमा पार की है। SDK डिफ़ॉल्ट रूप से पुनः प्रयास करता है, और अस्थायी ओवरलोड पर एक Retry-After हेडर भेजा जाता है।

आपकी कुंजी बस एक फॉर्म दूर है

एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। यही पूरा सेटअप है।

API कुंजी पाएँ