วิธีใช้ Kimi K3 API?

Moonshot AI ได้เปิดตัว Kimi K3 เมื่อวันที่ 16 กรกฎาคม 2026 และเรียกมันว่าเป็นโมเดลที่มีความสามารถสูงสุดเท่าที่เคยมีมา: ซึ่งเป็นโมเดล 3T-class แบบเปิดตัวแรกของโลก ด้วยการออกแบบ Mixture-of-Experts ขนาด 2.8T พารามิเตอร์ และหน้าต่างบริบท (context window) ขนาด 1,048,576 โทเค็น สิ่งที่น่าสนใจสำหรับนักพัฒนาไม่ใช่ขนาด แต่เป็น API Kimi K3 พูดภาษา OpenAI SDK dialect ดังนั้น หากคุณใช้งาน GPT หรือปลายทางที่เข้ากันได้กับ OpenAI อยู่แล้ว คุณสามารถชี้ไคลเอนต์เดิมไปยัง kimi-k3 และเริ่มรับการตอบสนองแบบสตรีมมิ่งได้ภายในไม่กี่นาที คู่มือนี้จะแนะนำการขอคีย์, การเริ่มต้นใช้งานอย่างรวดเร็วด้วย Python, JavaScript และ cURL, การสตรีมมิ่ง, การเรียกใช้เครื่องมือ, โหมด JSON, พารามิเตอร์ reasoning-effort ที่ปรับแต่งได้ และการแคชบริบทที่ทำให้การอินพุตแบบ cache-hit มีราคาถูกกว่า cache-miss ประมาณสิบเท่า จากนั้นคุณจะได้ทดสอบและดีบักการเรียกเหล่านั้นใน Apidog เพื่อดูคำขอแบบดิบและเหตุการณ์ที่เซิร์ฟเวอร์ส่งมาแทนการคาดเดา

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

API model ID คือ kimi-k3 บน OpenRouter คือ moonshotai/kimi-k3
ปลายทาง (endpoint) สามารถใช้งานร่วมกับ OpenAI-SDK ได้ กำหนดค่า base_url, กำหนดค่า api_key, กำหนดค่า model="kimi-k3" ก็เสร็จสิ้น ยืนยัน URL หลักที่แน่นอนได้ในคอนโซลที่ platform.kimi.ai; Kimi เคยใช้ https://api.moonshot.ai/v1 มาก่อน
หน้าต่างบริบท (Context window) มีขนาด 1M โทเค็น ราคาคือ 0.30 ดอลลาร์ต่อล้านโทเค็นอินพุตแบบ cache-hit, 3.00 ดอลลาร์ต่อล้านโทเค็นอินพุตแบบ cache-miss และ 15.00 ดอลลาร์ต่อล้านโทเค็นเอาต์พุต
การสตรีมมิ่ง, การเรียกใช้เครื่องมือ, โหมด JSON, เอาต์พุตที่มีโครงสร้าง และพารามิเตอร์ reasoning_effort (ปัจจุบันมี max ให้ใช้งาน) ทั้งหมดทำงานผ่านรูปแบบ chat-completions มาตรฐาน
ปริมาณงานการเขียนโค้ดแบบเก่าหรือแบบประหยัดอาจยังเหมาะกับ K2.7 มากกว่า; มีข้อสังเกตเกี่ยวกับการเลือกอยู่ด้านล่าง
นำเข้าคำขอไปยัง Apidog เพื่อตรวจสอบการสตรีมมิ่ง, ดีบักการเรียกใช้เครื่องมือ, จัดเก็บคีย์ของคุณเป็นตัวแปรสภาพแวดล้อม และ A/B ทดสอบ kimi-k3 กับ kimi-k2-7-code

คุณควรเรียกใช้โมเดล Kimi ตัวไหน

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

หากปริมาณงานของคุณเป็นผู้ช่วยเขียนโค้ดที่มีปริมาณมาก, ผู้เขียน CI test, หรืองานใดๆ ที่คุณจ่ายต่อการเรียกใช้ในวงกว้าง, โมเดล K2.7 Code เก่ามักจะเหมาะสมกว่าในเรื่องค่าใช้จ่าย เริ่มต้นด้วย คู่มือ Kimi K2.7 Code API และ ภาพรวม Kimi K2.7 Code คืออะไร เพื่อดูว่าระดับนี้ครอบคลุมกรณีของคุณหรือไม่ สำหรับการเปรียบเทียบความสามารถและราคาแบบเคียงข้างกัน, การเปรียบเทียบ Kimi K3 vs Kimi K2.7 Code จะแสดงให้เห็นว่าแต่ละโมเดลโดดเด่นในด้านใด เลือกใช้ kimi-k3 เมื่อคุณต้องการความลึกในการให้เหตุผลเป็นพิเศษ, บริบทเต็ม 1M, หรือการประสานงานเครื่องมือแบบ agentic; และลดระดับไปใช้ K2.7 เมื่องานเป็นงานประจำและมีปริมาณสูง หากคุณต้องการรายละเอียดความสามารถทั้งหมดก่อน, คำอธิบาย Kimi K3 คืออะไร จะครอบคลุมถึงสถาปัตยกรรมและตำแหน่งของโมเดล

ขอ API key บนแพลตฟอร์ม Kimi

ไปที่ platform.kimi.ai แล้วลงชื่อเข้าใช้ คอนโซลใหม่คือที่ที่คุณสร้างคีย์, ตรวจสอบการใช้งาน และยืนยัน base URL สำหรับบัญชีของคุณ

เปิดส่วน API keys ในคอนโซลและสร้างคีย์ใหม่
คัดลอกครั้งเดียวและจัดเก็บไว้ในที่ปลอดภัย คุณจะไม่เห็นค่าเต็มอีก
เพิ่มเครดิตหรือยืนยันระดับการเรียกเก็บเงินของคุณ เพื่อไม่ให้การเรียกใช้ kimi-k3 ถูกปฏิเสธเนื่องจากยอดเงินไม่เพียงพอ
จดบันทึก base URL ที่แสดงในคอนโซล Kimi เคยใช้ https://api.moonshot.ai/v1 มาก่อน; คอนโซลเป็นแหล่งข้อมูลที่เชื่อถือได้สำหรับบัญชีของคุณ

ส่งออกคีย์เป็นตัวแปรสภาพแวดล้อมเพื่อไม่ให้ปรากฏในซอร์สโค้ดของคุณ:

export KIMI_API_KEY="sk-your-key-here"

นิสัยเดียวนี้จะช่วยให้ความลับไม่ปรากฏในประวัติ Git และในภาพหน้าจอ ภายหลัง เมื่อคุณทดสอบใน Apidog คุณจะจัดเก็บค่าเดียวกันนั้นเป็นตัวแปรสภาพแวดล้อมที่นั่นด้วย ดังนั้นคีย์จะอยู่ในสองที่ที่คุณควบคุมได้เท่านั้น

สำหรับรายละเอียดทั้งหมดเกี่ยวกับการคำนวณ cache-hit กับ cache-miss และวิธีที่มันส่งผลต่อค่าใช้จ่ายรายเดือนจริง โปรดดู คู่มือราคา Kimi K3

เริ่มต้นอย่างรวดเร็ว: การเรียกใช้ kimi-k3 ครั้งแรกของคุณ

API ของ Kimi เป็นไปตามข้อกำหนดของ OpenAI chat-completions ดังนั้น OpenAI SDKs อย่างเป็นทางการจึงใช้งานได้โดยมีการเปลี่ยนแปลงสองอย่าง: base_url และ model ติดตั้ง SDK ที่คุณต้องการ จากนั้นเรียกใช้หนึ่งในตัวอย่างโค้ดด้านล่าง

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["KIMI_API_KEY"],
    # Kimi สามารถใช้งานร่วมกับ OpenAI-SDK ได้ ยืนยัน base URL ที่แน่นอนใน
    # คอนโซลที่ platform.kimi.ai; Kimi เคยใช้ค่าด้านล่างนี้
    base_url="https://api.moonshot.ai/v1",
)

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)

JavaScript / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  // ยืนยัน base URL ในคอนโซล platform.kimi.ai
  baseURL: "https://api.moonshot.ai/v1",
});

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);

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 ทำงานอย่างไรในหนึ่งย่อหน้า"}
    ]
  }'

ตั้งค่า KIMI_BASE_URL ให้ตรงกับที่คอนโซลแสดง (เช่น https://api.moonshot.ai/v1) หากการเรียกใช้ใดๆ เหล่านี้ส่งคืนค่า 401 หมายความว่าคีย์ไม่ถูกต้องหรือไม่ถูกตั้งค่า ค่า 404 บนพาร์ทมักจะหมายความว่า base URL ผิด ไม่ใช่ว่าโมเดลหายไป เอกสารประกอบ OpenAI Python SDK ครอบคลุมตัวเลือกของไคลเอนต์โดยละเอียด และทุกตัวเลือกที่นั่นสามารถนำมาใช้ได้ที่นี่เพราะรูปแบบการสื่อสารเป็นแบบเดียวกัน

การตอบสนองแบบสตรีมมิ่ง

สำหรับ UI แชทและบทสนทนาของ agent ที่ยาวนาน คุณต้องการโทเค็นทันทีที่มาถึง แทนที่จะรอให้การเติมเต็มทั้งหมดเสร็จสิ้น ตั้งค่า stream=True และวนซ้ำ deltas

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)

เบื้องหลังคือ stream ของเหตุการณ์ที่เซิร์ฟเวอร์ส่งมา (SSE): แต่ละบรรทัดคือเฟรม data: ที่บรรจุ JSON chunk เล็กๆ และ stream จะสิ้นสุดลงด้วย data: [DONE] SDK จะซ่อนการจัดเฟรมนี้จากคุณ ซึ่งสะดวกจนกว่าจะมีบางสิ่งขัดข้องกลาง stream และคุณจำเป็นต้องเห็นเฟรมดิบ นั่นคือจุดหนึ่งที่ส่วน Apidog ด้านล่างจะแสดงประโยชน์ของมัน

แฟล็กเดียวกันนี้ทำงานใน JavaScript:

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 ?? "");
}

การเรียกใช้เครื่องมือ (การเรียกใช้ฟังก์ชัน)

Kimi K3 รองรับการเรียกใช้เครื่องมือ, ข้อจำกัดในการเลือกเครื่องมือ และการโหลดเครื่องมือแบบไดนามิก คุณจึงสามารถเชื่อมต่อกับ agent ที่อ่านไฟล์, เรียกใช้ API หรือรันคำสั่งในเทอร์มินัลได้ คุณอธิบายฟังก์ชันของคุณด้วย JSON Schema, โมเดลจะตัดสินใจว่าจะเรียกใช้เมื่อใด และคุณจะส่งคืนผลลัพธ์ในข้อความ 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)       # get_weather
print(tool_call.function.arguments)  # {"city": "Singapore"}

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

import json

# เพิ่มบทสนทนาของผู้ช่วยที่ร้องขอเครื่องมือ จากนั้นผลลัพธ์ของเครื่องมือ
messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps({"city": "Singapore", "temp_c": 31, "sky": "humid"}),
})

final = client.chat.completions.create(model="kimi-k3", messages=messages, tools=tools)
print(final.choices[0].message.content)

ตั้งค่า tool_choice="required" เพื่อบังคับเรียกใช้เครื่องมือ หรือส่งอ็อบเจกต์ {"type": "function", "function": {"name": "get_weather"}} เพื่อกำหนดฟังก์ชันเดียว ข้อจำกัดเหล่านี้จะช่วยควบคุม agent เมื่อคุณรู้แล้วว่าควรใช้เครื่องมือใด

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

โหมด JSON และเอาต์พุตที่มีโครงสร้าง

เมื่อคุณต้องการเอาต์พุตที่เครื่องอ่านได้ ให้ขอ JSON โดยตรงแทนที่จะแยกวิเคราะห์ข้อความ ตั้งค่า response_format เป็น json_object และสั่งให้โมเดลส่งคืน JSON

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": "นักคณิตศาสตร์"}

เพื่อการรับประกันที่เข้มงวดมากขึ้น Kimi รองรับเอาต์พุตที่มีโครงสร้างตาม Schema หากเวอร์ชัน SDK ของคุณรองรับ ให้ส่งรูปแบบการตอบกลับ json_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 สำหรับบัญชีของคุณในคอนโซลก่อนที่คุณจะใช้งานจริง; หากไม่แน่ใจ, การใช้ json_object พร้อมขั้นตอนการตรวจสอบความถูกต้องในฝั่งของคุณเป็นทางเลือกที่ปลอดภัย Kimi ยังมีโหมดบางส่วน (partial mode) และการค้นหาทางอินเทอร์เน็ต ซึ่งช่วยได้เมื่อคุณต้องการเติมคำตอบของผู้ช่วยล่วงหน้าหรืออ้างอิงข้อมูลล่าสุด

ความพยายามในการให้เหตุผลที่กำหนดค่าได้

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

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

หาก OpenAI SDK เวอร์ชันของคุณปฏิเสธฟิลด์นี้ว่าไม่รู้จัก ให้ส่งผ่านช่องทางสำรองแทน:

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

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

ทดสอบและดีบัก kimi-k3 ใน Apidog

โค้ด SDK ซ่อนรูปแบบการสื่อสาร ซึ่งก็ดีจนกว่าการเรียกใช้เครื่องมือจะคืนค่าผิดพลาดหรือการสตรีมหยุดทำงานกลางคัน และคุณไม่สามารถบอกได้ว่าเป็นความผิดของคุณหรือปลายทาง นี่คือจุดที่ไคลเอนต์ API ที่ใช้ HTTP ดิบมีประโยชน์ Apidog ช่วยให้คุณสามารถส่งคำขอ kimi-k3 ที่แน่นอน, ดูสตรีม SSE ทีละเฟรม และเก็บคีย์ของคุณออกจากเนื้อหาคำขอ หากคุณต้องการทดสอบการเรียก API โดยไม่ต้องอยู่ในเทอร์มินัล นี่คือกระบวนการที่สะอาดกว่าการใช้ curl แล้วเพ่งสายตา; การทดสอบ API โดยไม่ต้องใช้ Postman จะครอบคลุมขั้นตอนการทำงานทั่วไป

นี่คือขั้นตอนที่เน้นสำหรับ kimi-k3:

สร้างคำขอ HTTP ใหม่ใน Apidog กำหนดเมธอดเป็น POST และ URL เป็น base URL ของคุณบวกกับ /chat/completions
จัดเก็บคีย์ของคุณเป็นตัวแปรสภาพแวดล้อม ในการตั้งค่าสภาพแวดล้อมของ Apidog ให้เพิ่ม KIMI_API_KEY จากนั้นตั้งค่าส่วนหัว Authorization เป็น Bearer {{KIMI_API_KEY}} ตอนนี้ความลับจะถูกอ้างอิง ไม่ใช่การวางลงไป และคุณสามารถสลับระหว่างคีย์ทดสอบและคีย์โปรดักชันได้โดยการสลับสภาพแวดล้อม
วางเนื้อหา JSON ที่มี "model": "kimi-k3" และอาร์เรย์ messages ของคุณ ส่งไปและอ่านการตอบกลับทั้งหมด รวมถึงการใช้โทเค็น เพื่อให้คุณสามารถเห็นจำนวน cache-hit เทียบกับ cache-miss ในการเรียกจริง
สลับ "stream": true และดูเหตุการณ์ที่เซิร์ฟเวอร์ส่งมาถึงทีละเฟรม การเห็น data: ชิ้นส่วนดิบทำให้ข้อบกพร่องในการสตรีมชัดเจนในแบบที่ iterator ที่เรียบร้อยของ SDK ไม่สามารถทำได้
ดีบักการเรียกใช้เครื่องมือโดยการตรวจสอบอาร์เรย์ tool_calls ในการตอบกลับ เมื่ออาร์กิวเมนต์กลับมาผิดรูปแบบ คุณสามารถดูได้ว่าโมเดลสร้าง JSON ที่ไม่ถูกต้องหรือ Schema ของคุณคลุมเครือ และแก้ไขคำอธิบายได้ทันที
A/B ทดสอบกับ kimi-k2-7-code ทำซ้ำคำขอ เปลี่ยนเฉพาะฟิลด์ model และเปรียบเทียบความหน่วงเวลา คุณภาพเอาต์พุต และค่าใช้จ่ายบนพรอมต์เดียวกัน นี่คือวิธีที่รวดเร็วและซื่อสัตย์ที่สุดในการตัดสินใจว่าความสามารถในการให้เหตุผลพิเศษของ K3 คุ้มค่ากับการเพิ่มราคาสำหรับงานของคุณหรือไม่

เนื่องจาก Apidog สามารถนำเข้าคำขอที่เข้ากันได้กับ OpenAI ได้โดยตรง คุณจึงสามารถวางคำสั่ง cURL และรับคำขอที่บันทึกไว้และสามารถเล่นซ้ำได้ พร้อมส่วนหัวและเนื้อหาที่กรอกไว้แล้ว จากนั้นมันจะกลายเป็นกรณีทดสอบที่ทีมของคุณสามารถเรียกใช้ซ้ำได้ทุกครั้งที่ Kimi อัปเดต หาก agent ของคุณสื่อสารกับโมเดลผ่าน MCP, คู่มือการดีบักด้วยภาพด้วยไคลเอนต์ Apidog MCP จะแสดงวิธีการติดตามการเรียกเหล่านั้นด้วย ดาวน์โหลด Apidog หากคุณต้องการทำตามขั้นตอนนี้ด้วยคีย์ของคุณเอง

กรณีการใช้งานจริง

รูปแบบการใช้งานบางอย่างตรงกับสิ่งที่ kimi-k3 ถูกสร้างขึ้นมาเพื่อ:

Agent เขียนโค้ดระดับ Repository บริบท 1M และการประสานงานเครื่องมือแบบ agentic ช่วยให้โมเดลสามารถจัดการ codebase ขนาดใหญ่, รันการทดสอบ, อ่าน log และปรับปรุงซ้ำ แคชโค้ดเบสเป็น prefix ที่คงที่ จะช่วยให้ค่าใช้จ่ายต่อรอบอยู่ในเกณฑ์ที่สมเหตุสมผล
งานความรู้เอกสารยาว ใส่สเปค, สัญญา หรือ corpus งานวิจัยทั้งหมด และขอการสกัดข้อมูลที่มีโครงสร้างด้วย json_schema เก็บเอกสารไว้ที่ต้นพรอมต์เพื่อให้การสอบถามซ้ำๆ ตรงกับแคช
การวางแผนการย้ายข้อมูลและการปรับโครงสร้าง (refactor) ปรับ reasoning_effort เป็น max สำหรับขั้นตอนการวางแผน ซึ่งการคิดเชิงลึกจะให้ผลตอบแทน จากนั้นลดกลับไปใช้โมเดลที่ถูกกว่าสำหรับการแก้ไขทางกลไก
คำตอบการวิจัยที่มีพื้นฐาน ด้วยการค้นหาทางอินเทอร์เน็ตและการเรียกใช้เครื่องมือ K3 สามารถดึงข้อมูลล่าสุดและอ้างอิงได้ ซึ่งเหมาะสำหรับผู้ช่วยที่ไม่สามารถพึ่งพาความรู้จากการฝึกอบรมที่ล้าสมัยได้

ในแต่ละกรณีเหล่านี้ ขั้นตอนการทำงานเหมือนกัน: สร้างคำขอด้วย SDK, ตรวจสอบพฤติกรรมดิบใน Apidog จากนั้นเชื่อมต่อเข้ากับแอปของคุณเมื่อคุณเชื่อมั่นในรูปแบบแล้ว

สรุป

การเรียกใช้ Kimi K3 สรุปได้ด้วยการตั้งค่าสามอย่างบนไคลเอนต์ที่เข้ากันได้กับ OpenAI: base URL จากคอนโซลของคุณ, API key ของคุณ และ model="kimi-k3" จากนั้น การสตรีมมิ่ง, การเรียกใช้เครื่องมือ, โหมด JSON, เอาต์พุตที่มีโครงสร้าง และ reasoning_effort ทั้งหมดเป็นไปตามข้อกำหนดของ chat-completions ที่คุณรู้อยู่แล้ว สิ่งสำคัญสองอย่างที่ควรทำความเข้าใจคือเศรษฐศาสตร์การแคช ซึ่งการรักษา prefix ที่คงที่เปลี่ยนอินพุต 3.00 ดอลลาร์ให้เป็น 0.30 ดอลลาร์ และข้อแลกเปลี่ยนที่ซื่อสัตย์ว่า K3 ซื้อความลึกในการให้เหตุผลด้วยราคาที่แท้จริง ดังนั้นจึงควรกำหนดงานที่มีปริมาณมากและเป็นงานประจำไปที่ K2.7 สร้างคำขอในโค้ด พิสูจน์มันใน Apidog และคุณจะสามารถใช้งาน kimi-k3 ได้โดยไม่มีปัญหา

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

API model ID สำหรับ Kimi K3 คืออะไร? คือ kimi-k3 บนแพลตฟอร์มของ Kimi เอง หากคุณเรียกใช้ผ่าน OpenRouter, slug คือ moonshotai/kimi-k3 คุณสามารถอ่านรายการโมเดลบน OpenRouter ได้ที่ openrouter.ai/moonshotai/kimi-k3

ฉันควรใช้ base URL ใด? ยืนยันได้ในคอนโซลที่ platform.kimi.ai เนื่องจากนั่นคือแหล่งข้อมูลที่เชื่อถือได้สำหรับบัญชีของคุณ Kimi เคยใช้ https://api.moonshot.ai/v1 มาก่อน ในโค้ด ให้เก็บเป็นตัวแปร base_url ที่คุณตั้งค่าจากคอนโซลแทนการฮาร์ดโค้ด

Kimi K3 เข้ากันได้กับ OpenAI SDK หรือไม่? ใช่ API เป็นไปตามรูปแบบ OpenAI chat-completions ดังนั้น OpenAI Python และ JavaScript SDKs อย่างเป็นทางการจึงใช้งานได้หลังจากที่คุณเปลี่ยน base_url และ model ฟิลด์เฉพาะผู้ให้บริการจะถูกส่งผ่าน extra_body

API Kimi K3 มีค่าใช้จ่ายเท่าไร? 0.30 ดอลลาร์ต่อล้านโทเค็นอินพุตแบบ cache-hit, 3.00 ดอลลาร์ต่อล้านโทเค็นอินพุตแบบ cache-miss และ 15.00 ดอลลาร์ต่อล้านโทเค็นเอาต์พุต การจัดโครงสร้างพรอมต์เพื่อนำแคชกลับมาใช้ใหม่คือปัจจัยสำคัญที่สุดในการควบคุมค่าใช้จ่ายของคุณ คู่มือราคา Kimi K3 จะอธิบายรายละเอียดตัวเลข

Context caching ทำอะไรจริงๆ? เมื่อโทเค็นนำหน้าของคำขอของคุณตรงกับคำขอก่อนหน้า ปลายทางจะนำสถานะที่คำนวณไว้กลับมาใช้ใหม่แทนที่จะคำนวณใหม่ ซึ่งลดค่าใช้จ่ายอินพุตจาก 3.00 ดอลลาร์เป็น 0.30 ดอลลาร์ต่อล้านโทเค็นในส่วนนั้น รักษา system prompt และบริบทที่ใช้ร่วมกันไว้ที่ด้านหน้าและเหมือนกันตลอดการเรียกใช้เพื่อให้เกิด cache-hit สูงสุด

ฉันสามารถควบคุมความพยายามในการคิดของโมเดลได้หรือไม่? ได้ โดยใช้ reasoning_effort ระดับที่มีให้ในปัจจุบันคือ max ซึ่งเป็นค่าเริ่มต้นด้วย Moonshot ได้กล่าวว่ามีแผนจะเพิ่มระดับอื่นๆ ความพยายามที่สูงขึ้นจะมีค่าใช้จ่ายโทเค็นเอาต์พุตมากขึ้นและเพิ่มความหน่วงเวลา

ฉันควรใช้ Kimi K3 หรือ Kimi K2.7 Code? ใช้ kimi-k3 เมื่อคุณต้องการความลึกในการให้เหตุผล, บริบทเต็ม 1M, หรือการประสานงานเครื่องมือแบบ agentic สำหรับงานเขียนโค้ดประจำวันที่มีปริมาณมาก โมเดล K2.7 ที่ถูกกว่ามักจะเป็นตัวเลือกที่ดีกว่า การเปรียบเทียบ Kimi K3 กับ Kimi K2.7 Code และ คู่มือ API Kimi K2.7 Code จะช่วยคุณในการตัดสินใจ

ฉันจะดีบักการสตรีมที่เสียหรือการตอบสนองการเรียกใช้เครื่องมือได้อย่างไร? ส่งคำขอแบบดิบใน Apidog ด้วย "stream": true และอ่านเหตุการณ์ที่เซิร์ฟเวอร์ส่งมาทีละเฟรม หรือตรวจสอบอาร์เรย์ tool_calls เพื่อดูว่าโมเดลส่งคืน JSON ที่มีรูปแบบผิดหรือไม่ การจัดเก็บคีย์ของคุณเป็นตัวแปรสภาพแวดล้อมจะช่วยให้มันไม่อยู่ในเนื้อหาคำขอในขณะที่คุณทดสอบ