บทช่วยสอน Kimi K3.1 Pro API: สร้างเอเจนต์ 3D CAD ที่ตรวจตัวเองได้ใน Python

ใช้ Kimi K3.1 Pro API เพื่อสร้างเอเจนต์แปลงภาพเป็น CAD

เอเจนต์แปลงภาพเป็น CAD จะเปลี่ยนรูปชิ้นส่วนให้เป็นโมเดล CAD ที่แก้ไขได้

เหตุใด Kimi K3.1 Pro และ CadQuery จึงเหมาะกับงานแปลงภาพเป็น CAD

Kimi K3.1 Pro อ่านภาพสี่รูปแล้วตอบสนองต่อสิ่งที่โค้ดของตัวเองสร้างขึ้นได้ บล็อก Moonshot เดิมที่อ้างถึงรายงานคะแนน 92.7% เมื่อใช้เครื่องมือ และ 72.8% เมื่อไม่ใช้ บนงาน Vision2Code ของ BenchCAD ซึ่งให้คะแนนโค้ด CAD ที่เขียนจากวิวเรนเดอร์ของชิ้นส่วน ตัวเลขเหล่านี้มาจากชุดย่อย 1,000 เคสที่ความพยายามระดับ max และคะแนนที่ใช้เครื่องมือใช้ harness ของ Claude Code ดังนั้นบางส่วนของคะแนนอาจเป็นของ harness

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

เลือกใช้ CadQuery เป็นฟอร์แมตเอาต์พุต เพราะสคริปต์ CadQuery เองคือโมเดลแบบพารามิตริก รูคือคำสั่งเรียกที่มีเส้นผ่านศูนย์กลางและตำแหน่ง ดังนั้นการแก้ครั้งหลังจึงเปลี่ยนเพียงตัวเลขเดียวแล้วของแข็งก็สร้างใหม่ ไฟล์ STL ให้เพียงสามเหลี่ยม และไม่มี slot_width ให้เปลี่ยน

เอเจนต์เห็นอะไรและอะไรที่ยังซ่อนอยู่

Kimi ได้รับภาพอ้างอิงสี่รูป ความกว้าง 60 มม. และพรอมป์ตระบบ พรอมป์ตนั้นกำหนดให้ใช้หน่วยมิลลิเมตรและแกนพิกัด จัดกึ่งกลางชิ้นงานบนแกน X และ Y โดยฐานอยู่ที่ Z=0 และขอชื่อมิติพร้อมของแข็งสุดท้ายในตัวแปร result

หลังจากนั้น Kimi รู้เฉพาะสิ่งที่เครื่องมือรายงาน API ของ Kimi ไม่ได้รัน CadQuery ดังนั้นเครื่องมือทั้งสี่จึงอยู่ในแอปพลิเคชัน:

• execute_cad รันโปรแกรมในคอนเทนเนอร์ Docker แบบไม่มีเครือข่าย และบันทึกผลเป็นแคนดิดต

• inspect_cad รายงานความถูกต้อง จำนวนของแข็ง กล่องล้อม (bounding box) ปริมาตร และผิวทรงกระบอก

• render_cad วาดแคนดิดตจากกล้องสี่ตัวเดียวกับอ้างอิง

• submit_cad จบเฟสด้วยแคนดิดตหนึ่งตัว

Kimi ไม่เคยเห็นโค้ดอ้างอิงหรือคะแนนใด ๆ ตัวประเมินอ่านเฉพาะไฟล์ STEP ที่บันทึกไว้หลังจากเอเจนต์เสร็จงาน ดังนั้นคะแนนจึงไม่อาจชี้นำหรือหยุดเอเจนต์ได้

คะแนนไม่เคยไหลกลับไปหา Kimi ภาพโดยผู้เขียน

ตั้งค่า Kimi K3.1 Pro API ใน Python

การใช้ Kimi K3.1 Pro API ใน Python ต้องมีสี่อย่าง ได้ทดสอบทั้งหมดบน Linux x86_64 ด้วยเวอร์ชันดังนี้:

• คีย์ API ของ Kimi ที่เติมเงินไว้อย่างน้อย $1 ตาม คู่มือเริ่มต้น K3.1 Pro

• Python 3.12.3 พร้อม openai 3.39.0 ซึ่งเป็น OpenAI SDK

• cadquery 2.8.0 สำหรับสร้างและตรวจสอบของแข็ง

• Docker 29.9.2 สำหรับแซนด์บ็อกซ์

ตัวอย่างโค้ดด้านล่างเป็นบางส่วนจากโปรเจ็กต์เต็มใน ที่เก็บ GitHub ซึ่งจะโคลนในขั้นถัดไป

ติดตั้ง CadQuery และสร้างแซนด์บ็อกซ์ Docker

คู่มือติดตั้ง ของ CadQuery แนะนำ conda แม้ pip บน Python 3.12 ก็ใช้ได้เช่นกัน โคลนที่เก็บแล้วตั้งค่า:

git clone https://github.com/KhalidAbdelaty/Kimi_K3.1_Pro_API_Tutorial.git
cd Kimi_K3.1_Pro_API_Tutorial
python -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\Activate.ps1
pip install -r requirements.txt
cp .env.example .env             # then add your MOONSHOT_API_KEY
docker build -t cad-sandbox:2.8.0 sandbox/ขับเคลื่อนโดย

อิมเมจแซนด์บ็อกซ์ติดตั้ง CadQuery เวอร์ชันเดียวกันและรันด้วยผู้ใช้ปกติ Docker ไม่ได้ตั้งข้อจำกัด CPU หรือหน่วยความจำโดยค่าเริ่มต้น ตาม เอกสาร resource constraints ดังนั้นตัวรันเนอร์จึงเป็นฝ่ายกำหนด หน้าแรกของที่เก็บสรุปคำสั่งที่ใช้รันและให้คะแนนการทดลอง รวมถึงเส้นทางที่ไม่ต้องใช้คีย์ API หรือ Docker

ก่อนที่โค้ดของ Kimi จะเข้าไปในคอนเทนเนอร์ ลองพังมันเองก่อน โปรแกรมทดสอบของเราพยายามอ่านคีย์ API เข้าถึงเครือข่าย และเขียนนอกโฟลเดอร์ชั่วคราว และทั้งสามความพยายามล้มเหลว

สามปฏิบัติการที่ถูกบล็อกในแซนด์บ็อกซ์ ภาพโดยผู้เขียน

เรียก Kimi K3.1 Pro API ครั้งแรก

นี่คือ OpenAI SDK ปกติที่ชี้ไปยังเอนด์พอยต์ของ Moonshot กำหนด reasoning_effort ในทุกคำขอ เพราะถ้าละไว้จะได้ค่า max และไม่สามารถปิดโหมดคิดได้

client = OpenAI(api_key=os.environ["MOONSHOT_API_KEY"], base_url="https://api.moonshot.ai/v1")

response = client.chat.completions.create(
    model="kimi-k3.1-pro",
    reasoning_effort="high",        # low, high, or max; the API default is max
    max_completion_tokens=2048,     # reasoning and answer share this cap
    messages=[{"role": "user", "content": "In one sentence, what does a STEP file store?"}],
)
print(response.choices[0].message.content)
print("usage:", response.usage.model_dump(exclude_none=True))ขับเคลื่อนโดย

อย่าใส่ temperature, top_p, n และ penalty ทั้งสอง ซึ่งคู่มือเริ่มต้นระบุว่าเป็นค่าคงที่ แม้คำตอบหนึ่งประโยคแบบนี้ก็ใช้โทเค็นส่วนใหญ่ไปกับการให้เหตุผล จึงควรกำหนดเพดานโดยคำนึงถึงจุดนี้

คำขอเดียวเพื่อยืนยันคีย์และโมเดล ภาพโดยผู้เขียน

หาก Kimi API ใหม่สำหรับคุณ บทช่วยสอน Kimi K3 ก่อนหน้าครอบคลุมการสตรีม การเรียกใช้เครื่องมือ แคช และอินพุตภาพ

สร้างโมเดล CAD อ้างอิงและวิวทดสอบสี่มุม

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

กำหนดมิติของขา

ขานี้เป็นรูป L โดยแผ่นตั้งเชื่อมกับด้านหลังของฐาน จุดกำเนิดอยู่กึ่งกลางผิวล่าง โดยแกน X เป็นความกว้าง ด้านหน้าไปทาง −Y และ Z ขึ้นบน:

กำหนดแถวรูและร่องให้อยู่กึ่งกลางผิวของมัน และใช้รู 6.5 มม. ซึ่งเป็นขนาดคลียร์รันซ์ M6 ที่พบได้บ่อย เพราะชิ้นจริงมักเป็นแบบนั้น การเลือกนี้กลายเป็นจุดอ่อนของขาชิ้นนี้ และจะอธิบายเหตุผลในภายหลัง

ภายในฟังก์ชันสร้าง w, dep, h และ t เก็บค่าความกว้าง ความลึก ความสูง และความหนา จากนั้นเชื่อมสองแผ่นและตัดฟีเจอร์:

base = cq.Workplane("XY").box(w, dep, t, centered=(True, True, False))
upright = cq.Workplane("XY").center(0, dep / 2 - t / 2).box(w, t, h, centered=(True, True, False))
holes = cq.Workplane("XY").pushPoints([(-17, -3), (17, -3)]).circle(3.25).extrude(t)
slot = (cq.Workplane("XZ", origin=(0, dep / 2 - t / 2, 0)).center(0, 25.5)
        .slot2D(20, 6, 90)            # end-to-end length, width, angle
        .extrude(t, both=True))
result = base.union(upright).cut(holes).cut(slot)ขับเคลื่อนโดย

สคริปต์ตรวจว่ามีของแข็งที่ถูกต้องหนึ่งชิ้นและมีขนาดตามคาดก่อนส่งออกไฟล์ STEP

เรนเดอร์สี่วิวด้วยกล้องคงที่

เรนเดอร์เล็ก ๆ ด้วย NumPy วาดวิวด้านหน้า ด้านบน ด้านขวา และไอโซเมตริก โดยจัดเฟรมคงที่แบบเดียวกันทั้งอ้างอิงและแคนดิดตทุกตัว ที่ 512 พิกเซล หนึ่งพิกเซลครอบคลุมประมาณ 0.19 มม. แม้ว่าการอ่านจากภาพอาจคลาดได้มากกว่านั้น การจัดเฟรมคงที่ยังทำให้แคนดิดตที่ใหญ่เกินหรือวางผิดดูผิดไป แทนที่จะถูกจัดกึ่งกลางใหม่

สี่ภาพที่ส่งให้ Kimi ภาพโดยผู้เขียน

ตั้งกติกาประเมินก่อนรันเอเจนต์

ตัวประเมินวัดจากของแข็งที่ส่งออก ดังนั้นการตั้งชื่อพารามิเตอร์จึงหลอกมันไม่ได้ มันตัดแต่ละไฟล์ STEP เพื่อหารู ร่อง และความหนาของแผ่นทั้งสอง และคำนวณ voxel IoU ซึ่งเป็นสัดส่วนปริมาตรที่ของแข็งสองชิ้นมีร่วมกัน บนกริด 0.5 มม. ที่ขนาดจริง ค่าคลาดตามสเกลพิกเซล: ±0.5 มม. สำหรับความหนา เส้นผ่านศูนย์กลางรู และความกว้างร่อง และ ±1 ถึง ±1.5 มม. สำหรับความยาวและตำแหน่งที่อ่านจากภาพ

IoU อย่างเดียวไม่พอ ตัวเลขนี้หยาบ และยังใช้มันเพราะไม่มีวิธีง่ายกว่านี้ในการเทียบของแข็งสองชิ้น L เปล่า ๆ ที่ไม่มีรูและไม่มีร่องยังได้คะแนนเกิน 0.96 และชิ้นที่ถูกต้องแต่ทำให้ใหญ่เกิน 20% จะได้ 1.0 เต็มเมื่อสเกลทั้งสองให้เท่ากัน

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

สร้างโค้ด CadQuery จากภาพด้วย Kimi K3.1 Pro

แคนดิดตตัวแรกมาจากคำขอเดียวโดยไม่ใช้เครื่องมือ และรันได้ตรงตามที่ส่งกลับมา

ส่งสี่วิวอ้างอิงไปยัง Kimi K3.1 Pro API

อินพุตวิชันของ Kimi รับ data URL แบบ base64 ภายในอาร์เรย์ content และไม่รับ URL รูปสาธารณะ พรอมป์ตระบบเก็บกติกาเฟรมและการตั้งชื่อที่กล่าวไว้ก่อนหน้า และข้อความผู้ใช้บรรจุ PNG ทั้งสี่พร้อมพรอมป์ตนี้:

These four images show one mechanical part, a bracket. Each view uses orthographic
projection, and all four use the same scale. The camera for each view is written at the
top of the image, and a small axis triad sits in the lower-left corner.

The overall width of the part along X is 60 mm. No other dimension is given, so estimate
the rest from the images.

Write one CadQuery program that rebuilds this part as an editable parametric model.
Return the complete program in a single python code block.ขับเคลื่อนโดย

ตัวคำขอเองสั้น ๆ:

images = [image_part(path) for path in view_paths]   # four PNGs as base64 data URLs
messages.append({"role": "user", "content": images + [{"type": "text", "text": BASELINE_PROMPT}]})
response = client.chat.completions.create(
    model="kimi-k3.1-pro", reasoning_effort="high",
    max_completion_tokens=32_768, messages=messages,
)ขับเคลื่อนโดย

เพื่อตรวจขนาดอินพุตก่อนเสียค่าใช้จ่าย ส่งข้อความชุดเดียวกันไปยัง เอนด์พอยต์ประเมินโทเค็น ซึ่งตัวประเมินตรงกับบิลเกือบเป๊ะ ภาพ 512 พิกเซลสี่รูปใช้โทเค็นอินพุตไม่ถึง 2,000

รันโปรแกรม CadQuery แรกในแซนด์บ็อกซ์

ตัวรันเนอร์เขียนโค้ดลงโฟลเดอร์ชั่วคราวแล้วสตาร์ทคอนเทนเนอร์ชั่วคราวด้วยคำสั่ง docker run:

cmd = ["docker", "run", "--rm", "--network", "none", "--read-only",
       "--tmpfs", "/tmp:size=64m", "--cap-drop", "ALL",
       "--security-opt", "no-new-privileges",
       "--memory", "1g", "--cpus", "1", "--pids-limit", "128",
       "-v", f"{work}:/work", "cad-sandbox:2.8.0"]
subprocess.run(cmd, capture_output=True, text=True, timeout=60)ขับเคลื่อนโดย

ในการลองครั้งแรก คำตอบของ Kimi ใช้เวลาประมาณหนึ่งนาที โปรแกรมของมันตั้งชื่อทุกมิติที่มีอยู่ในข้อมูลอ้างอิงที่ซ่อน ตั้งแต่ bracket_depth = 40.0 ถึง slot_center_z = 25.5 สร้างของแข็งที่ถูกต้องและผ่านทุกการตรวจ

กล้องเดียวกัน สเกลเดียวกัน ชิ้นส่วนตรงกัน ภาพโดยผู้เขียน

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

Kimi หา ตำแหน่งฟีเจอร์จากจุดกึ่งกลาง ภาพโดยผู้เขียน

สร้างเอเจนต์เรียกใช้เครื่องมือแบบตรวจตัวเองด้วย Kimi K3.1 Pro

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

สามเฟส แต่ละเฟสมีขีดจำกัดตายตัว ภาพโดยผู้เขียน

กำหนดเครื่องมือสำหรับรัน ตรวจ และเรนเดอร์ CAD

นี่คือสคีมาของ execute_cad มันคืนผลลัพธ์สั้น ๆ ในรูปแบบตายตัว พร้อมบรรทัดท้าย ๆ ของ traceback เมื่อโปรแกรมล้มเหลว:

{"type": "function", "function": {
    "name": "execute_cad",
    "description": "Run a complete CadQuery program in an isolated sandbox. Returns a "
                   "candidate id, whether it ran, and a short error if it did not.",
    "parameters": {"type": "object", "properties": {
        "code": {"type": "string",
                 "description": "The complete program. It must assign the final solid to result."}},
        "required": ["code"]}}}ขับเคลื่อนโดย

render_cad ส่งคืนภาพทั้งสี่ภายในข้อความเครื่องมือเอง เป็นรูปแบบมองอีกครั้งเช่นเดียวกับ บทช่วยสอน agentic vision ของเรากับ Gemini เอกสารของ Kimi ไม่ได้แสดงตัวอย่างแบบนี้ จึงมองว่าเป็นพฤติกรรมที่สังเกตได้ ในการทดลองทั้งสามครั้ง ข้อความ role: "tool" มีส่วน image_url และโมเดลอ่านมันได้

คงข้อความผู้ช่วยเต็มฉบับไว้ในลูปเครื่องมือ

มีรายละเอียดสามข้อสำคัญ ซึ่งสองข้อมาจาก คู่มือโมเดลแบบคิด และคู่มือเริ่มต้นของ Kimi:

• ส่งข้อความผู้ช่วยฉบับเต็มกลับไปทุกเทิร์น รวมทั้ง reasoning_content และ tool_calls

• เพิ่มข้อความเครื่องมือต่อหนึ่งการเรียกเครื่องมือ โดยจับคู่ tool_call_id ให้ตรงกัน

• ซีเรียไลซ์ข้อความด้วย model_dump() เพราะ OpenAI SDK ไม่มีฟิลด์ reasoning_content แบบไทป์

ลูปด้านล่างทำตามทั้งสามข้อ:

message = response.choices[0].message.model_dump(exclude_none=True)
messages.append(message)        # all of it, or the next turn quietly loses its reasoning
for call in message.get("tool_calls") or []:
    content = run_tool(call["function"]["name"], json.loads(call["function"]["arguments"]))
    messages.append({"role": "tool", "tool_call_id": call["id"], "content": content})ขับเคลื่อนโดย

อย่าหวังให้ API จับความผิดพลาดตรงนี้ คำขอที่ลบ reasoning_content ออกจากประวัติยังคงสำเร็จ แม้เอกสารจะกำหนดว่าต้องมีฟิลด์นี้ และการตัดมันอาจเปลี่ยนวิธีที่เทิร์นถัดไปดำเนินต่อ อยากได้ 400 มากกว่าบั๊กที่เงียบ

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

สิ่งที่เกิดขึ้นในเฟสซ่อม

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

สรุปนั้นไม่ได้ถูกเสมอ ในการลองหนึ่งครั้ง inspect_cad รายงานรัศมีรู 3.0 มม. จึงเป็นรู 6.0 มม. ในขณะที่อ้างอิงคือ 6.5 มม. และ Kimi ก็ส่งอยู่ดี ครึ่งมิลลิเมตรเล็กกว่า 3 พิกเซลในวิวเหล่านี้ (แม้สายตาตัวเองก็คงไม่เชื่อถือได้ที่ขนาดนั้น) และไม่มีอะไรในฟีดแบ็กบอกว่าค่าที่ถูกต้องคือเท่าไร

เครื่องมือรายงานรัศมี 3.0 มม. ภาพโดยผู้เขียน

แก้ไขโมเดล CAD แบบพารามิตริกด้วย Kimi K3.1 Pro

เมื่อ ลูปซ่อมไม่ค่อยทำงาน การเปลี่ยนดีไซน์จึงเป็นบททดสอบที่บอกอะไรได้มากกว่า ถึงอย่างนั้นก็ยังเป็นบททดสอบที่อ่อนโยน และการเปลี่ยนที่ทำให้สองฟีเจอร์ขยับพร้อมกันจะกดดันได้หนักกว่า

ขอให้ Kimi ขยายความกว้างร่อง

การแก้ไขดำเนินต่อในการสนทนาเดียวกัน และเริ่มจากแคนดิดตที่ Kimi ส่ง ไม่ใช่โค้ดอ้างอิงของเรา:

Increase the width of the vertical slot in the upright plate from 6 mm to 9 mm. 
Keep the slot's center position and its end-to-end length as they are in your model. 
Do not change the mounting holes, the plate thickness, or the outer dimensions.ขับเคลื่อนโดย

Kimi ใช้หนึ่งในโปรแกรมที่อนุญาต 3 ครั้ง ความต่างมีเพียงหนึ่งบรรทัด จาก slot_width = 6.0 เป็น slot_width = 9.0 จากนั้นหนึ่งเทิร์นเพื่อ inspect และ render แล้วก็ส่ง

ตรวจการแก้ไขบนเรขาคณิตที่ส่งออก

ตัวเลขใหม่ในโค้ดไม่ได้พิสูจน์ว่าของแข็งเปลี่ยน ตัวประเมินเทียบของแข็งก่อนและหลังการแก้แบบ voxel ต่อ voxel โดยเมินเฉพาะพื้นที่ที่ร่องกว้างขึ้นได้รับอนุญาตให้กิน:

• ร่องกว้าง 9 มม. โดยความยาวและกึ่งกลางเท่าเดิม
• รู ความหนาแผ่น และขนาดภายนอกไม่เปลี่ยน
• ไม่มีวัสดุเปลี่ยนนอกพื้นที่ร่อง

การตรวจหลังแก้ผ่านทุกข้อ ทุกครั้ง

การแก้ได้ผลสะอาดเพราะ slot2D() นับความยาวเป็นปลายถึงปลาย ดังนั้นร่องจึงยาว 20 มม. เท่าเดิมและส่วนตรงสั้นลง โปรแกรมที่เก็บระยะระหว่างจุดศูนย์กลางของอาร์คสองฝั่งจะทำให้ร่องยาวขึ้น 3 มม.

การแก้เปลี่ยนแค่ร่องเท่านั้น ภาพโดยผู้เขียน

เอเจนต์ CAD ของ Kimi K3.1 Pro แม่นยำแค่ไหน?

เอเจนต์ผ่านการตรวจที่ซ่อนทั้งหมดในทั้งสามการลอง ภายในค่าคลาดที่กำหนดไว้ล่วงหน้า อ่านตารางเป็น สรุป:

สามการลองไม่ใช่อัตราความสำเร็จ มีแต่สัญญาณว่าผลลัพธ์คงเส้นคงวากับขาชิ้นเดียว รู 6.0 มม. จากเฟสซ่อมผ่านได้เพราะพอดีกับค่าคลาดรู ±0.5 มม. เท่านั้น หากเข้มงวดกว่านี้ การลองนั้นอาจตก

การแก้ไขตัวเองไม่มีอะไรให้แก้

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

ต้นทุนโทเค็นและเวลาในแต่ละการลอง

แต่ละการลองมีค่าใช้จ่าย 6.3 ถึง 7.3 เซนต์ สำหรับหกคำขอและเจ็ดการเรียกเครื่องมือ คิดเฉพาะค่า API เพราะการเรนเดอร์และ Docker รันบนเครื่องของเราเอง

คิดราคาแต่ละคำขอจากฟิลด์ usage ตาม อัตราที่ประกาศ สำหรับ kimi-k3.1-pro ต่อหนึ่งล้านโทเค็น อินพุต $2.00 เอาต์พุต $10.00 แคชฮิต $0.20 และเขียนแคช 5 นาที $2.00

คำขอแรกแพงที่สุดเพราะเป็นที่ที่ Kimi ใช้เหตุผล เอาต์พุตมากกว่าครึ่งของบิลและการเขียนแคช 23% ถึง 35% ขณะที่แคชฮิตแทบไม่เสียค่าใช้จ่าย ต่อไปนี้คือการบวกรวมสามฟิลด์อินพุต ตามอ้างอิง Chat Completions ที่ลิงก์ไว้ก่อนหน้า และข้ามได้ถ้าตัวติดตามของคุณแยกการเขียนแคชอยู่แล้ว:

uncached = u.prompt_tokens - cached - written   # the three parts sum to prompt_tokens
cost = (uncached * 2.00 + cached * 0.20 + written * 2.00 + u.completion_tokens * 10.00) / 1e6ขับเคลื่อนโดย

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

หนึ่งการลองใช้เวลาราวสามนาที ส่วนใหญ่เป็นการรอ เพราะไคลเอนต์เว้นระยะคำขอ 21 วินาทีตามเพดานอัตราที่จะกล่าวในคำถามที่พบบ่อย

ข้อจำกัดของการสร้าง CAD จากภาพด้วย AI

ข้อจำกัดหลักคือภาพไม่สามารถบรรทุกทุกมิติได้ การทดสอบของเรายังเพิ่มอีกเล็กน้อย:

• ภาพเรนเดอร์ไม่แสดงรายละเอียดที่เล็กกว่าหนึ่งพิกเซล หากมิติมีความสำคัญ ควรให้เป็นข้อความหรือวัดด้วยเครื่องมือ
• ขาชิ้นนี้เดาง่าย รูที่เยื้องศูนย์และขนาดแปลกจะทดสอบว่า Kimi อ่านพิกเซลจริงหรืออ่านนิสัยการออกแบบ
• แฟลกของ Docker บล็อกได้เฉพาะสิ่งที่ระบุ มันหยุดโปรแกรมประพฤติผิดในส่วนตั้งค่า แต่โค้ดจากโมเดลยังใช้ CPU เต็มนาทีได้ คู่มือความปลอดภัยเอเจนต์ AI ในคอนเทนเนอร์ ของเราครอบคลุมชั้นถัดไป
• การผ่านการตรวจเหล่านี้ไม่ได้บอกอะไรเรื่องความแข็งแรง แรงที่รับ วัสดุ มุมในโค้งมนที่ชิ้นจริงต้องมี การพอดีของน็อต และการรวมกันของค่าคลาด อยู่ถ้วนอยู่นอกการทดสอบนี้

ความง่ายของชิ้นนี้เป็นข้อจำกัดของการทดสอบเรามากกว่าของ Kimi

บทสรุป

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

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

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

สำหรับเรื่องการเชื่อมโมเดลเข้ากับเครื่องมือของคุณเอง คอร์ส Developing AI Systems with the OpenAI API ของเราครอบคลุมการเรียกฟังก์ชันด้วย SDK ชุดเดียวกับที่เอเจนต์นี้ใช้