पायथन में LLM API: चैट, स्ट्रीमिंग और टूल कॉल्स
यह LLM API पायथन गाइड एक OpenAI-कम्पैटिबल एंडपॉइंट पर इंगित आधिकारिक OpenAI SDK का उपयोग करती है। आपको एक पहला कॉल, स्ट्रीमिंग, एक टूल कॉल और कोड में रीट्राई लॉजिक मिलता है जिसे आप पेस्ट और चला सकते हैं।

मुख्य बिंदु
- openai इंस्टॉल करें, base URL और कुंजी सेट करें, और मॉडल ID uncensored का उपयोग करें।
- stream=True के साथ स्ट्रीम करें और समानांतरता स्लॉट मुक्त करने के लिए स्ट्रीम को जल्दी बंद करें।
- टूल कॉल्स तर्क लौटाते हैं जिन्हें आपको कुछ भी चलाने से पहले पार्स और वैलिडेट करना चाहिए।
- Retry-After के साथ 429 हैंडल करें और पूर्ण कुंजी पर समानांतर अनुरोधों को 8 पर कैप करें।
SDK इंस्टॉल करें और पहला कॉल करें
यदि आप पायथन में एक llm api सेटअप चाहते हैं जो पाँच मिनट में काम करे, तो OpenAI SDK ही काफी है। API OpenAI-संगत है, इसलिए आप आधिकारिक क्लाइंट रखते हैं और दो मान बदलते हैं: base URL और कुंजी। मॉडल ID uncensored है।
सबसे पहले एक कुंजी प्राप्त करें। API कुंजी पेज पर साइन अप करें, वन-क्लिक ट्रायल क्रेडिट क्लेम करें और कुंजी कॉपी करें। फिर क्लाइंट इंस्टॉल करें और कुंजी को अपने सॉर्स कोड से बाहर रखें।
pip install openai
export LLM_API_KEY="your-key-here"
अब सबसे छोटा उपयोगी प्रोग्राम:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.llmmodelsapi.com/v1",
api_key=os.environ["LLM_API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise technical assistant."},
{"role": "user", "content": "Explain what a context window is in two sentences."},
],
temperature=0.7,
)
print(resp.choices[0].message.content)
print(resp.usage)
यह पूरी इंटीग्रेशन है। resp.usage प्रॉम्प्ट और कंप्लीशन टोकन गिनती देता है, जिसे आप मूल्य निर्धारण पृष्ठ ($0.15 प्रति 1M इनपुट टोकन, $0.50 प्रति 1M आउटपुट टोकन) पर दरों से गुणा करके यह देख सकते हैं कि प्रत्येक कॉल का खर्च कितना है। उसी एंडपॉइंट पर POST /v1/responses भी स्वीकार किया जाता है यदि आपका कोड पहले से उस फॉर्मेट का उपयोग कर रहा है, और GET /v1/models मॉडल ID सूचीबद्ध करता है।
अनुरोध और प्रतिक्रिया कैसी दिखती है
OpenAI क्लाइंट HTTP विवरण छुपाता है, लेकिन जब कुछ गलत हो जाता है तो उन्हें जानना मददगार होता है। SDK POST को /v1/chat/completions पर एक बेयरर टोकन के साथ भेजता है। आप curl के साथ कॉल को पुन: उत्पन्न कर सकते हैं और तुलना कर सकते हैं।
curl https://api.llmmodelsapi.com/v1/chat/completions \
-H "Authorization: Bearer $LLM_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello"}]}'
मॉडल को पास किए जाने वाले उपयोगी पैरामीटर: temperature, top_p, stop, seed और फ्रीक्वेंसी व प्रेजेंस पेनल्टी। max_tokens वैकल्पिक है। यदि आप इसे छोड़ देते हैं, तो कंप्लीशन 100,000-टोकन विंडो (प्रॉम्प्ट और कंप्लीशन मिलाकर) के जो भी शेष बचे, उसका उपयोग कर सकता है।
प्रत्येक कॉल में दो रिस्पॉन्स हेडर लॉग करने योग्य हैं: सपोर्ट सवालों के लिए X-Request-Id और आपके शेष क्रेडिट के लिए X-Balance-USD। पायथॉन SDK के साथ आप उन्हें रैस्पॉन्स के माध्यम से प्राप्त कर सकते हैं:
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Ping"}],
max_tokens=20,
)
print(raw.headers.get("X-Request-Id"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)आने वाले टोकन को स्ट्रीम करना
चैट इंटरफेस और किसी व्यक्ति के इंतजार करने वाली चीज़ों के लिए, उत्तर स्ट्रीम करें। stream=True सेट करें और चंक पर इटरेट करें। API उन्हें सर्वर-सेंट इवेंट्स के माध्यम से भेजता है, और अंतिम चंक में उपयोग का डेटा होता है जब आप इसे मांगते हैं।
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short product description for a mechanical keyboard."}],
stream=True,
stream_options={"include_usage": True},
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
if chunk.usage:
print("\n", chunk.usage)
दो विवरण लोगों को परेशान करते हैं। पहला, कुछ चंक में खाली choices लिस्ट होती है (उदाहरण के लिए, उपयोग चंक), इसलिए इंडेक्सिंग से पहले गार्ड करें। दूसरा, एक स्ट्रीम किए गए अनुरोध में कॉन्करेंसी स्लॉट स्ट्रीम समाप्त होने तक बंधा रहता है। यदि आप एक स्ट्रीम खोलते हैं और उसे बिना बंद किए छोड़ देते हैं, तो वह स्लॉट व्यस्त रहता है और बाद की कॉलें concurrency त्रुटि के साथ विफल हो सकती हैं। स्ट्रीम को with ब्लॉक में उपयोग करें या जल्दी पढ़ना बंद करने पर stream.close() कॉल करें।
यदि एक स्ट्रीम अस्पष्ट संदेश के साथ कट जाती है, तो इस साइट पर LLM मॉडल का उपयोग कैसे करें लेख त्रुटियों को पढ़ने और पुन: प्रयास करने की बुनियादी बातों को कवर करता है।
मॉडल के खिलाफ एक टूल कॉल
टूल कॉलिंग मॉडल को आपके कोड को एक फ़ंक्शन चलाने और फिर परिणाम के साथ जारी रखने की अनुमति देती है। प्रवाह तीन चरणों में होता है: टूल परिभाषाएँ भेजें, मॉडल द्वारा अनुरोधित कुछ चलाएँ, और role: "tool" के साथ आउटपुट वापस भेजें।
import json
def get_order_status(order_id: str) -> str:
# Replace with a real lookup
return json.dumps({"order_id": order_id, "status": "shipped"})
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, tool_choice="auto"
)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": get_order_status(**args),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)
वास्तविक कोड में हमेशा call.function.arguments को एक try ब्लॉक के अंदर JSON के रूप में पार्स करें, क्योंकि मॉडल कभी-कभी ऐसे तर्क उत्पन्न करते हैं जो आपके स्कीमा से मेल नहीं खाते हैं। साइड इफेक्ट्स के साथ कुछ भी निष्पादित करने से पहले सत्यापित करें। लंबे एजेंट लूप के लिए, एजेंट्स के लिए इस API का उपयोग करने का मार्गदर्शक देखें।
टूल कॉल भी स्ट्रीम होते हैं: तर्क delta.tool_calls में टुकड़ों में आते हैं, और आप इंडेक्स द्वारा उन्हें स्ट्रीम समाप्त होने तक संयोजित करते हैं।
संरचित आउटपुट के लिए JSON मोड
जब आपको प्रोस की बजाय मशीन-पठनीय आउटपुट की आवश्यकता हो, तो response_format को एक JSON ऑब्जेक्ट पर सेट करें। प्रॉम्प्ट में आपकी वांछित आकृति का वर्णन करें, क्योंकि JSON मोड वैध JSON सिंटैक्स की गारंटी देता है लेकिन आपके विशिष्ट स्कीमा की नहीं।
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "Reply only with JSON: {\"sentiment\": \"positive|negative|neutral\", \"confidence\": 0-1}"},
{"role": "user", "content": "The setup took ten minutes and everything just worked."},
],
response_format={"type": "json_object"},
temperature=0,
)
data = json.loads(resp.choices[0].message.content)
print(data["sentiment"])
एक्सट्रैक्शन और वर्गीकरण के लिए temperature=0 का उपयोग करें ताकि दोहराए गए रन समान लेबल दें। यदि आप सैंपलिंग को और अधिक स्थिर करना चाहते हैं तो seed जोड़ें, और अपने स्कीमा के खिलाफ पार्स किए गए परिणाम की अभी भी जाँच करें।
लिमिट्स, रेट्रिज़ और एरर हैंडलिंग
एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोध की अनुमति देती है। एक ट्रायल कुंजी 2 समानांतर और प्रति मिनट 60 की अनुमति देती है। किसी भी सीमा से अधिक जाने पर HTTP 429 लौटाया जाता है। त्रुटि कोड बताता है कि आपने कौन सी सीमा पार की: प्रति मिनट अनुरोधों के लिए rate_limited और एक साथ बहुत अधिक के लिए concurrency। अस्थायी ओवरलोड पर आपको एक Retry-After: 5 हेडर के साथ 429 भी मिलता है।
OpenAI SDK पहले से कुछ विफलताओं को पुन: प्रयास करता है, लेकिन आपको नीति स्वयं सेट करनी चाहिए:
import os
import time
from openai import OpenAI, RateLimitError, APIConnectionError
client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key=os.environ["LLM_API_KEY"], max_retries=0, timeout=120)
def ask(messages, tries=5):
delay = 2
for attempt in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError as e:
wait = float(e.response.headers.get("Retry-After", delay))
time.sleep(wait)
delay = min(delay * 2, 30)
except APIConnectionError:
time.sleep(delay)
delay = min(delay * 2, 30)
raise RuntimeError("gave up after retries")
यदि आप थ्रेड्स या asyncio के साथ कार्य फैलाते हैं, तो सेमाफोर के साथ पूल को 8 (या ट्रायल कुंजी पर 2) तक सीमित करें। यह आपको पुन: प्रयासों पर निर्भर किए बिना कॉन्करेंसी सीमा के नीचे रखता है। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है, इसलिए विफल प्रयासों के लिए पुन: प्रयास करने से अतिरिक्त लागत नहीं आती।
GET /v1/balance के साथ कोड से अपना बैलेंस जाँचें, या किसी भी प्रतिक्रिया से X-Balance-USD पढ़ें। पूर्ण पैरामीटर सूची API दस्तावेज़ में है।
इन उदाहरणों को चलाने की लागत
ऊपर दिए गए उदाहरण छोटे हैं। 300 प्रॉम्प्ट टोकन और 200 कंप्लीशन टोकन वाली एक कॉल की लागत 300 x $0.15 / 1M प्लस 200 x $0.50 / 1M है, जो $0.000045 प्लस $0.0001, या $0.000145 है। लगभग 6,900 ऐसे कॉल एक डॉलर में फिट होते हैं। $0.50 ट्रायल क्रेडिट उनमें से लगभग 3,400 को कवर करता है, और यह 7 दिनों के लिए मान्य है, बिना किसी भुगतान विवरण के।
ट्रायल के बाद, $20 से $500 तक किसी भी पूर्ण राशि को टॉप-अप करें, $50 से 5% बोनस, $100 से 10% और $200 से 15%। क्रेडिट कभी समाप्त नहीं होता और कोई सब्सक्रिप्शन नहीं है। प्रॉम्प्ट प्रशिक्षण के लिए उपयोग नहीं किए जाते हैं।
अधिक गाइड
प्रश्न और उत्तर
क्या मैं आधिकारिक OpenAI Python लाइब्रेरी का उपयोग कर सकता हूँ?
हाँ। base_url को API पता पर और api_key को अपनी कुंजी पर सेट करें, फिर मॉडल uncensored के साथ chat.completions.create कॉल करें।
क्या API async Python का समर्थन करता है?
हाँ, समान base URL और कुंजी के साथ AsyncOpenAI का उपयोग करें। पूर्ण कुंजी पर 8 से कम या बराबर समानांतर अनुरोध रखें, या ट्रायल कुंजी पर 2।
मैं यह कैसे देखूं कि एक कॉल में कितने टोकन का उपयोग हुआ?
सामान्य अनुरोध पर resp.usage पढ़ें, या स्ट्रीम किए गए अनुरोध पर include_usage के साथ stream_options पास करें। 1M इनपुट टोकन के लिए $0.15 और 1M आउटपुट टोकन के लिए $0.50 से गुणा करें।
मेरा प्रॉम्प्ट कितना लंबा हो सकता है?
कॉन्टेक्स्ट विंडो 100,000 टोकन है, प्रॉम्प्ट और पूर्णता मिलाकर। अनुरोध बॉडी 8 MB तक सीमित है।
आपकी कुंजी बस एक फ़ॉर्म दूर है
एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।