วิธีใช้ Kimi K3 API

TLDR Kimi K3 คือโมเดลเรือธงรุ่นใหม่ล่าสุดของ Moonshot AI เปิดตัวในเดือนกรกฎาคม 2026 เพื่อรองรับงานโค้ดระยะยาว การให้เหตุผลเชิงลึก ความเข้าใจแบบมัลติโหมด และงานความรู้แบบครบวงจร Moonshot อธิบายว่าเป็นโมเดลแบบเปิดระดับ 3T-class ที่มีพารามิเตอร์รวม 2.8 ล้านล้าน มาพร้อมวิชันแบบเนทีฟและหน้าต่างบริบทขนาด 1 ล้านโทเคน

สำหรับนักพัฒนาที่ต้องการเข้าถึงได้รวดเร็วโดยไม่ต้องจัดการบัญชีผู้ให้บริการหลายเจ้า CometAPI ลงรายการ Kimi K3 ให้ใช้งานจริงภายใต้ model ID kimi-k3 โดยใช้ endpoint แบบเข้ากันได้กับ OpenAI ที่ /v1/chat/completions และ base URL https://api.cometapi.com/v1. หน้า Kimi K3 ของ CometAPI แสดงราคาอินพุตที่ $2.40 ต่อ 1M โทเคน และเอาต์พุตที่ $12.00 ต่อ 1M โทเคน เมื่อเทียบกับ Kimi API อย่างเป็นทางการที่ระบุอินพุต cache-miss $3.00 และเอาต์พุต $15.00 เนื่องจากดีมานด์ของ Kimi K3 ทำให้ Moonshot ต้องจำกัดการสมัครใช้งานชั่วคราว ทีมโปรดักชันจึงควรใช้ CometAPI ไม่เพียงเพื่อการตั้งค่าอย่างง่าย แต่ยังเพื่อเปรียบเทียบโมเดล ติดตามการใช้งาน และกำหนดเส้นทางสำรอง

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

• สำหรับโปรดักชัน ควรเก็บข้อความผู้ช่วยทั้งหมดในเวิร์กโฟลว์หลายเทิร์น จำกัด max_completion_tokens ติดตามการใช้โทเคน และสร้างเส้นทางสำรอง
• Kimi K3 เป็นโมเดล Mixture-of-Experts ขนาด 2.8T จาก Moonshot AI ที่มีหน้าต่างบริบท 1M โทเคนและความเข้าใจภาพแบบเนทีฟ
• CometAPI Kimi k3 ใช้ model ID kimi-k3; endpoint หลักคือ POST https://api.cometapi.com/v1/chat/completions
• K3 จะทำการให้เหตุผลเสมอ ใช้ reasoning_effort เป็น low, high, หรือ max; เอกสารของ Kimi ระบุว่า max เป็นค่าเริ่มต้น
• แนะนำให้ใช้การสตรีมอย่างยิ่งสำหรับงานโค้ดยาว การวิจัย และการวิเคราะห์ เพราะผู้ใช้จะเห็นเอาต์พุตบางส่วนระหว่างที่โมเดลยังทำงาน
• อินพุตวิชันต้องใช้อาเรย์ content แบบมัลติโหมด เอกสารของ Kimi ระบุว่าไม่รองรับ public image URLs สำหรับเส้นทางวิชันของ Kimi; ให้ใช้ base64 หรือการอัปโหลดไฟล์แล้วอ้างอิง
• Kimi K3 รองรับเอาต์พุตแบบโครงสร้าง โหมด JSON การเรียกใช้เครื่องมือ tool_choice การโหลดเครื่องมือแบบไดนามิก และ context caching

CometAPI เป็นวิธีที่ใช้การได้จริงในการประเมิน Kimi K3 เทียบกับ GPT, Claude, Gemini, DeepSeek, Qwen และโมเดลอื่นๆ จาก API เลเยอร์เดียว

Kimi K3 คืออะไร: โมเดลเรือธงของ Moonshot AI

Moonshot AI เปิดตัว Kimi K3 เมื่อวันที่ 16 กรกฎาคม 2026 ในฐานะโมเดลที่ทรงพลังที่สุดของบริษัท — สถาปัตยกรรม Mixture-of-Experts (MoE) แบบสแปร์สที่มีพารามิเตอร์รวมประมาณ 2.8 ล้านล้าน (เปิดผู้เชี่ยวชาญ 16 จาก 896 ตัวต่อโทเคน) มาพร้อม Kimi Delta Attention เพื่อการถอดรหัสที่เร็วขึ้นสูงสุด 6.3 เท่าในบริบทระดับล้านโทเคน และ Attention Residuals ที่ช่วยให้ประสิทธิภาพการฝึกดีขึ้นราว 25%

สเปกสำคัญ (อ้างอิงจากรายงานอย่างเป็นทางการและอิสระ):

โดดเด่นด้านโค้ดระยะยาว งานเอเจนต์ ความเข้าใจภาพ และงานความรู้ เกณฑ์ชี้วัดอิสระจัดวางให้แข่งขันได้ (เช่น 57.1 บน Artificial Analysis Intelligence Index แข็งแกร่งในสนามโค้ดฝั่ง frontend)

Latest News Context from businessinsider: ความต้องการพุ่งสูงหลังเปิดตัวจน Moonshot ต้องหยุดรับสมัครสมาชิกใหม่ชั่วคราว สะท้อนการขับเคลื่อนของจีนในโมเดลน้ำหนักเปิดระดับแนวหน้า โดย Moonshot เล็ง IPO ครั้งใหญ่

กำหนดปล่อยน้ำหนักโมเดลเต็มในวันที่ 27 กรกฎาคม 2026

เอกสารของ Kimi K3 ระบุว่าจะปล่อยน้ำหนักโมเดลเต็มภายใน 27 กรกฎาคม 2026 จนกว่าการปล่อยจะเสร็จและเครื่องมือดีพลอยของบุคคลที่สามจะสุกงอม ทีมส่วนใหญ่ควรมองว่าการเข้าถึงผ่าน API โฮสต์คือวิธีที่เร็วที่สุดในทางปฏิบัติ แม้เมื่อน้ำหนักโมเดลมีให้ใช้งานแล้ว การเสิร์ฟโมเดล MoE ขนาด 2.8T ก็ไม่เหมือนกับการรันโมเดลเปิดขนาดเล็กบนเวิร์กสเตชันเครื่องเดียว บล็อกเทคนิคของ Moonshot ระบุว่าแนะนำคอนฟิก supernode ที่มีตัวเร่งความเร็ว 64 ตัวขึ้นไปสำหรับการดีพลอย K3 ซึ่งหมายความว่า API แบบโฮสต์จะยังเป็นตัวเลือกเริ่มต้นสำหรับหลายทีม SaaS เอเจนซี ผู้สร้างเครื่องมือภายใน และทีมผลิตภัณฑ์ AI

ประสิทธิภาพตามเกณฑ์ชี้วัด: ข้อมูล แหล่งที่มา และการวิเคราะห์

Kimi K3 ให้ผลระดับแนวหน้า โดยเฉพาะด้านโค้ดและงานเอเจนต์ ทั้งยังแข่งขันได้โดยรวม ห้องแล็บอิสระอย่าง Artificial Analysis ยืนยันคำกล่าวอ้างของผู้ขายพร้อมข้อทักท้วงบางประการ (เช่น อัตราเพ้อความ)

ความฉลาดโดยรวม

• Artificial Analysis Intelligence Index v4.1: 57.1 (อันดับ 4 โดยตามหลัง Fable 5 ~60, GPT-5.6 Sol ~59; นำหน้า Claude Opus 4.8 ~55.7)
• GDPval-AA v2 Elo: 1,668 (ก้าวกระโดดจาก K2.6 ที่ 1,190; แซง Opus 4.8 แต่ยังตามหลัง Fable 5)

ที่มา: reddit

เกณฑ์ชี้วัดด้านโค้ด (ผู้ขาย + อิสระ)

K3 โดดเด่นที่นี่ ครองอันดับสูงสุดใน Frontend Code Arena (Elo 1,679 อันดับ 1 เหนือ Fable 5 และ Sol)

ที่มา: Kimi

Coding Index (Artificial Analysis): แข็งแกร่ง ~76 แข่งขันได้กับผู้นำ

K3 เหมาะกับงานระดับ repository มุมมองฝั่ง frontend พร้อมการไอเทอเรตด้วยภาพ และเอเจนต์ที่ใช้เครื่องมือ นักพัฒนารายงานว่าประสิทธิภาพ "ระดับ Opus 4.8+" สำหรับงานโค้ดจำนวนมาก

Kimi K3 API คืออะไร?

Kimi K3 ในมุมของนักพัฒนาแบบตรงไปตรงมา

Kimi K3 API ให้การเข้าถึงโมเดล K3 ของ Moonshot AI ผ่านอินเทอร์เฟซแบบ chat-completions คำขอทั่วไปส่งรายการข้อความ เลือก model: "kimi-k3" และรับคำตอบจากผู้ช่วย นอกเหนือจากฟอร์แมตแชทพื้นฐาน K3 เพิ่มฟีเจอร์สำคัญสำหรับโปรดักชัน: ปรับระดับความพยายามในการคิด หน้าต่างบริบทยาว อินพุตวิชัน การสตรีม เอาต์พุต JSON และตามสคีมา การเรียกใช้เครื่องมือ และ context caching

Kimi K3 ไม่ได้เหมาะที่จะเข้าใจว่าเป็น "แชตบอทราคาถูกทั่วไป" คุณค่าที่แข็งแรงที่สุดคือการแบกงานหนัก หากโปรดักต์ของคุณต้องป้อนโมเดลด้วย repository ขนาดใหญ่ ชุดเอกสารยาว สเปรดชีตหนาแน่น ภาพหน้าจอหลายรูป บันทึกดีบัก หรือแผนการใช้เครื่องมือที่ซับซ้อน K3 ถูกออกแบบมาสำหรับเซสชันแบบนั้น หากแอปของคุณต้องการเพียงคำตอบ FAQ สั้นๆ หรือการจัดหมวดหมู่บนอินพุตเล็กมาก โมเดลขนาดเล็กอาจคุ้มค่ากว่า

ฟีเจอร์ใหม่ของ API K3 และการใช้งาน

Kimi K3 ต่อยอดจากโมเดล Kimi รุ่นก่อนด้วยความสามารถระดับแนวหน้า:

• 1M Context: ประมวลผลทั้ง repository หนังสือ หรือบทสนทนายาวโดยไม่ต้องตัดทอน
• Native Vision: วิเคราะห์ภาพได้โดยตรงในข้อความ (base64 หรือ URLs)
• Always-On Reasoning: ความพยายามสูงสุดโดยค่าเริ่มต้น; รองรับร่องรอยการคิดแบบมีโครงสร้าง (สตรีมจะแสดงเดลตา)
• Tool Calling & Agents: การเรียกใช้ฟังก์ชันแบบ OpenAI สำหรับเวิร์กโฟลว์ที่ซับซ้อน
• Structured Output: โหมด JSON เพื่อการพาร์สที่เชื่อถือได้
• Caching: prefix caching อัตโนมัติ ช่วยลดค่าใช้จ่ายอย่างมากสำหรับบริบทที่ซ้ำ (รายงานฮิต 90%+ ในงานโค้ด)

ความสามารถหลักของ Kimi K3 API บน CometAPI

บริบท 1M โทเคนสำหรับเอกสารยาวและโค้ดเบสขนาดใหญ่

CometAPI ลงรายการ Kimi K3 ด้วยหน้าต่างบริบท 1,000k โทเคน ขนาดนี้เปลี่ยนวิธีออกแบบเวิร์กโฟลว์ของนักพัฒนา แทนที่จะแตกเอกสารทุกไฟล์เป็นหลายชิ้น คุณสามารถทดสอบเวิร์กโฟลว์ที่คงบริบทขนาดใหญ่ไว้ในคำขอเดียว: เอกสารสถาปัตยกรรมพร้อมตัวอย่างโค้ด ข้อกำหนดผลิตภัณฑ์พร้อมรายงานบั๊ก งานวิจัยพร้อมบันทึก หรือประวัติการสนับสนุนลูกค้ายาวๆ

อย่างไรก็ตาม ไม่ได้หมายความว่าทุกคำขอควรใช้บริบทเต็ม บริบทยาวมีราคาแพงและอาจชะลอเวลาโทเคนแรก ใช้เมื่อโมเดลต้องเห็นภาพรวม มิใช่แทนที่การออกแบบ retrieval ที่ดี รูปแบบโปรดักชันที่แข็งแรงใน CometAPI คือการกำหนดเส้นทางแบบไฮบริด: ใช้ embeddings หรือการค้นหาเพื่อดึงส่วนที่เกี่ยวข้องที่สุด แต่คง K3 ไว้สำหรับงานที่หายากซึ่งบริบทกว้างช่วยเพิ่มคุณภาพคำตอบจริงๆ

การให้เหตุผลเปิดตลอดพร้อม reasoning_effort ที่ปรับได้

เอกสารของ Kimi ระบุว่า K3 ให้เหตุผลเสมอและรองรับฟิลด์ระดับบน reasoning_effort ด้วยค่า low, high, และ max ใช้ระดับต่ำสำหรับงานเบาที่แคร์เวลาและค่าใช้จ่าย ใช้สูงหรือสูงสุดสำหรับดีบัก คำนวณคณิตศาสตร์ รีวิวสถาปัตยกรรม ย้ายโค้ด สังเคราะห์เอกสารยาว และการวางแผนหลายเครื่องมือ

บน CometAPI ให้ส่ง reasoning_effort ในคำขอ Chat Completions เมื่อเส้นทาง Kimi K3 รองรับพารามิเตอร์เฉพาะผู้ให้บริการ หาก SDK ของคุณไม่รับฟิลด์ระดับบนนี้ ให้ส่งผ่าน extra_body หรือใช้ HTTPS ดิบ

การสตรีมคำตอบเพื่อประสบการณ์ผู้ใช้ที่ดีขึ้น

เอกสารสตรีมของ Kimi อธิบายว่าสตรีมจะส่งโทเคนผ่าน Server-Sent Events แทนการรอคำตอบเต็ม ซึ่งมีประโยชน์มากกับ K3 เพราะการคิดลึกและเอาต์พุตยาวอาจใช้เวลานานกว่า ในเครื่องมือนักพัฒนา ให้สตรีมแผนก่อน แล้วตามด้วยโค้ด ในผู้ช่วยวิจัย ให้สตรีมสรุปแต่ละส่วน ในแอปวิเคราะห์ภายใน ให้สตรีมข้อสังเกตเบื้องต้นขณะรอคำตอบแบบมีโครงสร้าง

อินพุตวิชันสำหรับภาพหน้าจอ แผนภูมิ และวิดีโอ

Kimi K3 รองรับความเข้าใจทางภาพ เอกสารวิชันของ Kimi ระบุว่า K3 เข้าใจทั้งภาพและวิดีโอ และข้อความวิชันควรใช้ content แบบอาเรย์ที่มีส่วน image_url หรือ video_url เอกสารเดียวกันระบุว่าไม่รองรับภาพแบบ URL สาธารณะ ให้ใช้ data URL แบบ base64 หรืออ้างอิงไฟล์อัปโหลด สำหรับผู้ใช้ CometAPI ให้เริ่มด้วยภาพ base64 ในสเตจจิงเพราะง่าย พกพาได้ และล็อกได้อย่างปลอดภัยโดยไม่ต้องพึ่งโฮสต์ภาพสาธารณะ

เอาต์พุตแบบโครงสร้าง โหมด JSON และการเรียกใช้เครื่องมือ

Kimi K3 รองรับเอาต์พุตแบบโครงสร้างผ่าน response_format และการเรียกใช้เครื่องมือผ่านประกาศฟังก์ชันตาม JSON Schema ฟีเจอร์ API รุ่นใหม่ของ K3 รวมถึง tool_choice และการโหลดเครื่องมือแบบไดนามิก ซึ่งสำคัญสำหรับผลิตภัณฑ์เอเจนต์เพราะคลังเครื่องมืออาจใหญ่โต แทนที่จะส่งคำอธิบายเครื่องมือทุกอย่างในทุกคำขอ แอปของคุณสามารถเปิดเผยฟังก์ชัน search_tools ขนาดเล็กก่อน ดึงเฉพาะเครื่องมือที่เกี่ยวข้อง แล้วแทรกคำอธิบายเครื่องมือเหล่านั้นลงในบทสนทนาแบบไดนามิก

การตัดสินใจเชิงปฏิบัติง่ายๆ คือ: อย่าเลือกจากตารางคะแนนเพียงอย่างเดียว ใช้ CometAPI เพื่อสร้างชุดประเมินที่ทำซ้ำได้จากพรอมป์ตของคุณเอง ใส่อย่างน้อย 20 ถึง 50 งานจริง: แก้บั๊ก งานดึงข้อมูล ภาพหน้าจอ PDF คำถามลูกค้า ร่องรอยการเรียกใช้เครื่องมือ และคำขอที่แคร์ต้นทุน จัดเส้นทาง Kimi K3 ไปยังงานที่บริบทยาว การให้เหตุผล และวิชันของมันคุ้มค่า

ราคา API: Kimi K3 มีค่าใช้จ่ายเท่าไร

ราคา Kimi K3 บน CometAPI

หน้ารุ่นของ Kimi K3 ใน CometAPI แสดง:

หน้าเดียวกันเปรียบเทียบกับราคาทางการที่อินพุต $3.00 และเอาต์พุต $15.00 ต่อ 1M โทเคน แสดงส่วนลด 20% บนรายการสดของ CometAPI ราคาอาจเปลี่ยนแปลงได้ ดังนั้นโปรดตรวจสอบหน้ารุ่นของ CometAPI ก่อนเผยแพร่ข้อมูลราคาสำหรับทราฟฟิกสูงหรือก่อนคุมงบโปรดักชัน

ราคา Kimi API อย่างเป็นทางการ

บล็อกเทคนิคของ Moonshot แสดงราคา Kimi API ที่ $0.30 ต่อ 1M โทเคนอินพุตแบบ cache-hit, $3.00 ต่อ 1M โทเคนอินพุตแบบ cache-miss และ $15.00 ต่อ 1M โทเคนเอาต์พุต นอกจากนี้ยังระบุว่า Kimi API ทำอัตรา cache hit ได้เกิน 90% ในงานโค้ด ให้ถือค่าดังกล่าวเป็นตัวเลขที่ผู้ให้บริการรายงานสำหรับเวิร์กโหลดเฉพาะ ไม่ใช่การรับประกันสำหรับทุกแอป การได้ hit มากน้อยขึ้นกับความเสถียรของพรอมป์ต คำอธิบายเครื่องมือ พรีฟิกซ์ของ repository และประวัติเซสชันของคุณ

ตัวอย่างต้นทุนแบบง่ายบน CometAPI

สูตร: (input_tokens / 1,000,000 * 2.40) + (output_tokens / 1,000,000 * 12.00).

มี 2 ประเด็นสำคัญ อย่างแรก โทเคนการให้เหตุผลมักถูกคิดค่าบริการเป็นเอาต์พุตโทเคนเมื่อสร้างโดยโมเดลที่มีการให้เหตุผล ดังนั้นกำหนด max_completion_tokens ให้เหมาะสม อย่างที่สอง บริบทยาวควรใช้โดยตั้งใจ มันทรงพลังที่จะส่ง 500,000 โทเคน แต่ไม่ค่อยคุ้มที่จะส่งมากขนาดนั้นหาก 20,000 โทเคนคุณภาพสูงให้คำตอบเดียวกัน

วิธีใช้ Kimi K3 API ใน CometAPI

ขั้นตอนที่ 1: สร้างคีย์ CometAPI

สร้างหรือเข้าสู่ระบบบัญชี CometAPI เปิดหน้าคีย์ API และสร้างคีย์ เก็บเป็นตัวแปรสภาพแวดล้อมฝั่งเซิร์ฟเวอร์ชื่อ COMETAPI_KEY หลีกเลี่ยงการใส่คีย์โปรดักชันใน JavaScript ฝั่งเบราว์เซอร์ แอปมือถือ รีโพสาธารณะ ภาพหน้าจอ หรือบันทึกฝั่งไคลเอนต์

PowerShell:

$env:COMETAPI_KEY = "your_cometapi_key_here"

macOS หรือ Linux:

export COMETAPI_KEY="your_cometapi_key_here"

ขั้นตอนที่ 2: ติดตั้ง OpenAI SDK

CometAPI รองรับ SDK ที่เข้ากันได้กับ OpenAI ใน Python ติดตั้ง SDK ครั้งเดียว:

python -m pip install --upgrade openai

ขั้นตอนที่ 3: เรียก Kimi K3 API ครั้งแรกของคุณ

ใช้ base URL ของ CometAPI และ model ID kimi-k3:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url="https://api.cometapi.com/v1",
)

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "system",
            "content": "You are a precise technical assistant for API developers.",
        },
        {
            "role": "user",
            "content": "Explain when I should use Kimi K3 for a coding agent.",
        },
    ],
    max_completion_tokens=1200,
)

print(completion.choices[0].message.content)
print(completion.usage)

คำขอ cURL ที่เทียบเท่า:

curl https://api.cometapi.com/v1/chat/completions \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {"role": "system", "content": "You are a precise technical assistant for API developers."},
      {"role": "user", "content": "Explain Kimi K3 in one paragraph."}
    ],
    "max_completion_tokens": 800
  }'

ฟีเจอร์ใหม่ของ K3 API และการใช้งาน

ระดับความพยายามในการคิด

ใช้ reasoning_effort เพื่อควบคุมงบประมาณการคิดที่ K3 ใช้ เอกสารของ Kimi ระบุค่า low, high, และ max โดย max เป็นค่าเริ่มต้น สำหรับโปรดักชัน ให้เลือกตามประเภทงาน:

ตัวอย่าง Python:

completion = client.chat.completions.create(
    model="kimi-k3",
    reasoning_effort="high",
    messages=[
        {
            "role": "user",
            "content": (
                "Review this migration plan for hidden risks. "
                "Return the top 5 issues and a safer rollout sequence."
            ),
        }
    ],
    max_completion_tokens=2000,
)

message = completion.choices[0].message
print(message.content)

หากเวอร์ชัน OpenAI SDK ของคุณไม่รองรับ reasoning_effort เป็นอาร์กิวเมนต์ชื่อ ให้ส่งผ่าน extra_body:

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[{"role": "user", "content": "Solve this scheduling problem."}],
    extra_body={"reasoning_effort": "high"},
)

รายละเอียดสำคัญในการทำงานจริง: เอกสารการคิดของ Kimi ระบุว่าในการสนทนาแบบหลายเทิร์นกับ K3 ควรเก็บข้อความผู้ช่วยทั้งหมดที่ API ส่งกลับ รวมถึงฟิลด์อย่าง reasoning_content และ tool_calls หากคุณเก็บเฉพาะ content ที่มองเห็นได้ อาจทำให้ความต่อเนื่องของการให้เหตุผลลดลงในเซสชันยาว

การสตรีมคำตอบ

ใช้การสตรีมเมื่อคำตอบอาจยาว เมื่อแคร์เวลา หรือเมื่อคุณต้องการแสดงความคืบหน้าใน UI แชท

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "Create a detailed refactor plan for a 200k-line monolith.",
        }
    ],
    stream=True,
    stream_options={"include_usage": True},
    max_completion_tokens=3000,
)

for chunk in stream:
    choice = chunk.choices[0]
    delta = choice.delta

    reasoning = getattr(delta, "reasoning_content", None)
    if reasoning:
        # In most products, store reasoning securely or hide it from end users.
        pass

    if delta.content:
        print(delta.content, end="", flush=True)

    usage = getattr(choice, "usage", None)
    if usage:
        print("\n\nUsage:", usage)

เอกสารสตรีมของ Kimi เน้นว่าการสตรีม SSE จะจบด้วย data: [DONE] ในไคลเอนต์ SSE ดิบ อย่าถือว่าการสตรีมเสร็จสมบูรณ์จนกว่าจะได้รับมาร์กเกอร์นี้

อินพุตวิชัน

Kimi K3 วิเคราะห์ภาพและวิดีโอได้ การทดสอบแรกบน CometAPI ที่ปลอดภัยคือคำขอภาพแบบ base64 ใช้ content แบบอาเรย์ ไม่ใช่สตริง JSON ที่บรรจุอาเรย์

import base64
import mimetypes
from pathlib import Path

image_path = Path("dashboard-screenshot.png")
mime_type = mimetypes.guess_type(image_path.name)[0] or "image/png"
image_b64 = base64.b64encode(image_path.read_bytes()).decode("utf-8")

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:{mime_type};base64,{image_b64}",
                    },
                },
                {
                    "type": "text",
                    "text": (
                        "Review this dashboard screenshot. "
                        "Identify UX issues, missing states, and data-quality risks."
                    ),
                },
            ],
        }
    ],
    max_completion_tokens=1800,
)

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

เอกสารวิชันของ Kimi ระบุฟอร์แมตภาพที่รองรับเช่น PNG, JPEG, WebP และ GIF และฟอร์แมตวิดีโอที่รองรับเช่น MP4, MOV, AVI, WebM และอื่นๆ อีกทั้งแนะนำให้คงความละเอียดภาพไม่เกิน 4K และวิดีโอไม่เกิน FHD เพราะความละเอียดสูงกว่านี้อาจใช้เวลาประมวลผลมากขึ้นโดยไม่ช่วยให้โมเดลเข้าใจดีขึ้น

เอาต์พุตแบบโครงสร้างด้วย JSON Schema

สำหรับไปป์ไลน์โปรดักชัน อย่าพาร์สข้อความอิสระหากขั้นตอนถัดไปคาดหวังข้อมูลแบบโครงสร้าง ใช้ response_format พร้อม JSON Schema เมื่อเส้นทางรองรับ

import json

completion = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": (
                "Extract implementation tasks from this request: "
                "Add SSO, migrate billing webhooks, and create admin audit logs."
            ),
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "implementation_tasks",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "tasks": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "title": {"type": "string"},
                                "risk": {"type": "string"},
                                "owner": {"type": "string"},
                            },
                            "required": ["title", "risk", "owner"],
                            "additionalProperties": False,
                        },
                    }
                },
                "required": ["tasks"],
                "additionalProperties": False,
            },
        },
    },
)

data = json.loads(completion.choices[0].message.content)
print(data["tasks"])

การเรียกใช้เครื่องมือและ tool_choice

เอกสารแนวทางที่ดีที่สุดของการเรียกใช้เครื่องมือใน K3 แนะนำให้หลีกเลี่ยงคลังเครื่องมือขนาดใหญ่ในคำขอเดียว รูปแบบคือ: เปิดเผยฟังก์ชันค้นหาเครื่องมือก่อน บังคับให้ดึงด้วย tool_choice: "required" ในเทิร์นแรก แล้วค่อยโหลดคำอธิบายเครื่องมือที่จำเป็นเท่านั้นแบบไดนามิก

ตัวอย่างสไตล์สภาพอากาศแบบมินิมัล:

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "Look up a customer's order status.",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"},
                },
                "required": ["order_id"],
                "additionalProperties": False,
            },
        },
    }
]

messages = [
    {"role": "user", "content": "Where is order A1024?"},
]

first = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
    tool_choice="required",
)

assistant_message = first.choices[0].message
messages.append(assistant_message.model_dump(exclude_none=True))

for call in assistant_message.tool_calls or []:
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "Shipped", "eta": "2026-07-24"}
    messages.append(
        {
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        }
    )

final = client.chat.completions.create(
    model="kimi-k3",
    messages=messages,
    tools=tools,
)

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

แนวทางปฏิบัติที่ดีที่สุดของ Kimi K3 สำหรับทีมโปรดักชัน

ใช้ Kimi K3 ในงานที่จุดแข็งของมันชัดเจน

Kimi K3 เป็นตัวเลือกที่แข็งแรงสำหรับการวิเคราะห์ระดับ repository โค้ดฝั่ง frontend การจำลองบั๊ก สังเคราะห์เอกสารยาว ให้เหตุผลจากสเปรดชีต QA ที่อาศัยวิชัน และเวิร์กโฟลว์แบบเอเจนต์ที่ต้องใช้เครื่องมือ อาจเกินความจำเป็นสำหรับการสร้างข้อความสั้น การจัดประเภทง่ายๆ หรือแมโครซัพพอร์ตความเสี่ยงต่ำ บน CometAPI สร้างกฎกำหนดเส้นทางโมเดลเพื่อให้ K3 รับงานยาก ในขณะที่โมเดลต้นทุนต่ำจัดการทราฟฟิกรูทีน

สร้างเส้นทางสำรองเพราะช่วงเปิดตัวมีข้อจำกัดด้านความจุ

รายงานของสื่อเกี่ยวกับการที่ Moonshot หยุดรับผู้ใช้ใหม่เป็นการเตือนว่าความพร้อมใช้งานคือส่วนหนึ่งของการเลือกโมเดล สร้าง fallback ในระดับแอป หาก Kimi K3 ส่งกลับข้อผิดพลาดความจุผู้ให้บริการ ให้กำหนดเส้นทางไปยังโมเดลอื่นใน CometAPI ที่มีจุดแข็งคล้ายกัน ลดขนาดบริบท หรือ retry พร้อม backoff ทำให้ประสบการณ์ผู้ใช้ราบรื่น: แสดงความคืบหน้า เก็บร่าง และทำให้ความล้มเหลวกู้คืนได้

รักษาบริบทอย่างระมัดระวังในเซสชันหลายเทิร์น

Kimi K3 ถูกฝึกด้วยประวัติการคิดที่ถูกรักษาไว้ บล็อกเทคนิคของ Moonshot เตือนว่าการสลับมาใช้ K3 กลางเซสชันหรือไม่ส่งต่อข้อความผู้ช่วยเต็มรูปแบบอาจลดความเสถียร ในทางปฏิบัติ ให้เก็บอ็อบเจ็กต์ข้อความผู้ช่วยเต็มที่ API ส่งกลับสำหรับเครื่องมือพัฒนาและเอเจนต์ อย่าบีบอัดทิ้ง tool_calls หรือฟิลด์การให้เหตุผลเฉพาะผู้ให้บริการ เว้นแต่คุณได้ทดสอบผลกระทบแล้ว

ควบคุมค่าใช้จ่ายของเอาต์พุตและการให้เหตุผล

กำหนด max_completion_tokens เสมอ เอกสารอ้างอิงของ Kimi ระบุว่า K3 มีค่าเริ่มต้นสูงสุดเอาต์พุต 131,072 โทเคน และตั้งได้สูงสุดถึง 1,048,576 ตามขีดจำกัดบริบทของโมเดล สิ่งนี้ทรงพลัง แต่สามารถทำให้แดชบอร์ดบิลลิงประหลาดใจได้หากพรอมป์ตชวนให้ตอบยาว สำหรับฟลว์ส่วนใหญ่ กำหนดเพดานแยกกัน: 800–1,500 โทเคนสำหรับสรุป 2,000–4,000 สำหรับการวิเคราะห์ละเอียด และเพดานใหญ่กว่าสำหรับการสร้างแบบยาวโดยเจตนาเท่านั้น

ออกแบบเพื่อการแคช

Context caching ของ Kimi ทำงานดีที่สุดเมื่อบริบทเริ่มต้นที่ซ้ำคงที่ เอกสารปัจจุบันอธิบายว่าเป็นอัตโนมัติ: ไม่ต้องสร้างแคชเอง ไม่มี cache ID หรือ TTL ให้จัดการ สำหรับเอเจนต์โค้ด ให้คงคำแนะนำรีโพ คำอธิบายเครื่องมือ และนโยบายโครงการไว้ในพรีฟิกซ์ที่สม่ำเสมอ สำหรับ QA เอกสาร ให้คงชุดเอกสารให้เสถียรระหว่างคำถามที่เกี่ยวข้อง หลีกเลี่ยงการเขียน system prompt ใหม่ทุกเทิร์น และวางบริบทขนาดใหญ่ที่คงที่ไว้ตอนต้นของอาเรย์ messages เพื่อให้แคชจดจำพรีฟิกซ์ที่ซ้ำได้

ใช้วิชันอย่างมีจุดประสงค์

อินพุตภาพมีคุณค่า แต่ภาพและวิดีโอกินโทเคนตามเนื้อหาและความละเอียด ใช้ภาพเมื่อมีข้อมูลที่ข้อความจับไม่ได้: เลย์เอาต์ UI แผนภูมิ โน้ตเขียนมือ ม็อกดีไซน์ ภาพหน้าจอ CAD และหน้าจอข้อผิดพลาด ลดสเกลภาพที่ใหญ่เกิน ตัดขอบขาวที่ไม่เกี่ยวข้อง และจับคู่ภาพกับคำถามที่แม่นยำ

บทสรุปและข้อแนะนำ

Kimi K3 บน CometAPI มอบความสามารถระดับแนวหน้า — บริบทมหึมา วิชัน และการให้เหตุผล — ในราคาที่เข้าถึงได้พร้อมการผสานใช้งานที่น้อย เริ่มจาก CometAPI เพื่อการเข้าถึงที่รวมศูนย์ การประหยัด และความน่าเชื่อถือ ไม่ว่าคุณจะสร้างเอเจนต์โค้ด แอปมัลติโหมด หรือบริการ AI ที่สเกลได้ ลงทะเบียน ทดลองด้วยควิกสตาร์ตข้างต้น และสเกลอย่างมั่นใจ