Python में MiniMax API: OpenAI SDK का उपयोग करें
Python से इस API को कॉल करने के लिए आपको एक विशेष क्लाइंट की आवश्यकता नहीं है। एक बार जब आप base URL और कुंजी सेट कर देते हैं तो मानक openai पैकेज काम करता है, और यह गाइड चैट, स्ट्रीमिंग, JSON, टूल्स, रीट्राइज़ और लागत गणना कवर करती है।
अपडेटेड

मुख्य बिंदु
- openai को इंस्टॉल करें, फिर base_url https://api.minimaxapikey.com/v1 और अपनी कुंजी क्लाइंट को पास करें।
- चैट, स्ट्रीमिंग, JSON मोड और टूल कॉलिंग के लिए मॉडल ID uncensored का उपयोग करें।
- HTTP 429 को backoff के साथ हैंडल करें, और एक पूर्ण कुंजी के लिए थ्रेड्स को 8 तक, और एक ट्रायल कुंजी के लिए 2 तक सीमित करें।
- प्रत्येक प्रतिक्रिया से usage पढ़ें और खर्च ट्रैक करने के लिए 1M टोकन प्रति $0.15 और $0.50 से गुणा करें।
इंस्टॉल करें और पहला कॉल करें
minimax api python के काम के लिए, सबसे तेज़ रास्ता PyPI से आधिकारिक openai पैकेज है। इस साइट के पीछे की सेवा एक स्वतंत्र प्रदाता द्वारा चलाया गया होस्टेड, OpenAI-कम्पैटिबल API है, इसलिए सीखने के लिए कोई अलग SDK नहीं है। यह वेंडर की अपनी प्लेटफ़ॉर्म नहीं है, और स्टॉक OpenAI स्क्रिप्ट से केवल बेस URL, कुंजी और मॉडल नाम में ही बदलाव हैं।
pip install --upgrade openai
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.minimaxapikey.com/v1",
api_key=os.environ["UNCENSORED_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "Answer in plain English, briefly."},
{"role": "user", "content": "What does a context window limit?"},
],
)
print(resp.choices[0].message.content)
print(resp.usage)
API कुंजी पेज से कुंजी प्राप्त करें। नए खातों में एक क्लिक में $0.50 का मुफ़्त ट्रायल क्रेडिट क्लेम किया जा सकता है, कार्ड की आवश्यकता नहीं है, और यह 7 दिनों के लिए मान्य रहता है। इसे स्रोत फ़ाइलों में पेस्ट करने के बजाय, एक एन्वायरनमेंट वेरिएबल में रखें, जैसा कि दिखाया गया है।
सैम्पलिंग पैरामीटर और max_tokens
सामान्य पैरामीटर सीधे पास किए जाते हैं: temperature, top_p, stop, seed, और frequency और presence पेनल्टी। एक निश्चित seed कम तापमान के साथ आपको परीक्षणों के लिए अधिक दोहराए जाने वाले आउटपुट देता है, हालांकि आपको इसे समान पाठ की गारंटी के रूप में नहीं मानना चाहिए।
resp = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "List five verbs for a changelog."}],
temperature=0.3,
top_p=0.9,
stop=["\n\n"],
seed=42,
max_tokens=120,
)
max_tokens वैकल्पिक है। इसके बिना, कंप्लीशन आपके प्रॉम्प्ट के बाद 100,000-टोकन विंडो में बचा हुआ पूरा हिस्सा उपयोग कर सकती है। यह लंबे दस्तावेजों के लिए उपयोगी है, लेकिन उत्पादन कोड में एक सीमा निर्धारित करें। एक बेकाबू जनरेशन वास्तविक आउटपुट टोकन खर्च करता है जो $0.50 प्रति 1M पर होता है, और एक सीमा खराब प्रॉम्प्ट से होने वाले नुकसान को एक छत पर रखती है।
स्ट्रीमिंग प्रतिक्रियाएं
stream=True पास करें और इटरेट करें। प्रतिक्रिया सर्वर-सेंट इवेंट्स (SSE) के रूप में प्रदान की जाती है, और SDK उन्हें चंक ऑब्जेक्ट्स में बदल देता है। एक प्रतिक्रियाशील चैट इंटरफ़ेस के लिए डेल्टा पाठ को आने पर प्रिंट करें।
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short product description for a notebook."}],
stream=True,
)
parts = []
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
parts.append(piece)
print(piece, end="", flush=True)
print()
text = "".join(parts)
usage की संख्याएँ स्ट्रीम के अंत में भेजे जाते हैं। यदि आपका SDK वर्जन आखिरी चंक पर usage एट्रिब्यूट एक्सपोज़ करता है, तो वहाँ से पढ़ें; अन्यथा बजटिंग के लिए अपने तरफ़ टोकन गिनें। एक व्यावहारिक बिंदु: एक स्ट्रीम किए गए अनुरोध में उसकी कॉन्करेंसी स्लॉट स्ट्रीम खत्म होने तक बनी रहती है। यदि आप एक पूर्ण कुंजी पर आठ लंबी स्ट्रीम्स खोलते हैं, तो एक नौवां अनुरोध 429 लौटाएगा concurrency कोड के साथ जब तक एक पूरा नहीं हो जाता। हमेशा स्ट्रीम को बंद करें या पूरी तरह से कन्ज़्यूम करें ताकि स्लॉट रिलीज़ हो जाए।
संरचित आउटपुट के लिए JSON मोड
जब आपको मशीन-पठनीय आउटपुट की आवश्यकता हो, तो response_format को एक JSON ऑब्जेक्ट पर सेट करें। प्रॉम्प्ट में JSON का भी उल्लेख करें, और उन कुंजियों का वर्णन करें जिन्हें आप चाहते हैं, क्योंकि फॉर्मेट फ्लैग वैध JSON सिंटैक्स की गारंटी देता है लेकिन आपके स्कीमा की नहीं।
import json
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "Reply only with JSON using keys: title, tags (list of strings)."},
{"role": "user", "content": "Summarise: a tutorial on caching HTTP responses in Python."},
],
response_format={"type": "json_object"},
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
फिर भी परिणाम का सत्यापन करें। उनका उपयोग करने से पहले जांचें कि आवश्यक कुंजियाँ मौजूद हैं और उनके पास सही प्रकार हैं, और निर्धारित करें कि जब वे नहीं होते हैं तो आपका कोड क्या करता है, जैसे कि एक स्पष्ट निर्देश के साथ एक बार फिर से प्रयास करना। एक पतला सत्यापन परत, भले ही कुछ isinstance जाँच, उत्पादन डीबगिंग में बहुत बचत करती है।
टूल कॉलिंग
टूल कॉलिंग OpenAI के फ़ॉर्मेट का पालन करती है। आप tools में फ़ंक्शन का वर्णन करते हैं, वैकल्पिक रूप से tool_choice के साथ एक चयन मजबूर करते हैं, और मॉडल tool_calls JSON तर्कों के साथ लौटाता है। आप फ़ंक्शन चलाते हैं और परिणाम को role: "tool" के साथ एक संदेश के रूप में वापस भेजते हैं।
import json
def get_rate(currency):
rates = {"EUR": 0.92, "GBP": 0.79}
return json.dumps({"currency": currency, "per_usd": rates.get(currency)})
tools = [{
"type": "function",
"function": {
"name": "get_rate",
"description": "Exchange rate per 1 USD for a currency code.",
"parameters": {
"type": "object",
"properties": {"currency": {"type": "string"}},
"required": ["currency"],
},
},
}]
messages = [{"role": "user", "content": "How many EUR is 50 USD?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message
messages.append(msg)
for call in msg.tool_calls or []:
args = json.loads(call.function.arguments)
messages.append({"role": "tool", "tool_call_id": call.id, "content": get_rate(args["currency"])})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
इस उदाहरण में दरें डेमो के लिए बनाई गई हैं। वास्तविक कोड में फ़ंक्शन अपनी ही सेवा को कॉल करेगा। आर्ग्युमेंट्स को सुरक्षात्मक ढंग से json.loads के साथ एक try ब्लॉक के अंदर पार्स करें, क्योंकि एक मॉडल कभी-कभी गलत फ़ॉर्मेट वाले आर्ग्युमेंट उत्पन्न कर सकता है।
रेट लिमिट, रीट्राई और समानांतर कार्य
एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 की अनुमति देती है; एक ट्रायल कुंजी 2 समानांतर और प्रति मिनट 60 की अनुमति देती है। सीमा पार करने पर HTTP 429 लौटाया जाता है। त्रुटि कोड प्रति मिनट की सीमा के लिए rate_limited है और बहुत सारे एक साथ कॉल के लिए concurrency है। अस्थायी ओवरलोड भी 429 देता है, Retry-After: 5 हेडर के साथ। OpenAI SDK कुछ विफलताओं को स्वयं पुनः प्रयास करता है, और आप max_retries के साथ उसे बढ़ा सकते हैं। बैच जॉब्स के लिए, थ्रेड्स पर अपनी खुद की लिमिट जोड़ें ताकि आप डिज़ाइन द्वारा कैप से नीचे रहें, पुनः प्रयास करने के बजाय।
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI, RateLimitError
import os, time
client = OpenAI(
base_url="https://api.minimaxapikey.com/v1",
api_key=os.environ["UNCENSORED_KEY"],
max_retries=2,
)
def ask(prompt):
for attempt in range(4):
try:
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": prompt}],
max_tokens=200,
)
return r.choices[0].message.content
except RateLimitError:
time.sleep(5 * (attempt + 1))
return None
prompts = [f"Write one tagline for product {i}." for i in range(20)]
with ThreadPoolExecutor(max_workers=8) as pool:
results = list(pool.map(ask, prompts))
एक ट्रायल कुंजी पर max_workers=2 का उपयोग करें। असिंक क्लाइंट, AsyncOpenAI, समान तर्क लेता है; इसे asyncio.Semaphore(8) के साथ जोड़ें ताकि समान छत लागू की जा सके। डॉक्स उन प्रतिक्रिया हेडर्स की सूची देते हैं जिनकी आप जाँच कर सकते हैं।
संवाद इतिहास बनाए रखना
API स्टेटलेस है। यह पिछली कॉल को याद नहीं रखता, इसलिए मल्टी-टर्न चैट हर बार पूरा संवाद भेजकर काम करता है। संदेशों की एक सूची रखें, यूज़र टर्न जोड़ें, API कॉल करें, फिर अगले राउंड से पहले असिस्टेंट रिप्लाई जोड़ें।
history = [{"role": "system", "content": "You are a patient Python tutor."}]
def chat(user_text):
history.append({"role": "user", "content": user_text})
r = client.chat.completions.create(model="uncensored", messages=history)
reply = r.choices[0].message.content
history.append({"role": "assistant", "content": reply})
return reply
print(chat("What is a list comprehension?"))
print(chat("Show me one with a filter."))
इस पैटर्न की लागत हर टर्न के साथ बढ़ती है: हर अनुरोध सभी पिछले टर्न के लिए इनपुट टोकन के लिए भुगतान करता है। 100,000-टोकन विंडो के साथ आपके पास बहुत जगह है, लेकिन लंबे सत्र महंगे और धीमे हो जाते हैं। एक सरल नीति सिस्टम संदेश और आखिरी N टर्न को रखना है, या मॉडल से पुराने टर्न का एक छोटा सारांश माँगना है और उन्हें इसके साथ बदलना है। एक नीति जल्दी तय करें, क्योंकि चैट ऐप में ट्रिमिंग को बाद में जोड़ना इसे शुरू से बनाने की तुलना में अधिक झंझट भरा है।
429 से परे त्रुटियों को संभालना
SDK टाइप्ड अपवाद उठाता है, और उन्हें सॉर्ट करना कुछ लाइनों के लायक है। ऑथेंटिकेशन समस्याएँ और खराब अनुरोध पुनः प्रयास पर ठीक नहीं होंगे, जबकि नेटवर्क त्रुटियाँ और ओवरलोड आमतौर पर होंगे। उन्हें अलग-अलग मानें।
import openai
try:
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Hello"}],
timeout=60,
)
except openai.AuthenticationError:
print("Check the API key and the Bearer header.")
except openai.RateLimitError as e:
print("Slow down:", e.response.headers.get("Retry-After"))
except openai.APIConnectionError:
print("Network problem, retry with backoff.")
except openai.APIStatusError as e:
print("Server said", e.status_code, e.response.headers.get("X-Request-Id"))
जब आप सहायता से संपर्क करते हैं, तो विफल कॉल से X-Request-Id का मान शामिल करें। यह उसी विशिष्ट अनुरोध की पहचान करता है। एक स्पष्ट timeout सेट करें जैसा कि दिखाया गया है, क्योंकि डिफ़ॉल्ट लंबा होता है, और एक अटका हुआ कॉल जो एक समानांतरता स्लॉट पकड़े रखता है, आपके थ्रूपुट को चुपचाप घटा देता है। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है, इसलिए एक विफल कॉल को फिर से प्रयास करने से बिल दोगुना नहीं होता है।
एक छोटा प्रोजेक्ट विन्यास जो स्केल करता है
स्क्रिप्ट्स बढ़कर सेवाएँ बन जाती हैं। शुरुआत में थोड़ी संरचना API विवरणों को एक जगह रखती है, ताकि मॉडल नाम, टाइमआउट या लिमिट में बाद का कोई भी बदलाव से केवल एक फ़ाइल प्रभावित हो, बीस की नहीं।
# llm.py
import os
from openai import OpenAI
BASE_URL = "https://api.minimaxapikey.com/v1"
MODEL = "uncensored"
_client = OpenAI(base_url=BASE_URL, api_key=os.environ["UNCENSORED_KEY"], timeout=60, max_retries=2)
def complete(messages, **kwargs):
r = _client.chat.completions.create(model=MODEL, messages=messages, **kwargs)
return r.choices[0].message.content, r.usage
हर अन्य मॉड्यूल complete को आयात करता है और कभी क्लाइंट नहीं बनाता है। वह एकमात्र जोड़-बिंदु वह जगह है जहाँ आप बाद में लॉगिंग, एक खर्च काउंटर या एक सेमाफोर जोड़ते हैं। यदि आप अधिक संदर्भ सामग्री चाहते हैं, तो डॉक्स पेज curl फॉर्म में समान एंडपॉइंट दिखाता है, जो एक विफल पायथन कॉल की तुलना एक ज्ञात-अच्छे अनुरोध से करने के लिए उपयोगी है।
संस्करण स्थिर करना भी मदद करता है। अपनी requirements फ़ाइल में openai पैकेज को स्थिर करें और जानबूझकर अपग्रेड करें, पहले रिलीज नोट्स पढ़कर, क्योंकि SDK परिवर्तन अपवाद के नाम या डिफ़ॉल्ट पुन: प्रयास व्यवहार को बदल सकते हैं। इसके साथ एक छोटा README नोट जोड़ें कि यह परियोजना किस बेस URL और मॉडल ID की उम्मीद करती है, ताकि एक नया सहकर्मी बिना पूछे पहले दिन ही इसे चला सके।
टेस्टिंग पर एक आखिरी बिंदु। कम से कम एक टेस्ट लिखें जो एक नकली (मॉक) क्लाइंट के विरुद्ध चलता है, ताकि आपका स्यूट क्रेडिट न खर्च करे या नेटवर्क पर निर्भर न रहे। एक एकल लाइव स्मोक टेस्ट रखें, जो मैन्युअल रूप से या नाइटली जॉब द्वारा चलाया जाए, ताकि असली API में बदलावों को जल्दी पकड़ा जा सके।
कोड में बैलेंस और लागत ट्रैक करना
प्रत्येक प्रतिक्रिया X-Balance-USD ले जाती है, और SDK आपको with_raw_response के माध्यम से हेडर्स पढ़ने देता है। प्रत्येक कॉल के बाद इसे लॉग करना आपके उपयोगकर्ताओं को पता चलने से पहले खत्म हो चुके बैलेंस को पकड़ने का सस्ता तरीका है।
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Say hello in French."}],
)
print("balance:", raw.headers.get("X-Balance-USD"))
print("request id:", raw.headers.get("X-Request-Id"))
resp = raw.parse()
def cost_usd(usage):
return usage.prompt_tokens * 0.15 / 1_000_000 + usage.completion_tokens * 0.50 / 1_000_000
print(cost_usd(resp.usage))
सूत्र का एक सत्यापन: 2,000 इनपुट टोकन और 500 आउटपुट टोकन के साथ एक कॉल की लागत 2,000 x 0.15 / 1,000,000 = $0.0003 इनपुट के लिए, प्लस 500 x 0.50 / 1,000,000 = $0.00025 आउटपुट के लिए, तो $0.00055। एक हजार ऐसे कॉल $0.55 आते हैं। विफल या अस्वीकृत अनुरोधों का शुल्क नहीं लिया जाता है, इसलिए सफल usage ऑब्जेक्ट्स से बना एक लॉग बिल के करीब मेल खाएगा।
बिलिंग प्रीपेड क्रेडिट से पे-एज़-यू-गो है, कोई सदस्यता नहीं। टॉप-अप $20 से $500 तक किसी भी पूर्ण मात्रा में चलते हैं, $50 से बोनस के साथ, और क्रेडिट कभी समाप्त नहीं होता; विवरण प्राइसिंग पेज पर हैं। प्रॉम्प्ट प्रशिक्षण के लिए उपयोग नहीं किए जाते हैं।
अधिक गाइड
प्रश्न और उत्तर
क्या MiniMax के लिए अलग पायथन पैकेज है?
आपको यहाँ एक की आवश्यकता नहीं है। यह सेवा OpenAI-कम्पैटिबल है, इसलिए नियमित openai पैकेज कस्टम base_url के साथ काम करता है। यह एक स्वतंत्र सेवा है, विक्रेता का आधिकारिक SDK नहीं।
एसिंक क्लाइंट काम करता है?
हाँ। AsyncOpenAI समान base_url और api_key तर्क लेता है। चल रहे अनुरोधों की संख्या को अपनी कॉन्करेंसी लिमिट पर या उससे नीचे रखें।
टोकन की गिनती कैसे प्राप्त करूँ?
प्रत्येक नॉन-स्ट्रीम्ड रिस्पॉन्स में एक usage ऑब्जेक्ट होता है जिसमें prompt_tokens और completion_tokens होते हैं। स्ट्रीम्स के लिए, usage अंत में भेजा जाता है, इसलिए यदि आपका क्लाइंट इसे एक्सपोज़ करता है तो इसे अंतिम चंक से पढ़ें।
मैं कितनी कॉन्टेक्स्ट लेंथ का उपयोग कर सकता हूँ?
विंडो 100,000 टोकन की है, जो प्रॉम्प्ट और कंप्लीशन के बीच साझा है। max_tokens वैकल्पिक है।
आपकी कुंजी बस एक फ़ॉर्म दूर है
एक खाता बनाएँ, कुंजी कॉपी करें, बेस URL बदलें। सेटअप यही है।