TH ▾
รับคีย์ API

ตัวอย่าง GLM API: Python, โหมด JSON และสตรีมมิง

ตัวอย่าง GLM API เหล่านี้ทำงานกับ endpoint ที่เข้ากันได้กับ OpenAI เดียวกัน โดย base URL คือ https://api.glmapikey.com/v1 และ model คือ uncensored โค้ดแต่ละส่วนสั้นและครบถ้วน คุณสามารถวาง เพิ่มคีย์ และรันได้ทันที

อัปเดต

หน้าต่างเทอร์มินัลแสดงโทเคนข้อมูลที่สตรีมมิงไปยังเซิร์ฟเวอร์คลาวด์ แสดงตัวอย่างโค้ด API

ประเด็นสำคัญ

  • ทุกตัวอย่างใช้ base URL https://api.glmapikey.com/v1, การตรวจสอบสิทธิ์แบบ bearer และ model ID uncensored
  • สตรีมมิง โหมด JSON และการเรียกใช้ฟังก์ชันรองรับทั้งหมดบนเอนด์พอยต์ chat completions เดียวกัน
  • อ่าน X-Balance-USD และบล็อกการใช้งานเพื่อติดตามค่าใช้จ่ายต่อการเรียก
  • จัดการ 429 ตามโค้ด: rate_limited, concurrency หรือ Retry-After: 5 เมื่อโอเวอร์โหลด

ก่อนที่คุณจะรันสิ่งใด

คุณต้องการคีย์อย่างเดียว สร้างได้ที่หน้า 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

ถาม-ตอบ

ตัวอย่างใช้ base URL อะไร?

ทุกตัวอย่างใช้ https://api.glmapikey.com/v1 พร้อม model ID uncensored และ bearer token SDK OpenAI ใดๆ ทำงานได้เมื่อเปลี่ยนค่าเหล่านี้

API รองรับสตรีมมิงหรือไม่

ใช่ ตั้งค่า stream เป็น true และอ่าน server-sent events การใช้งานจะถูกรายงานที่ท้าย stream

ฉันจะรับ JSON ที่ถูกต้องได้อย่างไร

ส่ง response_format พร้อม type json_object และอธิบายรูปแบบที่ต้องการใน prompt วิเคราะห์ผลลัพธ์ในโค้ดของคุณและตรวจสอบ keys ที่คุณต้องการ

ฉันสามารถใช้ function calling ได้ไหม

ใช่ ส่ง tools และ tool_choice รันฟังก์ชันที่โมเดลขอ และส่งผลลัพธ์กลับเป็น message พร้อม role tool

ฉันจะดูเครดิตที่เหลือได้อย่างไร

แต่ละ response มี header X-Balance-USD แสดงยอดคงเหลือ และ usage block แสดงจำนวน token

คีย์ของคุณอยู่ห่างแค่แบบฟอร์มเดียว

สร้างบัญชี คัดลอกคีย์ และเปลี่ยน base URL นั่นคือการตั้งค่าทั้งหมด

รับคีย์ API