Chat Completion API: วิธีทำงานและวิธีใช้งาน

สำรวจการทำงานของ Chat Completion API เรียนรู้การผสานรวมกับ Python ทำความเข้าใจพารามิเตอร์สำคัญ การสตรีม และการเรียกใช้เครื่องมือ พร้อมดูว่าแพลตฟอร์มที่เข้ากันได้กับ OpenAI อย่าง Kimi API ช่วยสนับสนุนการพัฒนาแอปพลิเคชัน AI ที่ยืดหยุ่นได้อย่างไร

9 นาทีในการอ่านอัปเดตแล้ว: 2026-11-14
ลองใช้ Kimi API
เวิร์กโฟลว์คำขอและการตอบกลับของ Chat Completion API

ไม่ว่าคุณจะกำลังสร้างแชตบอต AI หรือเพิ่มฟีเจอร์การสนทนาให้แอปพลิเคชัน การทำความเข้าใจว่า AI จัดการการสนทนาอย่างไรเป็นสิ่งสำคัญ Chat Completion API ช่วยให้ทำสิ่งนี้ได้ โดยเชื่อมแอปพลิเคชันเข้ากับโมเดล AI เพื่อสร้างคำตอบที่เกี่ยวข้องและเป็นธรรมชาติคล้ายมนุษย์ ด้วยฟีเจอร์ต่าง ๆ เช่น การผสานรวมกับ Python การสตรีม และการเรียกใช้เครื่องมือ นักพัฒนาจึงสร้างแอปพลิเคชันที่โต้ตอบได้มากขึ้น มาดูกันว่าระบบนี้ทำงานอย่างไร ใช้งานอย่างไร และผู้ให้บริการอย่าง Kimi API รองรับการพัฒนา AI ที่ยืดหยุ่นอย่างไร

Chat Completions API คืออะไร

Chat Completions API คืออินเทอร์เฟซที่ช่วยให้แอปพลิเคชันส่งลำดับข้อความไปยังโมเดล AI และรับคำตอบจากผู้ช่วย รองรับทั้งการสนทนาแบบรอบเดียวและหลายรอบ ตัวอย่างเช่น คุณสามารถใช้ Kimi K3.1 Pro ตอบคำถามเกี่ยวกับ Python decorators แล้วถามคำถามต่อเนื่องได้ดังนี้:

  • คำขอแรก: ส่งข้อความจากผู้ใช้ว่า "Python decorator คืออะไร" จากนั้น Kimi จะส่งข้อความจากผู้ช่วยที่อธิบายแนวคิดนี้กลับมา

  • คำขอที่สอง: หากต้องการสนทนาต่อ ให้ส่งข้อความก่อนหน้าจากผู้ใช้ ข้อความจากผู้ช่วยฉบับสมบูรณ์ของ Kimi และข้อความใหม่จากผู้ใช้ว่า "ช่วยยกตัวอย่างได้ไหม"

อาร์เรย์ messages ส่งบริบทที่จำเป็นสำหรับแต่ละคำขอ การตัดสินใจด้านการออกแบบที่สำคัญ 3 ประการทำให้อินเทอร์เฟซนี้ได้รับการใช้งานอย่างแพร่หลาย:

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

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

  • ความสามารถที่ยืดหยุ่น: อินเทอร์เฟซนี้สามารถรองรับการสตรีม การเรียกใช้เครื่องมือ ข้อมูลนำเข้าแบบภาพ และผลลัพธ์แบบมีโครงสร้างได้ ขึ้นอยู่กับการรองรับของโมเดล Kimi K3.1 Pro รองรับความสามารถเหล่านี้

วิธีใช้ Chat Completions API กับ Kimi

ตัวอย่างต่อไปนี้ใช้ Kimi K3.1 Pro และ OpenAI Python SDK เพื่อแสดงวิธีตั้งค่าไคลเอ็นต์ ส่งคำขอ จัดการคำตอบ และใช้การเรียกใช้เครื่องมือ:

เริ่มต้นอย่างรวดเร็ว: เรียกใช้ Kimi ด้วย OpenAI Python SDK

ติดตั้ง OpenAI Python SDK:

pip install --upgrade openai

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

export MOONSHOT_API_KEY="sk-your-kimi-key"

คุณไม่จำเป็นต้องมีคีย์ OpenAI API โดย OpenAI Python SDK ทำหน้าที่เป็นไลบรารีไคลเอ็นต์ ขณะที่คีย์ Kimi API และ URL ฐานของคุณใช้ยืนยันตัวตนและกำหนดเส้นทางคำขอไปยัง Kimi

เริ่มต้นไคลเอ็นต์และส่งคำขอแรกของคุณ:

import os from openai import OpenAI client = OpenAI( api_key=os.environ["MOONSHOT_API_KEY"], base_url="https://api.moonshot.ai/v1", ) resp = client.chat.completions.create( model="kimi-k3.1-pro", messages=[ {"role": "user", "content": "Explain REST in one paragraph."} ], ) print(resp.choices[0].message.content)

ตัวอย่างนี้ใช้เอ็นด์พอยต์ API ระหว่างประเทศของ Kimi สำหรับการตั้งค่าอย่างเป็นทางการและรายละเอียดโมเดล โปรดดู คู่มือเริ่มต้นอย่างรวดเร็ว Kimi K3.1 Pro

พารามิเตอร์หลัก

พารามิเตอร์เหล่านี้ครอบคลุมตัวเลือกหลักที่ใช้ได้เมื่อเรียก Kimi K3.1 Pro ผ่าน Chat Completions API:

พารามิเตอร์วัตถุประสงค์
modelระบุ ID ของโมเดล เช่น kimi-k3.1-pro
messagesระบุข้อความในการสนทนา รวมถึงข้อมูลที่ผู้ใช้ป้อนก่อนหน้าและคำตอบจากผู้ช่วย รองรับทั้งเนื้อหาข้อความและมัลติโหมด
reasoning_effortควบคุมระดับความลึกของการให้เหตุผล รับค่า low, high หรือ max (ค่าเริ่มต้น)
max_completion_tokensกำหนดงบประมาณการสร้างสูงสุด ซึ่งรวมทั้ง token สำหรับการให้เหตุผลและ token สำหรับคำตอบสุดท้าย token ของอินพุตจะนับแยกต่างหาก แต่ token ของอินพุตและ token ที่สร้างรวมกันต้องอยู่ภายในหน้าต่างบริบทของโมเดล
streamตั้งค่าเป็น true เพื่อรับการตอบกลับแบบทยอยส่ง แทนที่จะรอผลลัพธ์ทั้งหมด
toolsกำหนดฟังก์ชันที่โมเดลสามารถขอให้แอปพลิเคชันดำเนินการได้
response_formatควบคุมรูปแบบเอาต์พุต รองรับ json_object สำหรับโหมด JSON และ json_schema สำหรับเอาต์พุตแบบมีโครงสร้างที่จำกัดด้วยสคีมา

หมายเหตุ: Kimi K3.1 Pro ใช้การตั้งค่าการสุ่มตัวอย่างแบบคงที่ อย่าเพิ่ม temperature หรือ top_p ในคำขอ ดูรายละเอียดพารามิเตอร์และค่าที่รองรับได้ที่เอกสารอ้างอิง Chat Completions API

การอ่านคำตอบ

หลังจากส่งคำขอสำเร็จ คุณสามารถเข้าถึงฟิลด์คำตอบหลักผ่านออบเจ็กต์ completion ที่ส่งกลับมาได้:

  • choices[0].message – มีคำตอบของผู้ช่วย รวมถึง content หรือ tool_calls เมื่อโมเดลขอเรียกใช้ฟังก์ชัน

  • choices[0].finish_reason – ระบุเหตุผลที่การสร้างผลลัพธ์หยุดลง เช่น stop, length หรือ tool_calls

  • usage – ให้ข้อมูลการใช้ token รวมถึงจำนวน token ของข้อมูลนำเข้า ผลลัพธ์ และ token ที่แคชไว้เมื่อมีข้อมูล

สำหรับคำตอบข้อความพื้นฐาน ให้อ่าน choices[0].message.content หากโมเดลส่งกลับ tool_calls แอปพลิเคชันของคุณต้องเรียกใช้ฟังก์ชันที่ร้องขอ และส่งผลลัพธ์ของฟังก์ชันเหล่านั้นในคำขอถัดไป

ตัวอย่างการสตรีม

ตั้งค่า stream=True เพื่อรับคำตอบจาก Kimi เป็นส่วนย่อยแบบต่อเนื่อง ตัวอย่างต่อไปนี้ใช้ client ที่ตั้งค่าไว้ข้างต้นซ้ำ และพิมพ์คำตอบสุดท้ายออกมาทันทีที่ได้รับ:

stream = client.chat.completions.create( model="kimi-k3.1-pro", messages=[ {"role": "user", "content": "Write a haiku about autumn."} ], stream=True, ) for chunk in stream: if not chunk.choices: continue delta = chunk.choices[0].delta if delta.content: print(delta.content, end="", flush=True)

Kimi K3.1 Pro ส่งเนื้อหาการให้เหตุผลแยกจากคำตอบสุดท้าย ตัวอย่างนี้พิมพ์เฉพาะ delta.content จึงแสดงคำตอบสุดท้ายโดยไม่ประมวลผลฟิลด์ reasoning_content ที่แยกต่างหาก

สรุปการเรียกใช้เครื่องมือ

การเรียกใช้เครื่องมือช่วยให้ Kimi สามารถร้องขอฟังก์ชันภายนอกได้ เมื่องานต้องใช้ข้อมูลหรือการดำเนินการที่เกินกว่าคำตอบของโมเดลเอง ตัวอย่างเช่น หากผู้ใช้ถามว่า "วันนี้ควรพกร่มไปโตเกียวไหม" Kimi สามารถร้องขอฟังก์ชัน get_weather เพื่อดึงข้อมูลพยากรณ์อากาศได้

เวิร์กโฟลว์มี 3 ขั้นตอน:

  1. ประกาศฟังก์ชัน: กำหนด get_weather และอาร์กิวเมนต์ที่คาดว่าจะใช้ภายใต้พารามิเตอร์ tools

  2. เรียกใช้เครื่องมือ: Kimi จะส่งรายการ tool_calls ที่มีชื่อฟังก์ชันและอาร์กิวเมนต์ แอปพลิเคชันของคุณจะเรียกใช้ฟังก์ชันที่เกี่ยวข้องและดึงข้อมูลสภาพอากาศ

  3. ส่งผลลัพธ์กลับ: เพิ่มข้อความ assistant แบบสมบูรณ์ของ Kimi และผลลัพธ์จากเครื่องมือ (โดยใช้ tool_call_id ที่ตรงกัน) ลงในการสนทนา จากนั้นเรียก Kimi อีกครั้งเพื่อสร้างคำตอบสำหรับผู้ใช้

ตัวอย่างต่อไปนี้ใช้ client ที่ตั้งค่าไว้ข้างต้นซ้ำ ก่อนเรียกใช้ โปรดตรวจสอบว่าคุณได้ติดตั้งฟังก์ชัน get_weather(city) ซึ่งส่งคืนข้อมูลสภาพอากาศที่แปลงเป็น JSON ได้แล้ว ฟังก์ชันนี้จะถูกเรียกใช้โดยแอปพลิเคชันของคุณ ไม่ใช่โดย Kimi

import json tools = [ { "type": "function", "function": { "name": "get_weather", "description": "Get the weather forecast for a city.", "parameters": { "type": "object", "properties": { "city": {"type": "string"} }, "required": ["city"] } } } ] messages = [ {"role": "user", "content": "Should I bring an umbrella in Tokyo today?"} ] # Ask Kimi whether it needs to call a tool resp = client.chat.completions.create( model="kimi-k3.1-pro", messages=messages, tools=tools, ) assistant_message = resp.choices[0].message # Preserve the complete assistant message, including tool_calls messages.append(assistant_message) # Execute the requested function in your application for tool_call in assistant_message.tool_calls or []: if tool_call.function.name == "get_weather": args = json.loads(tool_call.function.arguments) # Call your own weather service or API weather_result = get_weather(city=args["city"]) messages.append({ "role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(weather_result) }) # Let Kimi interpret the tool result and answer the user final_resp = client.chat.completions.create( model="kimi-k3.1-pro", messages=messages, tools=tools, ) print(final_resp.choices[0].message.content)

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

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

เหตุใดความ "เข้ากันได้กับ OpenAI" จึงสำคัญเมื่อเลือกผู้ให้บริการ

ผู้ให้บริการหลายรายรองรับรูปแบบ OpenAI Chat Completions ซึ่งช่วยให้นักพัฒนานำ SDK และโครงสร้างคำขอที่คุ้นเคยกลับมาใช้ได้ การเปลี่ยนผู้ให้บริการโดยทั่วไปทำได้ด้วยการอัปเดต base URL, API key และรหัสโมเดล แล้วตรวจสอบพารามิเตอร์ที่รองรับและการจัดการการตอบกลับ เมื่อเปรียบเทียบผู้ให้บริการ ให้พิจารณาปัจจัยต่อไปนี้:

  1. ความสอดคล้องในการรองรับ: ตรวจสอบว่าการสตรีม การเรียกใช้เครื่องมือ เอาต์พุตแบบมีโครงสร้าง และการรายงาน usage ทำงานตามที่แอปพลิเคชันของคุณคาดหวัง การรองรับรูปแบบ API เดียวกันไม่ได้รับประกันว่าผู้ให้บริการทุกรายจะรองรับฟีเจอร์หรือมีพฤติกรรมการตอบกลับเหมือนกัน

  2. คุณภาพโมเดลสำหรับภาระงานของคุณ: สัดส่วนภาษาที่ใช้และประเภทงานของคุณสำคัญกว่าเกณฑ์วัดทั่วไป

  3. หน้าต่างบริบท: โมเดลที่รองรับบริบทยาวช่วยให้เวิร์กโฟลว์เอกสารบางประเภทง่ายขึ้นได้ ด้วยการประมวลผลเนื้อหาต้นทางได้มากขึ้นในคำขอเดียว

  4. โครงสร้างต้นทุน: ส่วนลดจากการแคชและการประมวลผลแบบแบตช์มักมีผลมากกว่าราคาต่อ token ที่ระบุไว้

  5. ขอบเขตของระบบนิเวศ: เอ็นด์พอยต์ที่เข้ากันได้เพิ่มเติม เช่น Responses และ Anthropic Messages ช่วยเพิ่มทางเลือกในการผสานรวมและความยืดหยุ่นเมื่อแอปพลิเคชันของคุณพัฒนาไป

Kimi API: ผู้ให้บริการที่เข้ากันได้กับ OpenAI ซึ่งโดดเด่น

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

ใช้แทนได้ทันที

หากแอปพลิเคชันของคุณใช้ OpenAI Python SDK อยู่แล้ว คุณสามารถผสาน Kimi ได้โดยไม่ต้องเขียนเวิร์กโฟลว์คำขอทั้งหมดใหม่ เพียงอัปเดตการตั้งค่า API ซึ่งรวมถึง base_url, api_key และรหัสโมเดล โดยยังคงใช้อินเทอร์เฟซ Chat Completions ที่คุ้นเคย

ตัวอย่างเช่น โค้ดต่อไปนี้อ่านรายงานในเครื่องจาก report.txt ส่งเนื้อหาไปให้ Kimi K3.1 Pro สรุป และสตรีมคำตอบที่สร้างขึ้น:

from pathlib import Path report_text = Path("report.txt").read_text(encoding="utf-8") resp = client.chat.completions.create( model="kimi-k3.1-pro", messages=[ { "role": "user", "content": f"Summarize the following report:\n\n{report_text}" } ], stream=True, ) for chunk in resp: if not chunk.choices: continue content = chunk.choices[0].delta.content if content: print(content, end="", flush=True)

ในที่นี้ client ใช้ Kimi client ที่เริ่มต้นไว้ก่อนหน้า โดยอ่าน API key ของคุณจากตัวแปรสภาพแวดล้อม เลือก base URL ให้ตรงกับภูมิภาคของคุณ: https://api.moonshot.ai/v1 สำหรับแพลตฟอร์มระหว่างประเทศ หรือ https://api.moonshot.cn/v1 สำหรับผู้ใช้ที่เข้าถึง API ในจีนแผ่นดินใหญ่

แนวทางนี้ช่วยให้คุณคงเวิร์กโฟลว์ OpenAI SDK เดิมไว้ได้ ขณะใช้โมเดล Kimi สำหรับงานต่าง ๆ เช่น การสรุปเอกสารและแอปพลิเคชันอื่น ๆ ที่ขับเคลื่อนด้วย API

จุดที่ Kimi แตกต่าง

  • โมเดลเรือธงที่มีหน้าต่างบริบท 1M-token: Kimi K3.1 Pro รองรับหน้าต่างบริบทสูงสุด 1M token และความเข้าใจภาพโดยตรง นักพัฒนาสามารถทำงานกับโค้ดเบสขนาดใหญ่ เอกสารยาวระดับหนังสือ และอินพุตภาพได้ในเวิร์กโฟลว์เดียว จึงเหมาะกับการให้เหตุผลที่ซับซ้อน การเขียนโค้ด และแอปพลิเคชันมัลติโมดัล

  • การเพิ่มประสิทธิภาพต้นทุนที่ยืดหยุ่น: Kimi API รองรับการแคชบริบทอัตโนมัติสำหรับคำนำหน้าคำขอที่ใช้ซ้ำ และการอนุมานผ่าน Batch API สำหรับงานขนาดใหญ่ที่ไม่ต้องการการตอบกลับแบบเรียลไทม์ ค่าบริการแคชและราคา Batch ขึ้นอยู่กับโมเดลและกฎการกำหนดราคาที่เกี่ยวข้อง ดูอัตราปัจจุบันและรายละเอียดการเรียกเก็บเงินได้ที่ราคา Kimi API อย่างเป็นทางการ

  • ความเข้ากันได้ครอบคลุมระบบนิเวศ API: Kimi มีเอ็นด์พอยต์ Chat Completions และ Responses API ที่เข้ากันได้กับ OpenAI รวมถึงเอ็นด์พอยต์ที่เข้ากันได้กับ Anthropic Messages นักพัฒนาสามารถผสาน Kimi K3.1 Pro เข้ากับเวิร์กโฟลว์เดิมโดยใช้ SDK และรูปแบบ API ที่คุ้นเคย โดยปรับตามเอ็นด์พอยต์และฟีเจอร์ที่รองรับ

บทสรุป

เริ่มต้นใช้งาน Chat Completions API ได้ง่าย ๆ เพียงตั้งค่าข้อมูลรับรอง API ส่งคำขอ แล้วอ่านข้อความตอบกลับที่สร้างขึ้นจาก choices[0].message.content เมื่อเรียก API ครั้งแรกได้สำเร็จ คุณก็ขยายการเชื่อมต่อให้ตรงกับความต้องการของแอปพลิเคชันได้ โดยเพิ่มการสนทนาหลายรอบ การสตรีมการตอบกลับ หรือการเรียกใช้เครื่องมือ พร้อมสร้างด้วย Kimi แล้วหรือยัง? รับคีย์ Kimi API แล้วเริ่มส่งคำขอ API ได้เลย

ลองใช้ Kimi API

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

ไม่ใช่ Chat Completions API ไม่ได้จำกัดเฉพาะโมเดลของ OpenAI ผู้ให้บริการ AI รายอื่น รวมถึง Kimi ก็มี API ที่ใช้รูปแบบ Chat Completions ซึ่งเข้ากันได้กับ OpenAI ด้วยเช่นกัน ซึ่งช่วยให้นักพัฒนานำ SDK และโครงสร้างคำขอที่คุ้นเคยมาใช้ซ้ำกับโมเดลที่รองรับจากผู้ให้บริการต่าง ๆ ได้ แม้ว่าการรองรับฟีเจอร์อาจแตกต่างกัน
API ทั้งสองช่วยให้แอปพลิเคชันโต้ตอบกับโมเดล AI ได้ แต่ใช้โครงสร้างคำขอและการตอบกลับต่างกัน Chat Completions ใช้อาร์เรย์ messages และส่งคืนการตอบกลับผ่านอาร์เรย์ choices ส่วน Responses API ใช้โครงสร้างอินพุตและเอาต์พุตที่ยืดหยุ่นกว่า ซึ่งรองรับเนื้อหาหลายประเภทและการโต้ตอบกับเครื่องมือ การจัดการสถานะการสนทนาจะแตกต่างกันไปตามผู้ให้บริการ สำหรับ Responses API ของ Kimi แอปพลิเคชันควรใส่ประวัติการสนทนาที่เกี่ยวข้องในคำขอแต่ละครั้ง แทนที่จะอาศัยการเชื่อมโยงด้วย ID ของการตอบกลับ
หากแอปพลิเคชันของคุณใช้ OpenAI SDK โดยทั่วไปคุณสามารถเปลี่ยนไปใช้ Kimi ได้ด้วยการอัปเดตค่าการกำหนดค่า 3 ค่า ได้แก่ เปลี่ยน base_url เป็นเอ็นด์พอยต์ API ของ Kimi เปลี่ยน api_key เป็นคีย์ Kimi API ของคุณ และเปลี่ยน model เป็น ID โมเดล Kimi ที่รองรับ จากนั้นทดสอบการผสานรวมเพื่อยืนยันว่าระบบรองรับพารามิเตอร์และฟีเจอร์ที่แอปพลิเคชันของคุณใช้ เช่น การสตรีมและการเรียกใช้เครื่องมือ
คุณอาจจะชอบสิ่งเหล่านี้ด้วย
Model API: คู่มือนักพัฒนาสำหรับ Kimi API
Model API: คู่มือนักพัฒนาสำหรับ Kimi API
2026-11-14
API ที่เข้ากันได้กับ OpenAI: คู่มือเชิงปฏิบัติสำหรับนักพัฒนา
API ที่เข้ากันได้กับ OpenAI: คู่มือเชิงปฏิบัติสำหรับนักพัฒนา
2026-11-14
AI API: คืออะไร ทำงานอย่างไร และใช้งานอย่างไร
AI API: คืออะไร ทำงานอย่างไร และใช้งานอย่างไร
2026-11-14
วิธีติดตั้ง Hermes Agent: คู่มือการตั้งค่าสำหรับผู้เริ่มต้น
วิธีติดตั้ง Hermes Agent: คู่มือการตั้งค่าสำหรับผู้เริ่มต้น
2026-11-05
ราคา Kimi K3 | แผน สมาชิก และค่าใช้จ่าย API
ราคา Kimi K3 | แผน สมาชิก และค่าใช้จ่าย API
2026-10-27