วิธีใช้ Kimi K2 Thinking API — คู่มือปฏิบัติ

Kimi K2 Thinking คือตัวแปรการใช้เหตุผลเชิงตัวแทนใหม่ล่าสุดในตระกูล Kimi K2: โมเดลขนาดใหญ่ที่ผสมผสานผู้เชี่ยวชาญ (MoE) ซึ่งได้รับการปรับแต่งเพื่อใช้การใช้เหตุผลแบบขั้นตอนต่อขั้นตอนอย่างต่อเนื่อง และเรียกใช้เครื่องมือภายนอกได้อย่างน่าเชื่อถือตลอดเวิร์กโฟลว์หลายขั้นตอนที่ยาวนาน ในคู่มือนี้ ฉันรวบรวมข้อมูลสาธารณะล่าสุด อธิบายว่า Kimi K2 Thinking คืออะไร เปรียบเทียบกับโมเดลเรือธงร่วมสมัย (GPT-5 และ Claude Sonnet 4.5) ได้อย่างไร API ทำงานอย่างไร การตั้งค่าทีละขั้นตอนและงานการใช้เหตุผลตัวอย่างที่รันได้ ข้อควรพิจารณาเกี่ยวกับราคา และแนวทางปฏิบัติที่ดีที่สุดสำหรับการผลิตที่แนะนำ พร้อมด้วยตัวอย่างโค้ดเพื่อให้คุณสามารถเริ่มต้นได้ทันที

Kimi K2 กำลังคิดอะไรอยู่ และทำไมถึงเป็นหัวข้อข่าว?

Kimi การคิดแบบ K2 เป็นการเปิดตัว "ตัวแทนการคิด" ใหม่ล่าสุดจาก Moonshot AI ซึ่งเป็นสมาชิกครอบครัวของผู้เชี่ยวชาญ (MoE) ที่มีพารามิเตอร์ล้านล้านตัวซึ่งได้รับการฝึกฝนและจัดเตรียมมาโดยเฉพาะเพื่อดำเนินการ การใช้เหตุผลแบบหลายขั้นตอนในขอบเขตยาว ในขณะที่เรียกใช้เครื่องมือภายนอกโดยอัตโนมัติ (เช่น การค้นหา การดำเนินการ Python การรวบรวมข้อมูลเว็บ ฯลฯ) การเปิดตัว (ซึ่งประกาศในช่วงต้นเดือนพฤศจิกายน 2025) ได้รับความสนใจด้วยเหตุผลสามประการ ได้แก่ (1) เป็น open-weight / open-licensed (ใบอนุญาตแบบ “Modified MIT”) (2) รองรับบริบทที่ยาวมาก (หน้าต่างบริบทโทเค็น 256k) และ (3) แสดงให้เห็นถึงการปรับปรุงที่ดีขึ้นอย่างเห็นได้ชัด ตัวแทน ประสิทธิภาพในการวัดประสิทธิภาพโดยใช้เครื่องมือเทียบกับโมเดลชายแดนแบบปิดชั้นนำหลายตัว

คิมิ K2 Thinking API และระบบนิเวศรองรับความหมายการเสร็จสิ้นการแชทแบบ OpenAI พร้อมด้วยเอาต์พุตที่มีโครงสร้างชัดเจนและรูปแบบการเรียกใช้เครื่องมือ คุณส่งประวัติการแชทและสคีมาของเครื่องมือ โมเดลจะตอบกลับด้วยการแสดงลำดับความคิด (หากร้องขอ) และสามารถส่งออก JSON ที่มีโครงสร้างซึ่งทริกเกอร์เครื่องมือภายนอก ผู้ให้บริการสามารถสตรีมโทเค็นและส่งคืนทั้งข้อความที่มนุษย์เห็นและบล็อกการเรียกใช้เครื่องมือที่เครื่องวิเคราะห์ได้ ซึ่งทำให้สามารถนำลูปของเอเจนต์มาใช้ได้: โมเดล → เครื่องมือ → การสังเกต → โมเดล

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

คุณสมบัติหลักของ Kimi K2 Thinking มีอะไรบ้าง?

ลักษณะสำคัญของโมเดล

• สถาปัตยกรรมแบบผสมผสานผู้เชี่ยวชาญ (MoE) โดยมีพารามิเตอร์ ~1 ล้านล้านตัว (เปิดใช้งาน 32B ต่อการส่งต่อในการตั้งค่าทั่วไป)
• หน้าต่างบริบทโทเค็น 256k สำหรับการจัดการเอกสารที่ยาวมาก การค้นคว้าจากหลายแหล่ง และการใช้เหตุผลที่ยาวนาน
• การฝึกอบรมเชิงปริมาณ INT4 ดั้งเดิม / การรับรู้เชิงปริมาณช่วยลดหน่วยความจำอนุมานได้มากและเพิ่มความเร็วได้อย่างมากเมื่อเทียบกับน้ำหนักที่มีขนาดไม่ซับซ้อน
• การเรียกใช้เครื่องมือในตัว และ API ที่ยอมรับรายการฟังก์ชัน/เครื่องมือ โดยโมเดลจะตัดสินใจโดยอัตโนมัติว่าจะเรียกใช้และวนซ้ำผลลัพธ์เมื่อใด

สิ่งนี้ช่วยให้สามารถนำไปปฏิบัติได้อย่างไร

• การให้เหตุผลเชิงลึกแบบเป็นขั้นตอน (ผลลัพธ์ในรูปแบบห่วงโซ่แห่งความคิดที่สามารถแสดงให้ผู้โทรเห็นได้เป็น "เนื้อหาการใช้เหตุผลแยกกัน" )
• เวิร์กโฟลว์ตัวแทนหลายขั้นตอนที่มีเสถียรภาพ:โมเดลสามารถรักษาความสอดคล้องของเป้าหมายได้ การเรียกใช้เครื่องมือแบบต่อเนื่อง 200–300 ครั้งนับเป็นก้าวกระโดดที่โดดเด่นจากรุ่นเก่าที่มีแนวโน้มจะดริฟท์หลังจากผ่านไปไม่กี่สิบขั้นตอน
• เปิดน้ำหนัก + จัดการ API: คุณสามารถรันมันในเครื่องได้หากคุณมีฮาร์ดแวร์ หรือเรียกใช้ผ่าน Moonshot/โคเมทเอพีไอ โดยใช้อินเทอร์เฟซ API ที่เข้ากันได้กับ OpenAI

การคิดของ Kimi K2 เผยให้เห็นพฤติกรรมของตัวแทนผ่านกลไกหลักสองประการ: (1) การส่งต่อ เครื่องมือ รายการเพื่อให้โมเดลสามารถเรียกใช้ฟังก์ชันได้ และ (2) โมเดลที่ปล่อยโทเค็นการให้เหตุผลภายในที่แพลตฟอร์มแสดงเป็นข้อความ (หรือห่วงโซ่ความคิดที่มีโครงสร้างเมื่อเปิดใช้งาน) ผมจะอธิบายรายละเอียดพร้อมตัวอย่างต่อไป

ฉันจะใช้ Kimi K2 Thinking API ได้อย่างไร

เบื้องต้น

1. การเข้าถึง API / บัญชี:สร้างบัญชีบนแพลตฟอร์มของ Moonshot (platform.moonshot.ai) หรือบนตัวรวบรวม API ที่รองรับ (โคเมทเอพีไอ มีราคาต่ำกว่าราคาอย่างเป็นทางการ) หลังจากสมัครสมาชิกแล้วคุณสามารถสร้างรหัส API ในแดชบอร์ดได้
2. คีย์ API: เก็บไว้อย่างปลอดภัยในตัวแปรสภาพแวดล้อมหรือที่เก็บข้อมูลลับของคุณ
3. ไลบรารีไคลเอ็นต์: คุณสามารถใช้ SDK มาตรฐาน HTTP (curl) หรือ OpenAI ที่เข้ากันได้กับ OpenAI เอกสารแพลตฟอร์มของ Moonshot มีตัวอย่างโดยตรง ตั้งค่าสภาพแวดล้อม Python ของคุณ คุณจะต้องใช้ OpenAI Python SDK ซึ่งเข้ากันได้กับ โคเมทเอพีไอ API เนื่องจากทั้งสองยังคงความเข้ากันได้กับ OpenAI

หากคุณต้องการโฮสติ้งท้องถิ่น/ส่วนตัว: ฮาร์ดแวร์ (GPU/คลัสเตอร์) ที่รองรับ MoE และ INT4—Moonshot แนะนำให้ใช้ vLLM, SGLang และเอ็นจินอนุมานอื่นๆ สำหรับการใช้งานจริง น้ำหนักโมเดลมีให้ใช้งานบน Hugging Face สำหรับการโฮสต์ด้วยตนเอง—หลายทีมชอบใช้ API แบบโฮสต์เนื่องจากขนาดของโมเดล

การไหลของการโทรขั้นต่ำ (ระดับสูง)

1. สร้างคำขอแชท (ระบบ + ข้อความผู้ใช้)
2. รวมถึงทางเลือก tools (อาร์เรย์ JSON ที่อธิบายฟังก์ชัน) เพื่อให้โมเดลสามารถเรียกใช้ฟังก์ชันเหล่านั้นได้โดยอัตโนมัติ
3. ส่งคำขอไปยังจุดสิ้นสุดการแชท/การดำเนินการโดยมีการตั้งค่าโมเดลเป็นตัวแปร K2 Thinking
4. สตรีมและ/หรือรวบรวมชิ้นส่วนการตอบสนองและประกอบทั้งสอง reasoning_content และเนื้อหาสุดท้าย
5. เมื่อโมเดลร้องขอการเรียกใช้เครื่องมือ ให้ดำเนินการเครื่องมือบนฝั่งของคุณ ส่งคืนผลลัพธ์เป็นข้อความติดตาม (หรือผ่านโปรโตคอลการส่งคืนฟังก์ชันของผู้ให้บริการ) และปล่อยให้โมเดลดำเนินการต่อ

“reasoning_content” ถูกเปิดเผยใน API หรือไม่

ใช่ Kimi K2 Thinking ส่งคืนฟิลด์เอาต์พุตเสริมอย่างชัดเจน (โดยทั่วไปเรียกว่า reasoning_content) ซึ่งประกอบด้วยร่องรอยการใช้เหตุผลระดับกลางของโมเดล ผู้ให้บริการและเอกสารชุมชนแสดงรูปแบบการสตรีมที่ปล่อย reasoning_content เดลต้าแยกจาก content เดลต้า — ซึ่งทำให้สามารถนำเสนอสตรีม “ความคิด” ที่มนุษย์สามารถอ่านได้ในขณะที่กำลังเรียบเรียงคำตอบสุดท้าย หมายเหตุ: แนะนำให้ใช้สตรีมสำหรับการติดตามการใช้เหตุผลขนาดใหญ่ เนื่องจากขนาดของการตอบสนองจะใหญ่ขึ้น

cURL — ขั้นแรก การแชทเสร็จสิ้นขั้นต่ำ：

curl -X POST "https://api.cometapi.com/v1/chat/completions" \
  -H "Authorization: Bearer $cometapi_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k2-thinking",
    "messages": [
      {"role":"system","content":"You are a careful reasoning assistant. Show step-by-step reasoning."},
      {"role":"user","content":"Outline a 5-step experiment to validate a micro-SaaS idea with $200 budget."}
    ],
    "temperature": 0.2,
    "max_tokens": 2048,
    "stream": false
  }'

นี่กลับมา content และ (สำหรับแบบจำลองการคิด) reasoning_content ฟิลด์ที่คุณสามารถจัดเก็บหรือสตรีมได้

พารามิเตอร์ที่แนะนำสำหรับโหมดการคิด

ด้านล่างนี้คือพารามิเตอร์เริ่มต้นที่แนะนำสำหรับงานการใช้เหตุผลแบบหลายขั้นตอน ปรับแต่งตามงานของคุณ:

• model: เลือกตัวแปร K2 Thinking (moonshotai/Kimi-K2-Thinking or kimi-k2-thinking-turbo) — ครอบครัว “คิด” เปิดเผย reasoning_content.
• การ์ดโมเดล Kimi-K2-Thinking แนะนำ temperature = 1.0 เป็นเกณฑ์มาตรฐานที่แนะนำสำหรับการสำรวจที่เข้มข้นยิ่งขึ้นในระหว่างการคิด ใช้อุณหภูมิที่สูงขึ้นสำหรับการใช้เหตุผลเชิงสำรวจ และอุณหภูมิที่ต่ำลงสำหรับงานที่ต้องการความแม่นยำ
• โทเค็นสูงสุด / บริบท: แบบจำลองการคิดสามารถสร้างร่องรอยภายในขนาดใหญ่ได้ max_tokens สูงพอและชอบสตรีมมิ่ง
• สตรีมมิ่ง: เปิดใช้งานการสตรีม (stream=True) เพื่อแสดงทั้งเหตุผลและเนื้อหาขั้นสุดท้ายอย่างก้าวหน้า
• โครงร่างเครื่องมือ: รวมถึง a tools/functions อาร์เรย์ที่อธิบายฟังก์ชันที่มีอยู่ K2 จะตัดสินใจโดยอัตโนมัติว่าจะเรียกใช้ฟังก์ชันเหล่านั้นเมื่อใด ให้ข้อมูลที่ชัดเจน description และรูปแบบ JSON ที่เข้มงวดสำหรับอาร์กิวเมนต์เพื่อหลีกเลี่ยงการเรียกที่ไม่ชัดเจน

ฉันจะเปิดใช้งานและใช้เครื่องมือการเรียกด้วย K2 Thinking ได้อย่างไร

รวมถึง tools อาร์เรย์ในเนื้อหาคำขอ เครื่องมือแต่ละอย่างมีคำอธิบายดังนี้:

• name: สตริง ตัวระบุเครื่องมือที่ไม่ซ้ำกัน
• description: คำอธิบายสั้น ๆ สำหรับโมเดล
• parameters:รูปแบบ JSON ที่ให้รายละเอียดอาร์กิวเมนต์ที่คาดหวัง

เมื่อโมเดลตัดสินใจเรียกใช้เครื่องมือ มันจะส่งออบเจ็กต์การเรียกใช้เครื่องมือ (ซึ่งมักจะเป็นโทเค็นแบบมีโครงสร้าง) รันไทม์ของคุณจะต้องรันเครื่องมือนั้น (ฝั่งเซิร์ฟเวอร์) บันทึกผลลัพธ์ และป้อนกลับเป็นข้อความตอบกลับของเครื่องมือ เพื่อให้โมเดลสามารถดำเนินการคิดเหตุผลต่อไปได้

คำแนะนำทีละขั้นตอน

K2 Thinking รองรับรูปแบบฟังก์ชัน/เครื่องมือที่คล้ายกับการเรียกใช้ฟังก์ชันของ OpenAI แต่มีการรองรับการวนซ้ำอย่างชัดเจนจนกว่าโมเดลจะเสร็จสิ้น (อาจร้องขอการเรียกใช้เครื่องมือหลายครั้ง) รูปแบบมีดังนี้:

1. กำหนดโครงร่างเครื่องมือ (ชื่อ, คำอธิบาย, โครงร่าง JSON ของพารามิเตอร์)
2. ส่ง tools จนกระทั่งการสนทนาเสร็จสิ้น
3. ในแต่ละคำตอบที่มี tool_callsดำเนินการเครื่องมือตามที่ร้องขอและผนวกเอาท์พุตของเครื่องมือกลับเข้าไปในข้อความเป็น role: "tool".
4. ทำซ้ำจนกว่าโมเดลจะคืนความสมบูรณ์แบบปกติ

เปิดใช้งานการเรียกใช้เครื่องมือ (รูปแบบตัวอย่าง)

เมื่อคุณต้องการให้โมเดลเรียกเครื่องมือ ให้ระบุโครงร่างเครื่องมือในคำขอ เช่น web_search, code_executorรวมไว้ในการร้องขอและแนะนำโมเดลถึงวิธีใช้งาน

{
  "model": "kimi-k2-thinking",
  "messages": [{"role":"system","content":"You can call available tools when needed. Return a JSON tool call when you want to invoke external code."},
               {"role":"user","content":"Find the latest CPU microarchitecture benchmarks for RISC-V and summarize differences."}],
  "tools": [
    {
      "name": "web_search",
      "description": "Performs a web query and returns top results as JSON",
      "input_schema": {"type":"object","properties":{"q":{"type":"string"}}}
    }
  ],
  "temperature": 0.1
}

นางแบบอาจตอบกลับด้วย tool_call วัตถุที่รันไทม์ตัวแทนของคุณต้องตรวจจับและกำหนดเส้นทางไปยังเครื่องมือที่ลงทะเบียน

รูปแบบนี้รองรับลำดับที่ลึกตามอำเภอใจของ tool-invoke → tool-run → model-continue ซึ่งเป็นสาเหตุที่ Kimi K2 Thinking เน้นย้ำถึงความเสถียรมากกว่าการเรียกแบบต่อเนื่องหลายๆ แบบในการออกแบบ

Kimi K2 Thinking API มีค่าใช้จ่ายเท่าไร?

รายชื่อแพลตฟอร์ม Moonshot (Kimi) อย่างเป็นทางการ จุดสิ้นสุดราคาหลักสองจุด สำหรับ Kimi K2 ความคิด:

• คิมิ-เคทู-คิด (มาตรฐาน) - โทเค็นอินพุต: 0.60 เหรียญสหรัฐ/1 ล้าน (ระดับแคชมิส) และ 0.15 เหรียญสหรัฐ/1 ล้าน (ระดับการเข้าถึงแคช); โทเค็นเอาท์พุต: 2.50 เหรียญสหรัฐ/1 ล้าน.
• คิมิ-เคทู-คิดกิ้ง-เทอร์โบ (ความเร็วสูง) — ระดับความหน่วง/ปริมาณงานที่สูงขึ้น: อินพุต: 1.15 เหรียญสหรัฐ/1 ล้าน; เอาท์พุต: 8.00 เหรียญสหรัฐ/1 ล้าน (หน้าแพลตฟอร์ม/พันธมิตร ทำซ้ำขั้นตอนนี้)

โคเมทเอพีไอ มีข้อได้เปรียบในด้านราคา เช่น อัตราการอินพุตต่ำมากและอัตราโทเค็นต่อเอาต์พุตต่ำกว่ารุ่นไฮเอนด์ที่เปรียบเทียบได้ — รวมถึงโทเค็นทดลองใช้งานฟรีสำหรับการออนบอร์ด:

การพิจารณาต้นทุน

• บริบทยาว (โทเค็น 128K–256K) และโซ่การเรียกเครื่องมือที่กว้างขวางทำให้การใช้โทเค็นทวีคูณ ดังนั้นจึงควรออกแบบคำเตือนและการโต้ตอบของเครื่องมือเพื่อลดขั้นตอนกลางที่ยืดยาวเมื่อต้นทุนมีความสำคัญ
• การรันโฟลว์แบบเอเจนต์ที่ให้ผลลัพธ์ของเครื่องมือจำนวนมากอาจเพิ่มบิลโทเค็นเอาต์พุตมากกว่าการแชทแบบรอบเดียวทั่วไป ควรติดตามและจัดงบประมาณให้เหมาะสม

การเปรียบเทียบเกณฑ์มาตรฐาน: Kimi K2 Thinking เทียบกับ GPT-5 เทียบกับ Claude Sonnet 4.5

เกณฑ์มาตรฐานที่แนบมาแสดงให้เห็นภาพที่มีความละเอียดอ่อน: K2 Thinking ประสิทธิภาพเหนือกว่า GPT-5 และ Claude Sonnet 4.5 ของ Anthropic ในหลาย ๆ เปิดใช้งานเครื่องมือ และเกณฑ์มาตรฐานของตัวแทน (ตัวอย่างเช่น BrowseComp และตัวแปร HLE ที่เปิดใช้งานด้วยเครื่องมือ) ในขณะที่ GPT-5 ยังคงแข็งแกร่งกว่าในเกณฑ์มาตรฐานเฉพาะข้อความหรือทางการแพทย์บางอย่าง (เช่น HealthBench ในรายงานการทำงานของ Moonshot)

Takeaway: คิมิ เคทู การคิดเป็นการแข่งขัน ตัวแทน แบบจำลอง — โดดเด่นในงานการให้เหตุผลที่ได้ประโยชน์จากการสลับเครื่องมือและบริบทยาวๆ ไม่ได้เหนือกว่า GPT-5 อย่างสม่ำเสมอ คล็อด ซอนเนต์ 4.5 ในเกณฑ์มาตรฐานทุกๆ ครั้ง (โดยเฉพาะอย่างยิ่งงานเฉพาะทางหรืองานที่ต้องใช้ความรู้มาก) แต่ในการทดสอบตัวแทน/การสืบค้น/ขอบเขตเวลาอันยาวไกลหลายๆ ครั้ง ก็ให้รายงานผลลัพธ์ชั้นนำ อย่างไรก็ตาม ต้นทุนการโทรที่ต่ำและลักษณะโอเพนซอร์สของ Kimi k2 ทำให้เป็นราชาแห่งประสิทธิภาพด้านต้นทุนที่แท้จริง

เมื่อใดควรเลือก Kimi K2 Thinking เทียบกับรุ่นอื่น

• เลือก Kimi K2 Thinking เมื่องานของคุณต้องใช้การใช้เหตุผลแบบต่อเนื่องยาวนาน การเรียกใช้เครื่องมือจำนวนมาก หรือการวิเคราะห์เชิงลึกในบริบทที่ใหญ่โต (ฐานโค้ด เอกสารยาวๆ)
• เลือก GPT-5 เมื่อคุณต้องการการบูรณาการหลายโหมดที่แน่นหนาที่สุด การรองรับระบบนิเวศของบุคคลที่สามที่กว้างขวาง หรือเครื่องมือ OpenAI และกรอบงานตัวแทนเฉพาะ
• เลือก Claude Sonnet 4.5 สำหรับเวิร์กโหลดที่เน้นความแม่นยำในการแก้ไขโค้ด เวิร์กโฟลว์การแก้ไขแบบกำหนดได้ และชุดเครื่องมือความปลอดภัยของ Anthropic

ปฏิบัติที่ดีที่สุด

• การใช้เหตุผลแบบสตรีม: สำหรับแอปที่ผู้ใช้เห็น ให้แสดง UI แบบ "คิด" โดยใช้การสตรีม reasoning_contentการสตรีมช่วยลดความล่าช้าและหลีกเลี่ยงเพย์โหลดขนาดใหญ่ ()
• เครื่องมือที่ให้ความสำคัญกับ Schema เป็นหลัก: กำหนดโครงร่าง JSON ที่รัดกุมสำหรับเครื่องมือเพื่อลดการเรียกที่คลุมเครือและข้อผิดพลาดในการแยกวิเคราะห์
• การใช้บริบทจุดตรวจสอบ: เก็บร่องรอยการใช้เหตุผลในอดีตไว้ในที่เก็บข้อมูลหน่วยความจำระยะยาวแยกต่างหาก แทนที่จะฝังประวัติร่องรอยจำนวนมหาศาลไว้ในคำเตือนที่ใช้งานอยู่ ใช้การดึงข้อมูลเพื่อนำเฉพาะส่วนที่เกี่ยวข้องกลับมาใช้ใหม่เท่านั้น
• การติดตามและราวกันตก: บันทึกทั้งสอง reasoning_content และสุดท้าย content เพื่อวินิจฉัยอาการล่องลอย อาการประสาทหลอน และการใช้ในทางที่ผิด พิจารณาการแก้ไขหรือความยินยอมของผู้ใช้ ขึ้นอยู่กับความละเอียดอ่อน

สรุป

Kimi K2 Thinking คือวิวัฒนาการครั้งสำคัญของสายผลิตภัณฑ์ K2 ที่มุ่งสู่การเป็นเอเจนซี่ที่แข็งแกร่งและครอบคลุมระยะยาว API นี้ได้รับการออกแบบให้เข้ากันได้กับรูปแบบไคลเอนต์ OpenAI/Anthropic และมอบแนวทางที่ใช้งานได้จริงสำหรับการผสานรวมการใช้เหตุผลเชิงเอเจนต์เข้ากับแอปพลิเคชัน พร้อมกับให้นักพัฒนาสามารถควบคุมพื้นผิวการเรียกใช้เครื่องมือได้

หากคุณต้องการทดลองใช้แบบรวดเร็ว ให้ใช้ คิมิ K2 Thinking API และเริ่มใช้งาน! เริ่มต้นด้วยการสำรวจความสามารถของโมเดลใน สนามเด็กเล่น และปรึกษา คู่มือ API สำหรับคำแนะนำโดยละเอียด ก่อนเข้าใช้งาน โปรดตรวจสอบให้แน่ใจว่าคุณได้เข้าสู่ระบบ CometAPI และได้รับรหัส API แล้ว โคเมทเอพีไอ เสนอราคาที่ต่ำกว่าราคาอย่างเป็นทางการมากเพื่อช่วยคุณบูรณาการ

พร้อมไปหรือยัง?→ ลงทะเบียน CometAPI วันนี้ !

หากคุณต้องการทราบเคล็ดลับ คำแนะนำ และข่าวสารเกี่ยวกับ AI เพิ่มเติม โปรดติดตามเราที่ VK, X และ ไม่ลงรอยกัน!