TL;DR
Kimi Hosted Agents ทำงาน AI แบบหลายขั้นตอนด้วยเซสชันที่คงอยู่ การเรียกใช้เครื่องมือ และแซนด์บ็อกซ์บนคลาวด์ คู่มือนี้พาคุณตั้งแต่คีย์ API ของ Kimi ไปจนถึงงานนำเสนอแบบสามสไลด์ที่ดาวน์โหลดได้ โดยใช้ Bash, curl และ jq เริ่มจากงานหนึ่งงานด้วยพรอมป์ต์ที่พึ่งพาตนเอง จากนั้นเพิ่มเอกสารที่อัปโหลด เชื่อมต่อเครื่องมือธุรกิจ และจัดการความล้มเหลวที่สำคัญต่อแอปพลิเคชันที่ดีพอจะใช้งานจริง
Key Takeaways
- Kimi Hosted Agents เชื่อมโยงคำจำกัดความของเอเจนต์ สภาพแวดล้อมการรัน และเซสชัน เก็บ ID ของทั้งสามไว้ใช้ตลอดเวิร์กโฟลว์
- เริ่มจากผลลัพธ์เล็ก ๆ ที่ตรวจสอบได้ ตัวอย่างแรกสร้างงานนำเสนอด้วยข้อมูลสมมติและการคำนวณที่คุณตรวจสอบได้
- ใช้สตรีมเหตุการณ์เพื่อติดตามการรัน แล้วตรวจสอบไฟล์ที่ส่งมอบ การตอบกลับ HTTP ที่สำเร็จอย่างเดียวไม่ยืนยันความสำเร็จของงาน
- ขยายตัวอย่างที่ใช้งานได้ด้วยอินพุตไฟล์ เครื่องมือแบบกำหนดเอง หรือบริการ MCP แต่ละการเชื่อมต่อมีข้อกำหนดการรันและข้อมูลยืนยันตัวตนของตนเอง
- วางงบประมาณรวมกันสำหรับอินเฟอเรนซ์ เวลารันของแซนด์บ็อกซ์ และการใช้ปลั๊กอิน รวมถึงการรันซ้ำที่จำเป็นเพื่อให้ได้ผลลัพธ์ที่ยอมรับได้
What Is Kimi Hosted Agents?
Moonshot AI ประกาศ Kimi Hosted Agents เมื่อวันที่ 5 พฤศจิกายน 2026 โดยวางตำแหน่งเป็นบริการสำหรับองค์กรและนักพัฒนาที่สร้างเอเจนต์ระยะยาว
ผลิตภัณฑ์นี้ใช้แนวทาง Harness as a Service โดย harness คือซอฟต์แวร์รอบโมเดลที่จัดการความคืบหน้าของงาน: รักษาสถานะ เรียกใช้เครื่องมือ จัดการการรัน และกู้คืนจากการหยุดชะงัก
ลองนึกถึงเวิร์กโฟลว์วิจัยรายสัปดาห์ การสร้างข้อความเป็นเพียงขั้นตอนเดียว แอปพลิเคชันอาจต้องดึงแหล่งข้อมูล ประมวลผลไฟล์ สร้างชาร์ต บันทึกงานนำเสนอ และรักษาสถานะให้มากพอที่จะดำเนินต่อหลังจากตัดการเชื่อมต่อ
Hosted Agents จัดหาเลเยอร์เชิงปฏิบัติการนั้น ทีมของคุณยังคงกำหนดงานธุรกิจ เลือกการเชื่อมต่อ และตัดสินว่าอะไรคือผลลัพธ์ที่ยอมรับได้
สถาปัตยกรรมอย่างเป็นทางการ ของ Kimi แสดงแอปพลิเคชัน บริการแพลตฟอร์ม และแกนการรันที่ใช้โดยรันไทม์แบบโฮสต์
ความสามารถหลักสำหรับการเชื่อมต่อครั้งแรกของคุณ
- เซสชันที่คงอยู่เก็บอินพุตของงาน เหตุการณ์การรัน และเอาต์พุตไว้ด้วยกัน
- แซนด์บ็อกซ์บนคลาวด์จัดเตรียมเครื่องมือที่ต้องใช้ในการประมวลผลไฟล์และสร้างสิ่งส่งมอบ
- Skills และปลั๊กอินแพ็กความสามารถที่ใช้ซ้ำได้; เครื่องมือแบบกำหนดเองและบริการ MCP เชื่อมระบบของคุณเอง
จุดตรวจแรกของคุณคืองานนำเสนอที่คุณสามารถเปิดและตรวจสอบได้ ข้อกำหนดรันไทม์ที่ละเอียดจะมีประโยชน์เมื่อคุณเพิ่มการพึ่งพา หรือย้ายเวิร์กโฟลว์ที่มีอยู่เข้าสู่แซนด์บ็อกซ์; อ้างอิงของแซนด์บ็อกซ์ บันทึกรายละเอียดสภาพแวดล้อมที่มีให้
What Do You Need Before Calling the Kimi Hosted Agents API?
- บัญชีแพลตฟอร์ม Kimi ที่เข้าถึง Hosted Agents และคีย์ API
- Bash, curl และ jq บน macOS, Linux หรือ Windows พร้อม WSL
- สองเทอร์มินัล: เทอร์มินัล A ส่งคำขอ; เทอร์มินัล B เฝ้าดูเหตุการณ์การรัน
- โปรแกรมดูงานนำเสนอสำหรับเปิด PPTX ที่สร้างขึ้น
สร้างบัญชีแพลตฟอร์ม Kimi และคีย์ API ในพื้นที่จัดการ API ของคอนโซล ใช้เทอร์มินัล Bash หนึ่งชุด เรียกชื่อว่าเทอร์มินัล A สำหรับคำสั่งตั้งค่าและงาน เก็บมันไว้เปิดเพื่อให้ขั้นตอนถัดไปสามารถนำตัวแปรกลับมาใช้ ติดตั้ง curl และ jq ก่อนดำเนินการ ตัวอย่างใช้เวอร์ชัน API แบบเบต้า 2026-09-01-beta
command -v curl &&
command -v jq &&
read -rsp "Kimi API key: " KIMI_API_KEY &&
printf '\n' &&
test -n "$KIMI_API_KEY" &&
export KIMI_API_KEY &&
export KIMI_BASE="https://api.moonshot.cn/v1" &&
export KIMI_VERSION="2026-09-01-beta"
How Do You Run Your First Kimi Hosted Agents Task
เวิร์กโฟลว์นี้ทำตามคู่มือเริ่มต้นเร็ว REST API ของ Kimi คุณจะใช้ผู้ช่วย PPT อย่างเป็นทางการเพื่อเปลี่ยนบรีฟธุรกิจสมมติสั้น ๆ ให้เป็นงานนำเสนอ อินพุตทั้งหมดถูกรวมไว้ในคำขอ ดังนั้นการรันครั้งแรกไม่ต้องอัปโหลดไฟล์หรือเชื่อมต่อข้อมูลส่วนตัว
รันแต่ละบล็อกตามลำดับและตรวจสอบผลลัพธ์ก่อนดำเนินการต่อ คำสั่งที่เชื่อมด้วย && จะหยุดบล็อกนั้นเมื่อคำขอหรือการตรวจสอบล้มเหลว แก้ไขข้อผิดพลาดที่รายงานก่อนย้ายไปขั้นต่อไป; ใช้ ID ของสภาพแวดล้อมและเซสชันเดิมเมื่อรันใหม่ในการตั้งค่าที่มีอยู่
Step 1: Select the official PPT assistant
ดึงเอเจนต์ที่มีอยู่และตรวจสอบชื่อกับคำจำกัดความ เมื่อได้รับการถาม ให้พิมพ์ ID ของผู้ช่วย PPT อย่างเป็นทางการที่ตั้งค่าไว้ด้วยทักษะ PPT คำสั่งสุดท้ายตรวจสอบว่าการเลือกของคุณมีอยู่ในรายการที่คืนมาและพิมพ์คำจำกัดความของมัน
curl --fail-with-body -sS "$KIMI_BASE/agents" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-o agents.json &&
jq -r '.items[] | [.id, .name] | @tsv' agents.json &&
read -rp "PPT assistant ID: " AGENT_ID &&
jq -e --arg id "$AGENT_ID" \
'.items[] | select(.id == $id)' agents.json &&
export AGENT_ID
คำสั่งสุดท้ายควรพิมพ์คำจำกัดความของเอเจนต์ที่เลือก หากผู้ช่วยนี้ไม่มีในโปรเจ็กต์ของคุณ ให้ใช้การตั้งค่าเอเจนต์ PPT อย่างเป็นทางการ เพื่อเตรียมเอเจนต์เทียบเท่าก่อนดำเนินการต่อ
Step 2: Create a cloud environment
Environment คือการกำหนดค่าที่นำกลับมาใช้ได้สำหรับการตั้งค่าการรันของคุณ รวมถึงแพ็กเกจที่ติดตั้ง การเข้าถึงเครือข่าย และคำสั่งเริ่มต้น การนำกลับมาใช้ทำให้เซสชันถัดไปได้การตั้งค่าเดียวกัน; แต่ละเซสชันบนคลาวด์ยังได้รับแซนด์บ็อกซ์และพื้นที่ทำงานของตนเอง ดูคู่มือสภาพแวดล้อม สำหรับตัวเลือกการกำหนดค่า
สร้างสภาพแวดล้อมครั้งเดียวและเก็บ ID ของมันไว้ อิมเมจคลาวด์ถูกสร้างอย่างไม่ประสานกัน ดังนั้นรอจนสถานะการสร้างเป็น ready ก่อนสร้างเซสชัน หาก API รายงานว่าไม่พร้อม ให้รอและลองอีกครั้งด้วย ENVIRONMENT_ID เดิม การสร้างสภาพแวดล้อมอีกอันไม่ได้ทำให้การสร้างแรกเสร็จ
curl --fail-with-body -sS "$KIMI_BASE/environments" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-H "Content-Type: application/json" \
-d '{"name":"First presentation environment","config":{"type":"cloud"}}' \
-o environment.json &&
ENVIRONMENT_ID="$(jq -er '.id | strings | select(length > 0)' environment.json)" &&
export ENVIRONMENT_ID &&
printf 'Environment: %s\n' "$ENVIRONMENT_ID"
Step 3: Create a session
Session จะตรึงเวอร์ชันของ Agent และ Environment ที่มีอยู่ ณ เวลาสร้าง คำขอด้านล่างส่ง ID ของทั้งสอง; แพลตฟอร์มจะเลือกและตรึงเวอร์ชัน คุณยังสามารถตั้งค่า agent_version เพื่อเลือกเวอร์ชัน Agent ที่แน่นอน การอัปเดต Agent หรือ Environment ในภายหลังจะไม่อัปเดตเซสชันที่มีอยู่ และเซสชันไม่สามารถสลับ environment_id ได้ สร้างเซสชันใหม่เพื่อใช้การตั้งค่าแก้ไข กฎเหล่านี้ถูกบันทึกไว้ในการสร้างเซสชัน
เก็บ ID เซสชันที่คืนมาสำหรับทั้งสตรีมเหตุการณ์และคำของาน เซสชันใหม่เริ่มในสถานะ idle; การส่ง user.message เริ่มงาน
test -n "$AGENT_ID" &&
test -n "$ENVIRONMENT_ID" &&
jq -n --arg agent "$AGENT_ID" --arg env "$ENVIRONMENT_ID" \
'{agent_id:$agent,environment_id:$env,title:"First product update presentation"}' \
> session-request.json &&
curl --fail-with-body -sS "$KIMI_BASE/sessions" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-H "Content-Type: application/json" \
--data-binary @session-request.json \
-o session.json &&
SESSION_ID="$(jq -er '.id | strings | select(length > 0)' session.json)" &&
export SESSION_ID &&
printf 'Session: %s\n' "$SESSION_ID"
Step 4: Watch execution in a second terminal
เปิดเทอร์มินัล B ใส่คีย์ API เดียวกัน แล้ววาง ID เซสชันที่พิมพ์ในเทอร์มินัล A สตรีมเหตุการณ์ที่ส่งจากเซิร์ฟเวอร์ จะแสดงอัปเดตการรันขณะที่เทอร์มินัล A ส่งงาน ปล่อยให้เทอร์มินัลนี้เชื่อมต่อจนคุณตรวจสอบผลลัพธ์แล้ว
read -rsp "Kimi API key: " KIMI_API_KEY &&
printf '\n' &&
test -n "$KIMI_API_KEY" &&
read -rp "Session ID from Terminal A: " SESSION_ID &&
test -n "$SESSION_ID" &&
curl --fail-with-body -sS -N \
"https://api.moonshot.cn/v1/sessions/$SESSION_ID/events/stream" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: 2026-09-01-beta" \
-H "Accept: text/event-stream"
Step 5: Send a self-contained task
กลับไปที่เทอร์มินัล A และส่งเหตุการณ์ user.message ตัวอย่างนี้ใช้ตัวเลขสมมติและขอสิ่งส่งมอบเฉพาะ เอเจนต์ควรใช้ข้อเท็จจริงที่ให้มาแทนที่จะค้นหาข้อมูลธุรกิจสนับสนุน
cat > task.json <<'JSON' &&
{
"events": [{
"type": "user.message",
"data": {"content": [{
"type": "text",
"text": "Create a three-slide PPTX for a fictional product called Northstar. Use only these supplied facts: the pilot has 120 users; 90 were active this week; the team plans to interview 10 users next week. Slide 1: pilot overview. Slide 2: weekly activity, including the active-user percentage. Slide 3: next steps. Label the business and data as fictional. Do not browse the web. Save the presentation and register the PPTX as a downloadable artifact using save_artifact."
}]}
}]
}
JSON
curl --fail-with-body -sS "$KIMI_BASE/sessions/$SESSION_ID/events" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-H "Content-Type: application/json" \
--data-binary @task.json
Step 6: Download and inspect the presentation
ดูเทอร์มินัล B สำหรับเหตุการณ์ session.status เมื่อเซสชันกลับไปเป็น idle ให้ตรวจสอบสาเหตุการหยุด: end_turn ระบุว่ารอบเสร็จแล้ว ขณะที่ requires_action หมายความว่าลูกค้าของคุณต้องส่งผลลัพธ์ของเครื่องมือหรือจัดการการยืนยัน ตรวจสอบเหตุการณ์ session.error ด้วย หลังจากรอบจบโดยไม่มีข้อผิดพลาดที่ยังไม่แก้ไข ให้แสดงรายการอาร์ติแฟกต์และเลือก PPTX ที่สร้าง
curl --fail-with-body -sS "$KIMI_BASE/artifacts?session_id=$SESSION_ID" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-o artifacts.json &&
jq . artifacts.json &&
read -rp "PPTX artifact ID: " ARTIFACT_ID &&
test -n "$ARTIFACT_ID" &&
curl --fail-with-body -sS "$KIMI_BASE/artifacts/$ARTIFACT_ID/content" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-o northstar.pptx &&
printf 'Downloaded northstar.pptx\n'
เปิด northstar.pptx ผลลัพธ์ที่สำเร็จมีสามสไลด์ ระบุว่าข้อมูลเป็นสมมติ และคำนวณกิจกรรมรายสัปดาห์เป็น 90 ÷ 120 = 75% ซึ่งให้การตรวจสอบที่เป็นรูปธรรมทั้งการส่งมอบไฟล์และความถูกต้องของเนื้อหาก่อนเชื่อมต่อข้อมูลธุรกิจจริง
How to Upload and Attach Files to a Kimi Hosted Agents Session?
หลังจากงานนำเสนอแรกทำงานได้ ให้วาง report.pdf ตัวอย่างไว้ในไดเรกทอรีทำงานของเทอร์มินัล A API ไฟล์ แยกการอัปโหลดไฟล์ออกจากการแนบกับเซสชัน รันบล็อกนี้ด้วย ID เซสชันที่มีอยู่หลังจากงานแรกเสร็จ
ใช้ purpose=file-extract เพื่อแยกข้อความจาก PDF API ไฟล์ อนุญาตสูงสุด 100 MiB ต่อไฟล์และค่าเริ่มต้น 10 GiB ของพื้นที่จัดเก็บต่อองค์กร ไฟล์ที่อัปโหลดไม่สามารถอัปเดตทับที่เดิมได้; อัปโหลดไฟล์แก้ไขและผูก ID ใหม่ ลบไฟล์ที่ไม่ใช้เมื่อคุณต้องการคืนพื้นที่จัดเก็บ
ด้วย kimi-api-version: 2026-09-01-beta ตรวจสอบ extract_status ในการตอบกลับการอัปโหลด ตัวอย่างนี้ดำเนินต่อเฉพาะเมื่อเป็น ready หากเป็น error ให้ตรวจสอบรูปแบบและเนื้อหาของ PDF แล้วอัปโหลดไฟล์ที่แก้ไข API สามารถแนบการแยกที่ล้มเหลวเป็นไฟล์ดิบ แต่จะไม่ให้ข้อความที่แยกออกมาซึ่งบทเรียนนี้คาดหวัง สถานะที่หายไปหรือไม่คาดคิดจะหยุดบล็อกด้วย; ตรวจสอบ upload.json ก่อนดำเนินการต่อ
test -f report.pdf &&
test -n "$SESSION_ID" &&
curl --fail-with-body -sS "$KIMI_BASE/files" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-F "file=@report.pdf" \
-F "purpose=file-extract" \
-o upload.json &&
FILE_ID="$(jq -er '.id | strings | select(length > 0)' upload.json)" &&
{
EXTRACT_STATUS="$(jq -r '.extract_status // "missing"' upload.json)" &&
case "$EXTRACT_STATUS" in
ready) true ;;
error)
printf '%s\n' 'PDF extraction failed. Check the PDF and upload a corrected file.' >&2
false ;;
*)
printf 'Unexpected extract_status: %s. Inspect upload.json before continuing.\n' "$EXTRACT_STATUS" >&2
false ;;
esac
} &&
jq -n --arg file "$FILE_ID" \
'{type:"file",file_id:$file}' > resource-request.json &&
curl --fail-with-body -sS "$KIMI_BASE/sessions/$SESSION_ID/resources" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-H "Content-Type: application/json" \
--data-binary @resource-request.json
การแนบไฟล์ไม่ได้ส่งงานใหม่ เก็บเทอร์มินัล B ให้เชื่อมต่อและส่งต่อเนื่องที่ระบุชื่อเอกสารและสิ่งที่ต้องการเป็นเอาต์พุต
jq -n --arg prompt \
"Use the attached report.pdf to create a new three-slide PPTX. Replace the earlier fictional brief. Summarize the report, its evidence, and its next steps. Do not invent missing figures or browse the web. Register the finished PPTX with save_artifact." \
'{events:[{type:"user.message",data:{content:[{type:"text",text:$prompt}]}}]}' \
> followup.json &&
curl --fail-with-body -sS "$KIMI_BASE/sessions/$SESSION_ID/events" \
-H "Authorization: Bearer $KIMI_API_KEY" \
-H "kimi-api-version: $KIMI_VERSION" \
-H "Content-Type: application/json" \
--data-binary @followup.json
เมื่อภารกิจนี้เสร็จ ให้ทำซ้ำขั้นตอนการแสดงรายการอาร์ติแฟกต์และเลือก PPTX ใหม่ เปรียบเทียบข้ออ้างของมันกับ PDF โดยเฉพาะตัวเลข วันที่ และการดำเนินการที่เสนอ
How Do You Connect Tools to Kimi Hosted Agents?
เครื่องมือแบบกำหนดเองที่ดำเนินการโดยแอปพลิเคชันของคุณ
สำหรับการดำเนินการทางธุรกิจ เช่น ดูสถานะการส่งมอบของโปรเจ็กต์ ให้ใช้เครื่องมือแบบกำหนดเอง ที่แอปพลิเคชันของคุณเป็นคนทำงาน การประกาศเครื่องมือทำให้เอเจนต์สามารถใช้งาน; โค้ดของคุณยังคงเป็นผู้ดำเนินการจริง
- ประกาศเอนทรี
customในอาร์เรย์toolsของเอเจนต์ โดยมีชื่อ คำอธิบาย และinput_schemaแบบอ็อบเจ็กต์ - จัดการ
agent.custom_tool_useจากสตรีมเหตุการณ์และตรวจสอบอาร์กิวเมนต์ที่ให้มาก่อนเรียกใช้ฟังก์ชันของคุณ - โพสต์เหตุการณ์
user.custom_tool_resultไปยังเซสชัน โดยใช้ค่า JSONidของเหตุการณ์ที่เรียกเป็นdata.event_id
เริ่มจากการดึงข้อมูลแบบอ่านอย่างเดียว เก็บการยืนยันตัวตนและการป้องกันการทำซ้ำไว้ในแอปพลิเคชันเมื่อการเชื่อมต่อสามารถแก้ไขระเบียนธุรกิจได้
บริการ MCP และเวิร์กโฟลว์ขนาดใหญ่กว่า
สำหรับบริการ MCP ระยะไกล ให้ประกาศการเชื่อมต่อของมันใน mcp_servers เก็บข้อมูลยืนยันตัวตนไว้ใน vault และผูก vault นั้นเมื่อสร้างเซสชัน แพลตฟอร์มจะค้นพบและเรียกเครื่องมือของบริการ; คำจำกัดความของเซิร์ฟเวอร์ควรมีรายละเอียดการเชื่อมต่อไม่ใช่ความลับ
การจัดออร์เคสเตรตแบบหลายเอเจนต์ (เลือกได้)
แพลตฟอร์มรองรับการมอบหมายจากผู้ประสานงานไปยังลูก ผู้ประสานงานสามารถมอบหมายงานที่จำกัดให้กับเธรดลูกและรวมผลลัพธ์ของพวกเขา
การกำหนดค่าการมอบหมายรับ เอ็นทรีเอเจนต์ 1–20 รายการ นี่เป็นข้อจำกัดการกำหนดค่า ไม่ใช่หลักฐานของคนงานพร้อมกัน 20 คนหรือการเร่งความเร็ว 20× เธรดลูกไม่สามารถสร้างอีกชั้นของเธรดลูกได้
การออกแบบที่มีประโยชน์อาจแยกการรวบรวมแหล่งข้อมูล การวิเคราะห์เชิงปริมาณ และการตรวจทานเชิงบรรณาธิการ งานย่อสั้นมักจัดการได้ดีกว่าด้วยเอเจนต์เดียว
How Should You Deploy a Kimi Hosted Agents Integration?
วางการเรียก Kimi API ไว้หลังแบ็กเอนด์ของแอปพลิเคชัน เบราว์เซอร์สามารถส่งงานและแสดงความคืบหน้าผ่านเอนด์พอยต์ของคุณเอง ขณะที่แบ็กเอนด์เก็บคีย์ API และแมปผู้ใช้แต่ละคนกับเซสชันที่พวกเขาเข้าถึงได้ เก็บ ID เซสชันไว้กับคำขอธุรกิจเพื่อให้การโหลดหน้าใหม่สามารถเปิดงานเดียวกันอีกครั้ง
Hosted vs. Self-Hosted Execution
ใช้สภาพแวดล้อมบนคลาวด์สำหรับเวิร์กโฟลว์ PPT ในคู่มือนี้: มันรองรับ save_artifact และเวิร์กโฟลว์ไฟล์เซสชัน เลือกสภาพแวดล้อมแบบ self-hosted เมื่อการรันในแซนด์บ็อกซ์ต้องทำงานบนโฮสต์ที่องค์กรของคุณจัดการ Kimi ยังคงรันอินเฟอเรนซ์ของโมเดล ออร์เคสเตรชัน และการจัดการเซสชัน; อินพุตเครื่องมือและผลลัพธ์ผ่านแพลตฟอร์มของมัน นี่คือโมเดลการรันแบบไฮบริด
- สภาพแวดล้อม self-hosted ต้องมีการยืนยันระดับองค์กร คุณดำเนินการโฮสต์ Worker ติดตั้งการพึ่งพา และจัดการการแยกและข้อมูลยืนยันตัวตน Worker ต้องมีการเข้าถึง HTTPS ขาออกไปยังแพลตฟอร์ม
- โหมด self-hosted ปัจจุบันไม่มี
save_artifact, IPython และเครื่องมือค้นหารูปภาพ ไฟล์ที่อัปโหลด ทักษะ และหน่วยความจำจะไม่ถูกเมานต์บน Worker และไฟล์เอาต์พุตของมันจะไม่ปรากฏในรายการไฟล์ของเซสชัน วางแผนว่าคุณจะส่งอินพุตและดึงเอาต์พุตอย่างไร ก่อนย้ายบทเรียนนี้ไปยังโหมดนั้น
สำหรับการเชื่อมต่อครั้งแรก เริ่มบนคลาวด์ พิจารณา self-hosting เมื่อการควบคุมโฮสต์การรันคุ้มค่ากับการตั้งค่าเพิ่มเติมและการเปลี่ยนแปลงการส่งไฟล์
การเลือกว่าผู้ใดจะเป็นผู้ดำเนินการรันไทม์
ใช้ Hosted Agents เมื่อคุณต้องการให้แพลตฟอร์มจัดการการรันของเซสชัน หากทีมของคุณต้องสร้างและดำเนินการลูปเอเจนต์เอง CometAPI ให้การเข้าถึง API โมเดลแบบรวม สำหรับสแตกแบบกำหนดเองนั้น ตัวอย่าง Hosted Agents ในคู่มือนี้ใช้เอนด์พอยต์และข้อมูลยืนยันตัวตนของ Kimi เอง
Kimi Hosted Agents Pricing and Cost Optimization
Kimi Hosted Agents คิดค่าบริการสำหรับโทเคนของโมเดล เวลารันแซนด์บ็อกซ์บนคลาวด์ และการเรียกปลั๊กอินที่มีค่าบริการ ตารางด้านล่างแสดงว่าค่าใช้จ่ายเหล่านั้นส่งผลต่อเวิร์กโฟลว์งานนำเสนออย่างไร ราคาคิดเป็นเงินหยวนจีน (CNY) ตรวจสอบเมื่อวันที่ 10 พฤศจิกายน 2026 เทียบกับราคา Hosted Agents และราคาอินเฟอเรนซ์โมเดล หนึ่งล้านโทเคนเท่ากับ 1 MTok
| องค์ประกอบค่าใช้จ่าย | หน่วยการคิดเงิน | อัตราและความหมายต่อภารกิจของคุณ |
|---|---|---|
| อินเฟอเรนซ์โมเดล | ต่อ 1 MTok | สำหรับ kimi-k3.1-pro: อินพุตฐาน ¥13 เอาต์พุต ¥68 การโดนแคช ¥1.30 การเขียนแคช 5 นาที ¥13 และการเขียนแคช 1 ชั่วโมง ¥26 ใช้อัตราสำหรับแต่ละหมวดการใช้งานครอบคลุมทุกการเรียกโมเดล |
| แซนด์บ็อกซ์บนคลาวด์ | เวลารัน; คิดเงินเป็นวินาที | ¥0.072/ชั่วโมง สำหรับแซนด์บ็อกซ์ที่มี CPU 1 คอร์และหน่วยความจำ 1 GB สิบนาทีมีค่า ¥0.012 |
| ปลั๊กอิน | ต่อการเรียกที่คิดเงิน | ตัวอย่าง: ค้นเว็บ ¥0.03/ครั้ง; ค้นหารูปภาพ ¥0.045/ครั้ง ปลั๊กอินอื่นมีอัตราของตนเอง คูณจำนวนครั้งของแต่ละปลั๊กอินด้วยราคาที่ระบุ |
| ราคารวมต่อภารกิจ | ต่อภารกิจที่เสร็จสมบูรณ์ | บวกค่าบริการโมเดล แซนด์บ็อกซ์ และปลั๊กอิน ตัวอย่าง PPT ที่ทำงานด้านล่างรวม ¥0.544 โดยไม่มีการเรียกปลั๊กอินที่คิดเงิน หรือ ¥0.724 เมื่อมีการค้นเว็บสามครั้งและการค้นหารูปภาพสองครั้ง ที่การใช้งานโมเดลและเวลารันสมมติเดียวกัน |
อัตราโมเดลเป็นตัวอย่างการวางงบประมาณสำหรับ kimi-k3.1-pro ไม่ใช่การอ้างว่าทุก Agent PPT อย่างเป็นทางการใช้โมเดลนั้น ตรวจสอบคำจำกัดความโมเดลของ Agent ที่เลือกก่อนใช้อัตราเหล่านี้ อัตราสำหรับโมเดลอื่นและรุ่นความเร็วสูงแตกต่างกัน
How to count input and output tokens
เอเจนต์สามารถเรียกโมเดลหลายครั้งขณะสร้างงานนำเสนอหนึ่งชุด รวมการใช้งานที่คิดเงินจากทุกการเรียก รวมถึงรอบต่อเนื่องและการแก้ไข อินพุตอาจรวมพรอมป์ต์ ข้อความ PDF ที่แยก เครื่องมือผลลัพธ์ และบริบทการสนทนา; การใช้งานเอาต์พุตไม่จำกัดเฉพาะคำที่มองเห็นบนสไลด์
สำหรับการแคช K3 ให้แยกอินพุตที่ไม่โดนแคช การเขียนแคช และการโดนแคช นี่เป็นหมวดอินพุตที่แตกต่างกัน: อย่าคิดเงินรวมอินพุตทั้งหมดที่อัตราฐานแล้วบวกค่าธรรมเนียมแคชสำหรับโทเคนเดียวกัน ใช้อัตราการเขียน 5 นาทีหรือ 1 ชั่วโมงที่เหมาะสม คู่มือการคิดเงินของแคช อธิบายวิธีปรับหมวดเหล่านี้ให้สอดคล้องกับการใช้งานที่รายงาน
Worked example: a three-slide presentation
สมมติว่าเอเจนต์ของคุณใช้ kimi-k3.1-pro และการรันงานนำเสนอครบสามสไลด์ใช้ 20,000 โทเคนอินพุต 4,000 โทเคนเอาต์พุตที่คิดเงิน และเวลารันบนคลาวด์ 10 นาที สมมติว่าไม่มีการโดนแคช ไม่มีการเขียนแคช 1 ชั่วโมง และไม่มีการเรียกปลั๊กอินที่คิดเงิน อินพุตทั้งหมดเป็นแบบไม่โดนแคชหรือเขียนไปยังแคชมาตรฐาน 5 นาที ซึ่งทั้งสองราคาที่ ¥13/MTok ปริมาณเหล่านี้เป็นค่าประมาณเพื่อการวางแผน ไม่ใช่การวัดของบทเรียน Northstar
| ค่าใช้จ่าย | การคำนวณ | ราคาประมาณ |
|---|---|---|
| อินพุตโมเดล | 20,000 ÷ 1,000,000 × ¥13 | ¥0.260 |
| เอาต์พุตโมเดล | 4,000 ÷ 1,000,000 × ¥68 | ¥0.272 |
| แซนด์บ็อกซ์คลาวด์ | 10 ÷ 60 × ¥0.072 | ¥0.012 |
| ปลั๊กอินที่คิดเงิน | 0 ครั้ง | ¥0.000 |
| รวม | ¥0.260 + ¥0.272 + ¥0.012 | ¥0.544 (ประมาณ ¥0.54) |
บทเรียนข้อมูลที่ให้มาขอให้เอเจนต์ไม่ท่องเว็บ หากภายหลังคุณขยายเป็นงานนำเสนอวิจัยที่มีการค้นเว็บสามครั้งและการค้นหารูปภาพสองครั้ง ค่าปลั๊กอินจะเป็น 3 × ¥0.03 + 2 × ¥0.045 = ¥0.180 โดยคงปริมาณอื่นไว้เท่าเดิมจะได้ ¥0.544 + ¥0.180 = ¥0.724 งานวิจัยอาจเพิ่มโทเคนโมเดลและเวลารันด้วย ดังนั้นใช้ปริมาณที่วัดได้สำหรับบิลสุดท้าย
What changes when you use multiple agents?
การมอบหมายสามารถเพิ่มการเรียกโมเดล บริบทซ้ำ การเรียกเครื่องมือ และงานแก้ไข เวิร์กโฟลว์หลายเอเจนต์ ของ Kimi วางผู้ประสานงานและเธรดลูกไว้ในเซสชันเดียว จำนวนเธรดลูกเพียงอย่างเดียวไม่ใช่ตัวคูณสำหรับค่าแซนด์บ็อกซ์ รวมการใช้งานโมเดลและปลั๊กอินข้ามเธรด และใช้เวลารันที่คิดเงินจริงของเซสชัน เวลาการรันที่ยาวขึ้นหรือเซสชันคลาวด์อิสระเพิ่มเติมสามารถเพิ่มค่าแซนด์บ็อกซ์ FAQ อธิบายว่าเวลาของแซนด์บ็อกซ์หยุดสะสมเมื่อเธรดทั้งหมดเสร็จและเซสชันกลับเป็น idle
Reduce cost per usable presentation
เริ่มจากเอเจนต์เดียวและสิ่งส่งมอบเล็ก ๆ จัดเตรียมข้อความต้นทางที่เกี่ยวข้อง จำกัดจำนวนสไลด์ และเปิดใช้งานการค้นแบบคิดเงินเฉพาะเมื่อภารกิจจำเป็น เชื่อมต่อสตรีมเหตุการณ์ที่หลุดอีกครั้งแทนการส่งงานเดิมซ้ำ สำหรับเวิร์กโฟลว์ที่ทำซ้ำ ให้ตรวจสอบการโดนแคชและคงบริบทที่ใช้ซ้ำได้ให้คงที่ เปรียบเทียบต้นทุนรวมของทุกความพยายามกับจำนวนงานนำเสนอที่คุณยอมรับจริง; ร่างแรกที่ราคาถูกซึ่งต้องรันใหม่หลายครั้งอาจมีต้นทุนรวมสูงกว่า
Troubleshooting Common API Errors
- การยืนยันตัวตนล้มเหลว: ตรวจสอบว่าคีย์ API ตั้งค่าในเทอร์มินัลที่ส่งคำขอและเป็นของบัญชีที่ต้องการ ตรวจสอบข้อผิดพลาด HTTP ก่อนทำคำขอซ้ำ
- curl ปฏิเสธออปชัน หรือ jq หายไป: ตรวจสอบยูทิลิตีที่ติดตั้ง ตัวอย่างนี้ต้องการ curl ที่รองรับ
--fail-with-bodyและโปรแกรม jq ที่ใช้งานได้ในสภาพแวดล้อม Bash เดียวกัน - jq ไม่สามารถดึง ID ได้: เปิด JSON ที่บันทึกไว้ อาจมีข้อผิดพลาด API แทนที่จะเป็นอ็อบเจ็กต์ทรัพยากรที่สำเร็จ แก้ไขคำขอก่อนแทนการส่งผ่าน ID ว่างไปยังเอนด์พอยต์ถัดไป
- เวิร์กโฟลว์เครื่องมือแบบกำหนดเองหยุดคืบหน้า: ตรวจสอบเหตุการณ์เครื่องมือที่ค้างอยู่ สาเหตุการหยุด
requires_actionหมายความว่าลูกค้าต้องส่งผลลัพธ์ของเครื่องมือหรือจัดการการยืนยันก่อนที่เธรดที่ได้รับผลจะดำเนินต่อ - สไลด์ที่ดาวน์โหลดมีข้ออ้างที่ไม่รองรับ: เปรียบเทียบกับบรีฟหรือรายงานที่ให้มา ปรับแก้งานด้วยความคลาดเคลื่อนเฉพาะและตรวจสอบสิ่งส่งมอบถัดไปก่อนใช้งาน
บันทึกเอนด์พอยต์ สถานะ HTTP ID เซสชัน และเหตุการณ์ที่เกี่ยวข้องเมื่อวินิจฉัยความล้มเหลว เก็บคีย์ API ไว้นอกบันทึกการวิเคราะห์
Conclusion
เริ่มจากเวิร์กโฟลว์ Kimi Hosted Agents ที่สมบูรณ์หนึ่งชุด: เลือกเอเจนต์ เตรียมสภาพแวดล้อม สร้างเซสชัน ส่งงาน และตรวจสอบไฟล์ที่ส่งมอบ เมื่อเส้นทางนั้นทำงานได้ ให้เพิ่มเอกสารต้นทางและเครื่องมือธุรกิจที่แอปพลิเคชันของคุณต้องการ รักษาความคืบหน้าให้มองเห็นได้และตัดสินแต่ละการรันโดยความมีประโยชน์ของผลลัพธ์ ไม่ใช่เพียงว่าคำขอสำเร็จหรือไม่
FAQ
ฉันต้องส่งงาน Kimi Hosted Agents ซ้ำหลังจากตัดการเชื่อมต่อหรือไม่?
ไม่จำเป็น การตัดการเชื่อมต่อสตรีมเหตุการณ์ไม่ต้องส่งงานใหม่ เชื่อมต่อใหม่ด้วยค่า id: ของเฟรม SSE ล่าสุดใน Last-Event-ID header เพื่อกลับมาอ่านต่อ ค่านี้เป็นเคอร์เซอร์ของสตรีม ไม่ใช่ ID JSON ของอ็อบเจ็กต์เหตุการณ์ การเชื่อมต่อใหม่ช่วยหลีกเลี่ยงการส่งงานเดียวกันซ้ำโดยไม่ตั้งใจ
จะทำอย่างไรหากเอาต์พุตของ Kimi Hosted Agents หายไปจากอาร์ติแฟกต์?
ไฟล์ในแซนด์บ็อกซ์อาจมีอยู่โดยไม่ได้ลงทะเบียนเป็นอาร์ติแฟกต์ ตรวจสอบว่าเอเจนต์ทำงานนำเสนอเสร็จและเรียก save_artifact หากการลงทะเบียนหายไป ให้ใช้API ไฟล์ของเซสชัน เพื่อตรวจสอบไดเรกทอรีเอาต์พุต: GET /v1/sessions/{session_id}/filesystem?prefix=output รายการครอบคลุมครั้งละไดเรกทอรีหนึ่งชุด; อัปเดต prefix เพื่อตรวจสอบไดเรกทอรีย่อย ดาวน์โหลดไฟล์ที่เลือกด้วย GET /v1/sessions/{session_id}/filesystem/raw?path=output/northstar.pptx แทนที่พาธตัวอย่างด้วยพาธที่แน่นอนตามที่รายการคืนค่า ค่าในคิวรีต้อง URL-encode หากพาธมีช่องว่างหรืออักขระสงวนอื่น รวม header การยืนยันตัวตนและเวอร์ชัน API เดียวกันตามที่ใช้ในบทเรียน
การอัปเดตการตั้งค่าของ Kimi Hosted Agents จะเปลี่ยนเซสชันที่ทำงานอยู่หรือไม่?
ไม่ เซสชันใช้เวอร์ชันของเอเจนต์ที่ตรึงไว้ ณ เวลาสร้าง การอัปเดตเอเจนต์จะสร้างเวอร์ชันใหม่สำหรับเซสชันถัดไป ขณะที่เซสชันที่มีอยู่จะคงการตั้งค่าเดิมไว้ หากต้องการทดสอบคำสั่งหรือเครื่องมือที่แก้ไข ให้เริ่มเซสชันใหม่และเปรียบเทียบผลลัพธ์กับการรันก่อนหน้า

