ก่อนที่คุณจะรันสิ่งใด
คุณต้องการคีย์อย่างเดียว สร้างได้ที่หน้า API key; บัญชีใหม่สามารถขอเครดิตทดลองใช้ฟรี $0.50 ได้ด้วยการคลิกหนึ่งครั้ง ไม่ต้องใช้บัตร ให้ export คีย์ไว้เพื่อให้ตัวอย่างอ่านค่าได้:
export API_KEY="YOUR_KEY"
pip install openai
npm install openai
API นี้ปฏิบัติตามรูปแบบ chat completions ของ OpenAI โดย expose POST /v1/chat/completions และ GET /v1/models, รับ Authorization: Bearer และให้บริการโมเดลเดียวที่มี ID uncensored โมเดลนี้เป็น open-weight model ที่ดำเนินการโดยผู้ให้บริการอิสระและปรับแต่งให้ตอบโดยไม่มีการปฏิเสธเนื้อหาสำหรับการใช้งานผู้ใหญ่ที่ถูกต้องตามกฎหมาย ไม่ใช่ API ทางการของผู้ขายโมเดลใด รองรับเฉพาะข้อความ: ไม่มีภาพ เสียง embedding หรือ fine-tuning
ตัวอย่างด้านล่างครอบคลุมตั้งแต่การเรียกใช้งานที่ง่ายที่สุดไปจนถึงการเรียกใช้ฟังก์ชัน หากคุณต้องการการตรวจสอบที่สั้นที่สุดว่าคีย์ของคุณใช้งานได้ คำสั่ง curl แรกก็เพียงพอแล้ว
คำขอแรกด้วย curl และพารามิเตอร์ที่สำคัญ
curl https://api.glmapikey.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": "What is a mutex, in one sentence?"}
],
"temperature": 0.3,
"max_tokens": 80
}'
การตอบกลับเป็นวัตถุ JSON ที่มี choices[0].message.content เก็บคำตอบ และวัตถุ usage ที่มี prompt_tokens และ completion_tokens ส่วนหัวของการตอบกลับรวมถึง X-Request-Id, X-Balance-USD และส่วนหัว X-RateLimit-Limit สองรายการ เพิ่ม -i ไปยัง curl เพื่อดูส่วนหัวเหล่านี้
ฟิลด์ temperature, top_p, stop, seed และค่าปรับสำหรับการมีอยู่และความถี่จะถูกส่งผ่านไปยังโมเดล max_tokens เป็นตัวเลือก หากไม่มีค่านี้ การสร้างข้อความอาจใช้พื้นที่ที่เหลือจากหน้าต่าง 100,000 โทเคนหลังจากพรอมต์ของคุณ
body ของ chat completions มีฟิลด์ตัวเลือกมากมาย แต่ห้าฟิลด์นี้ทำหน้าที่หลัก ฟิลด์ทั้งหมดจะถูกส่งต่อไปยังโมเดล
| ฟิลด์ | สิ่งที่มันทำ | การใช้งานทั่วไป |
|---|---|---|
temperature | ค่าที่สูงขึ้นให้รูปแบบข้อความที่หลากหลายมากขึ้น | 0.2 สำหรับการดึงข้อมูล, 0.8 สำหรับงานวรรณกรรม |
top_p | จำกัดการสุ่มตัวอย่างไปยังโทเคนที่น่าจะเป็นไปได้มากที่สุด | คงค่าเริ่มต้นไว้ เว้นแต่คุณจะปรับแต่ง |
stop | หยุดการตอบกลับเมื่อปรากฏสตริง | ตัดออกที่ตัวแบ่งเช่นบรรทัดว่าง |
seed | ทำให้การสุ่มตัวอย่างทำซ้ำได้ในระดับความพยายามที่ดีที่สุด | เปรียบเทียบเวอร์ชันพรอมต์สองเวอร์ชัน |
presence_penalty, frequency_penalty | ลดความน่าจะเป็นในการทำซ้ำโทเคน | ค่าเล็กๆ เช่น 0.3 เมื่อข้อความวนซ้ำ |
เปลี่ยนค่าหนึ่งค่าในแต่ละครั้งและรักษาพรอมต์ให้เหมือนกัน มิฉะนั้นคุณไม่สามารถบอกได้ว่าการเปลี่ยนแปลงใดช่วย สำหรับสิ่งใดๆ ที่ป้อนโค้ด เช่น การจำแนกประเภทหรือการดึงข้อมูล ให้ใช้อุณหภูมิต่ำและ seed คงที่เพื่อให้คุณสามารถรันการทดสอบอีกครั้งและเห็นผลลัพธ์เดียวกัน สำหรับการเขียนเชิงสร้างสรรค์ ให้เพิ่มอุณหภูมิและปล่อยให้ค่าปรับจัดการการทำซ้ำ
ฟิลด์ max_tokens เป็นตัวเลือกที่นี่ เมื่อคุณละเว้น ค่าตอบกลับอาจใช้พื้นที่ที่เหลือทั้งหมดในหน้าต่าง 100,000 โทเคน ซึ่งมักไม่ใช่สิ่งที่คุณต้องการสำหรับคำตอบหนึ่งบรรทัด ควรตั้งค่าเมื่อคุณรู้ความยาวของคำตอบที่ต้องการ
Python: การสนทนาที่มีหน่วยความจำ
API เป็น stateless ดังนั้นคุณต้องจัดการการสนทนาเองและส่งทุกครั้ง ลูปนี้เก็บรายการข้อความและเพิ่มทั้งสองฝั่ง:
from openai import OpenAI
client = OpenAI(
base_url="https://api.glmapikey.com/v1",
api_key="YOUR_KEY",
)
messages = [{"role": "system", "content": "You are a helpful assistant."}]
while True:
user = input("you> ")
if not user:
break
messages.append({"role": "user", "content": user})
resp = client.chat.completions.create(model="uncensored", messages=messages)
reply = resp.choices[0].message.content
messages.append({"role": "assistant", "content": reply})
print("bot>", reply)
เนื่องจากแต่ละ call ส่งรายการเต็มกลับมา โทเคนอินพุตจะเพิ่มขึ้นตามความยาวของการแชท ที่ $0.15 ต่อ 1M โทเคนอินพุตถือว่าถูก แต่จะสะสมในเซสชันยาว ดังนั้นให้ตัดข้อความเก่าเมื่อ thread มีขนาดเกินกว่าที่คุณต้องการจ่าย หน้าราคามีตัวอย่างการคำนวณ
สตรีมมิงใน Python และ Node
ตั้งค่า stream: true และเซิร์ฟเวอร์จะส่งโทเคนเมื่อผลิตเสร็จ ผ่าน server-sent events ใน Python:
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write four lines about the sea."}],
stream=True,
)
text = ""
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
piece = chunk.choices[0].delta.content
text += piece
print(piece, end="", flush=True)
if getattr(chunk, "usage", None):
print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)
สตรีมจะจบด้วยข้อมูลการใช้งาน ซึ่งเป็นเหตุผลที่ลูปตรวจสอบสิ่งนี้ ใน Node:
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://api.glmapikey.com/v1",
apiKey: process.env.API_KEY,
});
const stream = await client.chat.completions.create({
model: "uncensored",
messages: [{ role: "user", content: "Write four lines about the sea." }],
stream: true,
});
for await (const chunk of stream) {
process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}
หนึ่งรายละเอียดเกี่ยวกับขีดจำกัด: คำขอแบบสตรีมจะเก็บช่อง concurrent ไว้จนกว่าสตรีมจะจบ หากคุณเริ่มสตรีมแต่ไม่อ่านจนจบ ช่องนั้นจะยังไม่ว่าง ให้อ่านสตรีมจนจบหรือปิดสตรีมเสมอ
โหมด JSON สำหรับผลลัพธ์ที่มีโครงสร้าง
เมื่อโค้ดของคุณต้องการแยกวิเคราะห์คำตอบ ให้ขอ object JSON ด้วย response_format นอกจากนี้ให้ระบุในพรอมต์ว่าต้องการรูปแบบใด เพราะแฟลก format รับประกันไวยากรณ์ JSON ที่ถูกต้อง ไม่ใช่สคีมาเฉพาะของคุณ
import json
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply only with JSON: {\"title\": string, \"tags\": [string]}."},
{"role": "user", "content": "Suggest a title and three tags for a post about home espresso."},
],
temperature=0.2,
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])
ตรวจสอบว่าคีย์ที่คุณต้องการมีอยู่ก่อนใช้งาน และตั้งค่า temperature ต่ำสำหรับงานแยกวิเคราะห์ หากการแยกวิเคราะห์ล้มเหลว การลองใหม่หนึ่งครั้งด้วยอินพุตเดิมมักได้ผล และคำขอที่ล้มเหลวจะไม่คิดเงิน
การเรียกใช้ฟังก์ชัน: การเรียกแบบครบวงจร
การเรียกใช้ฟังก์ชันทำให้โมเดลสามารถขอให้โค้ดของคุณรันฟังก์ชันได้ คุณอธิบายฟังก์ชันใน tools โมเดลจะตอบกลับด้วย entry tool_calls คุณรันมันและส่งผลลัพธ์กลับเป็นข้อความ role: "tool"
import json
def get_weather(city: str) -> dict:
return {"city": city, "temp_c": 18, "sky": "cloudy"}
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
messages = [{"role": "user", "content": "Is it warm in Lisbon right now?"}]
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": json.dumps(get_weather(**args)),
})
final = client.chat.completions.create(
model="uncensored", messages=messages, tools=tools
)
print(final.choices[0].message.content)
else:
print(msg.content)
ฟังก์ชันที่นี่คืนค่าข้อมูลคงที่ ดังนั้นให้แทนที่ด้วยการค้นหาข้อมูลจริง อาร์กิวเมนต์ของเครื่องมือมาถึงเป็นสตริง JSON ดังนั้นให้แยกวิเคราะห์และตรวจสอบค่าก่อนดำเนินการ เมื่อใช้ stream: true, tool_calls จะมาถึงเป็นชิ้นส่วนที่คุณต้องประกอบก่อนแยกวิเคราะห์ ใช้ tool_choice เพื่อบังคับใช้เครื่องมือเฉพาะเมื่อต้องการ
ต้นทุนของตัวอย่าง และความผิดพลาดที่เสียเวลาหนึ่งชั่วโมง
การรันตัวอย่างมีต้นทุนต่ำมาก แต่การเห็นการคำนวณหนึ่งครั้งก็ช่วยได้ ที่ $0.15 ต่อ 1M โทเคนอินพุต และ $0.50 ต่อ 1M โทเคนเอาต์พุต:
- ลูปการสนทนา ด้วยพรอมต์ 1,200 โทเคนและคำตอบ 300 โทเคน: $0.00018 สำหรับอินพุต บวก $0.00015 สำหรับเอาต์พุต เป็น $0.00033 การสนทนา 1,000 รอบมีค่าใช้จ่าย $0.33
- การเรียกใช้เครื่องมือแบบไปกลับ ทำให้เกิดสอง call หาก call แรกใช้ 400 โทเคนอินพุตและ 60 โทเคนเอาต์พุต และ call ที่สองใช้ 500 โทเคนอินพุตและ 150 โทเคนเอาต์พุต ยอดรวมคือ 900 โทเคนอินพุตและ 210 โทเคนเอาต์พุต: $0.000135 บวก $0.000105 เป็น $0.00024
- สตรีมมิง มีต้นทุนเท่ากับการเรียกปกติที่มีจำนวนโทเคนเท่ากัน มันเปลี่ยนเฉพาะเวลาที่คุณเห็นข้อความ ไม่ใช่ต้นทุน
เครดิตทดลองใช้ $0.50 สามารถจ่ายสำหรับการสนทนามากกว่า 1,500 รอบที่ขนาดนั้น ($0.50 / $0.00033) ดังนั้นคุณสามารถทดลองได้อย่างอิสระก่อนเติมเงิน คำขอที่ล้มเหลวและถูกปฏิเสธจะไม่คิดเงิน ซึ่งหมายความว่าข้อบกพร่องในการแยกวิเคราะห์ที่ทำให้คุณรันการเรียกใหม่จะไม่ทำให้คุณเสียเงินสำหรับการลองที่ล้มเหลว
- Base URL ผิด ต้องลงท้ายด้วย
/v1การเพิ่ม/chat/completionsด้วยตนเองลงใน Base URL ของ SDK จะให้ 404 เพราะ SDK เพิ่มพาธเอง - ชื่อโมเดลอื่น ชื่อที่คัดลอกจากแพลตฟอร์มอื่นไม่มีที่นี่ ID คือ
uncensored - คาดหวังเรื่องหน่วยความจำ API ไม่จำการเรียกก่อนหน้า ส่งประวัติทุกครั้ง
- การแยก JSON จากโมเดลแบบไม่มี guard ห่อ
json.loadsใน try block และเตรียมแผนสำหรับ response ที่ผิดพลาด - การปล่อย stream ไว้เปิด stream ที่ยังไม่เสร็จสิ้นจะครอบครอง slot concurrency ไว้ และคีย์ทดลองมีเพียงสอง slot
- ใส่คีย์ในโค้ดฝั่งหน้าบ้าน เก็บไว้บนเซิร์ฟเวอร์
หากยังมีบางอย่างดูผิดปกติ ให้ส่งคำขอด้วย curl และเปรียบเทียบกับสิ่งที่โค้ดของคุณสร้าง รูปแบบ curl จะตัด SDK ออกและทำให้ความแตกต่างใน body ชัดเจน
การอ่านการใช้งาน ยอดเงิน และข้อผิดพลาด
เพื่อดู headers จาก Python SDK ให้ใช้ raw response wrapper:
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("x-request-id"))
print("balance usd:", raw.headers.get("x-balance-usd"))
print("rpm limit:", raw.headers.get("x-ratelimit-limit-requests"))
completion = raw.parse()
print(completion.usage.total_tokens)
บันทึก request ID ทุกครั้งที่จะเรียกใช้ เพื่อให้สามารถชี้ไปที่คำขอใดคำขอหนึ่งได้ในภายหลัง ใช้ header balance เพื่อแจ้งเตือนก่อนเครดิตหมด
เมื่อคุณเกินขีดจำกัด API จะส่ง HTTP 429 กลับมา และ error code จะบอกคุณว่าคือข้อใด:
| Code หรือ header | สิ่งที่ควรทำ | สิ่งที่ควรทำ |
|---|---|---|
rate_limited | คำขอเกินต่อนาที (300 สำหรับคีย์เต็ม, 60 สำหรับเครดิตทดลองใช้) | ลดความถี่และกระจายการเรียกใช้ |
concurrency | คำขอพร้อมกันเกิน (8 สำหรับคีย์เต็ม, 2 สำหรับเครดิตทดลองใช้) | รอให้คำขอที่กำลังทำงานอยู่เสร็จสิ้น |
Retry-After: 5 | โอเวอร์โหลดชั่วคราว | ลองใหม่หลังจากห้าวินาที |
คำขอที่ล้มเหลวหรือถูกปฏิเสธจะไม่ถูกเรียกเก็บเงิน request body สามารถมีขนาดได้สูงสุด 8 MB สำหรับเอกสารอ้างอิงฉบับสมบูรณ์และวิธีการนำโค้ดไคลเอนต์ที่มีอยู่กลับมาใช้ใหม่ ดูdocs สำหรับการแนะนำวิธีการรับ key ดูบทความ GLM API key
