LLM Inference APIमार्गदर्शिका
LLM इनफ़रेंस API: स्ट्रीमिंग, टूल्स और JSON मोड
एक LLM inference API आपको HTTPS के माध्यम से प्रॉम्प्ट भेजने और उत्पन्न टेक्स्ट प्राप्त करने की अनुमति देता है, आपके पास GPU की आवश्यकता नहीं होती। यह पेज एक OpenAI-कम्पैटिबल एंडपॉइंट के खिलाफ एक काम करने वाले सेटअप को दिखाता है, पहले अनुरोध से लेकर स्ट्रीमिंग, टूल्स, JSON मोड और रेट लिमिट तक।
अपडेट किया गया:

मुख्य बिंदु
- किसी भी OpenAI SDK को https://api.llminferenceapi.com/v1, की ओर इशारा करें, मॉडल ID uncensored का उपयोग करें और अपनी कुंजी Bearer टोकन के रूप में भेजें।
- दो एंडपॉइंट उपलब्ध हैं: POST /v1/chat/completions और GET /v1/models।
- स्ट्रीमिंग, टूल कॉलिंग और JSON मोड मानक अनुरोध फ़ील्ड्स के माध्यम से काम करते हैं।
- एक पूर्ण कुंजी 8 समकालीन अनुरोधों और प्रति मिनट 300 की अनुमति देती है; एक 429 प्रतिक्रिया आपको बताती है कि आपने कौन सी सीमा को छू लिया है।
पहली कॉल से पहले आपको क्या चाहिए
आपको तीन चीज़ें चाहिए: बेस URL, एक कुंजी और मॉडल नाम। बेस URL https://api.llminferenceapi.com/v1 है, मॉडल ID uncensored है, और कुंजी Google या ईमेल व पासवर्ड से साइन अप करने के बाद API कुंजी पृष्ठ से आती है। नए उपयोगकर्ता वहाँ एक क्लिक से $0.50 का ट्रायल क्रेडिट क्लेम कर सकते हैं। इसके लिए कार्ड की आवश्यकता नहीं है, यह 7 दिनों तक मान्य रहता है और प्रति व्यक्ति केवल एक ही बार क्लेम किया जा सकता है।
सेवा केवल टेक्स्ट है। यह POST /v1/chat/completions और GET /v1/models एंडपॉइंट प्रदान करता है। एम्बेडिंग रूट, इमेज या ऑडियो जनरेशन और फाइन-ट्यूनिंग नहीं है। यह एक ओपन-वेट मॉडल चलाता है, जिसे एक स्वतंत्र प्रदाता संचालित करता है और कानूनी वयस्क उपयोग के लिए बिना सामग्री अस्वीकृति के उत्तर देने के लिए ट्यून किया गया है। यह किसी मॉडल विक्रेता की आधिकारिक API नहीं है। एक कड़ा नियम लागू है: नाबालिगों को यौन रूप से दर्शाने वाली सामग्री अनुमत नहीं है।
कुंजी को स्रोत कोड में रखने के बजाय एक पर्यावरण चर में रखें। नीचे दिए गए उदाहरण भाषा की अनुमति होने पर इसे API_KEY से पढ़ते हैं।
आपका पहला अनुरोध
curl के साथ शुरू करें, क्योंकि यह दिखाता है कि वायर पर क्या जाता है।
curl https://api.llminferenceapi.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "uncensored",
"messages": [
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "List three uses of a message queue."}
],
"temperature": 0.7
}'
प्रतिक्रिया मानक चैट कंप्लीशन ऑब्जेक्ट है: choices[0].message.content टेक्स्ट रखता है और usage टोकन गणनाएं रखता है। आप GET /v1/models के साथ मॉडल भी सूचीबद्ध कर सकते हैं, जो किसी अन्य डिबगिंग से पहले कुंजी और URL के सही होने की पुष्टि करने का एक तेज़ तरीका है।
आधिकारिक OpenAI SDK के साथ Python में, केवल कन्स्ट्रक्टर बदलता है:
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.llminferenceapi.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "List three uses of a message queue."}],
)
print(resp.choices[0].message.content)
और Node में:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.llminferenceapi.com/v1",
apiKey: process.env.API_KEY,
});
const resp = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "List three uses of a message queue." }],
});
console.log(resp.choices[0].message.content);
आउटपुट आपके प्रॉम्प्ट के बाद 100,000-टोकन विंडो के शेष का उपयोग कर सकता है, इसलिए max_tokens वैकल्पिक है। लागत या लंबाई पर एक कड़ा सीमा निर्धारित करने के लिए इसे सेट करें। temperature, top_p, stop, seed जैसे सैंपलिंग नियंत्रण और आवृत्ति व उपस्थिति पेनल्टी पास की जाती हैं।
दो सेटिंग्स शुरुआत से जानने योग्य हैं। seed सैंपलिंग को परीक्षण के लिए पर्याप्त रूप से दोहराने योग्य बनाता है, जो प्रॉम्प्ट के दो संस्करणों की तुलना करते समय मदद करता है और चाहते हैं कि अंतर प्रॉम्प्ट से आए, संयोग से नहीं। stop एक या अधिक स्ट्रिंग्स लेता है जो मॉडल द्वारा उन्हें लिखते ही जनरेशन समाप्त कर देती हैं, एक डिलिमीटर पर प्रतिक्रिया काटने और उन टोकन के लिए भुगतान करने से बचने का सस्ता तरीका जो आप फेंक देंगे।
स्ट्रीमिंग प्रतिक्रियाएं
stream: true के साथ सर्वर सर्वर-सेंट इवेंट्स के जवाब देता है और टेक्स्ट छोटे-छोटे हिस्सों में भेजता है। उपयोगकर्ता को शब्द जल्दी दिखते हैं, जो चैट इंटरफेस के लिए मायने रखता है। उपयोग के आंकड़े स्ट्रीम के अंत में आते हैं।
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a four-line poem about a lighthouse."}],
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.prompt_tokens, chunk.usage.completion_tokens)
दो बिंदु आसानी से छूट सकते हैं। पहला, अंतिम चंक उपयोग आंकड़े और एक खाली choices सूची ले जा सकता है, इसलिए इसे इंडेक्स करने से पहले जांचें कि choices खाली नहीं है। दूसरा, एक स्ट्रीम किए गए अनुरोध में उसका कॉन्करेंसी स्लॉट तब तक आरक्षित रहता है जब तक स्ट्रीम समाप्त नहीं हो जाती। यदि एक क्लाइंट एक स्ट्रीम खोलता है और कभी भी इसे अंत तक नहीं पढ़ता है, तो वह स्लॉट व्यस्त रहता है और आपके बाद के अनुरोध concurrency त्रुटि से टकरा सकते हैं। हमेशा स्ट्रीम को बंद करें या पूरी तरह से उपभोग करें।
टूल कॉलिंग
टूल कॉलिंग मॉडल को आपके कोड में फ़ंक्शन चलाने और परिणाम का उपयोग करने की अनुमति देती है। आप फ़ंक्शन्स को tools में वर्णित करते हैं, मॉडल के निर्णय को tool_choice से वैकल्पिक रूप से प्रभावित करते हैं, मॉडल द्वारा अनुरोधित किसी भी चीज़ को निष्पादित करते हैं, और आउटपुट को role: "tool" संदेश के रूप में वापस भेजते हैं।
import json
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-1043?"}]
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)
result = {"order_id": args["order_id"], "status": "shipped"}
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 को हमेशा सुरक्षित रूप से पार्स करें। यह एक भाषा मॉडल द्वारा उत्पादित JSON स्ट्रिंग है, और दुर्लभ मामलों में यह खराब हो सकता है या एक ऐसा फ़ील्ड हो सकता है जिसे आपने परिभाषित नहीं किया है। इस पर कार्य करने से पहले इसे मान्य करें, विशेष रूप से जब फ़ंक्शन डेटा बदलता हो। टूल कॉलिंग स्ट्रीमिंग के साथ भी काम करती है, जिस मामले में tool_calls खंडों के रूप में आते हैं जिन्हें पार्स करने से पहले इंडेक्स द्वारा जोड़ना होता है।
कॉन्वर्सेशन हिस्ट्री प्रबंधित करना
API स्टेटलेस है। यह पिछले अनुरोधों को याद नहीं रखता, इसलिए बहु-चरण चैट केवल इसलिए काम करती है क्योंकि आपका कोड हर बार पिछले चरणों को फिर से भेजता है। संदेशों की एक सूची रखें, उपयोगकर्ता के नए संदेश को जोड़ें, एंडपॉइंट पर कॉल करें, और अगले चरण से पहले असिस्टेंट के जवाब को जोड़ें।
history = [{"role": "system", "content": "You are a patient writing coach."}]
def chat(user_text):
history.append({"role": "user", "content": user_text})
resp = client.chat.completions.create(model="uncensored", messages=history)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(chat("Give me a prompt for a ghost story."))
print(chat("Make it set on a ferry."))
चूँकि हर चरण इतिहास को फिर से भेजता है, इनपुट टोकन चैट की लंबाई के साथ बढ़ते हैं। विंडो 100,000 टोकन धारण करती है, जो अधिकांश बातचीत के लिए पर्याप्त है, लेकिन लागत सीमा तक पहुँचने से पहले ही तेज़ी से बढ़ जाती है। एक सामान्य पैटर्न सिस्टम संदेश और पिछले कई चरणों को बनाए रखना है, और पुराने चरणों को एक छोटे सारांश से बदलना है जिसे मॉडल स्वयं लिखता है। इतिहास कितना बड़ा हो गया है, यह देखने के लिए हर कॉल के बाद usage.prompt_tokens पढ़ें।
JSON मोड
जब आपको मशीन-पठनीय आउटपुट चाहिए, तो response_format को {"type": "json_object"} पर सेट करें और प्रॉम्प्ट में बताएं कि आपको JSON चाहिए। आपकी अपेक्षित कुंजियों का वर्णन करने से परिणाम बहुत अधिक स्थिर होता है।
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON only, using the keys title, tags and summary."},
{"role": "user", "content": "Describe a short story about a lost robot."},
],
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
JSON मोड आउटपुट को JSON के रूप में पार्स करने योग्य बनाता है, लेकिन यह आपके स्कीमा को लागू नहीं करता है। कोड में कुंजियों की जांच करें, और किसी मान के गायब होने के मामले के लिए एक फॉलबैक रखें। यदि जवाब टोकन सीमा तक पहुंचने के कारण काट दिया गया है, तो JSON अधूरा होगा, इसलिए संरचित आउटपुट के लिए max_tokens को बहुत कम न सेट करें।
जब कुछ विफल हो तो एक छोटी चेकलिस्ट
अधिकांश पहले-दिन की समस्याएं कुछ ही कारणों से आती हैं, और आप उन्हें क्रम से दूर कर सकते हैं।
- बेस यूआरएल। इसे
/v1पर समाप्त होना चाहिए। SDK स्वयं/chat/completionsजोड़ता है, इसलिए जिस URL में पहले से पथ शामिल है वह काम नहीं करेगा। - कुंजी हेडर। कुंजी
Authorization: Bearerमें जाती है, उसके बाद कुंजी आती है। कुंजी के साथ कॉपी किया गया एक अतिरिक्त स्पेस या नई लाइन प्रमाणीकरण त्रुटियों का एक सामान्य कारण है। - मॉडल आईडी। बिल्कुल
uncensoredका उपयोग करें। अन्य विक्रेताओं के मॉडल के नाम यहाँ मान्य नहीं हैं। - अनुरोध आकार। बॉडी सीमा 8 MB है, और प्रॉम्प्ट प्लस पूर्णता को 100,000 टोकन में फिट होना चाहिए।
- बैलेंस। यह देखने के लिए कि क्या क्रेडिट समस्या है, किसी भी प्रतिक्रिया पर
X-Balance-USDहेडर देखें। - अनुरोध आईडी को उद्धृत करें। यदि आप support से संपर्क करते हैं, तो विफल प्रतिक्रिया से
X-Request-Idमान शामिल करें ताकि अनुरोध को खोजा जा सके।
ध्यान रखें कि अस्वीकृति त्रुटि से अलग है। चूंकि मॉडल कानूनी वयस्कों के उपयोग के लिए सामग्री अस्वीकृति से बचाने के लिए ट्यून्ड किया गया है, आपको फिल्टर वाली सेवाओं की तुलना में कम अस्वीकृतियां देखने को मिलेंगी, लेकिन मॉडल अभी भी एक अस्पष्ट प्रॉम्प्ट के लिए अस्वीकार कर सकता है या एक कमजोर उत्तर दे सकता है। एक स्पष्ट सिस्टम संदेश आमतौर पर उच्च तापमान से बेहतर उसकी मरम्मत करता है।
सीमाएँ, हेडर और पुनः प्रयास
एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोध अनुमति देती है। एक ट्रायल कुंजी 2 समानांतर अनुरोध और प्रति मिनट 60 अनुमति देती है। अनुरोध बॉडी 8 MB तक हो सकती है। प्रत्येक प्रतिक्रिया X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests और X-RateLimit-Limit-Concurrency ले जाती है, जो लॉगिंग और एक एडमिन स्क्रीन में संतुलन दिखाने के लिए उपयोगी हैं।
जब आप एक सीमा से अधिक हो जाते हैं, तो API HTTP 429 लौटाता है। त्रुटि कोड rate_limited का अर्थ है प्रति मिनट बहुत अधिक अनुरोध, और concurrency का अर्थ है एक साथ बहुत अधिक। अस्थायी ओवरलोड पर आपको Retry-After: 5 हेडर के साथ 429 भी मिलता है। एक सरल पुनः प्रयास रैपर तीनों को कवर करता है:
import time
from openai import RateLimitError
def ask(messages, tries=4):
for attempt in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError as e:
wait = 5 if attempt == 0 else 5 * (attempt + 1)
retry_after = getattr(e.response, "headers", {}).get("retry-after")
time.sleep(int(retry_after) if retry_after else wait)
raise RuntimeError("still rate limited after retries")
वर्कर पूल के लिए, पुनः प्रयास पर निर्भर रहने के बजाय पूल के आकार को अपनी समानांतर अनुरोध सीमा पर सीमित करें। एक पूर्ण कुंजी पर आठ वर्कर दुर्लभ ही concurrency त्रुटि देखेंगे। यदि आप अप्रत्याशित त्रुटियों का सामना करते हैं, तो समस्या निवारण लेख सामान्य कारणों की जांच करता है।
इसके लिए भुगतान करना
बिलिंग प्रीपेड क्रेडिट से पे-एज़-यू-गो है: 1M इनपुट टोकन के लिए $0.15 और 1M आउटपुट टोकन के लिए $0.50, कोई सदस्यता नहीं। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है, और क्रेडिट कभी समाप्त नहीं होता है। 1,500 इनपुट टोकन और 400 आउटपुट टोकन वाले एक अनुरोध की लागत 1,500 / 1,000,000 x $0.15 + 400 / 1,000,000 x $0.50 = $0.000225 + $0.0002 = $0.000425 है।
टॉप-अप $20 से $500 तक किसी भी पूर्ण राशि पर होते हैं, $50 पर 5% बोनस, $100 पर 10% और $200 पर 15% मिलता है। आप क्रिप्टो (TRC20 पर USDT, Base पर USDC) से भुगतान कर सकते हैं। प्रॉम्प्ट्स को प्रशिक्षण के लिए उपयोग नहीं किया जाता है। मूल्य निर्धारण पृष्ठ विवरण सूचीबद्ध करता है और त्वरित प्रारंभ सेटअप चरणों को संक्षेप में दोहराता है।
अधिक गाइड
प्रश्न और उत्तर
क्या मैं इस API के साथ आधिकारिक OpenAI लाइब्रेरी का उपयोग कर सकता हूँ?
हाँ। Python या Node के लिए OpenAI SDK इंस्टॉल करें, बेस URL को https://api.llminferenceapi.com/v1, पर सेट करें, अपनी कुंजी पास करें, और मॉडल ID uncensored का उपयोग करें।
क्या API फ़ंक्शन कॉलिंग का समर्थन करता है?
हाँ। टूल्स और वैकल्पिक रूप से tool_choice पास करें, फिर प्रत्येक परिणाम को role tool भूमिका के साथ एक संदेश के रूप में लौटाएं। स्ट्रीम किए गए tool_calls भी समर्थित हैं।
यहाँ 429 त्रुटि का अर्थ क्या है?
आप एक सीमा पर पहुँच गए हैं। कोड rate_limited का अर्थ है प्रति मिनट बहुत अधिक अनुरोध, concurrency का अर्थ है एक ही समय में बहुत अधिक अनुरोध, और एक Retry-After: 5 हेडर अस्थायी ओवरलोड को चिह्नित करता है। प्रतीक्षा करें और पुनः प्रयास करें।
क्या मैं इसे एम्बेडिंग्स या इमेज के लिए उपयोग कर सकता हूँ?
नहीं। API केवल टेक्स्ट है और चैट पूर्णताएँ और एक मॉडल सूची प्रदान करता है।
आपकी कुंजी पाने के लिए केवल एक फॉर्म भरो
एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। यही संपूर्ण सेटअप है।
API कुंजी पाएँ