Blog

วิธีใช้ Kimi K2.6 API อย่างไร

Ashley Innocent

Ashley Innocent

21 April 2026

วิธีใช้ Kimi K2.6 API อย่างไร

การประกาศเปิดตัว Kimi K2.6 ของ Moonshot AI วางตำแหน่งให้เป็นนวัตกรรมโอเพ่นซอร์สที่ทันสมัยที่สุดสำหรับการเขียนโค้ด การดำเนินการระยะยาว และกลุ่มเอเจนต์ API ที่ขับเคลื่อนมันเข้ากันได้กับ OpenAI โฮสต์อยู่ที่ https://api.moonshot.ai/v1 และมีเอกสารบน แพลตฟอร์ม หากคุณติดตั้ง OpenAI SDK คุณจะสามารถส่งคำขอจริงได้ภายในเวลาประมาณห้านาที

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

💡
ทางลัด: ทดสอบ Kimi K2.6 API ด้วยภาพใน Apidog ก่อนที่จะคอมมิตโค้ดผสานรวมใดๆ เพียงนำเข้าครั้งเดียว ใส่ Bearer token คุณก็สามารถส่งคำขอแบบสตรีมมิ่งจริงได้พร้อมประวัติทั้งหมดและการตรวจสอบสคีมา ดาวน์โหลด Apidog ฟรี
button

สรุปสั้นๆ: Kimi K2.6 API ใน 60 วินาที

คำสั่ง curl แบบย่อ:

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "Write a Python function that reverses a string."}]
  }'

แค่นั้นเอง ส่วนที่เหลือของคู่มือนี้จะอธิบายรายละเอียดเพิ่มเติม รวมถึง Agent Swarm และขีดจำกัดการดำเนินการ 4,000 ขั้นตอนที่ Moonshot กำหนด

สิ่งที่คุณสามารถทำได้จริงด้วย API นี้

จากการ ประกาศเปิดตัว Kimi K2.6, API นี้ปลดล็อกความสามารถทั้งหมดนี้ในการใช้งานจริง:

หากคุณกำลังสร้างเครื่องมือในหมวดหมู่เดียวกับ การใช้งานคอมพิวเตอร์ด้วย Claude Code, การสร้าง Claude Code ของคุณเอง, หรือ Cursor Composer 2, K2.6 API สามารถใช้แทนที่ได้โดยตรงในชั้นโมเดล

ขั้นตอนที่ 1: รับคีย์ API

  1. ไปที่ platform.moonshot.ai (หรือ platform.kimi.ai) และลงทะเบียน สามารถใช้ได้ทั้งอีเมลหรือ Google OAuth
  2. ยืนยันบัญชีของคุณ ผู้ใช้ต่างประเทศอาจต้องยืนยันด้วย SMS
  3. เพิ่มข้อมูลการเรียกเก็บเงิน โดยปกติ Moonshot จะให้เครดิตฟรีจำนวนเล็กน้อยแก่บัญชีใหม่
  4. เปิด API Keys ในแดชบอร์ดแล้วคลิก Create Key
  5. คัดลอกคีย์ทันที (จะแสดงเพียงครั้งเดียว)
  6. ส่งออก:
export KIMI_API_KEY="sk-..."

เพิ่มลงใน .zshrc, .bashrc หรือตัวจัดการความลับสำหรับการใช้งานจริง ห้ามคอมมิตเด็ดขาด

ต้องการหลีกเลี่ยงการชำระเงินระหว่างการพัฒนาหรือไม่? วิธีใช้ Kimi K2.6 ฟรี ครอบคลุม Cloudflare Workers AI, น้ำหนักโมเดลที่โฮสต์เอง และโปรแกรมเครดิตฟรี

ขั้นตอนที่ 2: เลือก SDK ของคุณ

API เข้ากันได้กับ OpenAI ดังนั้น OpenAI SDK อย่างเป็นทางการจึงใช้งานได้หลังจากที่คุณเปลี่ยน Base URL

ตัวเลือก ติดตั้ง เหมาะสำหรับ
curl มีมาให้ในระบบ การทดสอบอย่างรวดเร็ว, CI
OpenAI Python pip install openai บริการ Python
OpenAI Node npm install openai แอป JS/TS

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "What is the capital of France?"}],
)

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

Node.js

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.KIMI_API_KEY,
  baseURL: "https://api.moonshot.ai/v1",
});

const response = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "What is the capital of France?" }],
});

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

curl

curl https://api.moonshot.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $KIMI_API_KEY" \
  -d '{
    "model": "kimi-k2.6",
    "messages": [{"role": "user", "content": "What is the capital of France?"}]
  }'

ทั้งสามวิธีส่งคืนรูปแบบการตอบสนองที่เหมือนกัน

ขั้นตอนที่ 3: ทำความเข้าใจเนื้อหาคำขอ

ฟิลด์เดียวกับ OpenAI chat completions:

{
  "model": "kimi-k2.6",
  "messages": [
    { "role": "system", "content": "You are a helpful assistant." },
    { "role": "user", "content": "Your prompt here." }
  ],
  "temperature": 1.0,
  "top_p": 1.0,
  "max_tokens": 8192,
  "stream": false,
  "tools": [],
  "tool_choice": "auto",
  "thinking": { "type": "disabled" }
}

สองข้อสังเกตเฉพาะของ Moonshot:

ขั้นตอนที่ 4: การสตรีม

การสตรีมเป็นค่าเริ่มต้นที่เหมาะสมสำหรับ UI หรืองานที่สร้างเนื้อหายาวๆ ใดๆ เอาต์พุตสูงสุดสำหรับงานให้เหตุผลสามารถเข้าถึง 98,304 โทเค็นได้ คุณคงไม่อยากรอให้ข้อมูลทั้งหมดมาพร้อมกัน

Python

stream = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Write a 500-word essay on MoE models."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Node.js

const stream = await client.chat.completions.create({
  model: "kimi-k2.6",
  messages: [{ role: "user", content: "Write a 500-word essay on MoE models." }],
  stream: true,
});

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

การสตรีมยังทำงานกับการเรียกใช้เครื่องมือได้ด้วย อาร์กิวเมนต์จะมาถึงในรูปแบบ JSON deltas ที่คุณนำมาเชื่อมต่อกัน

ขั้นตอนที่ 5: การเรียกใช้เครื่องมือ

Moonshot รายงาน คะแนน Toolathlon 50.0% และ ความสำเร็จในการเรียกใช้เครื่องมือ 96.60% ในการทดสอบกับพันธมิตร รูปแบบนี้เป็นสคีมาการเรียกใช้ฟังก์ชันมาตรฐานของ OpenAI ดังนั้น เวิร์กโฟลว์การทดสอบ API สำหรับวิศวกร QA ที่มีอยู่จึงสามารถนำมาใช้ได้

กำหนดเครื่องมือ

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather in a location.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]

การเรียกครั้งแรก (โมเดลตัดสินใจ)

import json

messages = [{"role": "user", "content": "What's the weather in Tokyo?"}]

resp = client.chat.completions.create(
    model="kimi-k2.6",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

msg = resp.choices[0].message
messages.append(msg)

if msg.tool_calls:
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = fetch_weather(args["location"], args.get("unit", "celsius"))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })

การเรียกครั้งที่สอง (คำตอบสุดท้าย)

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

K2.6 มีความแข็งแกร่งในเรื่องเชนเครื่องมือหลายขั้นตอน ซึ่งทำให้เอเจนต์เขียนโค้ดที่ทำงานได้ยาวนานอย่าง Kimi Code เป็นไปได้ สำหรับการเปรียบเทียบเฟรมเวิร์ก เวิร์กโฟลว์ Claude Code ครอบคลุมลูปเดียวกันแต่ใช้แบ็กเอนด์ที่แตกต่างกัน

ขั้นตอนที่ 6: การป้อนข้อมูลด้วยภาพ (Vision input)

K2.6 ได้คะแนน 79.4% ใน MMMU-Pro และ 96.9% ใน V* (ด้วย Python) รูปภาพจะถูกส่งไปยังข้อความผู้ใช้โดยใช้รูปแบบเนื้อหา image_url ของ OpenAI:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image in one sentence."},
                {"type": "image_url", "image_url": {"url": "https://example.com/photo.jpg"}}
            ]
        }
    ],
)

สำหรับไฟล์ในเครื่อง ให้เข้ารหัสเป็น base64:

import base64
with open("photo.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

image_url = f"data:image/jpeg;base64,{b64}"

สำหรับการรู้จำตัวอักษร (OCR) หรือการอ่านไดอะแกรม ให้รวมคำสั่งข้อความที่ชัดเจนเข้ากับรูปภาพ สำหรับโจทย์คณิตศาสตร์ ให้รวมเครื่องมือ Python interpreter; คะแนน MathVision 93.2% วัดได้เมื่อเปิดใช้งานการเข้าถึง Python

ขั้นตอนที่ 7: การป้อนข้อมูลด้วยวิดีโอ (Video input)

ส่ง URL ของวิดีโอหรือลำดับเฟรม:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Summarize what happens in this video."},
                {"type": "video_url", "video_url": {"url": "https://example.com/clip.mp4"}}
            ]
        }
    ],
)

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

ขั้นตอนที่ 8: โหมดการคิด (Thinking mode)

kimi-k2.6-thinking สร้างร่องรอยการให้เหตุผลที่มองเห็นได้ (คล้ายกับโมเดลสไตล์ o1 ของ OpenAI) Moonshot รายงาน 96.4% บน AIME 2026 และ 90.5% บน GPQA-Diamond เมื่อเปิดใช้งานโหมดการคิด

เปิดการคิด (ค่าเริ่มต้นสำหรับโมเดลการคิด):

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Prove sqrt(2) is irrational."}],
)

ปิดการคิด:

response = client.chat.completions.create(
    model="kimi-k2.6-thinking",
    messages=[{"role": "user", "content": "Quick: what's 17 * 23?"}],
    extra_body={"thinking": {"type": "disabled"}},
)

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

ขั้นตอนที่ 9: Agent Swarm

Agent Swarm เป็นฟีเจอร์ที่คุ้มค่าแก่การเรียนรู้มากที่สุด จาก บล็อก Kimi K2.6: ซับเอเจนต์สูงสุด 300 ตัว, ขั้นตอนที่ประสานกันมากกว่า 4,000 ขั้นตอน, ความจุเพิ่มขึ้น 3 เท่าของ K2.5

เรียกใช้ผ่านพารามิเตอร์เอเจนต์ของแพลตฟอร์ม:

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{
        "role": "user",
        "content": "Build a 5-page marketing site for a coffee brand with responsive design and a newsletter signup."
    }],
    extra_body={
        "agent": {
            "type": "swarm",
            "max_agents": 30,
            "max_steps": 4000
        }
    },
)

การเรียก Swarm สามารถทำงานได้นานหลายนาทีหรือหลายชั่วโมง สามเคล็ดลับที่เป็นประโยชน์:

  1. ใช้การสตรีม คุณจะต้องเห็นความคืบหน้าและยุติการทำงานที่ไม่ดีตั้งแต่เนิ่นๆ
  2. จำกัด max_agents 300 คือขีดจำกัดสูงสุด; 10 ถึง 30 ตัวจะคาดการณ์ได้แม่นยำกว่าสำหรับงานส่วนใหญ่
  3. กำหนดงบประมาณ งาน Swarm ที่ยาวนานสามารถใช้โทเค็นได้อย่างรวดเร็ว; บันทึก usage ในทุกการตอบสนองและส่งเข้าสู่ระบบเมตริกของคุณ

ใน บล็อกของ Kimi อธิบายการรันเดโมที่แก้ไขโค้ดมากกว่า 4,000 บรรทัดภายใน 13 ชั่วโมง สถาปัตยกรรมคือสิ่งที่ทำให้สิ่งเหล่านี้เป็นไปได้; ส่วนแฟล็ก API ก็แค่เปิดใช้งานมัน

ขั้นตอนที่ 10: ทดสอบทุกอย่างด้วย Apidog

ทุกส่วนข้างต้นแนะนำรูปแบบบอดี้ ข้อกำหนดส่วนหัว หรือรูปแบบการตอบสนองที่แตกต่างกัน Apidog เปลี่ยนกระบวนการดีบักให้เป็นเวิร์กโฟลว์แบบภาพ

การตั้งค่า Kimi K2.6 ใน Apidog

  1. ดาวน์โหลด Apidog และสร้างโปรเจกต์
  2. สร้างสภาพแวดล้อม kimi-prod พร้อมตัวแปรสองตัว: BASE_URL = https://api.moonshot.ai/v1 และ KIMI_API_KEY = sk-...
  3. คำขอ API ใหม่: POST {{BASE_URL}}/chat/completions
  4. ส่วนหัว: Authorization: Bearer {{KIMI_API_KEY}}, Content-Type: application/json
  5. เนื้อหา (ตัวอย่างการสตรีม):
{
  "model": "kimi-k2.6",
  "messages": [{ "role": "user", "content": "Hello, Kimi K2.6!" }],
  "stream": true
}
  1. คลิก Send โทเค็นจะไหลเข้าสู่แผงการตอบสนองแบบเรียลไทม์

สิ่งที่ Apidog เพิ่มเติมเข้ามา

สำหรับการทดสอบในตัวแก้ไข Apidog ยังมาในรูปแบบ ส่วนขยาย VS Code หากคุณกำลังติดอยู่กับ Postman, วิธีทดสอบ API โดยไม่ต้องใช้ Postman จะแนะนำการย้ายการใช้งาน

การจัดการข้อผิดพลาดที่ไม่สร้างปัญหา

Moonshot ใช้รหัสสถานะ HTTP มาตรฐาน:

ตัวห่อหุ้มการลองใหม่:

import time
from openai import OpenAI, RateLimitError, APIError

def call_kimi(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="kimi-k2.6",
                messages=messages,
            )
        except RateLimitError:
            time.sleep(2 ** attempt)
        except APIError as e:
            if e.status_code >= 500 and attempt < max_retries - 1:
                time.sleep(2 ** attempt)
            else:
                raise
    raise RuntimeError("Kimi K2.6 failed after retries")

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

การควบคุมต้นทุน

Moonshot เผยแพร่ราคาที่ kimi.com/membership/pricing สามเคล็ดลับระดับโปรดักชันสำหรับการรักษายอดค่าใช้จ่ายให้คาดการณ์ได้:

รูปแบบการผลิต: ตัวแก้ไขปัญหา GitHub

นี่คือเอเจนต์ที่อ่านปัญหา GitHub, ค้นหาโค้ดที่เกี่ยวข้อง, เสนอแนวทางแก้ไข และรันการทดสอบ ซึ่งจัดโครงสร้างตามลูปการเรียกใช้เครื่องมือของ Kimi K2.6:

from openai import OpenAI
import os, json

client = OpenAI(
    api_key=os.getenv("KIMI_API_KEY"),
    base_url="https://api.moonshot.ai/v1",
)

tools = [
    {"type": "function", "function": {
        "name": "read_file",
        "description": "Read a file in the repo.",
        "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
        }
    }},
    {"type": "function", "function": {
        "name": "search_code",
        "description": "Ripgrep the codebase for a pattern.",
        "parameters": {
            "type": "object",
            "properties": {"query": {"type": "string"}},
            "required": ["query"]
        }
    }},
    {"type": "function", "function": {
        "name": "run_tests",
        "description": "Run the project test suite.",
        "parameters": {"type": "object", "properties": {}}
    }},
]

def tool_dispatch(name, args):
    if name == "read_file":
        with open(args["path"]) as f:
            return f.read()
    if name == "search_code":
        return run_ripgrep(args["query"])
    if name == "run_tests":
        return run_pytest()
    raise ValueError(f"Unknown tool: {name}")

messages = [
    {"role": "system", "content": "You are a senior engineer. Fix the described bug."},
    {"role": "user", "content": "Issue: login form submits twice on slow networks."}
]

while True:
    resp = client.chat.completions.create(
        model="kimi-k2.6",
        messages=messages,
        tools=tools,
    )
    msg = resp.choices[0].message
    messages.append(msg)

    if not msg.tool_calls:
        print(msg.content)
        break

    for call in msg.tool_calls:
        result = tool_dispatch(call.function.name, json.loads(call.function.arguments))
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": result,
        })

สิ่งนี้สามารถขยายขนาดไปสู่ Agent Swarm ได้โดยการเพิ่มการกำหนดค่า Swarm ใน extra_body นอกจากนี้ยังทำงานได้ดีกับ สแต็คเอเจนต์หลายตัวของ Hermes หากคุณต้องการจุดตรวจสอบที่มนุษย์เข้าร่วมในกระบวนการ

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

ฉันต้องใช้ SDK เฉพาะของ Moonshot หรือไม่?ไม่จำเป็น OpenAI Python และ Node SDK สามารถทำงานได้หลังจากคุณเปลี่ยน base_url

API มีการจำกัดอัตราการเรียกใช้หรือไม่?มี ขีดจำกัดจะเพิ่มขึ้นตามระดับของคุณและประวัติการใช้งาน ตรวจสอบในแดชบอร์ดได้

Kimi K2.6 ใช้งานได้กับ LangChain, LlamaIndex, Vercel AI SDK หรือไม่?ได้ เฟรมเวิร์กใดๆ ที่รองรับ Base URL ที่เข้ากันได้กับ OpenAI ก็สามารถใช้งานได้

Kimi K2.6 รองรับ JSON mode หรือไม่?รองรับ ส่ง response_format: {"type": "json_object"} เพื่อให้ได้เอาต์พุต JSON ที่ถูกต้อง หรือ {"type": "json_schema", "json_schema": {...}} สำหรับสคีมาที่เข้มงวด

ขนาดของหน้าต่างบริบท (context window) คือเท่าใด?อินพุต 262,144 โทเค็น, เอาต์พุตสูงสุด 98,304 โทเค็นสำหรับงานการให้เหตุผล ตามที่ระบุใน บล็อกอย่างเป็นทางการ

ฉันสามารถปรับแต่ง Kimi K2.6 ผ่าน API ได้หรือไม่?ยังไม่รองรับ ในตอนนี้ การปรับแต่งหมายถึงการรัน น้ำหนักโมเดลแบบโอเพนซอร์ส บนฮาร์ดแวร์ของคุณเอง

อะไรคือความแตกต่างระหว่าง kimi-k2.6 และ kimi-k2.6-thinking?kimi-k2.6 เป็นโมเดลเอเจนต์ที่รวดเร็ว ส่วน kimi-k2.6-thinking จะเปิดเผยขั้นตอนการให้เหตุผลและถูกปรับแต่งมาสำหรับคณิตศาสตร์ ตรรกะ และการวางแผนที่ซับซ้อน (AIME 2026: 96.4%, GPQA-Diamond: 90.5%)

มีแพ็กเกจฟรีหรือไม่?ดู คู่มือการเข้าถึง Kimi K2.6 ฟรี สำหรับ Cloudflare Workers AI, แชท kimi.com และตัวเลือกการโฮสต์ด้วยตัวเอง

สรุป

Kimi K2.6 API สามารถนำไปใช้กับชุดเครื่องมือที่เข้ากันได้กับ OpenAI ได้ด้วยการเปลี่ยนแปลงเพียงสองอย่าง: Base URL และคีย์ API ของคุณ จากนั้นคุณจะได้รับหน้าต่างบริบทขนาด 262K, Agent Swarm พร้อมซับเอเจนต์ 300 ตัว, การเรียกใช้เครื่องมือที่ปรับแต่งให้สำเร็จ 96.60% และน้ำหนักโมเดลโอเพ่นซอร์สเป็นทางเลือกสำรอง หากคุณต้องการเปลี่ยนจาก API ที่โฮสต์ไว้

หากคุณกำลังสร้างการผสานรวมใหม่ ให้ใช้ Apidog เพื่อสร้างและตรวจสอบแต่ละเอนด์พอยต์ก่อน คุณจะพบข้อผิดพลาดของสคีมา ข้อบกพร่องในการสตรีม และปัญหาการยืนยันตัวตน ก่อนที่จะส่งผลกระทบต่อ codebase ของคุณ จากนั้นนำคำขอที่ใช้งานได้ไปใส่ในบริการ Python หรือ Node ของคุณได้อย่างมั่นใจ

ข้อมูลอ้างอิงและอ่านเพิ่มเติม

ฝึกการออกแบบ API แบบ Design-first ใน Apidog

ค้นพบวิธีที่ง่ายขึ้นในการสร้างและใช้ API

ลงทะเบียนฟรีดาวน์โหลด