Solutions Choose your path
For individuals Build, learn, and create with simple usage-based access. For business Scale teams, billing, governance, and model workflows. More English 繁體中文 日本語 한국어 Français Deutsch Español Italiano Português Русский العربية ไทย Tiếng Việt Bahasa Indonesia Bahasa Melayu Türkçe Polski Nederlands Danish Norsk Қазақ اردو
เริ่มต้นฟรี เริ่มต้นฟรี
500+ AI Model API, All In One API.
Just In CometAPI © 2026 CometAPI · All rights reserved
Home Blog วิธีปรับใช้ Kimi K3.1 Pro ในเครื่อง: ข้อกำหนดฮาร์ดแวร์, การตั้งค่า vLLM guide / งานวิจัย CometAPI
วิธีปรับใช้ Kimi K3.1 Pro ในเครื่อง: ข้อกำหนดฮาร์ดแวร์, การตั้งค่า vLLM เรียนรู้วิธีโฮสต์ Kimi K3.1 Pro เองด้วย vLLM, ตรวจสอบข้อกำหนดของ GPU, ดาวน์โหลดน้ำหนักโมเดล, ทดสอบอินเฟอเรนซ์, และเปรียบเทียบการปรับใช้แบบโลคัลกับการเข้าถึงผ่าน API.
Deon Goodwin ทีมวิจัยโมเดล AI และ API เรียนรู้วิธีโฮสต์ Kimi K3.1 Pro เองด้วย vLLM, ตรวจสอบข้อกำหนดของ GPU, ดาวน์โหลดน้ำหนักโมเดล, ทดสอบอินเฟอเรนซ์, และเปรียบเทียบการปรับใช้แบบโลคัลกับการเข้าถึงผ่าน API.
ใช้สรุปนี้เพื่อดูคำตอบอย่างรวดเร็ว แล้วอ่านคู่มือเพื่อดูบริบท ตัวอย่าง และรายละเอียดการใช้งาน
from openai import OpenAI
client = OpenAI(
api_key="YOUR_COMETAPI_KEY",
base_url="https://api.cometapi.com/v1",
)
response = client.chat.completions.create(
model="gpt-5-mini",
messages=[{"role": "user", "content": "Build this workflow."}],
)
print(response.choices[0].message.content)TL;DR
ติดตั้งและให้บริการ Kimi K3.1 Pro บนเซิร์ฟเวอร์ Linux ที่มี GPU แล้วเชื่อมต่อแอปพลิเคชันภายในเครื่องเข้ากับเอ็นด์พอยต์อินเฟอเรนซ์ของมัน บทนำนี้ใช้โหนด NVIDIA B300 แปด GPU พร้อม vLLM คุณจะต้องมีสิทธิ์เชลล์บนเซิร์ฟเวอร์ ไดรเวอร์ที่เข้ากันได้ และที่เก็บสำหรับเช็คพอยต์ฉบับเต็ม เริ่มจากทำคำขอสั้นๆ หนึ่งรายการให้สำเร็จ ก่อนทดสอบอินพุตยาวหรือเวิร์กโฟลว์ของเอเจนต์
หากไม่มี GPU ที่เหมาะสม คุณสามารถรันแอปพลิเคชันในเครื่องแล้วเชื่อมต่อกับ Kimi API อย่างเป็นทางการหรือผู้ให้บริการบุคคลที่สาม เช่น CometAPI
Key Takeaways
พารามิเตอร์ที่ใช้งาน 104B ของโมเดลไม่ได้แสดงถึงความต้องการพื้นที่จัดเก็บทั้งหมด
ความเข้ากันได้ของฮาร์ดแวร์รวมถึงหน่วยความจำ GPU การเชื่อมต่อระหว่างกัน การรองรับการควอนไทซ์ และเคอร์เนลสำหรับอินเฟอเรนซ์
เรียนรู้ต่อ
เชื่อมโยงบทความนี้กับการตัดสินใจถัดไป ดูทุกหัวข้อ เผยแพร่เมื่อ Nov 10, 2026 อัปเดตล่าสุด Nov 10, 2026 ตรวจสอบความชัดเจน การอ้างอิงแหล่งที่มา และคำศัพท์ API ปัจจุบันแล้ว
ผลทดสอบเบนช์มาร์กที่แข็งแกร่งทำให้โมเดลน่าลองใช้งาน แต่ไม่รับประกันประสิทธิภาพเทียบเท่าในแอปพลิเคชันของคุณ
เอ็นด์พอยต์อินเฟอเรนซ์ที่ทำงานได้ไม่ได้หมายความว่าจะมีเบราว์เซอร์ sandbox โค้ด หรือรันไทม์เอเจนต์ครบชุดโดยอัตโนมัติ
เปรียบเทียบการโฮสต์เองและการเข้าถึงผ่าน API โดยวัดต้นทุนต่อภารกิจที่สำเร็จ รวมทั้งการลองใหม่และการบำรุงรักษา
What Is Kimi K3.1 Pro? Kimi K3.1 Pro คือโมเดลมัลติโมดัลแบบเปิดน้ำหนักของ Moonshot AI สำหรับงานเขียนโค้ด วิเคราะห์เอกสาร และการใช้เครื่องมือ รายละเอียดหลักแสดงด้านล่าง อ้างอิงจาก official model card
Architecture MoE; 2.8T total parameters, 104B active Attention 93 layers: 69 KDA + 24 Gated DSA Experts 896 routed; 16 selected per token; 2 shared Context 1,048,576 tokens Inputs Text and images; MoonViT-V2 vision encoder Quantization MXFP4 weights / MXFP8 activations; mixed-precision checkpoint Recommended engines vLLM, SGLang, TokenSpeed
โมเดลเปิดใช้งานพารามิเตอร์ 104B ต่อโทเค็น แต่การให้บริการยังต้องการเช็คพอยต์ 2.8T พารามิเตอร์ฉบับเต็ม เอนจินอินเฟอเรนซ์ต้องรองรับเลเยอร์ KDA และ Gated DSA รวมถึงการควอนไทซ์ MXFP4
What Hardware Do You Need to Run Kimi K3.1 Pro Locally? ตารางด้านล่างสรุป vLLM configurations ที่เกี่ยวข้องกับคู่มือนี้ บทนำนี้ใช้โหนด B300 แบบแปด GPU หนึ่งเครื่อง; การปรับใช้ GB300 และ AMD ต้องใช้การกำหนดค่าที่สอดคล้องของตน
NVIDIA B300 One eight-GPU node, TP8 ค่าเริ่มต้นสำหรับบทนำด้านล่าง NVIDIA GB300 Eight GPUs across two trays, TP8 ต้องใช้การกำหนดค่าหลายโหนดและตั้งค่าการเชื่อมต่อระหว่างกัน AMD MI355X Eight-GPU node with AMD-specific configuration ใช้เส้นทาง ROCm/AITER; ห้ามนำการตั้งค่าแวดล้อมของ NVIDIA มาใช้ซ้ำ Single 24–32 GB consumer GPU Insufficient for direct full-checkpoint loading ไม่ใช่เป้าหมายที่ใช้งานได้จริงสำหรับบทช่วยสอนนี้
เพื่อการเปรียบเทียบเฉพาะขนาด พารามิเตอร์ 2.8T จะใช้พื้นที่ประมาณ 5.6 TB ที่ BF16, 2.8 TB ที่แปดบิต, หรือ 1.4 TB ที่สี่บิตในอุดมคติ นี่คือการคำนวณการจัดเก็บพารามิเตอร์ดิบ ไม่ใช่ขนาดเช็คพอยต์จริงหรือขั้นต่ำ VRAM ระหว่างรันไทม์ ความละเอียดแบบผสมและเมทาดาทาเปลี่ยนขนาดไฟล์; แคชและการจัดสรรรันไทม์เพิ่มความต้องการในการให้บริการ
สำรองความจุ NVMe สำหรับการดาวน์โหลดฉบับเต็ม ไฟล์ชั่วคราว และสำเนาสำหรับย้อนกลับ ในระบบหลายโหนด ให้ตรวจสอบการสื่อสารก่อนโหลดโมเดล
How to Deploy Kimi K3.1 Pro ใช้การโฮสต์เองหากคุณมีฮาร์ดแวร์ที่เหมาะสม; มิฉะนั้นเริ่มต้นด้วย API แบบโฮสต์ ขั้นตอนด้านล่างใช้ vLLM และมี SGLang เป็นทางเลือกตอนท้ายของส่วนนี้ เปรียบเทียบต้นทุนการโฮสต์หลังจากที่คุณมีคำขอทำงานได้
รันคำสั่งตั้งค่า ดาวน์โหลด เปิดให้บริการ และตรวจสอบเบื้องต้นในเชลล์ Bash บนเซิร์ฟเวอร์ GPU หากคุณทำงานจากแล็ปท็อป ให้เชื่อมต่อไปยังเซิร์ฟเวอร์นั้นผ่าน SSH ก่อน ต่อมาคลient Python สามารถรันบนเครื่องใดก็ได้โดยใช้คำแนะนำการเชื่อมต่อด้านล่าง
บทนำนี้ทำตามสูตรการปรับใช้ทางการ; ไม่ได้ทดสอบอย่างอิสระสำหรับบทความนี้
1. ตรวจสอบการมองเห็น GPU ที่จัดเก็บ และการเชื่อมต่อ เริ่มจากการตรวจสอบโครงสร้างพื้นฐานพื้นฐาน:
nvidia-smi
nvidia-smi topo -m
df -h
ยืนยันว่า GPU เป้าหมายทั้งหมดถูกมองเห็น และไดเรกทอรีโมเดลมีพื้นที่เพียงพอ กันพื้นที่เพิ่มเติมสำหรับแคชดาวน์โหลด บันทึก และเวอร์ชันเช็คพอยต์ในอนาคต
สำหรับการปรับใช้หลายโหนด ให้ตรวจสอบการสื่อสารระหว่างโหนดก่อนพยายามเริ่มโมเดล
รักษาหมายความสำเร็จแรกให้แคบ: โหลดเช็คพอยต์และทำคำขอข้อความสั้นๆ ให้สำเร็จ วิธีนี้ช่วยให้วินิจฉัยความล้มเหลวได้ง่ายขึ้น
2. เตรียมแวดล้อมสำหรับการให้บริการ ใช้โฮสต์ Linux ที่มี GPU B300 แปดตัวสำหรับตัวอย่างโหนดเดียวนี้ ในแวดล้อม CUDA ที่เข้ากันได้กับสูตรที่เผยแพร่ สร้างแวดล้อมแยกและติดตั้งเครื่องมือให้บริการ:
python3 -m venv kimi-env
source kimi-env/bin/activate
python -m pip install --upgrade pip
python -m pip install --upgrade huggingface_hub
python -m pip install "vllm>=0.34.0" fastsafetensors
python -c "import vllm; print(vllm.__version__)"
เวอร์ชันขั้นต่ำไม่รับประกันความเข้ากันได้กับไดรเวอร์หรือ wheel ทุกตัว หากสูตรฮาร์ดแวร์ต้องใช้คอนเทนเนอร์หรือบิลด์เฉพาะ ให้ใช้แวดล้อมนั้นแทน ปักหมุดเวอร์ชันที่ทดสอบผ่านก่อนใช้งานจริง
3. ดาวน์โหลดเช็คพอยต์ฉบับเต็ม ติดตั้ง Hugging Face CLI และดาวน์โหลดรีโพสิทอรีโมเดล:
python -m pip install --upgrade huggingface_hub
hf download moonshotai/Kimi-K3.1-Pro \
--local-dir /srv/models/Kimi-K3.1-Pro
เก็บไฟล์การกำหนดค่า ตัวแยกโทเค็น ตัวประมวลผล และดัชนีน้ำหนักไว้กับชาร์ดน้ำหนัก การคัดลอกเฉพาะไฟล์เทนเซอร์บางส่วนอาจทำให้การปรับใช้ไม่สมบูรณ์
เพื่อการปรับใช้งานจริงที่ทำซ้ำได้ ให้บันทึกและปักหมุด revision ของรีโพสิทอรีที่คุณยืนยัน ตรวจสอบสัญญาอนุญาตแบบกำหนดเองของรีโพสิทอรีก่อนการใช้งานเชิงพาณิชย์
4. เปิดให้บริการ vLLM server หลังจากเตรียมแวดล้อมแล้ว ใช้คำสั่งพื้นฐานต่อไปนี้ โดยเริ่มการทำงานแบบ parallelism ของเทนเซอร์แปดทางและจำกัดหน้าต่างคอนเท็กซ์เริ่มต้นไว้ที่ 32,768 โทเค็น:
export VLLM_ENGINE_READY_TIMEOUT_S=3600
vllm serve /srv/models/Kimi-K3.1-Pro \
--served-model-name kimi-local \
--tensor-parallel-size 8 \
--trust-remote-code \
--load-format fastsafetensors \
--enable-auto-tool-choice \
--tool-call-parser kimi_k3 \
--reasoning-parser kimi_k3 \
--max-model-len 32768 \
--host 127.0.0.1 \
--port 8000
ชื่อ kimi-local เป็นนามแฝงฝั่งแอปพลิเคชัน ใช้ชื่อนี้ในคำขอถัดไป
การตั้งค่า 32,768 โทเค็นเป็นจุดเริ่มต้นที่ระมัดระวังสำหรับบทนำนี้ ไม่ใช่คอนเท็กซ์สูงสุดที่โมเดลรองรับ
ตัวเลือก --trust-remote-code อนุญาตให้โหลดโค้ดที่กำหนดเองจากรีโพสิทอรี ควรใช้ร่วมกับเช็คพอยต์ revision ที่ทบทวนแล้วและปักหมุด
ในที่นี้ 127.0.0.1 หมายถึงเครื่องที่รันคลient คำสั่งตรวจสอบด้วย curl ด้านล่างรันบนเซิร์ฟเวอร์ GPU ซึ่งจะเข้าถึงกระบวนการอินเฟอเรนซ์ของมัน หากต้องการใช้คลient Python จากแล็ปท็อปของคุณ ให้เปิด SSH tunnel ในเทอร์มินัลแล็ปท็อปอีกหน้าต่างหนึ่งและคงการเชื่อมต่อนั้นไว้:
ssh -N -L 8000:127.0.0.1:8000 user@gpu-server
แทนที่ user@gpu-server ด้วยข้อมูลเข้าสู่ระบบ SSH และที่อยู่เซิร์ฟเวอร์ของคุณ เมื่อ tunnel เปิดแล้ว คลientบนแล็ปท็อปสามารถใช้ http://127.0.0.1:8000/v1. หากพอร์ต 8000 ถูกใช้งานอยู่บนแล็ปท็อป ให้เลือกพอร์ตภายในเครื่องอื่นและอัปเดต URL ในคลient
5. ตรวจสอบเอ็นด์พอยต์ภายในเครื่อง ตรวจสอบว่าเซิร์ฟเวอร์แสดงโมเดล:
curl http://127.0.0.1:8000/v1/models
จากนั้นส่งคำขอทำข้อความสั้นๆ:
curl http://127.0.0.1:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-local",
"messages": [
{
"role": "user",
"content": "Explain database indexes in three sentences."
}
],
"reasoning_effort": "low",
"max_tokens": 2048
}'
ตรวจสอบการตอบกลับและบันทึกเซิร์ฟเวอร์สำหรับ:
ชื่อโมเดลที่คาดหวัง
คำตอบสุดท้ายในผลตอบกลับ
finish_reason ที่ระบุว่าการสร้างผลลัพธ์เสร็จสมบูรณ์หรือถึงขีดจำกัดข้อผิดพลาดหน่วยความจำ GPU หรือการดำเนินการที่ไม่รองรับ
การใช้เหตุผลอาจบริโภคส่วนหนึ่งของงบประมาณการสร้าง หากคำขอถึงขีดจำกัดก่อนผลิตคำตอบสุดท้าย ให้เพิ่มงบประมาณและลองใหม่ก่อนสรุปว่าเซิร์ฟเวอร์มีปัญหา
6. เชื่อมต่อแอปพลิเคชัน Python ภายในเครื่อง python -m pip install openai
from openai import OpenAI
client = OpenAI(
base_url="http://127.0.0.1:8000/v1",
api_key="EMPTY",
timeout=300.0,
max_retries=1,
)
response = client.chat.completions.create(
model="kimi-local",
messages=[{"role": "user", "content": "Write a Python function that removes duplicate filenames while preserving order."}],
reasoning_effort="low",
max_tokens=2048,
)
print(response.choices[0].message.content)
print(response.choices[0].finish_reason)
EMPTY เป็น placeholder สำหรับเซิร์ฟเวอร์ loopback-only นี้ที่ไม่มีการยืนยันตัวตนด้วย API key ใช้ข้อมูลประจำตัวที่คุณตั้งค่าสำหรับเอ็นด์พอยต์ที่ต้องยืนยันตัวตน ตรวจสอบอินพุตรูปภาพและการเรียกใช้เครื่องมือแยกต่างหากก่อนเชื่อมต่อเอเจนต์
SGLang alternative สำหรับ SGLang ให้ใช้ official hardware-specific cookbook เลือก B300, Unified และ Low-Latency (TP8) เพื่อให้ใกล้เคียงที่สุดกับบทนำโหนดเดียวนี้ ตรวจสอบสถานะการยืนยันที่แสดง; การกำหนดค่าที่สร้างขึ้นไม่จำเป็นต้องเป็นการกำหนดค่าที่ผ่านการทดสอบ
บนเซิร์ฟเวอร์ GPU ติดตั้ง Docker และตั้งค่า NVIDIA Container Toolkit จากนั้นสร้างคอนเทนเนอร์โดยเมานต์เช็คพอยต์ที่ดาวน์โหลดไว้ไปยัง /models/Kimi-K3.1-Pro หยุด vLLM ก่อนเพื่อไม่ให้ทั้งสองเอนจินแข่งขันกันใช้ GPU เดียวกัน
docker pull lmsysorg/sglang:dev-kimi-k31-pro
docker run --rm -it --gpus all \
--shm-size 32g --ipc=host \
-p 127.0.0.1:30000:30000 \
-v /srv/models/Kimi-K3.1-Pro:/models/Kimi-K3.1-Pro:ro \
lmsysorg/sglang:dev-kimi-k31-pro bash
ภายในคอนเทนเนอร์ ให้วางคำสั่งเปิดให้บริการฉบับเต็มที่ cookbook สร้างสำหรับการกำหนดค่าที่คุณเลือก แทนที่เส้นทางโมเดลด้วย /models/Kimi-K3.1-Pro ตั้งค่า host ของบริการเป็น 0.0.0.0 และพอร์ตเป็น 30000 และรักษาธงที่เฉพาะฮาร์ดแวร์ไว้ คอนเทนเนอร์ต้องฟังบนอินเทอร์เฟซเครือข่ายของตัวเองเพื่อให้การส่งต่อพอร์ตของ Docker ทำงาน; พอร์ตฝั่งโฮสต์ด้านบนยังคงผูกกับ loopback รอข้อความพร้อมให้บริการก่อนทดสอบ
ในเชลล์ที่สองบนเซิร์ฟเวอร์ GPU แสดงรายการโมเดลที่ให้บริการ แล้วส่งคำขอโดยใช้ MODEL ID ที่ตอบกลับมาอย่างถูกต้อง:
curl http://127.0.0.1:30000/v1/models
MODEL_ID="replace-with-id-from-models-response"
curl http://127.0.0.1:30000/v1/chat/completions \
-H "Content-Type: application/json" \
-d "{\"model\":\"$MODEL_ID\",\"messages\":[{\"role\":\"user\",\"content\":\"Explain database indexes in three sentences.\"}],\"reasoning_effort\":\"low\",\"max_tokens\":2048}"
การตอบกลับที่สำเร็จควรมีคำตอบสุดท้าย หากเริ่มต้นล้มเหลว ให้ตรวจสอบบันทึกคอนเทนเนอร์และยืนยันว่า recipe ฮาร์ดแวร์และ image ที่เลือกตรงกัน สำหรับการเข้าถึงจากแล็ปท็อป ใช้รูปแบบ SSH tunnel เดิมกับพอร์ต 30000 ดู SGLang Docker installation guide สำหรับข้อกำหนดเบื้องต้นของคอนเทนเนอร์
ใช้ official evaluation results ด้านล่างเพื่อเลือกงานสำหรับการทดสอบการปรับใช้ของคุณ คะแนนเหล่านี้อธิบายการตั้งค่าการประเมินที่เผยแพร่ ไม่ได้วัดเซิร์ฟเวอร์ภายในเครื่องที่กำหนดค่าในคู่มือนี้
ตารางต่อไปนี้แสดงผลลัพธ์ที่เลือกและตำแหน่งภายในชุดเปรียบเทียบที่เผยแพร่ใน model card
Terminal-Bench 4.0 65.7 อันดับสอง SWE Marathon v1.1 51.7 อันดับหนึ่ง Program Bench 31.5 อันดับสี่ OfficeQA Pro v2 64.4 อันดับหนึ่งในผลที่รายงาน Frontier Finance 58.6 อันดับสอง
ผลลัพธ์สนับสนุนการทดสอบโมเดลสำหรับงานวิศวกรรมระยะยาวและเวิร์กโฟลว์เอกสาร Kimi K3.1 Pro อยู่หัวตารางในการเปรียบเทียบนี้บน SWE Marathon แต่ได้อันดับสี่ใน ProgramBench ทำให้ทั้งสองเป็นตัวเลือกที่ดีสำหรับการทดสอบเฉพาะแอปพลิเคชัน
ตำแหน่งเหล่านี้คำนวณภายในตารางเปรียบเทียบอย่างเป็นทางการ ไม่ใช่ลีดเดอร์บอร์ดทั่วโลกแบบสด ชุดเครื่องมือประเมิน งบประมาณการใช้เหตุผล เครื่องมือ และการคัดเลือกตัวอย่างแตกต่างกันไประหว่างเบนช์มาร์ก
สำหรับการตัดสินใจปรับใช้ ให้สร้างชุดประเมินเล็กๆ จากงานจริง: การแก้ไขรีโพสิทอรี คำถามข้ามเอกสาร และงานหลายขั้นตอนที่ใช้เครื่องมือ วัดคุณภาพการทำเสร็จ การแก้ไขโดยมนุษย์ และเวลาที่ใช้ คะแนนที่เผยแพร่มีประโยชน์สำหรับการคัดเลือกเบื้องต้น; การทดสอบในแอปพลิเคชันเป็นตัวกำหนดว่าการปรับใช้นั้นคุ้มค่าไหม
How Can You Optimize Kimi K3.1 Pro Local Inference?
ควบคุมคอนเท็กซ์และความขนาน เมื่อคำขอสั้นๆ ทำงานได้ ให้ทดสอบเอกสารยาว ภาพ บทสนทนาหลายรอบ และการเรียกใช้เครื่องมือแยกกัน
ติดตามความหน่วงโทเค็นแรก จำนวนโทเค็นขาออกต่อวินาที และหน่วยความจำ GPU สูงสุดที่ความยาวคอนเท็กซ์และความขนานที่คุณตั้งใจใช้ บันทึกความสำเร็จของงานและต้นทุนต่อภารกิจที่สำเร็จด้วย เพื่อไม่ให้ผลลัพธ์ที่เร็วขึ้นซ่อนการลองใหม่หรือการแก้ไขโดยมนุษย์ที่มากขึ้น
เปลี่ยนทีละตัวแปรหลัก การเพิ่มความยาวคอนเท็กซ์ ความขนาน และการตั้งค่าปรับแต่งพร้อมกันทำให้การอธิบายการถดถอยด้านประสิทธิภาพทำได้ยาก
เลือกระดับ reasoning และการตั้งค่าแคชอย่างตั้งใจ ใช้ reasoning effort แบบ low, high หรือ max ตามงาน เริ่มด้วย low เพื่อทดสอบอินเทอร์เฟซ จากนั้นเปรียบเทียบ high และ max บนงานที่ยาก โดยใช้ทั้งคุณภาพการทำเสร็จและเวลาที่ใช้ ร่องรอยการใช้เหตุผลที่ยาวขึ้นไม่ใช่หลักฐานโดยตัวมันเองว่าจะได้ผลลัพธ์ที่ดีกว่า
สำหรับเซสชันยาว ให้ประเมินความจุแคชและการใช้ prefix ซ้ำก่อนเพิ่ม speculative decoding หรือความขนานมากขึ้น รักษาค่าพื้นฐานที่ทราบว่าดี และเปลี่ยนการตั้งค่าเพียงครั้งละหนึ่งรายการ
แอปพลิเคชันของคุณดำเนินการเรียกใช้เครื่องมือ ส่งคืนผลลัพธ์ แล้วดำเนินบทสนทนาต่อ ให้คงรักษาข้อความของผู้ช่วยอย่างครบถ้วน—รวมทั้ง reasoning_content และ tool_calls—และส่งคืนผลลัพธ์ของแต่ละเครื่องมือพร้อม tool_call_id ที่จับคู่
Unrecognized model architecture รุ่นของรันไทม์ โค้ดกำหนดเอง และการกำหนดค่า Out of memory while loading ความจุ GPU ระดับ parallelism และโปรเซสที่แข่งขันกัน Short requests work but long requests fail ขีดจำกัดคอนเท็กซ์ ความจุแคช และความขนาน Tool calls cannot be parsed การตั้งค่าตัวแยกและสคีมาของเครื่องมือ The agent stops after requesting a tool การดำเนินงานฝั่งแอปและการส่งคืนผลลัพธ์เครื่องมือ Multi-turn answers become inconsistent การขาดฟิลด์ข้อความของผู้ช่วย
ใช้คำขอที่ย่อส่วนซึ่งทำซ้ำได้เพื่อแยกการล้มเหลวแต่ละกรณี เมื่อมันทำงานได้ ให้ค่อยๆ นำการตั้งค่าเพิ่มเติมของแอปพลิเคชันกลับเข้ามาทีละรายการ
Should You Self-Host or Use a Hosted API? เลือกการโฮสต์เองเมื่อคุณต้องการควบคุมน้ำหนัก โมลโครงสร้างพื้นฐาน หรือสถานที่เก็บข้อมูล และสามารถใช้ประโยชน์จาก GPU ได้อย่างต่อเนื่อง สำหรับการประเมินเบื้องต้นหรือความต้องการแปรผัน ให้เปรียบเทียบ official Kimi API และ CometAPI โดยใช้พรอมต์และเกณฑ์การยอมรับเดียวกัน ยืนยันการเข้าถึงโมเดล พารามิเตอร์ที่รองรับ โควตา และเงื่อนไขการจัดการข้อมูลของแต่ละบริการ
Capacity cost ซื้อหรือเช่า GPU รวมถึงเวลาว่าง คิดค่าบริการการใช้งาน API; ตรวจสอบอัตราปัจจุบันของผู้ให้บริการ Storage and networking การจัดเก็บเช็คพอยต์ แคช และค่าบริการเครือข่าย การจัดเก็บและค่าเครือข่ายฝั่งแอป (ถ้ามี) Operations การปรับใช้ การมอนิเตอร์ อัปเกรด และกู้คืน การผสานรวม การจัดการโควตา และการมอนิเตอร์คำขอ Retries รวมเวลา GPU ของการลองใหม่ไว้ในต้นทุนคอมพิวต์ รวมโทเค็นหรือจำนวนคำขอในค่าบริการ API Human review นับเวลาการแก้ไขโดยมนุษย์ด้วยอัตราเดียวกัน นับเวลาการแก้ไขโดยมนุษย์ด้วยอัตราเดียวกัน Best fit ความต้องการคงที่และการควบคุมโครงสร้างพื้นฐาน การประเมินและความต้องการแปรผัน
การเปรียบเทียบที่มีประโยชน์คือ:
ต้นทุนต่อภารกิจที่สำเร็จ = (ค่าใช้จ่ายคอมพิวต์ GPU หรือ API + การจัดเก็บและเครือข่าย + การปฏิบัติการ + การแก้ไขโดยมนุษย์) / จำนวนภารกิจที่เสร็จสมบูรณ์
ใช้ต้นทุนและจำนวนภารกิจที่เสร็จสมบูรณ์จากช่วงเวลาการวัดเดียวกัน รวมความพยายามที่ล้มเหลวและการลองใหม่ไว้ในยอดรวมของคอมพิวต์หรือ API เพียงครั้งเดียว; อย่าเพิ่มค่าบริการการลองใหม่ครั้งที่สอง สำหรับเวิร์กโฟลว์แบบไฮบริด ให้รวมทั้งค่าใช้จ่ายคอมพิวต์และ API นับเฉพาะภารกิจที่เสร็จสิ้นจริง ไม่ใช่ความพยายามในการส่งคำขอ
เซิร์ฟเวอร์ที่ใช้งานไม่เต็มที่สามารถยังคงมีค่าใช้จ่ายสูงแม้ throughput ในทางทฤษฎีจะยอดเยี่ยม ในทางกลับกัน ทีมที่มีโครงสร้างพื้นฐานอยู่แล้ว ความต้องการคงที่ และข้อกำหนดข้อมูลที่เข้มงวด อาจได้รับคุณค่ามากจากการโฮสต์เอง
ใช้พรอมต์และเกณฑ์การยอมรับเหมือนกันเมื่อเปรียบเทียบเส้นทางการปรับใช้ รวมทั้งเวลาหน่วงปลายทางและคุณภาพผลลัพธ์ในการตัดสินใจ
ลองใช้เอ็นด์พอยต์แบบโฮสต์โดยไม่ต้องโหลดน้ำหนัก official Kimi API quickstart ใช้เอ็นด์พอยต์ด้านล่าง ตั้งค่า MOONSHOT_API_KEY ในแวดล้อมของคุณและยืนยันการเข้าถึงโมเดลในบัญชีของคุณ คำขอนี้ทำงานบนโครงสร้างพื้นฐานของผู้ให้บริการ
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["MOONSHOT_API_KEY"],
base_url="https://api.moonshot.ai/v1",
)
response = client.chat.completions.create(
model="kimi-k3.1-pro",
messages=[{"role": "user", "content": "Explain database indexes in three sentences."}],
reasoning_effort="low",
max_completion_tokens=2048,
)
print(response.choices[0].message.content)
สำหรับ Kimi K3.1 Pro API in CometAPI ให้ตั้งค่า COMETAPI_API_KEY ในแวดล้อมของคุณและยืนยันว่าบัญชีของคุณมีสิทธิ์เข้าถึงโมเดลที่ร้องขอ คำขอจะทำงานจากระยะไกล:
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_API_KEY"],
base_url="https://api.cometapi.com/v1",
)
response = client.chat.completions.create(
model="kimi-k3.1-pro",
messages=[{"role": "user", "content": "Explain database indexes in three sentences."}],
max_tokens=2048,
)
print(response.choices[0].message.content)
เปรียบเทียบผลลัพธ์กับเอ็นด์พอยต์ภายในเครื่องของคุณโดยใช้เกณฑ์การยอมรับเดียวกัน ตรวจสอบราคาปัจจุบันของเส้นทางและพารามิเตอร์ที่รองรับก่อนประมาณต้นทุนใช้งานจริง
Conclusion การโฮสต์ Kimi K3.1 Pro ด้วยตนเองสามารถทำได้จริงเมื่อมีการกำหนดค่า GPU ที่รองรับและแวดล้อมอินเฟอเรนซ์ที่ตรงกัน ใช้ขั้นตอนการปรับใช้ด้านบนเพื่อสร้างเอ็นด์พอยต์ที่ทำงานได้ จากนั้นวัดคุณภาพงาน ความหน่วง และต้นทุนบนงานของคุณเอง เลือก API แบบโฮสต์หากคุณยังทดสอบความเหมาะสมของแอปพลิเคชันหรือไม่มีฮาร์ดแวร์ที่เหมาะสม
FAQ
แล็ปท็อปทั่วไปสามารถรันโมเดลฉบับเต็มได้หรือไม่? แล็ปท็อปทั่วไปไม่ใช่เป้าหมายที่ใช้งานได้จริงสำหรับความต้องการความจุของเช็คพอยต์ต้นฉบับ มันสามารถทำหน้าที่เป็นคลientที่เชื่อมต่อกับเซิร์ฟเวอร์อินเฟอเรนซ์ของคุณเองหรือ API แบบโฮสต์
การติดตั้งแอปเดสก์ท็อปถือเป็นการปรับใช้ภายในเครื่องหรือไม่? ตำแหน่งที่ติดตั้งแอปไม่ได้ระบุว่าการอินเฟอเรนซ์เกิดขึ้นที่ไหน การโฮสต์เองต้องมีน้ำหนักโมเดลและกระบวนการอินเฟอเรนซ์ทำงานในโครงสร้างพื้นฐานที่คุณควบคุม
ทำไมโมเดลต้องใช้หน่วยความจำมากหากมีพารามิเตอร์ใช้งานเพียง 104B? โทเค็นต่างกันสามารถเลือกผู้เชี่ยวชาญต่างกันได้ พารามิเตอร์ที่ใช้งานอธิบายการมีส่วนร่วมในการคำนวณ; การปรับใช้งานยังต้องจัดเก็บและเข้าถึงชุดน้ำหนักทั้งหมด
สามารถเปิดใช้งานคอนเท็กซ์ครบหนึ่งล้านโทเค็นได้ทันทีหรือไม่? เพิ่มความยาวคอนเท็กซ์ทีละน้อยและวัดการใช้หน่วยความจำ GPU ที่ความขนานที่คุณตั้งใจ โมเดลรองรับ 1,048,576 โทเค็น แต่ความจุที่สามารถให้บริการได้ขึ้นอยู่กับแคชและการตั้งค่าความขนาน
การปรับใช้ภายในเครื่องจะทำให้ได้คะแนนเบนช์มาร์กที่เผยแพร่เหมือนกันโดยอัตโนมัติหรือไม่? ไม่โดยอัตโนมัติ การควอนไทซ์ งบประมาณการใช้เหตุผล เครื่องมือ พรอมต์ และเฟรมเวิร์กการประเมินล้วนส่งผลต่อผลลัพธ์ ตรวจสอบการกำหนดค่ากับงานของคุณเอง
ควรทดสอบผ่าน API ก่อนซื้อฮาร์ดแวร์หรือไม่? หากคุณยังไม่ยืนยันว่าโมเดลตอบโจทย์คุณภาพตามที่ต้องการ การทดสอบผ่าน API ให้ค่าเริ่มต้นโดยใช้โครงสร้างพื้นฐานน้อยกว่า ทีมที่มีฮาร์ดแวร์เหมาะสมและข้อกำหนดที่ชัดเจนเกี่ยวกับที่อยู่ข้อมูลสามารถดำเนินการประเมินการโฮสต์เองที่ควบคุมได้โดยตรง
