วิธีใช้ GLM-5.1 API: คู่มือฉบับสมบูรณ์พร้อมตัวอย่างโค้ด

สรุป (TL;DR)

GLM-5.1 สามารถใช้งานได้ผ่าน BigModel API ที่ https://open.bigmodel.cn/api/paas/v4/. API นี้เข้ากันได้กับ OpenAI: มีโครงสร้างปลายทาง (endpoint) เดียวกัน, รูปแบบคำขอ (request format) เดียวกัน, รูปแบบการสตรีม (streaming pattern) เดียวกัน คุณต้องมีบัญชี BigModel, คีย์ API และชื่อโมเดล glm-5.1. คู่มือนี้ครอบคลุมการยืนยันตัวตน, คำขอแรกของคุณ, การสตรีม, การเรียกใช้เครื่องมือ (tool calling) และการทดสอบการผสานรวมของคุณด้วย Apidog

บทนำ

GLM-5.1 เป็นโมเดล AI ตัวแทน (agentic model) เรือธงของ Z.AI ซึ่งเปิดตัวในเดือนเมษายน 2026 ได้รับการจัดอันดับที่ 1 บน SWE-Bench Pro และเป็นผู้นำ GLM-5 ในทุกเกณฑ์มาตรฐานการเขียนโค้ดที่สำคัญ หากคุณกำลังสร้างผู้ช่วยเขียนโค้ด AI, ตัวแทนอัตโนมัติ หรือแอปพลิเคชันใดๆ ที่ได้รับประโยชน์จากการดำเนินการภารกิจระยะยาว (long-horizon task execution) GLM-5.1 ก็คุ้มค่าที่จะรวมเข้าด้วยกัน

ข่าวดีสำหรับนักพัฒนา: API เข้ากันได้กับ OpenAI หากคุณเคยพัฒนาด้วย GPT-4 หรือ Claude มาก่อน คุณสามารถเปลี่ยนไปใช้ GLM-5.1 ได้โดยเปลี่ยน Base URL และชื่อโมเดล ไม่จำเป็นต้องเรียนรู้ SDK ใหม่ ไม่ต้องจัดการรูปแบบการตอบกลับที่แตกต่างกัน

ข้อกำหนดเบื้องต้น

ก่อนที่จะทำการเรียกใช้ครั้งแรก คุณต้องมีสิ่งต่อไปนี้:

1. บัญชี BigModel ที่ bigmodel.cn การลงทะเบียนฟรี
2. คีย์ API จากคอนโซล BigModel ภายใต้ API Keys
3. Python 3.8+ หรือ Node.js 18+ (ตัวอย่างครอบคลุมทั้งสองภาษา)
4. OpenAI SDK หรือ requests/fetch มาตรฐาน (API ของ GLM-5.1 เข้ากันได้กับ OpenAI)

ตั้งค่าคีย์ API ของคุณเป็นตัวแปรสภาพแวดล้อม:

export BIGMODEL_API_KEY="your_api_key_here"

ห้ามฮาร์ดโค้ดคีย์ API ในซอร์สโค้ดของคุณเด็ดขาด

การยืนยันตัวตน

ทุกคำขอต้องมี Bearer token ใน Authorization header:

Authorization: Bearer YOUR_API_KEY

รูปแบบคีย์ API ของ BigModel มีลักษณะเหมือน xxxxxxxx.xxxxxxxxxxxxxxxx ซึ่งเป็นสตริงสองส่วนคั่นด้วยจุด สิ่งนี้แตกต่างจากรูปแบบ sk- ของ OpenAI แต่ทำงานใน header ได้ในลักษณะเดียวกัน

Base URL

https://open.bigmodel.cn/api/paas/v4/

ปลายทาง (endpoint) สำหรับ chat completions คือ:

POST https://open.bigmodel.cn/api/paas/v4/chat/completions

คำขอแรกของคุณ

การใช้ curl

curl https://open.bigmodel.cn/api/paas/v4/chat/completions \
  -H "Authorization: Bearer $BIGMODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "glm-5.1",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that finds all prime numbers up to n using the Sieve of Eratosthenes."
      }
    ],
    "max_tokens": 1024,
    "temperature": 0.7
  }'

การใช้ Python (requests)

import os
import requests

api_key = os.environ["BIGMODEL_API_KEY"]

response = requests.post(
    "https://open.bigmodel.cn/api/paas/v4/chat/completions",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "model": "glm-5.1",
        "messages": [
            {
                "role": "user",
                "content": "Write a Python function that finds all prime numbers up to n using the Sieve of Eratosthenes."
            }
        ],
        "max_tokens": 1024,
        "temperature": 0.7
    }
)

result = response.json()
print(result["choices"][0]["message"]["content"])

การใช้ OpenAI SDK (แนะนำ)

เนื่องจาก API เข้ากันได้กับ OpenAI คุณจึงสามารถใช้ OpenAI Python SDK อย่างเป็นทางการพร้อมกับ Base URL แบบกำหนดเองได้:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BIGMODEL_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/"
)

response = client.chat.completions.create(
    model="glm-5.1",
    messages=[
        {
            "role": "user",
            "content": "Write a Python function that finds all prime numbers up to n using the Sieve of Eratosthenes."
        }
    ],
    max_tokens=1024,
    temperature=0.7
)

print(response.choices[0].message.content)

นี่เป็นวิธีการที่สะอาดที่สุด OpenAI SDK จัดการการลองใหม่ (retries), การจัดการหมดเวลา (timeout management) และการแยกวิเคราะห์การตอบกลับ (response parsing) คุณได้รับทั้งหมดนั้นฟรีเพียงแค่ชี้ไปที่ BigModel Base URL

รูปแบบการตอบกลับ

โครงสร้างการตอบกลับเหมือนกับของ OpenAI ทุกประการ:

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1744000000,
  "model": "glm-5.1",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "def sieve_of_eratosthenes(n):\n    ..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 32,
    "completion_tokens": 215,
    "total_tokens": 247
  }
}

เข้าถึงข้อความตอบกลับผ่าน result["choices"][0]["message"]["content"]

ฟิลด์ usage แสดงจำนวนโทเค็นสำหรับคำขอ ติดตามสิ่งนี้เพื่อตรวจสอบการใช้โควต้าของคุณ เนื่องจาก GLM-5.1 จะเรียกเก็บค่าโควต้า 3 เท่าในช่วงเวลาเร่งด่วน (14:00-18:00 UTC+8)

การตอบกลับแบบสตรีมมิ่ง

สำหรับงานสร้างโค้ดยาวๆ การสตรีมจะให้โทเค็นแก่คุณเมื่อมาถึง แทนที่จะรอการตอบกลับทั้งหมด สิ่งนี้จำเป็นสำหรับแอปพลิเคชันที่ผู้ใช้ต้องใช้งาน

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BIGMODEL_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/"
)

stream = client.chat.completions.create(
    model="glm-5.1",
    messages=[
        {
            "role": "user",
            "content": "Explain how a B-tree index works in a database, with a code example."
        }
    ],
    stream=True,
    max_tokens=2048
)

for chunk in stream:
    if chunk.choices[0].delta.content is not None:
        print(chunk.choices[0].delta.content, end="", flush=True)

print()  # newline after streaming completes

แต่ละส่วนข้อมูล (chunk) ในสตรีมคือส่วนต่าง (delta) ที่มีเฉพาะโทเค็นใหม่ตั้งแต่ส่วนข้อมูลสุดท้าย ส่วนข้อมูลสุดท้ายจะมี finish_reason ตั้งค่าเป็น "stop" (หรือ "length" หากถึงขีดจำกัดโทเค็น)

การสตรีมด้วยคำขอแบบดิบ (raw requests)

หากคุณไม่ต้องการใช้ OpenAI SDK:

import os
import json
import requests

api_key = os.environ["BIGMODEL_API_KEY"]

response = requests.post(
    "https://open.bigmodel.cn/api/paas/v4/chat/completions",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    },
    json={
        "model": "glm-5.1",
        "messages": [{"role": "user", "content": "Write a merge sort in Python."}],
        "stream": True,
        "max_tokens": 1024
    },
    stream=True
)

for line in response.iter_lines():
    if line:
        line = line.decode("utf-8")
        if line.startswith("data: "):
            data = line[6:]
            if data == "[DONE]":
                break
            chunk = json.loads(data)
            delta = chunk["choices"][0]["delta"]
            if "content" in delta:
                print(delta["content"], end="", flush=True)

การเรียกใช้เครื่องมือ (Tool calling)

GLM-5.1 รองรับการเรียกใช้เครื่องมือ: ความสามารถในการร้องขอการดำเนินการฟังก์ชันกลางการสนทนา นี่คือกลไกหลักสำหรับเวิร์กโฟลว์ของ Agent ที่โมเดลต้องรันโค้ด, ค้นหาฐานข้อมูล, เรียกใช้ API ภายนอก หรือดำเนินการต่างๆ ในโลกจริง

การกำหนดเครื่องมือ

import os
import json
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["BIGMODEL_API_KEY"],
    base_url="https://open.bigmodel.cn/api/paas/v4/"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "run_python",
            "description": "Execute Python code and return the output. Use this to test, profile, or benchmark code.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "The Python code to execute"
                    }
                },
                "required": ["code"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "Read the contents of a file",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "File path to read"
                    }
                },
                "required": ["path"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="glm-5.1",
    messages=[
        {
            "role": "user",
            "content": "Write a function to compute Fibonacci numbers, test it for n=10, and show me the output."
        }
    ],
    tools=tools,
    tool_choice="auto"
)

message = response.choices[0].message
print(f"Finish reason: {response.choices[0].finish_reason}")

if message.tool_calls:
    for tool_call in message.tool_calls:
        print(f"\nTool called: {tool_call.function.name}")
        print(f"Arguments: {tool_call.function.arguments}")

การจัดการการตอบกลับการเรียกใช้เครื่องมือ

เมื่อ GLM-5.1 ร้องขอการเรียกใช้เครื่องมือ คุณจะดำเนินการฟังก์ชัน จากนั้นส่งคืนผลลัพธ์ในข้อความถัดไป:

import subprocess

def execute_tool(tool_call):
    """Execute the tool and return the result."""
    name = tool_call.function.name
    args = json.loads(tool_call.function.arguments)

    if name == "run_python":
        result = subprocess.run(
            ["python3", "-c", args["code"]],
            capture_output=True,
            text=True,
            timeout=10
        )
        return result.stdout or result.stderr

    elif name == "read_file":
        try:
            with open(args["path"]) as f:
                return f.read()
        except FileNotFoundError:
            return f"Error: file {args['path']} not found"

    return f"Unknown tool: {name}"


def run_agent_loop(user_message, tools, max_iterations=20):
    """Run a full agent loop with tool calling."""
    messages = [{"role": "user", "content": user_message}]

    for i in range(max_iterations):
        response = client.chat.completions.create(
            model="glm-5.1",
            messages=messages,
            tools=tools,
            tool_choice="auto",
            max_tokens=4096
        )

        message = response.choices[0].message
        messages.append(message.model_dump())

        if response.choices[0].finish_reason == "stop":
            # Model is done
            return message.content

        if response.choices[0].finish_reason == "tool_calls":
            # Execute each tool call and add results
            for tool_call in message.tool_calls:
                tool_result = execute_tool(tool_call)
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": tool_result
                })

    return "Max iterations reached"


result = run_agent_loop(
    "Write a quicksort implementation, test it with a random list of 1000 integers, and report the time.",
    tools
)
print(result)

รูปแบบนี้ขยายโดยตรงไปยังจุดแข็งของ GLM-5.1 ในฐานะโมเดล Agent คุณปล่อยให้โมเดลตัดสินใจว่าจะเรียกใช้เครื่องมือเมื่อใด ประมวลผลผลลัพธ์ และดำเนินการต่อจนกว่าจะถึงวิธีแก้ปัญหาหรือตัดสินใจว่าเสร็จสิ้นแล้ว

พารามิเตอร์สำคัญ

การตั้งค่าที่แนะนำสำหรับงานเขียนโค้ด:

{
    "model": "glm-5.1",
    "temperature": 1.0,
    "top_p": 0.95,
    "max_tokens": 163840  # full context for long agentic runs
}

Z.AI ใช้การตั้งค่าเหล่านี้ในการประเมินเกณฑ์มาตรฐานของตนเอง สำหรับการสร้างโค้ดที่กำหนดได้แน่นอน ให้ลดอุณหภูมิลงเหลือ 0.2-0.4

การใช้ GLM-5.1 กับผู้ช่วยเขียนโค้ด

Z.AI Coding Plan ให้คุณกำหนดเส้นทาง Claude Code, Cline, Kilo Code และผู้ช่วยเขียนโค้ด AI อื่นๆ ผ่าน GLM-5.1 ทาง BigModel API สิ่งนี้มีประโยชน์หากคุณต้องการโมเดลเขียนโค้ดที่แข็งแกร่งในราคาที่ต่ำกว่าการรัน Claude Opus หรือ GPT-5.4 โดยตรง

การตั้งค่า Claude Code

ในไฟล์การกำหนดค่า Claude Code ของคุณ (~/.claude/settings.json หรือไฟล์ที่เทียบเท่า):

{
  "model": "glm-5.1",
  "baseURL": "https://open.bigmodel.cn/api/paas/v4/",
  "apiKey": "your_bigmodel_api_key"
}

การตั้งค่า Cline / Roo Code

ในการตั้งค่า VS Code ของคุณหรือการกำหนดค่าส่วนขยาย Cline:

{
  "cline.apiProvider": "openai",
  "cline.openAIBaseURL": "https://open.bigmodel.cn/api/paas/v4/",
  "cline.openAIApiKey": "your_bigmodel_api_key",
  "cline.openAIModelId": "glm-5.1"
}

การใช้โควต้า

GLM-5.1 ใช้ระบบโควต้าของ Z.AI แทนการเรียกเก็บเงินต่อโทเค็น: - ช่วงเวลาเร่งด่วน (14:00-18:00 UTC+8): โควต้า 3 เท่าต่อคำขอ - นอกช่วงเวลาเร่งด่วน: โควต้า 2 เท่าต่อคำขอ - อัตราโปรโมชันถึงเดือนเมษายน 2026: 1 เท่าในช่วงนอกช่วงเวลาเร่งด่วน

สำหรับปริมาณงานของ Agent ที่หนักหน่วง ให้กำหนดเวลางานที่ใช้เวลานานสำหรับช่วงนอกช่วงเวลาเร่งด่วน การดำเนินการเพิ่มประสิทธิภาพ 600 รอบเช่นที่ Z.AI แสดงให้เห็นจะใช้โควต้ามากกว่าอย่างมีนัยสำคัญในช่วงเวลาเร่งด่วน

การทดสอบ GLM-5.1 API ด้วย Apidog

การทดสอบการผสานรวม Agentic API จำเป็นต้องจัดการประเภทการตอบกลับหลายประเภทอย่างถูกต้อง: การเติมข้อความปกติ, ส่วนข้อมูลการสตรีม, คำขอเรียกใช้เครื่องมือ, ข้อความผลลัพธ์ของเครื่องมือ และสถานะข้อผิดพลาด การทดสอบทั้งหมดนี้กับ API จริงจะใช้โควต้าและต้องมีการเชื่อมต่อแบบสด

Smart Mock ของ Apidog ให้คุณกำหนดสถานะการตอบกลับทั้งหมดเหล่านี้และทดสอบได้โดยไม่ต้องเรียกใช้ API จริง

การตั้งค่าปลายทาง Mock

1. ใน Apidog สร้างปลายทางใหม่: POST https://open.bigmodel.cn/api/paas/v4/chat/completions
2. เพิ่ม Mock Expectation สำหรับการตอบกลับที่สำเร็จมาตรฐาน:

{
  "id": "chatcmpl-test123",
  "object": "chat.completion",
  "created": 1744000000,
  "model": "glm-5.1",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "def sieve(n): ..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 32,
    "completion_tokens": 120,
    "total_tokens": 152
  }
}

1. เพิ่ม Expectation ที่สองสำหรับการตอบกลับการเรียกใช้เครื่องมือ:

{
  "id": "chatcmpl-tool456",
  "object": "chat.completion",
  "created": 1744000001,
  "model": "glm-5.1",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": null,
        "tool_calls": [
          {
            "id": "call_abc",
            "type": "function",
            "function": {
              "name": "run_python",
              "arguments": "{\"code\": \"print(2+2)\"}"
            }
          }
        ]
      },
      "finish_reason": "tool_calls"
    }
  ],
  "usage": {
    "prompt_tokens": 48,
    "completion_tokens": 35,
    "total_tokens": 83
  }
}

1. เพิ่มการตอบกลับอัตราการจำกัด (HTTP 429):

{
  "error": {
    "message": "Rate limit exceeded. Please retry after 60 seconds.",
    "type": "rate_limit_error",
    "code": "rate_limit_exceeded"
  }
}

การทดสอบ Agent Loop เต็มรูปแบบ

ใช้ Test Scenarios ของ Apidog เพื่อเชื่อมโยงคำขอหลายรายการเข้าด้วยกัน สำหรับการทดสอบ Agent Loop:

1. ขั้นตอนที่ 1: POST ไปยัง /chat/completions ด้วยข้อความเริ่มต้นของคุณ ยืนยัน 200 และ finish_reason == "tool_calls"
2. ขั้นตอนที่ 2: POST อีกครั้งพร้อมผลลัพธ์ของเครื่องมือในอาร์เรย์ข้อความ ยืนยัน 200 และ finish_reason == "stop"
3. ขั้นตอนที่ 3: ดึงเนื้อหาสุดท้ายและยืนยันว่ามีโค้ดที่คาดไว้

สิ่งนี้จะทดสอบ Agent Loop ทั้งหมดโดยไม่ต้องใช้โควต้าใดๆ คุณยังสามารถทดสอบการจัดการข้อผิดพลาดโดยการสลับ mock ให้ส่งคืน 429 จากนั้นตรวจสอบว่าตรรกะการลองใหม่ของคุณทำงานอย่างถูกต้อง

สำหรับเวิร์กโฟลว์ Agentic แบบหลายขั้นตอน Test Scenarios ของ Apidog ให้คุณส่งข้อมูลระหว่างขั้นตอนโดยใช้ตัวแปร ดังนั้นค่า request_id หรือ tool_call_id จากขั้นตอนที่ 1 จะไหลไปยังขั้นตอนที่ 2 โดยอัตโนมัติ สิ่งนี้สะท้อนวิธีการทำงานของ Agent Loop จริงและตรวจจับข้อผิดพลาดในการผสานรวมก่อนการนำไปใช้งานจริง

การจัดการข้อผิดพลาด

API จะส่งคืนรหัสสถานะ HTTP มาตรฐาน:

import time
import requests

def call_with_retry(payload, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.post(
                "https://open.bigmodel.cn/api/paas/v4/chat/completions",
                headers={"Authorization": f"Bearer {os.environ['BIGMODEL_API_KEY']}",
                         "Content-Type": "application/json"},
                json=payload,
                timeout=120
            )

            if response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 60))
                print(f"Rate limited. Waiting {retry_after}s...")
                time.sleep(retry_after)
                continue

            response.raise_for_status()
            return response.json()

        except requests.exceptions.Timeout:
            wait = 2 ** attempt
            print(f"Timeout on attempt {attempt + 1}. Retrying in {wait}s...")
            time.sleep(wait)

    raise Exception("Max retries exceeded")

สำหรับการรัน Agentic ที่ยาวนานซึ่งแต่ละขั้นตอนอาจใช้เวลา 30-60 วินาที ควรตั้งค่าหมดเวลาให้เผื่อไว้ (120-300 วินาที) เสมอ โมเดลอาจต้องใช้เวลาในการสร้างไฟล์โค้ดที่สมบูรณ์หรือวิเคราะห์ผลลัพธ์เกณฑ์มาตรฐานที่ซับซ้อน

สรุป

API ที่เข้ากันได้กับ OpenAI ของ GLM-5.1 หมายความว่าคุณสามารถรวมเข้าด้วยกันได้ในไม่กี่นาทีหากคุณเคยทำงานกับ GPT หรือ Claude มาก่อน ความแตกต่างที่สำคัญคือปลายทาง (open.bigmodel.cn) และระบบโควต้าแทนการเรียกเก็บเงินต่อโทเค็น

สำหรับแอปพลิเคชัน Agentic ที่โมเดลรันการเรียกใช้เครื่องมือหลายร้อยครั้งตลอดเซสชันยาวนาน ความสามารถในการเพิ่มประสิทธิภาพระยะยาวของ GLM-5.1 เป็นข้อได้เปรียบที่แท้จริง จับคู่กับ Apidog's Smart Mock และ Test Scenarios เพื่อให้แน่ใจว่าการผสานรวมของคุณจัดการกรณีขอบทั้งหมดก่อนที่จะทำงานโดยไม่ได้รับการดูแล

สำหรับข้อมูลพื้นฐานเกี่ยวกับ GLM-5.1 คืออะไรและเปรียบเทียบเกณฑ์มาตรฐานอย่างไร โปรดดูที่ ภาพรวมโมเดล GLM-5.1 สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการสร้างและทดสอบเวิร์กโฟลว์ Agent AI ด้วย Apidog โปรดดูที่ วิธีการทำงานของหน่วยความจำ Agent AI

คำถามที่พบบ่อย

GLM-5.1 API เข้ากันได้กับ OpenAI หรือไม่?ใช่ รูปแบบคำขอ, โครงสร้างการตอบกลับ, โปรโตคอลการสตรีม และรูปแบบการเรียกใช้เครื่องมือทั้งหมดเหมือนกับ OpenAI chat completions API คุณสามารถใช้ OpenAI Python SDK อย่างเป็นทางการหรือไคลเอนต์ใดๆ ที่เข้ากันได้กับ OpenAI โดยตั้งค่า Base URL เป็น https://open.bigmodel.cn/api/paas/v4/

ชื่อโมเดลที่จะใช้ในคำขอ API คืออะไร?ใช้ "glm-5.1" เป็นชื่อโมเดล ไม่ต้องใช้ชื่อเวอร์ชันเต็ม เพียงแค่ glm-5.1 ก็ใช้ได้

การกำหนดราคา GLM-5.1 API ทำงานอย่างไร?BigModel API ใช้ระบบโควต้า GLM-5.1 ใช้โควต้า 3 เท่าในช่วงเวลาเร่งด่วน (14:00-18:00 UTC+8) และ 2 เท่าในช่วงนอกเวลาเร่งด่วน จนถึงสิ้นเดือนเมษายน 2026 การใช้งานนอกเวลาเร่งด่วนจะถูกเรียกเก็บเงินในอัตราโปรโมชันที่โควต้า 1 เท่า

ความยาวบริบทสูงสุดคือเท่าใด?บริบทอินพุต 200,000 โทเค็น เอาต์พุตสูงสุดคือ 163,840 โทเค็น สำหรับการรัน Agentic ที่ยาวนาน ให้ตั้งค่า max_tokens เป็นค่าสูงๆ (32,768 หรือสูงกว่า) เพื่อหลีกเลี่ยงการตัดเอาต์พุตของโมเดลกลางงาน

ฉันสามารถใช้ GLM-5.1 สำหรับการเรียกใช้ฟังก์ชัน / การใช้เครื่องมือได้หรือไม่?ใช่ GLM-5.1 รองรับรูปแบบการเรียกใช้เครื่องมือเดียวกับ API ของ OpenAI กำหนดเครื่องมือด้วยสคีมา type: "function" ส่งผ่านในอาร์เรย์ tools และจัดการการตอบกลับ finish_reason: "tool_calls" ใน Agent Loop ของคุณ

ฉันจะทดสอบการเรียก GLM-5.1 API โดยไม่ใช้โควต้าได้อย่างไร?ใช้ Smart Mock ของ Apidog เพื่อกำหนด mock responses สำหรับแต่ละสถานะ API: สำเร็จ, การเรียกใช้เครื่องมือ, การจำกัดอัตรา, ข้อผิดพลาด เรียกใช้ชุดทดสอบของคุณกับ mock ในระหว่างการพัฒนาและใช้ API จริงสำหรับการตรวจสอบขั้นสุดท้ายเท่านั้น

ฉันสามารถหา weights ของโมเดล GLM-5.1 ได้ที่ไหน?weights แบบโอเพนซอร์สอยู่ที่ HuggingFace ที่ zai-org/GLM-5.1 พวกเขาถูกปล่อยภายใต้ MIT License และรองรับ vLLM และ SGLang สำหรับการอนุมานในเครื่อง (local inference)