HI ▾

डेवलपर्स के लिए बिना सेंसर AI API विकल्प

https://api.veniceapialternative.com/v1

veniceapialternative.com

Venice API वैकल्पिक Python: OpenAI SDK सेटअप

आप base URL, कुंजी और मॉडल नाम बदलकर इस API के विरुद्ध आधिकारिक OpenAI Python SDK का उपयोग कर सकते हैं। नीचे प्रत्येक सामान्य कार्य के लिए काम करने वाला कोड दिया गया है।

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

एक टर्मिनल से एक क्लाउड सर्वर तक कोड ब्लॉक्स की पट्टी, पायथन API सेटअप को दर्शाती हुई

मुख्य बिंदु

  • openai पैकेज इंस्टॉल करें, base_url को https://api.veniceapialternative.com/v1 पर सेट करें और मॉडल को uncensored पर सेट करें।
  • स्ट्रीमिंग, टूल कॉलिंग और JSON मोड सभी मानक SDK कॉल्स के माध्यम से काम करते हैं।
  • समानांतर कार्य की संख्या 8 समानांतर अनुरोधों से अधिक न रखें (ट्रायल कुंजी पर 2)।
  • 429 का अर्थ है rate_limited, concurrency या अस्थायी ओवरलोड; बैक ऑफ़ करें और पुनः प्रयास करें।

इंस्टॉल करें और पहला कॉल करें

venice api alternative python सेटअप के लिए आपको कोई विशेष लाइब्रेरी की आवश्यकता नहीं है। सेवा OpenAI चैट फॉर्मेट का उपयोग करती है, इसलिए मानक SDK काम करता है। इसे pip install openai के साथ इंस्टॉल करें, फिर एक कुंजी प्राप्त करें। नए उपयोगकर्ता Google या ईमेल और पासवर्ड से साइन इन करने के बाद API कुंजी पृष्ठ पर $0.50 का मुफ़्त ट्रायल क्रेडिट दावा कर सकते हैं। कार्ड की आवश्यकता नहीं है।

कुंजी को स्रोत फ़ाइल के बजाय एक एनवायरनमेंट वेरिएबल में स्टोर करें। फिर बेस URL के साथ एक क्लाइंट बनाएं और मॉडल uncensored को कॉल करें:

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise writing assistant."},
        {"role": "user", "content": "Give me three opening lines for a noir story."},
    ],
    temperature=0.8,
)

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

SDK आपके लिए Authorization: Bearer <key> भेजता है। usage ऑब्जेक्ट प्रॉम्प्ट और कंप्लीशन टोकन दिखाता है, जिन्हें आप बाद में लागत ट्रैकिंग के लिए उपयोग करेंगे। यदि कॉल प्रमाणीकरण त्रुटि के साथ विफल हो जाती है, तो जांचें कि कुंजी में कोई ट्रेलिंग न्यूलाइन नहीं है और बेस URL /v1 पर समाप्त होता है।

तापमान, top_p, stop और seed पैरामीटर, साथ ही फ्रीक्वेंसी और प्रेजेंस पेनल्टी मॉडल को पास की जाती हैं, इसलिए आप सैंपलिंग को उसी तरह ट्यून कर सकते हैं जैसे आप कहीं और करते। यदि आप चाहते हैं कि मॉडल विंडो में बचे हुए स्थान का उपयोग करे, तो max_tokens को छोड़ दें, या जब आप प्रतिक्रिया की लंबाई और लागत पर कठोर सीमा चाहते हैं तो इसे सेट करें।

मॉडल्स एंडपॉइंट के साथ कनेक्शन जांचें

कुछ भी बनाने से पहले, सुनिश्चित करें कि एंडपॉइंट पहुंच योग्य है। दूसरा समर्थित विधि, GET /v1/models, उस सूची को दिखाता है जिसका उपयोग कुंजी कर सकती है:

import os
from openai import OpenAI

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

for m in client.models.list():
    print(m.id, m.id == "uncensored")

आपको uncensored दिखना चाहिए। यह एकमात्र मॉडल ID है, और यह हर अनुरोध में model के रूप में पास करने के लिए मान है। यदि आप एक ऐप को पोर्ट कर रहे हैं जिसने कई मॉडल नामों के बीच चयन किया था, तो चयन तर्क को एक स्थिरांक से बदल दें। चयन करने के लिए कुछ और नहीं है।

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

स्ट्रीमिंग प्रतिक्रियाएं

स्ट्रीमिंग टोकन को उत्पादित होते ही वापस करती है, जिससे चैट इंटरफ़ेस तेज़ लगते हैं। stream=True सेट करें और चंक पर पुनरावृत्ति करें। उपयोग स्ट्रीम के अंत में आता है, इसलिए उन चंक की रक्षा करें जिनमें कोई चॉइस नहीं है:

import os
from openai import OpenAI

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

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Describe a rainy harbor town in 120 words."}],
    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("\n", chunk.usage)

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

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

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

import json
import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.veniceapialternative.com/v1",
    api_key=os.environ["UNCENSORED_API_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 the next encounter."}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = {"value": 14, "sides": args["sides"]}
    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)

उत्पादन कोड में हमेशा function.arguments को try/except के साथ पार्स करें, क्योंकि कभी-कभी मॉडल खराब JSON उत्पन्न कर सकता है। JSON मोड उन स्थितियों में मदद करता है जब आप टूल के बिना संरचित आउटपुट चाहते हैं:

import json
import os
from openai import OpenAI

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

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

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

429 त्रुटियों और रेट लिमिट हैंडल करना

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

  • rate_limited: प्रति मिनट बहुत सारे अनुरोध। गति धीमी करें।
  • concurrency: उड़ान में बहुत सारे अनुरोध। कुछ के समाप्त होने का प्रतीक्षा करें।
  • एक Retry-After: 5 हेडर के साथ 429: अस्थायी ओवरलोड। 5 सेकंड प्रतीक्षा करें और पुनः प्रयास करें।

SDK डिफ़ॉल्ट रूप से पहले से कुछ बार रीट्राई करता है और Retry-After का सम्मान करता है। किसी भी भारी कार्य के लिए, अपना खुद का wrapper जोड़ें और लिमिट हेडर पढ़ें। आप with_raw_response के माध्यम से रेस्पॉन्स तक पहुँच सकते हैं:

import os
import time
import openai
from openai import OpenAI

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

def ask(prompt, attempts=4):
    for n in range(attempts):
        try:
            raw = client.chat.completions.with_raw_response.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            print("balance:", raw.headers.get("X-Balance-USD"),
                  "request id:", raw.headers.get("X-Request-Id"))
            return raw.parse().choices[0].message.content
        except openai.RateLimitError as e:
            wait = int(e.response.headers.get("Retry-After", 2 ** n))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

print(ask("Name three plot twists for a heist story."))

हर फेल्योर के साथ X-Request-Id लॉग करें। यदि आप सपोर्ट से संपर्क करते हैं, तो वह ID उन्हें सटीक कॉल खोजने में मदद करता है। X-Balance-USD हेडर आपको बिना किसी अतिरिक्त अनुरोध के शेष क्रेडिट देता है। फेल और रिफ्यूज अनुरोधों के लिए चार्ज नहीं किया जाता है।

कैप को पार किए बिना समानांतर अनुरोध चलाना

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

import asyncio
import os
from openai import AsyncOpenAI

client = AsyncOpenAI(
    base_url="https://api.veniceapialternative.com/v1",
    api_key=os.environ["UNCENSORED_API_KEY"],
)
gate = asyncio.Semaphore(6)

async def summarize(text):
    async with gate:
        r = await client.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": "Summarize in one sentence: " + text}],
            max_tokens=80,
        )
        return r.choices[0].message.content

async def main():
    docs = ["First long text ...", "Second long text ...", "Third long text ..."]
    for line in await asyncio.gather(*(summarize(d) for d in docs)):
        print(line)

asyncio.run(main())

प्रति मिनट कैप के लिए गति महत्वपूर्ण है। 6 समानांतर वर्कर्स और प्रति कॉल 4 सेकंड पर, आप प्रति मिनट लगभग 90 अनुरोध भेजते हैं, जो 300 से काफी कम है। यदि आपके कॉल तेज़ हैं, तो एक छोटा नींद या टोकन बकेट जोड़ें ताकि आप बर्स्ट में कैप से अधिक न हों।

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

अधिकांश माइग्रेशन लोगों की उम्मीद से छोटे होते हैं। यदि आपका कोड पहले से OpenAI(...) क्लाइंट बना रहा है, तो आपको दो कंस्ट्रक्टर आर्गुमेंट्स और एक स्ट्रिंग बदलनी होगी। यदि आप सेटिंग्स को एनवायरनमेंट वेरिएबल्स से पढ़ते हैं, तो आप अक्सर कोड को छुए बिना ही काम कर सकते हैं: openai पैकेज OPENAI_API_KEY और OPENAI_BASE_URL पढ़ता है, इसलिए अपने शेल या .env फ़ाइल में उन दो सेटिंग्स को सेट करने से पूरा प्रोग्राम नए एंडपॉइंट की ओर इशारा करता है।

फिर अपने प्रोजेक्ट में इन आइटमों के लिए खोजें, क्योंकि ये टूटने के आम स्रोत हैं:

  • हार्ड-कोडेड मॉडल नाम। हर पुराने नाम को uncensored से बदलें। model= के लिए grep ज्यादातर उन्हें ढूंढ लेता है।
  • अन्य एंडपॉइंट्स पर कॉल। छवि, ऑडियो, एम्बेडिंग और फाइन-ट्यूनिंग कॉल्स का यहाँ कोई समकक्ष नहीं है। उन्हें एक सेवा में रूट करें जो उन्हें प्रदान करती है, या उन्हें हटा दें।
  • वेंडर-विशिष्ट अतिरिक्त। आपके पुराने प्रदाता से जुड़े अतिरिक्त अनुरोध फ़ील्ड या कस्टम हेडर त्रुटियाँ पैदा कर सकते हैं। उन्हें सादे OpenAI फ़ॉर्मेट में बदलें।
  • टोकन बजट। विंडो प्रॉम्प्ट और पूर्णता के लिए 100,000 टोकन है। यदि आपने इतिहास को छोटी विंडो में फिट करने के लिए काटा है, तो आप अब अधिक रख सकते हैं, लेकिन लागत पर नज़र रखें, क्योंकि हर रखे गए संदेश के लिए प्रत्येक टर्न पर फिर से भुगतान किया जाता है।

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

सामान्य समस्याएँ और उनके समाधान

पायथन से एक नए OpenAI-संगत एंडपॉइंट को जोड़ते समय अक्सर दिखने वाली त्रुटियों की एक छोटी सूची:

  • पहले कॉल पर 404। बेस URL में /v1 गायब है, या इसमें एक अतिरिक्त पथ सेगमेंट है। यह बिल्कुल https://api.veniceapialternative.com/v1 होना चाहिए।
  • 401 या प्रमाणीकरण त्रुटि। कुंजी गलत है, कॉपी किए गए .env लाइन से इसके चारों ओर अभी भी कोट्स हैं, या इसे Python चलाए जाने वाले शेल में एक्सपोर्ट नहीं किया गया था।
  • बड़े इनपुट पर अनुरोध लटक जाता है। अधिकतम बॉडी 8 MB है। प्रॉम्प्ट में एक विशाल फ़ाइल पेस्ट करने से आप टोकन सीमा तक पहुँचने से पहले ही इसे पार कर सकते हैं। टेक्स्ट को विभाजित करें।
  • टेस्टिंग के दौरान यादृच्छिक 429। ट्रायल कुंजी पर आपके पास केवल 2 समानांतर अनुरोध हैं। एक टेस्ट रनर जो एक साथ पाँच भेजता है, वह सीमा को ट्रिगर कर देगा। टेस्ट को सीरियल चलाएँ, या टॉप-अप करें और पूर्ण कुंजी का उपयोग करें।
  • कटे हुए उत्तर। finish_reason जाँचें। length मान का अर्थ है कि आउटपुट ने आपकी max_tokens सेटिंग को छू लिया या विंडो भरी।
  • रन से रन अलग परिणाम। यदि आपको टेस्ट के लिए दोहराने योग्य आउटपुट चाहिए, तो seed और कम temperature पास करें।

यदि कुछ अभी भी गलत दिखता है, तो कॉल के समय के साथ X-Request-Id मान सहायता को भेजें।

कोड में लागत का अनुमान

मूल्य 1M इनपुट टोकन के लिए $0.15 और 1M आउटपुट टोकन के लिए $0.50 है। एक छोटा हेल्पर किसी भी उपयोग ब्लॉक को $ में बदल देता है:

import os
from openai import OpenAI

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

def cost_usd(usage):
    return (usage.prompt_tokens * 0.15 + usage.completion_tokens * 0.50) / 1_000_000

r = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a limerick about a lighthouse."}],
)
print(round(cost_usd(r.usage), 6))

2,000 प्रॉम्प्ट टोकन और 500 कंप्लीशन टोकन वाले एक अनुरोध पर 0.00055 आता है। 1,000 ऐसे चलाएं और आप $0.55 खर्च करेंगे। $0.50 का मुफ़्त ट्रायल क्रेडिट लगभग 909 ऐसे अनुरोधों को कवर करता है। ट्रायल के बाद, टॉप-अप $20 से शुरू होते हैं और क्रेडिट कभी नहीं खत्म होता; मूल्य सूची पेज पर बोनस स्तर सूचीबद्ध हैं। यदि आपका ऐप एक चैटबॉट प्रोजेक्ट से आता है जिसमें अपनी चुनौतियाँ हैं, तो सामान्य API गलतियों पर लेख उन कई मुद्दों को कवर करता है जो यहाँ भी लागू होते हैं।

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

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

आधिकारिक openai पैकेज। इसे pip के साथ इंस्टॉल करें, base_url को https://api.veniceapialternative.com/v1, पर सेट करें और मॉडल uncensored का उपयोग करें। किसी अन्य क्लाइंट लाइब्रेरी की आवश्यकता नहीं है।

SDK के साथ स्ट्रीमिंग काम करता है?

हाँ। stream=True पास करें और चंक (chunks) पर इटरेट करें। उपयोग स्ट्रीम के अंत में रिपोर्ट किया जाता है।

मुझे 429 त्रुटि क्यों मिल रही है?

या तो आपने requests-per-minute लिमिट (rate_limited) पार कर दी, एक साथ बहुत सारे अनुरोध खोले (concurrency), या सेवा अस्थायी रूप से ओवरलोड हो गई और Retry-After: 5 भेजा। बैक ऑफ करें और पुनः प्रयास करें।

मैं कितने समानांतर अनुरोध चला सकता हूँ?

एक फुल कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 की अनुमति देती है। एक ट्रायल कुंजी 2 समानांतर और प्रति मिनट 60 की अनुमति देती है।

क्या मैं LangChain या अन्य OpenAI-संगत टूल्स का उपयोग कर सकता हूँ?

कोई भी क्लाइंट जो आपको एक OpenAI-संगत बेस URL और कुंजी सेट करने देता है, काम करना चाहिए। समान बेस URL और मॉडल नाम uncensored का उपयोग करें।

आपकी कुंजी बस एक फॉर्म भरने के लिए बाकी है

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

API कुंजी पाएँ