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

Hosted API के साथ Python में LLM कैसे लागू करें

अधिकांश परियोजनाओं के लिए, Python में LLM लागू करने का तरीका खुद ट्रेन या सर्व करने के बजाय HTTP के माध्यम से एक होस्टेड मॉडल को कॉल करने तक सीमित है। एक OpenAI-compatible API के साथ यह लगभग दस पंक्तियों में होता है, और वही कोड स्ट्रीमिंग, JSON आउटपुट और टूल कॉलिंग में बढ़ जाता है।

अपडेटेड

एक टर्मिनल जो क्लाउड सर्वर को बीम भेज रहा है और डेटा क्यूब्स प्राप्त कर रहा है, जो एक होस्टेड LLM के लिए Python कॉल का चित्रण करता है

मुख्य बिंदु

  • openai पैकेज इंस्टॉल करें, base URL और कुंजी सेट करें, और model ID uncensored का उपयोग करें।
  • स्ट्रीमिंग, JSON मोड और टूल कॉलिंग सभी समर्थित हैं और मानक SDK तर्कों का उपयोग करते हैं।
  • चैट इतिहास को एक सूची में रखें और 100,000-टोकन विंडो पर नज़र रखें।
  • HTTP 429 को एक छोटे रीट्राइज़ के साथ हैंडल करें; विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है।

Hosted API या अपना खुद का मॉडल

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

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

चरण 1: इंस्टॉल करें और पहला कॉल करें

SDK इंस्टॉल करें और अपनी API कुंजी को एनवायरनमेंट वेरिएबल में सहेजें, ताकि वह कभी आपके सोर्स कोड में न आए।

pip install openai
export API_KEY="your-key-here"

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

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain list comprehensions in two sentences."},
    ],
)
print(resp.choices[0].message.content)
print(resp.usage)

यह एक पूर्ण कार्यशील प्रोग्राम है। इसके पीछे एंडपॉइंट POST /v1/chat/completions है, जिसे Authorization: Bearer <key> से प्रमाणीकृत किया जाता है, और GET /v1/models मॉडल ID सूचीबद्ध करता है। आप कुंजी पेज पर एक API कुंजी और एक छोटा मुफ़्त ट्रायल क्रेडिट प्राप्त कर सकते हैं।

चरण 2: उत्तर स्ट्रीम करें

पूर्ण उत्तर के लिए कई सेकंड इंतज़ार करना टर्मिनल या वेब पेज पर धीमा लगता है। stream=True सेट करें और सर्वर-सेंट इवेंट्स के माध्यम से टोकन प्राप्त होते ही उन्हें प्रिंट करें।

# client from step 1: base_url https://api.fluxapikey.com/v1
stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short story opening about a lighthouse keeper."}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()

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

चरण 3: बातचीत बनाए रखें

मॉडल के पास कॉल्स के बीच कोई मेमोरी नहीं है। एक चैट केवल संदेशों की एक बढ़ती हुई लिस्ट है जिसे आप हर बार फिर से भेजते हैं। एक छोटी क्लास काफी है:

# client from step 1: base_url https://api.fluxapikey.com/v1
class Chat:
    def __init__(self, system):
        self.messages = [{"role": "system", "content": system}]

    def say(self, text):
        self.messages.append({"role": "user", "content": text})
        r = client.chat.completions.create(model="uncensored", messages=self.messages)
        answer = r.choices[0].message.content
        self.messages.append({"role": "assistant", "content": answer})
        return answer

bot = Chat("You are a patient Python tutor.")
print(bot.say("What is a generator?"))
print(bot.say("Show me one with yield."))

कॉन्टेक्स्ट विंडो 100,000 टोकन की है, जो प्रॉम्प्ट और कम्प्लीशन दोनों के लिए साझा है। यह जगह भरपूर है, लेकिन एक लंबी चैट हर टर्न के साथ बढ़ती है, और आप हर अनुरोध पर पूरी हिस्ट्री के लिए भुगतान करते हैं। जब यह बड़ा हो जाए, तो सबसे पुराने टर्न्स को हटा दें या उन्हें एक छोटे सारांश से बदल दें जिसे आप मॉडल से लिखने के लिए कहें।

चरण 4: संरचित आउटपुट प्राप्त करें

प्रोग्राम्स को पैराग्राफ्स नहीं, डेटा चाहिए। JSON मोड जवाब को वैध JSON बनाता है। प्रॉम्प्ट में बताएं कि आप किन कीज़ की उम्मीद कर रहे हैं।

# client from step 1: base_url https://api.fluxapikey.com/v1
import json

r = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": 'Return JSON like {"title": str, "tags": [str]}.'},
        {"role": "user", "content": "Summarise: a tutorial on async IO in Python."},
    ],
)
data = json.loads(r.choices[0].message.content)
print(data["title"], data["tags"])

वैध JSON आपकी कीज़ की गारंटी नहीं देता। कोड में उनका चेक करें और यदि कोई की गायब हो तो एक बार फिर से प्रयास करें।

चरण 5: मॉडल को आपके फ़ंक्शन कॉल करने दें

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

# client from step 1: base_url https://api.fluxapikey.com/v1
import json

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

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

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = len(args["text"].split())
        messages.append({"role": "tool", "tool_call_id": call.id, "content": str(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

किसी भी कार्रवाई से पहले हमेशा आर्ग्युमेंट्स को वैलिडेट करें, क्योंकि मॉडल ऐसा कॉल बना सकता है जिसकी आपने उम्मीद नहीं की थी। टूल कॉल भी tool_calls डेल्टा के रूप में स्ट्रीम होते हैं, यदि आपको इसकी ज़रूरत हो। दस्तावेज़ीकरण में हर फ़ील्ड सूचीबद्ध है।

चरण 6: रेट लिमिट और त्रुटियों को हैंडल करें

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

# client from step 1: base_url https://api.fluxapikey.com/v1
import time
from openai import RateLimitError

def ask(messages, tries=4):
    for i in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError:
            time.sleep(5 * (i + 1))
    raise RuntimeError("still limited after retries")

यदि आप थ्रेड्स में कार्य चलाते हैं, तो ThreadPoolExecutor(max_workers=8) के साथ उन्हें 8 पर सीमित करें ताकि आप कन्करेंसी लिमिट को कम ही पार करें। प्रत्येक प्रतिक्रिया में X-Request-Id होता है, जिसे सहायता से संपर्क करते समय उद्धृत करना चाहिए, और X-Balance-USD आपके शेष क्रेडिट को दर्शाता है। अधिकतम बॉडी साइज़ 8 MB है।

सेटिंग्स जो आउटपुट बदलती हैं

दैनिक ट्यूनिंग का अधिकांश हिस्सा कुछ ही पैरामीटर में होता है, जिन्हें मॉडल में भेजा जाता है।

  • temperature यादृच्छिकता को नियंत्रित करता है। एक्सट्रैक्शन और क्लासिफिकेशन के लिए 0.2 या उससे कम, चैट के लिए लगभग 0.7, और ब्रेनस्टॉर्मिंग व फिक्शन के लिए 1.0 या उससे अधिक का उपयोग करें।
  • top_p शब्द चयन के कम संभावना वाले हिस्से (टेल) को काटता है। या तो इसे या temperature को बदलें, दोनों को एक साथ नहीं, ताकि आप यह बता सकें कि किसने काम किया।
  • seed दोहराए जाने वाले रन को अधिक तुलनीय बनाता है। यह उन टेस्ट में उपयोगी है जहाँ आप प्रॉम्प्ट बदलाव के प्रभाव को देखना चाहते हैं और शोर को नहीं।
  • stop आपकी चुनी हुई स्ट्रिंग पर जनरेशन समाप्त करता है, जो मॉडल को टिप्पणी जोड़ते हुए रोकने के लिए उपयोगी है।
  • max_tokens वैकल्पिक है। इसके बिना कम्प्लीशन 100,000-टोकन विंडो के शेष का उपयोग कर सकता है। लंबाई और लागत पर कठोर सीमा चाहने पर इसे सेट करें।
  • फ्रीक्वेंसी और प्रेजेंस पेनल्टी दोहराव को कम करती हैं, जो लंबी क्रिएटिव आउटपुट में लूपिंग शुरू होने पर मदद करती है।

जिस भी आउटपुट की आपको परवाह हो, उसके बगल में इस्तेमाल की गई सेटिंग्स लिख लें। महीनों बाद, "इसने अलग जवाब क्यों दिया" लगभग हमेशा एक बदले गए पैरामीटर या बदले गए सिस्टम मैसेज के कारण होता है।

एक साथ कई अनुरोध चलाना

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

from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI

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

def summarise(text):
    r = client.chat.completions.create(
        model="uncensored",
        messages=[{"role": "user", "content": "Summarise in one line: " + text}],
        max_tokens=60,
    )
    return r.choices[0].message.content

texts = ["first document", "second document", "third document"]
with ThreadPoolExecutor(max_workers=8) as pool:
    for line in pool.map(summarise, texts):
        print(line)

वर्कर काउंट को 8 या उससे कम रखें, या ट्रायल की पर 2। यदि आप अभी भी कोड concurrency के साथ 429 प्रतिक्रियाएं देखते हैं, तो संख्या को एक या दो कम करें। प्रति मिनट 300 की लिमिट तेज़, छोटे अनुरोधों के लिए मायने रखती है, इसलिए छोटे कॉल्स का बैच कन्करेंसी सीमा से पहले ही उसे छू सकता है।

सामान्य समस्याएं और समाधान

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

  • 401 या ऑथेंटिकेशन एरर। कुंजी गायब है, गलत टाइप की गई है या गलत होस्ट पर भेजी गई है। अपने क्लाइंट द्वारा वास्तव में उपयोग किए जाने वाले base URL को प्रिंट करें और सुनिश्चित करें कि यह /v1 पर समाप्त होता है।
  • मॉडल नहीं मिला। मॉडल ID uncensored होनी चाहिए। यदि आप यह पुष्टि करना चाहते हैं कि सर्वर क्या सूचीबद्ध करता है, तो GET /v1/models कॉल करें।
  • खाली या कट-ऑफ रिप्लाई। एक कम max_tokens जवाब को मध्य-वाक्य में रोक देता है। इसे बढ़ाएं या हटा दें। चॉइस पर finish_reason चेक करें: length का मतलब है कि सीमा पूरी हो गई।
  • JSON जो पार्स नहीं होता। या तो रिप्लाई ट्रंकेटेड थी, या प्रॉम्प्ट ने शैप का वर्णन नहीं किया था। पहले प्रॉम्प्ट को ठीक करें और पार्सिंग को ट्राई ब्लॉक में लपेटें।
  • धीमा पहला टोकन। एक बहुत लंबा प्रॉम्प्ट प्रोसेस करने में अधिक समय लेता है। हिस्ट्री ट्रिम करें या कम कॉन्टेक्स्ट भेजें।
  • अनुरोध बहुत बड़ा है। बॉडी की सीमा 8 MB है, और टोकन विंडो 100,000 है। बड़े दस्तावेज़ों को टुकड़ों में बाँटें और प्रत्येक का सारांश तैयार करें।

जब कुछ अभी भी गलत दिखे, तो विफल इनपुट के साथ X-Request-Id हेडर लॉग करें। यह सहायता को सटीक अनुरोध खोजने में मदद करता है।

इसकी लागत

आप प्रीपेड क्रेडिट से प्रति 1M इनपुट टोकन के लिए $0.15 और प्रति 1M आउटपुट टोकन के लिए $0.50 चुकाते हैं। 2,000 टोकन इनपुट और 500 आउटपुट वाले एक सामान्य कॉल की लागत इनपुट के लिए 0.002 x $0.15 = $0.0003 और आउटपुट के लिए 0.0005 x $0.50 = $0.00025 होती है, इसलिए कुल $0.00055 आती है। दस हजार ऐसे कॉल की लागत $5.50 है। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता और क्रेडिट कभी समाप्त नहीं होता। टॉप-अप $20 से $500 तक चलते हैं; बोनस स्तरों के लिए मूल्य निर्धारण देखें। प्रॉम्प्ट को प्रशिक्षण के लिए उपयोग नहीं किया जाता है।

आउटपुट टोकन की लागत इनपुट टोकन से अधिक है, इसलिए सबसे सस्ती आदत छोटे उत्तर माँगना है: दो वाक्य कहें, या केवल JSON, और max_tokens को एक उचित छत पर सेट करें। अपने प्रॉम्प्ट के लिए वास्तविक टोकन गणना देखने के लिए विकास के दौरान resp.usage पढ़ें, और एक कार्य को स्केल करने से पहले ऊपर दी गई दरों से गुणा करें। X-Balance-USD हेडर प्रत्येक कॉल के बाद शेष राशि दिखाता है।

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

क्या मुझे Python में LLM लागू करने के लिए GPU की आवश्यकता है?

होस्टेड एपीआई के साथ नहीं। आपका पायथन कोड केवल HTTP अनुरोध भेजता है, इसलिए कोई भी लैपटॉप काम करता है।

क्या मैं आधिकारिक openai पैकेज का उपयोग कर सकता हूँ?

हाँ। base_url को सेवा URL पर और api_key को अपनी कुंजी पर सेट करें, और मॉडल ID uncensored का उपयोग करें।

क्या यह एसिंक कोड का समर्थन करता है?

SDK का AsyncOpenAI क्लाइंट समान base URL और कुंजी के साथ काम करता है। समानांतर अनुरोधों की संख्या 8 से कम या बराबर रखें।

मैं भुगतान किए बिना इसे कैसे आज़मा सकता हूँ?

साइन अप करें और कुंजी पेज पर $0.50 का मुफ़्त ट्रायल क्रेडिट क्लेम करें। यह 7 दिनों के लिए मान्य है और कार्ड की आवश्यकता नहीं है।

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

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

API कुंजी पाएँ