Kimi K3.1 Pro API ट्यूटोरियल: Python में एक सेल्फ-चेकिंग 3D CAD एजेंट बनाएँ

Kimi K3.1 Pro API से इमेज-टू-CAD एजेंट बनाएं

एक इमेज-टू-CAD एजेंट किसी पार्ट की तस्वीरों को ऐसे CAD मॉडल में बदलता है जिसे आप एडिट कर सकें।

क्यों Kimi K3.1 Pro और CadQuery इमेज-टू-CAD के लिए उपयुक्त हैं

Kimi K3.1 Pro चार इमेज पढ़ सकता है और फिर अपने ही कोड के नतीजों पर प्रतिक्रिया दे सकता है। वही Moonshot ब्लॉग जो मैंने पहले उल्लेख किया, टूल्स के साथ 92.7% और बिना टूल्स 72.8% BenchCAD के Vision2Code टास्क पर रिपोर्ट करता है, जो रेंडर्ड व्यूज़ से लिखे CAD कोड को स्कोर करता है। ये नंबर 1,000-केस सबसेट में max प्रयास पर आते हैं, और टूल्स के साथ स्कोर Claude Code हॉर्नेस से लिया गया, तो स्कोर का कुछ हिस्सा हॉर्नेस का भी हो सकता है।

बेंचमार्क भी चारों व्यूज़ को एक ही इमेज में भेजता है और स्कोरिंग से पहले हर पार्ट को एक ही आकार में स्केल करता है। मेरा सेटअप चार अलग-अलग व्यूज़ के साथ एक वास्तविक डायमेंशन high प्रयास पर भेजता है, इसलिए Moonshot के नंबर को नतीजे के बजाय टेस्ट चलाने का कारण समझें। जब मैंने ये ट्रायल चलाए, तब ओपन वेट्स अभी डाउनलोडेबल नहीं थे।

आउटपुट फॉर्मेट CadQuery है क्योंकि CadQuery स्क्रिप्ट खुद एक पैरामीट्रिक मॉडल होती है। एक छेद डायमीटर और पोजीशन के साथ एक कॉल है, इसलिए बाद की एडिट में सिर्फ एक संख्या बदलती है और सॉलिड रीबिल्ड हो जाता है। STL फाइल सिर्फ त्रिभुज देती है, और बदलने के लिए कोई slot_width नहीं होता।

एजेंट क्या देखता है और क्या छुपा रहता है

Kimi को चार रेफरेंस इमेज, 60 mm चौड़ाई, और एक सिस्टम प्रॉम्प्ट मिलता है। वह प्रॉम्प्ट मिलीमीटर और एक्सिस तय करता है, पार्ट को X और Y पर सेंटर करता है और Z=0 पर उसकी बॉटम सेट करता है, और result में नाम दिए गए डायमेंशनों और अंतिम सॉलिड की माँग करता है।

उसके बाद, Kimi सिर्फ वही जानता है जो उसके टूल्स रिपोर्ट करते हैं। Kimi API CadQuery नहीं चलाता, इसलिए चारों टूल्स एप्लिकेशन में रहते हैं:

• execute_cad एक प्रोग्राम को बिना नेटवर्क वाले Docker कंटेनर में चलाता है और परिणाम को एक कैंडिडेट के रूप में सेव करता है

• inspect_cad वैधता, सॉलिड काउंट, बॉन्डिंग बॉक्स, वॉल्यूम और सिलिंड्रिकल फेसेज़ रिपोर्ट करता है

• render_cad रेफरेंस वाली ही चार कैमरों से कैंडिडेट को ड्रॉ करता है

• submit_cad एक कैंडिडेट के साथ एक फेज़ समाप्त करता है

Kimi कभी रेफरेंस कोड या कोई स्कोर नहीं देखता। इवैल्यूएटर एजेंट के खत्म होने के बाद ही सेव की गई STEP फाइलें पढ़ता है, इसलिए कोई स्कोर एजेंट को प्रभावित या रोक नहीं सकता।

स्कोर कभी Kimi तक वापस नहीं जाते। इमेज: लेखक द्वारा।

Python में Kimi K3.1 Pro API सेट करें

Python में Kimi K3.1 Pro API इस्तेमाल करने के लिए आपको चार चीज़ों की जरूरत है। मैंने सब कुछ Linux x86_64 पर इन वर्ज़न्स के साथ टेस्ट किया:

• K3.1 Pro क्विकस्टार्ट के अनुसार कम से कम $1 टॉप-अप वाला Kimi API की

• Python 3.12.3 और openai 3.39.0, यानी OpenAI SDK

• cadquery 2.8.0 सॉलिड्स बनाने और जाँचना के लिए

• Docker 29.9.2 सैंडबॉक्स के लिए

नीचे दिए स्निपेट्स इस GitHub रेपो के पूर्ण प्रोजेक्ट से लिए गए अंश हैं, जिसे आप अगला क्लोन करेंगे।

CadQuery इंस्टॉल करें और Docker सैंडबॉक्स बनाएं

CadQuery की इंस्टॉलेशन गाइड conda को प्राथमिकता देती है, हालाँकि Python 3.12 पर pip भी काम करता है। रेपो क्लोन करें और सेटअप करें:

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 या मेमोरी लिमिट सेट नहीं करता, इसकी रिसोर्स कंस्ट्रेंट्स डॉक्यूमेंटेशन के अनुसार, इसलिए रनर उन्हें सेट करता है। रेपो के फ्रंट पेज पर एक्सपेरिमेंट चलाने और स्कोर करने के कमांड्स सूचीबद्ध हैं, जिनमें बिना API की या Docker वाला पथ भी शामिल है।

Kimi का कोड कंटेनर तक पहुँचने से पहले, खुद उसे तोड़ने की कोशिश करें। मेरे टेस्ट प्रोग्राम ने API की पढ़ने, नेटवर्क तक पहुँचने और अपने स्क्रैच फोल्डर के बाहर लिखने की कोशिश की, और तीनों प्रयास असफल रहे।

सैंडबॉक्स में तीन ब्लॉक की गई क्रियाएँ। इमेज: लेखक द्वारा।

अपना पहला Kimi K3.1 Pro API कॉल करें

यह Moonshot के एंडपॉइंट की ओर इंगित किया हुआ सामान्य OpenAI SDK है। हर रिक्वेस्ट पर 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 और दोनों पेनल्टी छोड़ दें, जिन्हें क्विकस्टार्ट फिक्स्ड बताता है। इस तरह के एक-वाक्यीय उत्तर में भी कंप्लीशन टोकन्स का अधिकांश भाग रीज़निंग पर खर्च होता है, इसलिए कैप तय करते समय इसे ध्यान में रखें।

एक रिक्वेस्ट से की और मॉडल कन्फर्म होते हैं। इमेज: लेखक द्वारा।

अगर Kimi API आपके लिए नया है, तो मेरा पहले का Kimi K3 ट्यूटोरियल स्ट्रीमिंग, टूल कॉलिंग, कैशिंग, और विज़न इनपुट को कवर करता है।

एक रेफरेंस CAD मॉडल और चार टेस्ट व्यू बनाएँ

रेफरेंस CAD मॉडल आपका उत्तर-कुंजी है, ताकि हर स्कोर के पास तुलना करने के लिए कुछ सटीक हो। मैंने अपना पहला रिक्वेस्ट भेजने से पहले ही इसे लॉक कर दिया—कैमरों से लेकर स्कोरिंग नियमों तक—और नतीजे देखने के बाद भी इसमें कुछ नहीं बदला।

ब्रैकेट के डायमेंशन तय करें

ब्रैकेट L-आकार का है, जिसमें अप्राइट बेस के पीछे जुड़ा है। इसका ओरिजिन बॉटम फेस के सेंटर पर बैठता है, X चौड़ाई के आर-पार, फ्रंट −Y की ओर, और Z ऊपर:

मैंने होल रो और स्लॉट को उनके चेहरों के बीचोंबीच रखा और 6.5 mm होल्स लिए—एक सामान्य 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 px पर, एक पिक्सेल करीब 0.19 mm कवर करता है, हालांकि इमेज से पढ़ाई इससे ज्यादा चूक सकती है। फिक्स्ड फ्रेमिंग एक ऐसे कैंडिडेट को भी गलत दिखाती है जो बहुत बड़ा या गलत जगह हो, बजाय इसके कि उसे दोबारा सेंटर करे।

Kimi को भेजी गई चार इमेज। इमेज: लेखक द्वारा।

एजेंट चलाने से पहले इवैल्यूएशन नियम तय करें

इवैल्यूएटर एक्सपोर्टेड सॉलिड को मापता है, इसलिए पैरामीटर नाम उसे प्रभावित नहीं कर सकते। यह हर STEP फाइल को स्लाइस कर छेद, स्लॉट, और दोनों प्लेट मोटाईयाँ ढूंढता है, और 0.5 mm ग्रिड पर वास्तविक आकार में वोक्सल IoU निकालता है—यानी दो सॉलिड्स के साझा वॉल्यूम का हिस्सा। टॉलरेंस पिक्सेल स्केल के मुताबिक हैं: मोटाइयों, होल डायमीटर और स्लॉट चौड़ाई के लिए ±0.5 mm, और इमेज से पढ़ी जाने वाली लंबाइयों और पोजीशन्स के लिए ±1 से ±1.5 mm।

सिर्फ IoU काफी नहीं है। यह एक मोटा नंबर लगता है, और मैं इसे इसलिए इस्तेमाल करता हूँ क्योंकि इससे सरल कुछ भी दो सॉलिड्स की तुलना नहीं करता। एक सादा L—बिना छेद और स्लॉट के—भी 0.96 से ऊपर स्कोर करता है, और सही पार्ट को 20% बड़ा बनाकर अगर दोनों को एक ही साइज में स्केल कर दें, तो परफेक्ट 1.0 स्कोर करता है।

इसीलिए यहाँ हर स्कोर के साथ 13 पास/फेल चेक्स आते हैं। एक परफेक्ट 1.0 भी सिर्फ यह बताता है कि ग्रिड पर दो सॉलिड्स मैच करते हैं—हर माइक्रॉन तक नहीं—और इन नंबरों में से कोई भी मैन्युफैक्चरिंग गारंटी नहीं है।

Kimi K3.1 Pro से इमेज से CadQuery कोड जनरेट करें

पहला कैंडिडेट एक बिना-टूल रिक्वेस्ट से आता है, और वैसा ही चलता है जैसा लौटता है।

चार रेफरेंस व्यू Kimi K3.1 Pro API को भेजें

Kimi का विज़न इनपुट content ऐरे के अंदर base64 डेटा URL लेता है, और पब्लिक इमेज URLs स्वीकार नहीं करता। सिस्टम प्रॉम्प्ट में पहले बताई फ्रेमिंग और नेमिंग नियम हैं, और यूज़र मैसेज में चार 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 px इमेज मिलकर 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 तक। इसने एक वैध सॉलिड बनाया और हर चेक पास किया।

वही कैमरा, वही स्केल, मिलते-जुलते पार्ट्स। इमेज: लेखक द्वारा।

पहली कोशिश में परफेक्ट नतीजे ने मुझे किसी लीक की जाँच करवाई, पर PNGs में कोई मेटाडाटा नहीं है, और किसी प्रॉम्प्ट में कोई हिडन वैल्यू नहीं। Kimi का कोड नतीजे की व्याख्या करता है। जैसा कि मैंने ब्रैकेट तय करते समय कहा, फीचर्स वहीं बैठे हैं जहाँ एक डिज़ाइनर रखेगा—और Kimi ने भी वैसा ही किया।

Kimi फीचर पोजीशन मिडपॉइंट से निकालता है। इमेज: लेखक द्वारा।

Kimi K3.1 Pro के साथ सेल्फ-चेकिंग टूल-कॉलिंग एजेंट बनाएँ

टूल-कॉलिंग एजेंट लूप में चलता है। Kimi किसी टूल की माँग करता है, आपका कोड उसे चलाता है, और नतीजा टूल मैसेज के रूप में वापस जाता है—जब तक Kimi खत्म न कर दे।

तीन फेज़, प्रत्येक पर कड़े लिमिट्स। इमेज: लेखक द्वारा।

CAD को एक्जीक्यूट, इंस्पेक्ट और रेंडर करने के टूल्स परिभाषित करें

यह रहा execute_cad का स्कीमा। यह फिक्स्ड फॉर्मेट में छोटा नतीजा लौटाता है, और प्रोग्राम फेल होने पर ट्रेसबैक की आखिरी कुछ लाइनें देता है:

{"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 अपने चार इमेजेज़ टूल मैसेज के अंदर ही लौटाता है—वही लुक-अगेन पैटर्न जो हमारा एजेंटिक विज़न ट्यूटोरियल 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 mm होल रेडियस रिपोर्ट किया—यानी रेफरेंस के 6.5 mm की जगह 6.0 mm के होल—और Kimi ने फिर भी सबमिट किया। आधा मिलीमीटर इन व्यूज़ में 3 पिक्सेल से कम है (मैं खुद भी इतनी बारीकी पर आँखों पर भरोसा नहीं करता), और फीडबैक में कहीं यह नहीं था कि सही डायमीटर क्या है।

टूल ने 3.0 mm रेडियस रिपोर्ट किया। इमेज: लेखक द्वारा।

Kimi K3.1 Pro से पैरामीट्रिक CAD मॉडल एडिट करें

रिपेयर लूप के निष्क्रिय रहने पर, डिजाइन बदलाव ज्यादा निर्णायक टेस्ट बन गया। यह हल्का टेस्ट है, हालांकि एक ऐसा बदलाव जो साथ में दो फीचर्स को हिलाए, वह कहीं ज्यादा कठिन होगा।

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, फिर एक टर्न निरीक्षण और रेंडर का और एक सबमिट।

एक्सपोर्टेड ज्योमेट्री पर एडिट जाँचें

कोड में एक नया नंबर खुद साबित नहीं करता कि सॉलिड बदला। इवैल्यूएटर ने एडिट से पहले और बाद के सॉलिड्स को वोक्सल-दर-वोक्सल तुलना की, सिर्फ उतनी जगह को अनदेखा करते हुए जितनी चौड़े स्लॉट को लेने की अनुमति थी:

• स्लॉट 9 mm चौड़ा है, वही लंबाई और सेंटर के साथ
• होल्स, प्लेट मोटाई और बाहरी आकार अपरिवर्तित हैं
• स्लॉट क्षेत्र के बाहर कोई मैटेरियल नहीं बदला

हर एडिट चेक हर बार पास हुआ।

एडिट साफ़ तरह से इसलिए काम किया क्योंकि slot2D() अपनी लंबाई को सिरे-से-सिरे मानता है, इसलिए स्लॉट 20 mm का ही रहा और सीधा हिस्सा छोटा हो गया। एक प्रोग्राम जो दोनों आर्क सेंटर्स के बीच की दूरी स्टोर करता, स्लॉट को 3 mm लंबा बना देता।

एडिट ने सिर्फ स्लॉट बदला। इमेज: लेखक द्वारा।

Kimi K3.1 Pro CAD एजेंट कितना सटीक था?

एजेंट तीनों ट्रायल्स में हर हिडन चेक पास कर गया, उन टॉलरेंस के भीतर जो मैंने पहले से तय किए थे। तालिका को एक रिकैप के रूप में पढ़ें:

तीन ट्रायल सफलता दर नहीं होते—सिर्फ इस बात का संकेत हैं कि नतीजा एक ब्रैकेट पर बना रहा। रिपेयर फेज़ वाले 6.0 mm होल्स सिर्फ इसलिए पास हुए क्योंकि वे ±0.5 mm के होल टॉलरेंस की ठीक सीमा पर थे—कड़ा लिमिट होता तो वह ट्रायल फेल हो जाता।

सेल्फ-करेक्शन के पास ठीक करने को कुछ नहीं था

वह टेस्ट जो दिखाता कि लूप मॉडल में सुधार करता है, एक फॉल्ट-इंजेक्शन रन है—जो एक ज्ञात गलती वाले प्रोग्राम से एजेंट शुरू करता है। मैं उसे इन ट्रायल्स से अलग रिपोर्ट करूंगा।

प्रति ट्रायल टोकन लागत और रन टाइम

हर ट्रायल में छह रिक्वेस्ट और सात टूल कॉल्स के लिए 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 सेकंड के अंतर से भेजता है, जिसकी चर्चा मैं FAQs में करूँगा।

जहाँ इमेजेस से AI CAD जेनरेशन कम पड़ता है

सबसे बड़ी सीमा यह है कि इमेज हर डायमेंशन नहीं दे सकतीं। मेरे टेस्ट में कुछ और भी जोड़ हैं:

• रेंडर्स एक पिक्सेल से छोटे डिटेल नहीं दिखा सकते। अगर कोई डायमेंशन महत्वपूर्ण है, तो उसे टेक्स्ट में दें या टूल से मापें।
• ब्रैकेट का अंदाजा लगाना आसान था। ऑफ-सेंटर होल्स और अजीब साइजेज़ यह परखेंगे कि Kimi पिक्सेल पढ़ता है या डिजाइन आदतें।
• Docker फ्लैग्स सिर्फ वही ब्लॉक करते हैं जिसका वे नाम लेते हैं। उन्होंने सेटअप सेक्शन वाले मिसबिहेविंग प्रोग्राम को रोका, लेकिन मॉडल कोड फिर भी अपना पूरा एक मिनट CPU जला सकता है। हमारे कंटेनर्स में AI एजेंट्स को सुरक्षित करने की गाइड अगली परतें कवर करती है।
• इन चेक्स को पास करना मजबूती के बारे में कुछ नहीं कहता। लोड, मैटेरियल, असल पार्ट के लिए जरूरी अंदरूनी गोल कोना, बोल्ट फिट, और टॉलरेंस कैसे जुड़ते हैं—ये सब इस टेस्ट से बाहर हैं।

आसान ब्रैकेट Kimi की कमी से ज्यादा मेरे टेस्ट की सीमा है।

अंतिम विचार

हमने ऐसा एजेंट बनाया जो चार इमेज से पैरामीट्रिक CadQuery कोड लिखता है, अपने सॉलिड को टूल्स से जाँचता है, और अनुरोध पर एक फीचर एडिट करता है। इस ब्रैकेट के लिए, मेरे शुरुआती सवाल का जवाब हाँ है। तीनों ट्रायल्स पहली रिक्वेस्ट पर मेरे तय टॉलरेंस के भीतर पास हुए, और स्लॉट एडिट से पार्ट के बाकी हिस्से पर असर नहीं पड़ा।

रिपेयर लूप वह हिस्सा है जिसकी मैं गारंटी नहीं दे सकता, क्योंकि Kimi को ठीक करने को कुछ मिला ही नहीं। उसकी समीक्षा ने 0.5 mm की एक गलती इसलिए छोड़ दी क्योंकि उसने पिक्सेल देखे, असली डायमीटर नहीं। मैं परिणाम को किसी अजीब-साइज पार्ट या असली फोटो पर सामान्यीकृत नहीं करूंगा।

जो बात आगे ले जाने लायक है, वह है रेफरेंस छुपाना, पहले रिक्वेस्ट से पहले स्कोरिंग नियम फ्रीज़ करना, और कोड के बजाय एक्सपोर्टेड सॉलिड को स्कोर करना। Kimi ने तीन बार कहा कि उसका कैंडिडेट मैच करता है, और सिर्फ इवैल्यूएटर बता पाया कि वह दो बार सही और एक बार क़रीब था। वही इवैल्यूएटर मैं रखूंगा, और फॉल्ट-इंजेक्शन रन मेरी पहली एक्सटेंशन होगी।

अपने टूल्स से मॉडल्स जोड़ने पर और जानने के लिए, हमारा Developing AI Systems with the OpenAI API कोर्स उसी SDK के साथ फंक्शन कॉलिंग कवर करता है जिसे यह एजेंट इस्तेमाल करता है।