Thanawat Wongchai

Posted on Jul 17 • Originally published at apidog.com

วิธีใช้ Kimi K3 API?

Moonshot AI เปิดตัว Kimi K3 เมื่อวันที่ 16 กรกฎาคม 2026 โดยระบุว่าเป็นโมเดล 3T-class แบบเปิดตัวแรกของโลก ใช้สถาปัตยกรรม Mixture-of-Experts (MoE) ขนาด 2.8T พารามิเตอร์ และรองรับ context window สูงสุด 1,048,576 โทเค็น สำหรับนักพัฒนา จุดสำคัญคือ API ของ Kimi K3 ใช้รูปแบบที่เข้ากันได้กับ OpenAI SDK: หากโปรเจกต์ของคุณเรียก GPT หรือ OpenAI-compatible endpoint อยู่แล้ว คุณเพียงเปลี่ยน base_url, api_key และ model="kimi-k3" ก็เริ่มใช้งานได้ บทความนี้จะพาคุณตั้งค่า API key, เรียกใช้งานผ่าน Python, JavaScript และ cURL, เปิดสตรีมมิ่ง, ใช้ tool calling, JSON mode, reasoning_effort, รวมถึงตรวจสอบคำขอและ SSE แบบดิบด้วย Apidog

ลองใช้ Apidog วันนี้

สรุปย่อ (TL;DR)

Model ID บน Kimi คือ kimi-k3
หากเรียกผ่าน OpenRouter ให้ใช้ moonshotai/kimi-k3
API ใช้รูปแบบ OpenAI Chat Completions: ตั้งค่า base_url, api_key และ model
ยืนยัน base URL ที่ใช้กับบัญชีของคุณจาก platform.kimi.ai โดย Kimi เคยใช้ https://api.moonshot.ai/v1
รองรับ context window ขนาด 1M โทเค็น
ราคาที่ระบุคือ:
- cache-hit input: 0.30 ดอลลาร์ / 1M โทเค็น
- cache-miss input: 3.00 ดอลลาร์ / 1M โทเค็น
- output: 15.00 ดอลลาร์ / 1M โทเค็น
รองรับ streaming, tool calling, JSON mode, structured output และ reasoning_effort
สำหรับงานเขียนโค้ดทั่วไปที่มีปริมาณสูง kimi-k2-7-code อาจคุ้มค่ากว่า
ใช้ Apidog เพื่อตรวจสอบ request, response, SSE stream และทดสอบ K3 เทียบกับ K2.7

เลือกโมเดลให้ตรงกับงาน

ก่อนเริ่มเขียนโค้ด ให้แยกงานที่ต้องการออกเป็นสองกลุ่ม:

งาน	โมเดลที่ควรพิจารณา
งาน reasoning ซับซ้อน, agent หลายรอบ, context ขนาดใหญ่, orchestration เครื่องมือ	`kimi-k3`
งานเขียนโค้ดซ้ำ ๆ, CI tests, งานปริมาณมากที่ต้องคุมต้นทุน	`kimi-k2-7-code`

Kimi K3 เป็นโมเดลแนวหน้าของตระกูล Kimi ที่เน้นงานเขียนโค้ดซับซ้อน งาน agentic ระยะยาว และงานความรู้ที่ต้องใช้บริบทขนาดใหญ่ อย่างไรก็ตาม ต้นทุนโทเค็นเอาต์พุตสูงกว่าโมเดลอื่นในกลุ่ม และ โพสต์เปิดตัวของ Moonshot ระบุว่า K3 ยังตามหลัง Claude Fable 5 และ GPT-5.6 Sol ในการเปรียบเทียบภายในบางรายการ

หากคุณต้องการประเมิน K2.7 สำหรับงานที่เน้นต้นทุน ให้ดู:

แนวทางใช้งานที่ตรงไปตรงมาคือ:

เริ่มจาก kimi-k2-7-code สำหรับงาน routine และ throughput สูง
ย้ายงานที่ต้องใช้ context ยาว, reasoning ลึก หรือ agentic tool coordination ไปที่ kimi-k3
ทดสอบ prompt เดียวกันกับทั้งสองโมเดลก่อนตัดสินใจใช้งานจริง

1. สร้าง API key และตั้งค่า environment

ไปที่ platform.kimi.ai แล้วลงชื่อเข้าใช้ จากนั้นสร้าง API key ใหม่ในส่วน API keys

ขั้นตอนที่ควรทำ:

เปิดหน้า API keys ในคอนโซล
สร้างคีย์ใหม่
คัดลอกคีย์และเก็บไว้ใน secret manager หรือ password manager
ตรวจสอบเครดิตหรือระดับการเรียกเก็บเงิน
จด base URL ที่แสดงในคอนโซลของบัญชีคุณ

Kimi เคยใช้ base URL นี้:

https://api.moonshot.ai/v1

แต่ควรใช้ค่าที่คอนโซลแสดงสำหรับบัญชีของคุณเสมอ

ตั้งค่า environment variables

export KIMI_API_KEY="sk-your-key-here"
export KIMI_BASE_URL="https://api.moonshot.ai/v1"

อย่า hard-code API key ลงใน source code, commit Git หรือ screenshot ของคำขอ API

สำหรับรายละเอียดการคิดราคา cache-hit และ cache-miss ดู คู่มือราคา Kimi K3

2. เรียก `kimi-k3` ครั้งแรก

Kimi K3 ใช้รูปแบบ OpenAI Chat Completions ดังนั้น flow พื้นฐานคือ:

สร้าง OpenAI client
ตั้ง api_key
ตั้ง base_url
เรียก chat.completions.create()
กำหนด model="kimi-k3"

Python

ติดตั้ง SDK ก่อน:

pip install openai

จากนั้นสร้างไฟล์ kimi.py:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["KIMI_API_KEY"],
    # ยืนยัน URL นี้จาก platform.kimi.ai ก่อนใช้งานจริง
    base_url=os.environ["KIMI_BASE_URL"],
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "system",
            "content": "คุณคือผู้ช่วยเขียนโค้ดที่แม่นยำ",
        },
        {
            "role": "user",
            "content": "อธิบายว่า token bucket rate limiter ทำงานอย่างไรในหนึ่งย่อหน้า",
        },
    ],
)

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

รันคำสั่ง:

python kimi.py

JavaScript / TypeScript

ติดตั้ง SDK:

npm install openai

ตัวอย่าง kimi.mjs:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  // ยืนยัน URL นี้จาก platform.kimi.ai ก่อนใช้งานจริง
  baseURL: process.env.KIMI_BASE_URL,
});

const response = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [
    {
      role: "system",
      content: "คุณคือผู้ช่วยเขียนโค้ดที่แม่นยำ",
    },
    {
      role: "user",
      content: "อธิบายว่า token bucket rate limiter ทำงานอย่างไรในหนึ่งย่อหน้า",
    },
  ],
});

console.log(response.choices[0].message.content);

รันด้วย:

node kimi.mjs

cURL

หากต้องการตรวจสอบ request โดยไม่ใช้ SDK ให้เริ่มด้วย cURL:

curl "$KIMI_BASE_URL/chat/completions" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {
        "role": "user",
        "content": "อธิบายว่า token bucket rate limiter ทำงานอย่างไรในหนึ่งย่อหน้า"
      }
    ]
  }'

แก้ปัญหาพื้นฐาน

สถานะ	สาเหตุที่พบบ่อย	สิ่งที่ควรตรวจสอบ
`401 Unauthorized`	API key ไม่ถูกต้อง หรือไม่ได้ตั้งค่า	ตรวจ `KIMI_API_KEY`
`404 Not Found`	base URL หรือ path ไม่ถูกต้อง	ตรวจ `KIMI_BASE_URL` และ `/chat/completions`
ถูกปฏิเสธเพราะเครดิตไม่พอ	เครดิตหรือ billing ไม่พร้อม	ตรวจหน้า billing ในคอนโซล
SDK ปฏิเสธพารามิเตอร์ใหม่	SDK ยังไม่รู้จักฟิลด์นั้น	ใช้ `extra_body`

ดูตัวเลือกของไคลเอนต์เพิ่มเติมได้จาก OpenAI Python SDK

3. รับคำตอบแบบสตรีมมิ่ง

สำหรับ chat UI หรือ agent ที่ตอบยาว ควรเปิด streaming เพื่อแสดง token ทันทีที่มาถึง แทนการรอ response ทั้งก้อน

Python streaming

stream = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "เขียนบทกวี 6 บรรทัดเกี่ยวกับ flaky tests",
        }
    ],
    stream=True,
)

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

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

เบื้องหลัง SDK จะอ่าน Server-Sent Events (SSE) ซึ่งมีลักษณะคล้าย:

data: {"choices":[{"delta":{"content":"..."}}]}

data: [DONE]

JavaScript streaming

const stream = await client.chat.completions.create({
  model: "kimi-k3",
  messages: [
    {
      role: "user",
      content: "เขียนบทกวี 6 บรรทัดเกี่ยวกับ flaky tests",
    },
  ],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

เมื่อ streaming มีปัญหา อย่าดูเฉพาะผลลัพธ์จาก SDK เพราะ SDK ซ่อนรายละเอียด SSE ไว้ การดูเฟรม data: แบบดิบจะช่วยแยกได้ว่าเกิดปัญหาที่ client, network หรือ endpoint

4. ใช้ tool calling กับ Kimi K3

Kimi K3 รองรับ function calling, การกำหนด tool choice และการโหลดเครื่องมือแบบไดนามิก คุณสามารถใช้รูปแบบนี้สร้าง agent ที่:

อ่านไฟล์
เรียก internal API
ค้นหาข้อมูล
รันคำสั่ง
ตรวจสถานะ deployment
ดึงข้อมูลจากฐานข้อมูล

โมเดลจะ ไม่รันฟังก์ชันแทนคุณ แต่จะส่งชื่อฟังก์ชันและ JSON arguments กลับมา จากนั้นแอปของคุณต้องเป็นผู้รัน tool และส่งผลลัพธ์กลับไป

ขั้นที่ 1: ประกาศ tool

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "รับสภาพอากาศปัจจุบันสำหรับเมืองใดเมืองหนึ่ง",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "ชื่อเมือง เช่น สิงคโปร์",
                    },
                },
                "required": ["city"],
            },
        },
    }
]

messages = [
    {
        "role": "user",
        "content": "ตอนนี้สภาพอากาศในสิงคโปร์เป็นอย่างไร?",
    }
]

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

tool_call = first.choices[0].message.tool_calls[0]

print(tool_call.function.name)
print(tool_call.function.arguments)

ตัวอย่างผลลัพธ์:

get_weather
{"city":"Singapore"}

ขั้นที่ 2: รัน tool ในแอปของคุณ

ในตัวอย่างนี้ เราจำลองผลลัพธ์จาก weather service:

import json

weather_result = {
    "city": "Singapore",
    "temp_c": 31,
    "sky": "humid",
}

ขั้นที่ 3: ส่งผลลัพธ์กลับไปให้โมเดล

messages.append(first.choices[0].message)

messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps(weather_result),
})

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

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

ควบคุมการเลือก tool

บังคับให้โมเดลต้องเลือก tool:

tool_choice = "required"

บังคับให้เรียกฟังก์ชันเฉพาะ:

tool_choice = {
    "type": "function",
    "function": {
        "name": "get_weather",
    },
}

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

5. ใช้ JSON mode และ structured output

หาก response จะถูกส่งต่อไปยังระบบอื่น อย่า parse จากข้อความอิสระถ้าไม่จำเป็น ให้ขอ JSON ตั้งแต่ต้น

JSON mode

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "system",
            "content": "ส่งคืนเฉพาะ JSON ที่ถูกต้องเท่านั้น ห้ามใช้ข้อความ ห้ามใช้มาร์กดาวน์",
        },
        {
            "role": "user",
            "content": "ดึงชื่อและบทบาทจาก: 'Ada Lovelace, นักคณิตศาสตร์'.",
        },
    ],
    response_format={"type": "json_object"},
)

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

ตัวอย่างผลลัพธ์:

{
  "name": "Ada Lovelace",
  "role": "นักคณิตศาสตร์"
}

แม้จะใช้ JSON mode ก็ควร parse และ validate response ฝั่งแอปเสมอ:

import json

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

if "name" not in result or "role" not in result:
    raise ValueError("JSON response ไม่มีฟิลด์ที่ต้องการ")

Structured output ด้วย JSON Schema

หาก SDK และบัญชีของคุณรองรับ json_schema ให้กำหนด schema ที่ชัดเจน:

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "ดึงชื่อและบทบาทจาก: 'Ada Lovelace, นักคณิตศาสตร์'.",
        }
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "role": {"type": "string"},
                },
                "required": ["name", "role"],
            },
        },
    },
)

ก่อนนำ json_schema ไปใช้ใน production ให้ตรวจสอบการรองรับจากคอนโซล Kimi สำหรับบัญชีของคุณ หากยังไม่แน่ใจ ใช้ json_object พร้อม validation ฝั่งแอปเป็นทางเลือกที่ปลอดภัยกว่า

Kimi ยังมี partial mode และ web search ซึ่งใช้ได้เมื่อคุณต้องการเติมคำตอบล่วงหน้า หรือทำงานกับข้อมูลล่าสุด

6. ตั้งค่า `reasoning_effort`

Kimi K3 มีพารามิเตอร์ reasoning_effort สำหรับควบคุมระดับความพยายามในการให้เหตุผลก่อนสร้างคำตอบ

ปัจจุบันระดับที่ระบุว่าใช้งานได้คือ:

max

ตัวอย่าง:

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "วางแผนการย้ายข้อมูลจาก REST ไปยัง GraphQL สำหรับ API ที่มี 40 ปลายทาง",
        }
    ],
    reasoning_effort="max",
)

ใช้กับงานที่ต้องการการวางแผนหรือวิเคราะห์เชิงลึก เช่น:

วางแผน migration
วิเคราะห์ dependency ใน monorepo
แตกงาน refactor ขนาดใหญ่
สร้าง rollout plan
ออกแบบ agent workflow

ความพยายามในการให้เหตุผลที่สูงขึ้นอาจเพิ่มจำนวน output tokens และความหน่วงเวลา ดังนั้นไม่ควรใช้กับทุก request โดยอัตโนมัติ

เมื่อ SDK ยังไม่รองรับฟิลด์นี้

หาก OpenAI SDK เวอร์ชันของคุณปฏิเสธ reasoning_effort ให้ส่งผ่าน extra_body:

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {
            "role": "user",
            "content": "วางแผนการย้ายข้อมูลจาก REST ไปยัง GraphQL",
        }
    ],
    extra_body={
        "reasoning_effort": "max",
    },
)

extra_body มีประโยชน์สำหรับฟิลด์เฉพาะผู้ให้บริการที่ endpoint รองรับแล้ว แต่ SDK เวอร์ชันที่คุณติดตั้งยังไม่รู้จัก

7. ลดต้นทุนด้วย context caching

Kimi K3 ระบุราคาต่างกันระหว่าง input ที่ cache-hit และ cache-miss:

ประเภท	ราคา / 1M โทเค็น
Cache-hit input	0.30 ดอลลาร์
Cache-miss input	3.00 ดอลลาร์
Output	15.00 ดอลลาร์

ความแตกต่างของ cache-hit กับ cache-miss คือส่วน prefix ของ request ที่เหมือนกับ request ก่อนหน้า สามารถนำ state ที่คำนวณไว้กลับมาใช้ใหม่ได้

โครงสร้าง prompt ที่ควรใช้

วางข้อมูลคงที่ไว้ด้านหน้าเสมอ:

messages = [
    {
        "role": "system",
        "content": """
คุณคือผู้ช่วยสำหรับ codebase นี้
กฎการตอบ:
- ให้คำตอบกระชับ
- อ้างอิงชื่อไฟล์เมื่อเสนอการแก้ไข
- อย่าสร้าง API ที่ไม่มีอยู่จริง
""",
    },
    {
        "role": "user",
        "content": "ตรวจสอบ src/auth/login.ts และเสนอการปรับปรุง error handling",
    },
]

หากคุณส่ง system prompt, repository context หรือเอกสารชุดเดิมซ้ำหลายครั้ง ให้รักษาข้อความเหล่านั้น:

ไว้ต้น request
ใช้เนื้อหาเดิม
เรียงลำดับเดิม
ไม่แก้ whitespace โดยไม่จำเป็น

รูปแบบนี้ช่วยเพิ่มโอกาสเกิด cache-hit และลดต้นทุน input ลงอย่างมาก

8. ทดสอบและดีบัก Kimi K3 ด้วย Apidog

SDK ทำให้การเรียก API ง่ายขึ้น แต่ก็ซ่อนรายละเอียด HTTP, headers, request body และ SSE frames ไปพร้อมกัน เมื่อเกิดปัญหา เช่น:

stream หยุดกลางทาง
tool_calls ส่ง arguments ผิดรูปแบบ
response ไม่ตรง JSON schema
key หรือ base URL ผิด
model ตอบต่างจากที่คาด

คุณควรตรวจ request และ response แบบดิบ

Apidog ช่วยให้คุณส่งคำขอ Kimi K3 แบบ HTTP โดยตรง ดู SSE ทีละเฟรม และเก็บ API key เป็น environment variable แทนการใส่ค่าไว้ใน request body

สร้าง request ใน Apidog

สร้าง HTTP request ใหม่
ตั้ง method เป็น POST
ตั้ง URL เป็น:

{{KIMI_BASE_URL}}/chat/completions

เพิ่ม headers:

Authorization: Bearer {{KIMI_API_KEY}}
Content-Type: application/json

ตั้งค่า environment variables:

KIMI_BASE_URL=https://api.moonshot.ai/v1
KIMI_API_KEY=sk-your-key-here

ใส่ request body:

{
  "model": "kimi-k3",
  "messages": [
    {
      "role": "user",
      "content": "อธิบายว่า token bucket rate limiter ทำงานอย่างไร"
    }
  ]
}

ตรวจสอบ streaming แบบดิบ

เพิ่ม "stream": true:

{
  "model": "kimi-k3",
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "เขียนบทกวี 6 บรรทัดเกี่ยวกับ flaky tests"
    }
  ]
}

จากนั้นตรวจสอบว่า SSE stream มี:

data: ...

และปิดท้ายด้วย:

data: [DONE]

หาก SDK ของคุณแสดงผลไม่ครบ แต่ Apidog เห็นเฟรมจาก server ครบ ปัญหาอาจอยู่ที่ client-side stream handling ไม่ใช่ endpoint

ดีบัก tool calling

ส่ง request ที่มี tools แล้วตรวจ response field:

{
  "tool_calls": [
    {
      "id": "call_...",
      "type": "function",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\":\"Singapore\"}"
      }
    }
  ]
}

ใช้จุดนี้ตรวจว่า:

โมเดลเลือก tool ถูกตัวหรือไม่
JSON arguments ถูกต้องหรือไม่
JSON Schema ของ tool คลุมเครือหรือไม่
แอปของคุณส่ง tool_call_id กลับถูกต้องหรือไม่

คุณยังสามารถนำคำสั่ง cURL ที่ใช้งานได้ไป import ใน Apidog เพื่อบันทึกเป็น request ที่ทีมเรียกใช้ซ้ำได้ ดู workflow เพิ่มเติมได้จาก การทดสอบ API โดยไม่ต้องใช้ Postman

หาก agent ของคุณเชื่อมต่อกับโมเดลผ่าน MCP ดู คู่มือการดีบักด้วยภาพด้วยไคลเอนต์ Apidog MCP และ ดาวน์โหลด Apidog เพื่อทดลองกับ API key ของคุณเอง

9. กรณีใช้งานที่เหมาะกับ Kimi K3

Agent เขียนโค้ดระดับ repository

ใช้ context ขนาด 1M ร่วมกับ tools เพื่อให้ agent ทำงานข้ามไฟล์ได้ เช่น:

อ่านโครงสร้าง repository
วิเคราะห์ test failures
เรียก test runner
อ่าน logs
แก้ไขโค้ด
รันทดสอบซ้ำ

ให้วาง codebase context ที่ใช้ร่วมกันไว้ต้น prompt เพื่อเพิ่มโอกาส cache-hit

งานเอกสารขนาดใหญ่

ส่งสเปก, สัญญา, เอกสารออกแบบ หรือ research corpus เข้าไปใน context แล้วขอผลลัพธ์แบบ structured output เช่น:

{
  "requirements": [],
  "risks": [],
  "open_questions": []
}

กรณีนี้เหมาะกับ json_schema และควรรักษาเอกสารหลักไว้เป็น prefix คงที่

การวางแผน migration และ refactor

ใช้ reasoning_effort="max" กับช่วงวางแผน เช่น:

แตก REST endpoints เป็น GraphQL schema
วางแผนแยก monolith
จัดลำดับการย้าย database
ประเมินผลกระทบของ dependency upgrade

หลังจากได้แผนแล้ว งานแก้ไขเชิงกลไกที่ทำซ้ำได้อาจย้ายไปโมเดลที่ต้นทุนต่ำกว่า

คำตอบที่อิงข้อมูลล่าสุด

เมื่อเชื่อมกับ web search หรือ tools ที่ดึงข้อมูลจากระบบของคุณ K3 สามารถใช้ตอบคำถามที่ไม่ควรพึ่งพาเฉพาะความรู้จากการฝึก เช่น:

สถานะ deployment ล่าสุด
release notes ล่าสุด
สถานะ incident
ข้อมูลจาก internal API
เอกสารเวอร์ชันล่าสุด

สรุป

การเริ่มใช้ Kimi K3 ผ่าน API มีแกนหลักเพียงสามค่า:

base_url
api_key
model="kimi-k3"

หลังจากนั้น คุณสามารถใช้รูปแบบ OpenAI Chat Completions เดิมสำหรับ:

streaming
tool calling
JSON mode
structured output
reasoning_effort

สิ่งที่ควรวางแผนก่อนขึ้น production คือ:

ใช้ base URL จากคอนโซล Kimi ของบัญชีคุณ
เก็บ API key ใน environment variable หรือ secret manager
ออกแบบ prompt ให้ prefix คงที่เพื่อเพิ่ม cache-hit
ใช้ K3 กับงาน reasoning, agentic workflow และ context ยาว
ใช้ K2.7 กับงาน routine ปริมาณสูงเมื่อเหมาะสม
ตรวจสอบ request และ SSE แบบดิบด้วย Apidog ก่อนเชื่อมเข้ากับแอปจริง

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

API model ID สำหรับ Kimi K3 คืออะไร?

บนแพลตฟอร์ม Kimi ให้ใช้:

kimi-k3

หากเรียกผ่าน OpenRouter ให้ใช้:

moonshotai/kimi-k3

ดูรายการโมเดลได้ที่ openrouter.ai/moonshotai/kimi-k3

ควรใช้ base URL ใด?

ให้ยืนยัน base URL จาก platform.kimi.ai เพราะเป็นค่าที่เชื่อถือได้สำหรับบัญชีของคุณ Kimi เคยใช้:

https://api.moonshot.ai/v1

ควรเก็บค่าเป็น environment variable แทนการ hard-code:

export KIMI_BASE_URL="https://api.moonshot.ai/v1"

Kimi K3 ใช้กับ OpenAI SDK ได้หรือไม่?

ได้ API ใช้รูปแบบ OpenAI Chat Completions ดังนั้น OpenAI Python และ JavaScript SDK ใช้งานได้หลังจากเปลี่ยน base_url และ model

สำหรับฟิลด์เฉพาะผู้ให้บริการที่ SDK ยังไม่รู้จัก ให้ใช้ extra_body

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

ราคาที่ระบุคือ:

0.30 ดอลลาร์ / 1M cache-hit input tokens
3.00 ดอลลาร์ / 1M cache-miss input tokens
15.00 ดอลลาร์ / 1M output tokens

ดูรายละเอียดได้จาก คู่มือราคา Kimi K3

Context caching ช่วยอะไร?

เมื่อ prefix ของ request ตรงกับคำขอก่อนหน้า ระบบสามารถนำ state ที่คำนวณไว้กลับมาใช้ใหม่ ทำให้ค่า input tokens ของส่วนนั้นลดจาก 3.00 ดอลลาร์เป็น 0.30 ดอลลาร์ต่อ 1M โทเค็น

รักษา system prompt และ shared context ให้คงที่และอยู่ต้น request เพื่อเพิ่มโอกาสเกิด cache-hit

ควบคุมความพยายามในการคิดของโมเดลได้หรือไม่?

ได้ ผ่าน reasoning_effort โดยระดับที่ระบุว่ามีอยู่ปัจจุบันคือ:

max