MiniMax API ใน Python: ใช้ SDK ของ OpenAI
คุณไม่จำเป็นต้องใช้ไคลเอนต์พิเศษเพื่อเรียก API นี้จาก Python แพ็กเกจ openai มาตรฐานใช้งานได้เมื่อคุณตั้งค่า base URL และคีย์ และคู่มือนี้ครอบคลุมการแชท สตรีมมิง JSON เครื่องมือ การลองใหม่ และการคำนวณต้นทุน
อัปเดต

จุดสำคัญ
- ติดตั้ง openai จากนั้นส่ง base_url https://api.minimaxapikey.com/v1 และคีย์ของคุณไปยังไคลเอนต์
- ใช้ ID โมเดล uncensored สำหรับการแชท สตรีมมิง โหมด JSON และการเรียกใช้ฟังก์ชัน
- จัดการ HTTP 429 ด้วย backoff และจำกัดคำขอพร้อมกันไว้ที่ 8 สำหรับคีย์เต็ม และ 2 สำหรับคีย์ทดลอง
- อ่าน usage จากแต่ละการตอบกลับและคูณด้วย $0.15 และ $0.50 ต่อ 1M โทเคนเพื่อติดตามการใช้จ่าย
ติดตั้งและเรียกใช้งานครั้งแรก
สำหรับ minimax api python วิธีที่เร็วที่สุดคือการใช้แพ็กเกจ openai ทางการจาก PyPI บริการที่อยู่เบื้องหลังเว็บไซต์นี้คือ API ที่เข้ากันได้กับ OpenAI ที่โฮสต์โดยผู้ให้บริการอิสระ ดังนั้นจึงไม่มี SDK แยกที่ต้องเรียนรู้ ไม่ใช่แพลตฟอร์มของผู้จัดจำหน่ายเอง และการเปลี่ยนแปลงจากสคริปต์ OpenAI มาตรฐานมีเพียง base 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 และค่าปรับความถี่และการปรากฏ ค่า 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 และวนลูปอ่านค่า การตอบสนองจะถูกส่งเป็นเหตุการณ์ที่ส่งจากเซิร์ฟเวอร์ และ SDK จะแปลงเหตุการณ์เหล่านี้เป็นออบเจ็กต์ chunk พิมพ์ข้อความส่วนที่เปลี่ยนแปลงเมื่อได้รับเพื่อสร้างอินเทอร์เฟซแชทที่ตอบสนองรวดเร็ว
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)
ข้อมูลการใช้งานจะถูกส่งที่ท้ายสตรีม หากเวอร์ชัน SDK ของคุณเปิดให้เข้าถึงแอตทริบิวต์ usage บน chunk สุดท้าย ให้อ่านค่าจากจุดนั้น มิฉะนั้นให้นับโทเคนเองเพื่อวางแผนงบประมาณ จุดปฏิบัติสำคัญคือคำขอแบบสตรีมจะยึดช่องการทำงานพร้อมกันไปจนกว่าสตรีมจะเสร็จสิ้น หากคุณเปิดสตรีมยาวแปดสตรีมด้วยคีย์เต็มช่องที่เก้าจะกลับเป็น 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 SDK ของ OpenAI จะลองใหม่สำหรับข้อผิดพลาดบางรายการโดยอัตโนมัติ และคุณสามารถเพิ่มจำนวนนั้นด้วย 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 และไม่ได้สร้างไคลเอนต์ จุดเชื่อมต่อเดียวนี้คือจุดที่คุณเพิ่มการบันทึกข้อมูล ตัวนับการใช้จ่าย หรือ semaphore ภายหลัง หากต้องการข้อมูลอ้างอิงเพิ่มเติม หน้า เอกสาร แสดงเอนด์พอยต์เดียวกันในรูปแบบ curl ซึ่งสะดวกสำหรับการเปรียบเทียบคำขอ Python ที่ล้มเหลวกับคำขอที่ทำงานได้ปกติ
การตรึงเวอร์ชันก็ช่วยได้เช่นกัน ตรึงแพ็กเกจ openai ในไฟล์ requirements และอัปเกรดอย่างตั้งใจ โดยอ่านบันทึกการปล่อยรุ่นก่อนเสมอ เพราะการเปลี่ยนแปลง SDK อาจเปลี่ยนชื่อข้อยกเว้นหรือพฤติกรรมการลองซ้ำโดยค่าเริ่มต้น จับคู่กับบันทึก README สั้นๆ ที่ระบุว่าโปรเจกต์คาดหวัง base URL และ model ID ใด เพื่อให้เพื่อนร่วมทีมใหม่สามารถรันได้ในวันแรกโดยไม่ต้องถาม
อีกจุดหนึ่งเกี่ยวกับการทดสอบ เขียนอย่างน้อยหนึ่งเทสต์ที่รันกับไคลเอนต์ปลอม เพื่อให้ชุดเทสต์ของคุณไม่ใช้เครดิตหรือพึ่งพาเครือข่าย เก็บsmoke test กับ API จริงเพียงรายการเดียว รันด้วยมือหรือในงานประจำคืน เพื่อจับการเปลี่ยนแปลงใน 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 คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน ดังนั้นบันทึกที่สร้างจากวัตถุการใช้งานที่สำเร็จจะตรงกับบิลอย่างใกล้ชิด
การเรียกเก็บเงินเป็นแบบจ่ายตามการใช้งานจากเครดิตแบบเติมเงินล่วงหน้าโดยไม่มีการสมัครสมาชิก การเติมเงินเริ่มต้นที่ $20 ถึง $500 ในจำนวนเต็มใดๆ พร้อมโบนัสจาก $50 และเครดิตไม่หมดอายุ รายละเอียดอยู่ที่ หน้าราคา พรอมต์ไม่ถูกใช้ในการฝึกโมเดล
คู่มือเพิ่มเติม
ถาม-ตอบ
มีแพ็กเกจ Python ของ MiniMax แยกต่างหากหรือไม่?
คุณไม่จำเป็นต้องใช้แพ็กเกจแยกที่นี่ บริการนี้เข้ากันได้กับ OpenAI ดังนั้นแพ็กเกจ openai ทั่วไปจึงใช้งานได้พร้อมกำหนด base_url แบบกำหนดเอง บริการนี้เป็นอิสระ ไม่ใช่ SDK ทางการของผู้จัดจำหน่าย
ไคลเอนต์แบบ async ทำงานได้หรือไม่?
ได้ AsyncOpenAI รับอาร์กิวเมนต์ base_url และ api_key เดียวกัน ให้คงจำนวนคำขอที่กำลังดำเนินการไว้ที่หรือต่ำกว่าขีดจำกัดการทำงานพร้อมกันของคุณ
ฉันจะรับจำนวนโทเคนได้อย่างไร?
การตอบกลับที่ไม่ใช่สตรีมแต่ละรายการมีวัตถุการใช้งานที่มี prompt_tokens และ completion_tokens สำหรับสตรีม ข้อมูลการใช้งานจะถูกส่งที่ท้ายสุด ดังนั้นให้อ่านจากchunk สุดท้ายหากไคลเอนต์ของคุณแสดงให้เข้าถึง
ฉันสามารถใช้ความยาวบริบทได้เท่าใด?
หน้าต่างคือ 100,000 โทเคน ซึ่งใช้ร่วมกันระหว่างพรอมต์และการตอบกลับ max_tokens เป็นตัวเลือก
คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว
สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด