HI ▾
API कुंजी पाएँ

Python में LLM API वर्कफ़्लो: चरण-दर-चरण सेटअप

OpenAI SDK को एक नए बेस URL पर निर्देशित करें, मॉडल ID uncensored का उपयोग करें, और रीट्राइज़, समानांतर रन और टूल कॉल्स को एक-एक परत जोड़ते हुए जोड़ें।

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

चमकते हुए ब्लॉकों की पाइपलाइन, जिसमें डेटा क्यूब्स समानांतर लेनों में विभाजित हो रहे हैं, जो एक Python LLM वर्कफ़्लो का प्रतिनिधित्व करते हैं

मुख्य बिंदु

  • openai को इंस्टॉल करें, base_url को https://api.veo3apis.com/v1 पर सेट करें और मॉडल uncensored का उपयोग करें।
  • Retry-After के लिए प्रतीक्षा करके 429 हैंडल करें; विफल अनुरोधों के लिए शुल्क नहीं लगाया जाता है।
  • थ्रेड पूल को कुंजी के अनुसार आकार दें: पूर्ण कुंजी के लिए 8 वर्कर, ट्रायल कुंजी के लिए 2।
  • प्रत्येक रन पर खर्च ट्रैक करने के लिए प्रतिक्रिया हेडर से X-Balance-USD पढ़ें।

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

एक LLM API वर्कफ़्लो पायथन स्क्रिप्ट बनाने के लिए, आधिकारिक OpenAI SDK इंस्टॉल करें, बेस URL को https://api.veo3apis.com/v1 पर सेट करें, अपनी कुंजी को API कुंजी के रूप में उपयोग करें और मॉडल uncensored को कॉल करें। कुछ भी अन्य नहीं बदलता। सेवा OpenAI-संगत है, इसलिए SDK से आपको जो भी पैटर्न पहले से पता है, वह काम करता है: साधारण चैट कॉल, स्ट्रीमिंग, JSON मोड और टूल कॉलिंग।

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

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

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

आपको Python 3.9 या उससे नया संस्करण चाहिए। SDK को इंस्टॉल करें:

pip install openai

साइन इन करने के बाद API कुंजी पृष्ठ से एक कुंजी बनाएं। इस पृष्ठ पर $0.50 का 7 दिनों के लिए मान्य मुफ़्त ट्रायल क्रेडिट एक क्लिक में क्लेम करने का विकल्प भी है, एक व्यक्ति के लिए एक बार, बिना कार्ड के। फिर सबसे छोटा संभव कॉल चलाएं:

from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "List three uses for a hosted text API."},
    ],
)

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

यदि यह टेक्स्ट और उपयोग ऑब्जेक्ट प्रिंट करता है, तो प्रमाणीकरण, रूटिंग और मॉडल ID सभी सही हैं। SDK आपकी कुंजी को Authorization: Bearer के रूप में भेजता है, और अनुरोध POST /v1/chat/completions पर जाता है। आप client.models.list() के साथ जाँच सकते हैं कि आपकी कुंजी कौन से मॉडल IDs देखती है, जो GET /v1/models को कॉल करता है।

एक कच्चा curl संस्करण उपयोगी है जब आप पायथन के बिना सर्वर से डिबग करते हैं:

curl https://api.veo3apis.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello."}]}'

कॉन्फ़िगरेशन को एक क्लाइंट में रखें

स्क्रिप्ट में कुंजी को हार्ड-कोड करना उसे रिपॉजिटरी में लीक करने का सबसे तेज़ तरीका है। दोनों मानों को एन्वायरनमेंट से पढ़ें, और क्लाइंट को एक जगह बनाएं ताकि वर्कफ़्लो का हर चरण उसे साझा कर सके।

import os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.veo3apis.com/v1"),
    api_key=os.environ["LLM_API_KEY"],
    max_retries=0,
    timeout=120,
)

MODEL = "uncensored"


def ask(system: str, user: str, **kwargs) -> str:
    resp = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user},
        ],
        **kwargs,
    )
    return resp.choices[0].message.content

यहाँ दो विकल्प जानबूझकर चुने गए हैं। max_retries=0 SDK के बिल्ट-इन रेट्राइज़ को बंद कर देता है ताकि अगले सेक्शन में रेट्राइ लॉजिक ही एकमात्र रहे, जिससे व्यवहार को समझना आसान हो जाता है। 120-सेकंड का टाइमआउट लंबी कम्पलीशन के लिए जगह छोड़ता है; कॉन्टेक्स्ट विंडो प्रॉम्प्ट और कम्पलीशन के लिए 100,000 टोकन की है, और एक बड़ा जवाब स्ट्रीम करने में समय लेता है। temperature, top_p, stop, seed जैसे सैंपलिंग पैरामीटर और पेनल्टी **kwargs के माध्यम से सामान्य तरीके से पास हो जाती हैं।

सही त्रुटियों को रीट्राई करें

हर असली वर्कफ़्लो में रेट लिमिट जल्द या बाद में आती है। एक फुल कुंजी प्रति मिनट 300 अनुरोध और एक साथ 8 की अनुमति देती है। एक ट्रायल कुंजी प्रति मिनट 60 और एक साथ 2 की अनुमति देती है। किसी भी सीमा को पार करने पर API HTTP 429 लौटाता है। एरर कोड बताता है कि आप किस लिमिट पर पहुंचे: rate_limited प्रति मिनट अनुरोधों के लिए, concurrency एक साथ बहुत सारे अनुरोधों के लिए। अस्थिर ओवरलोड के दौरान API 429 भी भेजता है Retry-After: 5 हेडर के साथ।

तीनों मामलों का एक ही इलाज है: प्रतीक्षा करें, फिर फिर से कोशिश करें। यह वेपर हेडर का सम्मान करता है और जब यह अनुपस्थित हो तो बैकऑफ़ करता है।

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import time
from openai import RateLimitError, APIConnectionError, APIStatusError


def call_with_retry(messages, tries=5, **kwargs):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(
                model="uncensored", messages=messages, **kwargs
            )
        except RateLimitError as err:
            wait = err.response.headers.get("Retry-After")
            time.sleep(int(wait) if wait else delay)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
        except APIStatusError as err:
            if err.status_code < 500:
                raise
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("request failed after retries")

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

बहुत इनपुट को पैरलल चलाएं

कई इनपुट्स पर एक लूप के लिए, एक थ्रेड पूल काफी है। SDK क्लाइंट थ्रेड्स के बीच साझा करने के लिए सुरक्षित है। पूल का साइज़ अपनी कुंजी के अनुसार सेट करें: फुल कुंजी के लिए 8 वर्कर्स, ट्रायल कुंजी के लिए 2।

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import time
from concurrent.futures import ThreadPoolExecutor
from openai import RateLimitError


def summarize(text: str) -> str:
    for _ in range(5):
        try:
            resp = client.chat.completions.create(
                model="uncensored",
                messages=[
                    {"role": "system", "content": "Summarize the text in two sentences."},
                    {"role": "user", "content": text},
                ],
                max_tokens=150,
            )
            return resp.choices[0].message.content.strip()
        except RateLimitError as err:
            time.sleep(int(err.response.headers.get("Retry-After", "5")))
    return ""


documents = ["First long text...", "Second long text...", "Third long text..."]

with ThreadPoolExecutor(max_workers=8) as pool:
    summaries = list(pool.map(summarize, documents))

for s in summaries:
    print(s)

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

संरचित आउटपुट और टूल कॉल

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

JSON मोड

response_format को एक JSON ऑब्जेक्ट पर सेट करें और प्रॉम्प्ट में कुंजियों का वर्णन करें।

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON: {\"title\": string, \"tags\": [string]}"},
        {"role": "user", "content": "A short post about nightly backups."},
    ],
)
post = json.loads(resp.choices[0].message.content)
print(post["title"], post["tags"])

टूल कॉलिंग

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

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import json

tools = [{
    "type": "function",
    "function": {
        "name": "word_count",
        "description": "Count the words in a piece of text.",
        "parameters": {
            "type": "object",
            "properties": {"text": {"type": "string"}},
            "required": ["text"],
        },
    },
}]

messages = [{"role": "user", "content": "How many words are in 'the quick brown fox'?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = {"words": len(args["text"].split())}
        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)
else:
    print(msg.content)

tool_calls मौजूद है या नहीं, हमेशा जांचें। मॉडल सीधे जवाब दे सकता है, और आपका कोड दोनों परिणामों को संभालना चाहिए।

स्टेप्स को पाइपलाइन में जोड़ें

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

from openai import OpenAI

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

def step(system: str, user: str, temperature: float = 0.7) -> str:
    resp = client.chat.completions.create(
        model="uncensored",
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user},
        ],
        temperature=temperature,
        max_tokens=800,
    )
    return resp.choices[0].message.content.strip()


topic = "a changelog entry for a new export feature"

draft = step("Write the requested text in under 120 words.", topic)
review = step(
    "List at most three concrete problems with this text: vague wording, missing detail, wrong tone.",
    draft,
    temperature=0.2,
)
final = step(
    "Rewrite the text so it fixes every listed problem. Reply with the text only.",
    "TEXT:\n" + draft + "\n\nPROBLEMS:\n" + review,
)
print(final)

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

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

बैलेंस और अनुरोध ID ट्रैक करें

प्रत्येक रिस्पॉन्स में हेडर्स होते हैं जिन्हें लॉग करने के लायक है: X-Request-Id सपोर्ट से संपर्क करने पर कॉल की पहचान करता है, X-Balance-USD आपके क्रेडिट का शेष दिखाता है, और दो X-RateLimit-Limit हेडर्स आपकी कुंजी के लिए अनुरोध और कॉन्करेंसी लिमिट रिपोर्ट करते हैं। SDK डिफ़ॉल्ट रूप से हेडर्स छुपा देता है; उन्हें पढ़ने के लिए रॉ-रिस्पॉन्स रैपर का उपयोग करें।

from openai import OpenAI

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

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Reply with the single word ready."}],
    max_tokens=10,
)

print("request id:", raw.headers.get("X-Request-Id"))
print("balance usd:", raw.headers.get("X-Balance-USD"))
print("req limit:", raw.headers.get("X-RateLimit-Limit-Requests"))
print("concurrency limit:", raw.headers.get("X-RateLimit-Limit-Concurrency"))

resp = raw.parse()
print(resp.choices[0].message.content)

मूल्य $0.15 प्रति मिलियन इनपुट टोकन और $0.50 प्रति मिलियन आउटपुट टोकन है, इसलिए 1,000 इनपुट और 500 आउटपुट टोकन वाले कॉल का खर्च $0.00015 + $0.00025 = $0.0004 होता है। एक वर्कफ़्लो जो 5,000 ऐसे कॉल चलाता है, $2.00 खर्च करता है। रन की शुरुआत और अंत में बैलेंस प्रिंट करें, और आप जानेंगे कि प्रत्येक बैच का खर्च क्या है, बिना किसी अतिरिक्त टूलिंग के। दरों और टॉप-अप बोनस के लिए, मूल्य निर्धारण पृष्ठ देखें; प्रत्येक समर्थित पैरामीटर के लिए, API दस्तावेज़ीकरण पढ़ें।

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

नई सेटअप की समस्या निवारण

अधिकतर पहले-रन समस्याएं कारणों की एक छोटी सूची से आती हैं।

  • कॉल कनेक्ट पर हंग हो जाता है या त्रुटि देता है। बेस URL जांचें। इसका अंत /v1 पर होना चाहिए, और SDK स्वयं /chat/completions जोड़ता है। डबल पाथ आमतौर पर गलती होती है।
  • प्रमाणीकरण त्रुटि। कुंजी गायब है, ट्रंकेट है या कॉपी-पेस्ट से एक अतिरिक्त स्पेस या न्यूलाइन है। इसकी लंबाई प्रिंट करें, कुंजी को नहीं, और इसे API कुंजी पृष्ठ पर दिखाए गए मान से तुलना करें।
  • मॉडल नहीं मिला। मॉडल ID uncensored है, छोटे अक्षरों में। यह देखने के कि आपकी कुंजी क्या उपयोग कर सकती है, मॉडल एंडपॉइंट पर कॉल करें।
  • छोटे स्क्रिप्ट पर स्थिर 429। आप ट्रायल कुंजी पर हो सकते हैं, जो 2 समानांतर अनुरोध और प्रति मिनट 60 की अनुमति देती है। पूल को 2 वर्कर्स तक कम करें, या एक पूर्ण कुंजी प्राप्त करने के लिए टॉप-अप करें।
  • कट-ऑफ उत्तर। एक कम max_tokens जवाब को जल्दी समाप्त कर देता है। इसे बढ़ाएं, या इसे हटा दें और पूर्णता को विंडो का शेष भाग उपयोग करने दें।
  • अनुरोध बहुत बड़ा है। बॉडी लिमिट 8 MB है, और प्रॉम्प्ट और पूर्णता दोनों के लिए टोकन विंडो 100,000 टोकन है। बड़े इनपुट को टुकड़ों में बांटें और उन्हें अलग-अलग कॉल के रूप में प्रोसेस करें।

जब सेवा पक्ष पर कुछ गलत दिखे, तो साइट पर संपर्क को X-Request-Id का मान भेजें। एक अनुरोध ID ऑपरेटर को आपकी सटीक कॉल खोजने में मदद करती है, जो इससे अधिक उपयोगी है कि आपने क्या देखा।

01

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

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

नहीं। आधिकारिक OpenAI Python SDK तब काम करता है जब आप बेस URL और अपनी कुंजी सेट कर लेते हैं।

मुझे कौन सा मॉडल ID उपयोग करना चाहिए?

uncensored का उपयोग करें। आप GET /v1/models से उपलब्ध ID की सूची बना सकते हैं।

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

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

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

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

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

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

API कुंजी प्राप्त करेंदस्तावेज़ पढ़ें