Thinking Machines Lab เปิดตัว Inkling 2 Mini เมื่อวันที่ 20 พฤศจิกายน ด้วยคำสัญญาที่ไม่ธรรมดาสำหรับโมเดลโอเพนซอร์สที่มีความสามารถระดับนี้: มันทำงานบนแล็ปท็อปได้ บริษัทรองรับมันบน Mac ทุกรุ่นที่มีหน่วยความจำ 32 GB ขึ้นไป ผ่าน Ollama นักวิจัยของบริษัทยังรันมันแบบออฟไลน์บน MacBook Pro ระหว่างเที่ยวบิน ซึ่งมันสร้างเครื่องจำลองการบินที่เล่นได้ คู่มือนี้จะแสดงให้คุณเห็นทีละขั้นตอนถึงวิธีรัน Inkling 2 Mini ด้วย Ollama บน Mac 32 GB เริ่มตั้งแต่การติดตั้งใหม่ไปจนถึงเอเจนต์เขียนโค้ดบนเครื่องที่ใช้งานได้
ฉบับสั้นคือสามคำสั่ง ฉบับยาวคือเหตุผลที่คู่มือนี้มีอยู่ บน Mac 32 GB โมเดลกินพื้นที่ประมาณ 20 GB โดยค่าเริ่มต้น macOS ยังกันหน่วยความจำราวหนึ่งในสามออกจากโปรเซสเซอร์กราฟิก Ollama จึงตอบสนองโดยให้หน้าต่างบริบท 4,000 โทเคนแก่โมเดล: เหมาะสำหรับการแชต แต่เล็กเกินไปมากสำหรับเอเจนต์เขียนโค้ด และบน Mac 32 GB ส่วนใหญ่ พรอมต์ที่ยาวมากยังอาจทำให้หน่วยความจำไม่พอได้ในปัจจุบัน ทั้งหมดนั้นไม่ใช่เหตุผลที่จะข้ามมันไป แต่เป็นเหตุผล’ที่จะตั้งค่าให้ถูกต้อง
คุณไม่จำเป็นต้องรู้วิธีเขียนโค้ด’ คุณ’จะคัดลอกคำสั่งสองสามข้อไปยัง Terminal แอปบรรทัดคำสั่งของ Mac’ (กด Cmd-Space พิมพ์ Terminal แล้วกด Return) แต่ละคำสั่งมีคำอธิบาย การรองรับ Inkling 2 Mini ของ Ollama เพิ่งมีมาได้ไม่กี่วัน’และกำลังพัฒนาอย่างรวดเร็ว ดังนั้นทุกข้อเท็จจริงด้านล่างจึงได้รับการตรวจสอบเมื่อ 21 พฤศจิกายน 2026.
การเปิดเผยความเป็นอิสระและลิงก์พันธมิตร: ไม่มีบริษัทใดที่กล่าวถึงในที่นี้สนับสนุน ตรวจทาน หรืออนุมัติคู่มือนี้ บทความนี้มี ลิงก์พันธมิตรหนึ่งลิงก์, ไปยัง GLM Coding Plan ของ Z.ai (ในตอนที่ 10) การสมัครสมาชิกผ่านลิงก์นั้นทำให้คุณได้ส่วนลด 10% และอาจทำให้ผมได้รับค่าคอมมิชชันโดยที่คุณไม่ต้องจ่ายเพิ่ม
สรุปสั้น — ฉบับ 60 วินาที
- คุณต้องมี: Mac ชิป Apple silicon ที่มี หน่วยความจำ 32 GB ขึ้นไป, macOS 14 หรือใหม่กว่า, ประมาณ พื้นที่ว่างบนดิสก์ 25 GB และ และ Ollama 0.40.17 หรือใหม่กว่า.
- สามคำสั่ง:
ollama --version(0.40.17 หรือสูงกว่า),ollama pull inkling-2-mini(ดาวน์โหลด 20.2 GB),ollama run inkling-2-mini. - จุดที่ต้องระวังในเครื่อง 32 GB: น้ำหนักโมเดลกินพื้นที่ 18.8 GiBและโดยค่าเริ่มต้น macOS ให้ GPU ใช้เพียงประมาณ 21.3 GiBดังนั้น Ollama จึงตั้งค่า หน้าต่างบริบท 4Kซึ่งเล็กเกินไปสำหรับเอเจนต์
- การตั้งค่าที่สำคัญ: ตั้งค่าหน้าต่างบริบทเป็น 16K–32K ในการตั้งค่าสำหรับเอเจนต์ของ Ollama’s คุณอาจเพิ่มงบ GPU เป็น 24 GiB ได้ด้วย
sudo sysctl iogpu.wired_limit_mb=24576(ค่าจะรีเซ็ตเมื่อรีสตาร์ต) คงระดับความพยายามในการคิดไว้ที่ สูง สำหรับงานเขียนโค้ด ต่ำ สำหรับคำถามเร็ว ๆ ปิดแอปที่กินหน่วยความจำก่อน - ชิปของคุณสำคัญในตอนนี้: Ollama 0.40.17 เปิดใช้การอ่านพรอมต์แบบประหยัดหน่วยความจำเฉพาะ M2 Pro, M2 Ultra, M3 Ultra, M4 Pro และ M5 Pro, Max และ Ultra ในการทดสอบ 32 GB ที่เผยแพร่เพียงครั้งเดียว เครื่อง M2 Max ล่มด้วยข้อความ "Insufficient Memory" หลังผ่านไปราว 12,000 โทเคน
- เอเจนต์: Pi เหมาะกับ 32 GB ที่สุด เพราะคำสั่งและเครื่องมือของมันใช้ไม่ถึง 1,000 โทเคน (
ollama launch pi --model inkling-2-mini). มันรันคำสั่งโดยไม่ถาม ดังนั้นให้เก็บไว้ในโฟลเดอร์ชั่วคราว OpenCode เปิดมาที่ราว 6,900 โทเคน และจะถามก่อนหลังเปลี่ยนคอนฟิกหนึ่งครั้ง Claude Code ถามโดยค่าเริ่มต้น แต่คำขอแรกวัดได้ราว 32,800 โทเคน: เริ่มใช้ได้ดีกว่าที่ 48 GB - ความเร็ว: เกี่ยวกับ 24 โทเคนต่อวินาที บน M2 Max 32 GB และราว 32 บน M4 Pro 48 GB
- ความปลอดภัย: Thinking Machines เตือนว่าโมเดลอาจวนซ้ำ ลบหรือเขียนทับไฟล์โดยไม่ถาม และรายงานผลผิด ทำงานใน Git หรือสำเนา เปิดพรอมต์ขออนุญาตไว้ และจำกัดจำนวนขั้นของเอเจนต์’
ภาพรวมโดยย่อ
| รุ่น | Inkling 2 Mini จาก Thinking Machines Lab เปิดตัว 20 พฤศจิกายน 2026 สัญญาอนุญาต Apache 2.0 |
| ขนาด | 26.4B พารามิเตอร์, 3.4B ที่ทำงานต่อโทเคน; 5.4B การทำงานของน้ำหนักเมื่อนับเลเยอร์แบบวนซ้ำ |
| แท็ก Ollama | inkling-2-mini (รวมถึง 26b-a5b และ 26b-a5b-nvfp4: แพ็กเกจ 20 GB เดียวกัน) |
| ดาวน์โหลด | 20,188,097,271 ไบต์ (20.2 GB หรือ 18.8 GiB) |
| เวลาที่ใช้ | ประมาณครึ่งชั่วโมง บวกเวลาดาวน์โหลดอีก 3 ถึง 60 นาที |
| เวอร์ชัน Ollama | 0.40.17 หรือใหม่กว่า; ในรุ่นนั้นรองรับเฉพาะ Apple silicon |
| เอนจิน | MLX runner ของ Ollama’s ซึ่งสร้างขึ้นบนเฟรมเวิร์กแมชชีนเลิร์นนิงของ Apple’s |
| ทำได้ | รับข้อความและภาพ เรียกใช้เครื่องมือ และคิด |
| บริบท | สูงสุด 1M โทเคนในตัวโมเดล; ค่าเริ่มต้นของ Ollama’s บน Mac 32 GB ส่วนใหญ่: 4K |
| ขั้นต่ำที่รองรับ | Mac Apple silicon 32 GB (Thinking Machines และ Ollama) |
| macOS | 14 Sonoma หรือใหม่กว่า (ข้อกำหนดของ Ollama’s) |
| ระดับความพยายามในการคิด | none, minimal, ต่ำ, medium, สูง (ค่าเริ่มต้น), xhigh, สูงสุด |
| เอเจนต์แบบคำสั่งเดียว | Pi, OpenCode, Claude Code, Hermes Agent และ OpenClaw ผ่าน ollama launch |
| ความเร็วที่วัดได้ | M2 Max 32 GB: ราว 24 tok/s; M4 Pro 48 GB: ราว 32 tok/s ตอนเขียน, 279 tok/s ตอนอ่าน |
Measured speeds are third-party results.
สารบัญ
- ตอนที่ 1 — ก่อนเริ่ม: Mac ของคุณพร้อมหรือยัง?
- ตอนที่ 2 — ขั้นตอนที่ 1: ติดตั้งหรืออัปเดต Ollama
- ตอนที่ 3 — ขั้นตอนที่ 2: ดาวน์โหลด Inkling 2 Mini
- ตอนที่ 4 — ขั้นตอนที่ 3: รัน Inkling 2 Mini ใน Ollama เป็นครั้งแรก
- ตอนที่ 5 — ขั้นตอนที่ 4: การตั้งค่าที่แนะนำสำหรับ Mac 32 GB
- ตอนที่ 6 — เช็กความจริงเรื่อง 32 GB: ชิปของคุณสำคัญ
- ตอนที่ 7 — ขั้นตอนที่ 5: ใช้ Inkling 2 Mini เป็นแบ็กเอนด์โลคอลสำหรับเอเจนต์เขียนโค้ด
- ตอนที่ 8 — Inkling 2 Mini เร็วแค่ไหนบน Mac 32 GB?
- ตอนที่ 9 — แก้ปัญหา Inkling 2 Mini ใน Ollama
- ตอนที่ 10 — เมื่อ 32 GB ยังไม่พอ
- คำถามที่พบบ่อย
- บทสรุป

ตอนที่ 1 — ก่อนเริ่ม: Mac ของคุณพร้อมหรือยัง?
มีสี่ปัจจัยที่ตัดสินว่าคุณจะรัน Inkling 2 Mini ด้วย Ollama ได้หรือไม่: ชิป หน่วยความจำ เวอร์ชัน macOS และพื้นที่ดิสก์ว่าง สามอย่างแรกอยู่ในหน้าจอเดียว: เปิดเมนู Apple แล้วเลือก เกี่ยวกับ Mac เครื่องนี้. สำหรับพื้นที่ดิสก์ ให้เปิด การตั้งค่าระบบ → ทั่วไป → พื้นที่จัดเก็บ.
| ข้อกำหนด | ขั้นต่ำ | ทำไม |
|---|---|---|
| ชิป | Apple silicon (ชิปตระกูล M รุ่นใดก็ได้) | Ollama 0.40.17 รัน Inkling 2 Mini ได้เฉพาะบน Apple silicon บน Mac ที่ใช้ Intel นั้น Ollama ใช้ได้แค่โปรเซสเซอร์ ไม่สามารถใช้ GPU |
| ความจำ | 32 GB | ขั้นต่ำที่ Thinking Machines’ และ Ollama’ รองรับ ตัวโมเดลอย่างเดียวใช้พื้นที่ประมาณ 20 GB |
| macOS | 14 Sonoma หรือใหม่กว่า | ข้อกำหนดของ Ollama’ เอง |
| พื้นที่ดิสก์ว่าง | ประมาณ 25 GB | 20.2 GB สำหรับตัวโมเดล บวกพื้นที่ให้ macOS ได้หายใจ |
| Ollama | 0.40.17 หรือใหม่กว่า | รุ่นแรกที่รู้จักโมเดลนี้ (ตอนที่ 2) |
แล้ว Mac 16 GB กับ 24 GB ล่ะ? ไม่ได้กับแพ็กเกจของ Ollama’ ซึ่งเป็นไฟล์เดียวขนาด 20 GB ไม่มีเวอร์ชันเล็กกว่า แต่มีสำเนาที่บีบอัดแล้ว: Unsloth เผยแพร่ไฟล์ 2-bit และ 3-bit ขนาดราว 9 ถึง 14 GB ที่รันด้วยบิลด์ llama.cpp ของตัวเอง นั่นเป็นอีกเส้นทางที่เน้นเทคนิคกว่า ซึ่งผมเล่าไว้ใน Inkling 2 Mini เทียบกับ Qwen3.8-27B, พร้อมกับสิ่งที่คุณต้องเสียไปในเรื่องคุณภาพ
คุณใช้ Mac 32 GB รุ่นไหน?
ชิปของคุณสำคัญด้วยสองเหตุผล ข้อแรกคือความเร็ว โมเดลแบบนี้เขียนแต่ละคำโดยอ่านค่าน้ำหนักที่ใช้งานอยู่จากหน่วยความจำ ความเร็วในการเขียนจึงขึ้นอยู่กับ แบนด์วิดท์หน่วยความจำ: ว่าชิปอ่านหน่วยความจำได้เร็วแค่ไหน M1 Max และ M2 Max มีแบนด์วิดท์เป็นสองเท่าของ M1 Pro และ M2 Pro และราวสามเท่าของ M4 และ M5 รุ่นพื้นฐาน
เหตุผลที่สองเป็นเรื่องใหม่และเฉพาะกับ Ollama 0.40.17 (ตอนที่ 6 อธิบายไว้) Ollama มี วิธีอ่านพรอมต์ยาวที่ประหยัดหน่วยความจำ สำหรับโมเดลนี้ แต่เปิดใช้เฉพาะชิปบางรุ่น ในบรรดา Mac ที่มีความจุ 32 GB พอดี ตอนนี้มีเพียง M2 Pro เท่านั้น
| ชิป | มาพร้อม 32 GB ไหม? | แบนด์วิดท์หน่วยความจำ | การอ่านพรอมต์แบบประหยัดหน่วยความจำใน Ollama 0.40.17 |
|---|---|---|---|
| M1 Pro | ใช่ | 204.8 GB/s | ไม่ใช่ |
| M1 Max | ใช่ | 409.6 GB/s | ไม่ใช่ |
| M2 Pro | ใช่ | 204.8 GB/s | ใช่ |
| M2 Max | ใช่ | 409.6 GB/s | ไม่ใช่ |
| M4 | ใช่ | 120 GB/s | ไม่ใช่ |
| M5 | ใช่ | 153.6 GB/s | ไม่ใช่ |
| M3 Pro, M3 Max, M4 Max | รุ่น 36 GB | 153.6 / 307.2 / 409.6 GB/s | ไม่ใช่ |
| M5 Max | รุ่น 36 GB | 460.8 GB/s | ใช่ |
ข้อมูลแบนด์วิดท์และตัวเลือกหน่วยความจำมาจากสเปกของ Apple ตามที่รวบรวมไว้ใน Wikipedia การรองรับการอ่านพรอมต์มาจากซอร์สโค้ดของ Ollama 0.40.17 ซึ่งเปิดใช้สำหรับ M2 Pro, M2 Ultra, M3 Ultra, M4 Pro และ M5 Pro, Max และ Ultra ส่วน M4 Pro และ M5 Pro ไม่ได้จำหน่ายพร้อมหน่วยความจำ 32 GB
เครื่องที่มีหน่วยความจำ 36 GB จะมีพื้นที่เหลือมากกว่าที่คู่มือนี้สมมติไว้ราว 4 GB ขั้นตอนเดิมจึงใช้ได้โดยมีที่เผื่อเพิ่มขึ้นเล็กน้อย

ตอนที่ 2 — ขั้นตอนที่ 1: ติดตั้งหรืออัปเดต Ollama
Ollama เป็นแอปฟรีที่ดาวน์โหลดโมเดลโอเพนเวตและรันบน Mac ของคุณเอง นอกจากนี้ยังรันเซิร์ฟเวอร์เล็ก ๆ ไว้เบื้องหลัง ซึ่งเป็นตัวที่เอเจนต์สำหรับเขียนโค้ดจะติดต่อด้วยในภายหลัง
ถ้าคุณยังไม่มี Ollama
- ไปที่ ollama.com/download แล้วดาวน์โหลดเวอร์ชันสำหรับ Mac,
Ollama.dmg. - เปิดไฟล์แล้วลาก Ollama ไปยัง โฟลเดอร์ Applications โฟลเดอร์
- เปิด Ollama จากโฟลเดอร์ Applications ครั้งแรกที่เริ่มทำงาน แอปจะตรวจว่าคำสั่งของ Ollama
ollamaพร้อมใช้งานใน Terminal หรือไม่ ถ้าไม่มี จะขออนุญาตเพิ่มคำสั่งลงใน/usr/local/bin. กดยอมรับแล้วใส่รหัสผ่าน Mac หากระบบถาม ไอคอนลามาตัวเล็กจะปรากฏบนแถบเมนูขณะ Ollama ทำงาน - เปิด Terminal แล้วพิมพ์:
ollama --version
คุณต้องได้ 0.40.17 หรือสูงกว่า.
ถ้าคุณมี Ollama อยู่แล้ว
เรียกใช้ ollama --version. ถ้าเวอร์ชันเก่ากว่า 0.40.17 ให้อัปเดต:
- ผ่านแอป: Ollama ดาวน์โหลดอัปเดตเอง คลิกไอคอนลามาบนแถบเมนูแล้วเลือก รีสตาร์ตเพื่ออัปเดต ถ้ามีตัวเลือกนี้ ถ้าไม่มี ให้ดาวน์โหลด Ollama ใหม่จาก ollama.com/download แล้วติดตั้งทับแอปเดิม โมเดลที่ดาวน์โหลดไว้จะยังอยู่ที่เดิม
- ผ่าน Homebrew: ให้รัน
brew upgrade ollama. แพ็กเกจ Ollama ของ Homebrew อยู่ที่ 0.40.17 แล้วเมื่อวันที่ 21 พฤศจิกายน
ตรวจเวอร์ชันเมื่อวันที่ 21 พฤศจิกายน 2026: Ollama ประกาศรองรับ Inkling 2 Mini ใน 0.40.17 เมื่อวันที่ 20 พฤศจิกายน ในฐานะพรีรีลีส เวอร์ชัน 0.40.17 สุดท้ายถูกแท็กบน GitHub ภายในหนึ่งวัน และ Homebrew มีให้แล้ว ถ้าหน้าดาวน์โหลดยังให้ 0.40.16 อยู่ ให้รับ 0.40.17 หรือใหม่กว่าจาก หน้ารีลีสบน GitHub. Ollama เวอร์ชันเก่าจะปฏิเสธการดาวน์โหลดด้วยข้อความ
pull model manifest: 412: The model you are attempting to pull requires a newer version of Ollama.
การตั้งค่าสองอย่างที่ควรดู (ไม่บังคับ)
เปิดของ Ollama’s การตั้งค่า จากไอคอนลามะหรือหน้าต่างแอป
- คลาวด์ สวิตช์นี้เปิดใช้โมเดลบนคลาวด์และการค้นเว็บของ Ollama’s ไม่ว่าจะทางไหน Inkling 2 Mini ก็ทำงานบน Mac ของคุณทั้งหมด คำถามที่พบบ่อยของ Ollama’s เองระบุว่าเมื่อคุณรันในเครื่อง มันจะไม่เห็นพรอมต์หรือข้อมูลของคุณ’ ปิด Cloud ถ้าคุณต้องการแน่ใจว่าไม่มีอะไรถอยไปใช้โมเดลบนคลาวด์ได้ โปรดทราบว่าเครื่องมือค้นเว็บในเอเจนต์บางตัวใช้คลาวด์ของ Ollama
- ตำแหน่งโมเดล ถ้าไดรฟ์ภายในของคุณพื้นที่ไม่พอ ให้ชี้ไปที่ SSD ภายนอก ก่อน คุณดาวน์โหลด 20 GB
ตอนที่ 3 — ขั้นตอนที่ 2: ดาวน์โหลด Inkling 2 Mini
คำสั่งเดียว:
ollama pull inkling-2-mini
ไฟล์ดาวน์โหลดมีขนาด 20,188,097,271 ไบต์, มากกว่า 20 GB เล็กน้อย นี่คือเวลาคร่าว ๆ ที่ใช้เมื่อความเร็วเต็ม’ การดาวน์โหลดจริงมักช้ากว่านี้:
| การเชื่อมต่อของคุณ | เวลาดาวน์โหลด |
|---|---|
| 50 Mbit/s | ประมาณ 54 นาที |
| 100 Mbit/s | ประมาณ 27 นาที |
| 250 Mbit/s | ประมาณ 11 นาที |
| 500 Mbit/s | ประมาณ 5½ นาที |
| 1 Gbit/s | ประมาณ 3 นาที |
ถ้าการดาวน์โหลดหยุด ให้รันคำสั่งเดิมอีกครั้ง แล้วมันจะทำต่อจากจุดที่ค้างไว้
มีบางเรื่องที่ควรรู้’เกี่ยวกับสิ่งที่คุณเพิ่งดาวน์โหลด:
- มีเพียงเวอร์ชันเดียว’ แท็กทั้งสามบนหน้าคลังของ Ollama’s,
latest,26b-a5bและ26b-a5b-nvfp4, เป็นแพ็กเกจ 20 GB เดียวกัน ไม่มีเวอร์ชัน Ollama ที่เล็กกว่าให้เลือก’ - มันคือต้นฉบับ ไม่ใช่สำเนาที่ถูกบีบอัด’ Thinking Machines ฝึกน้ำหนักส่วนใหญ่ของโมเดลในรูปแบบ 4 บิตที่เรียกว่า NVFP4 และสี่เลเยอร์สุดท้ายในรูปแบบ 8 บิต MXFP8 แล้วจัดส่งออกมาแบบนั้น แพ็กเกจของ Ollama’s มีน้ำหนักเหล่านี้อยู่ จึงไม่มีอะไรสูญหายไปในการแปลง’
- มันมองเห็นได้ แพ็กเกจนี้รองรับทั้งรูปภาพและข้อความ และเรียกใช้เครื่องมือได้ ซึ่งเป็นสิ่งที่ทำให้เอเจนต์เขียนโค้ดใช้งานมันได้
ตรวจสอบว่าได้มาถึงแล้ว:
ollama ls
คุณควรเห็น inkling-2-mini:latest โดยมีขนาด 20 GB
ตอนที่ 4 — ขั้นตอนที่ 3: รัน Inkling 2 Mini ใน Ollama เป็นครั้งแรก
เริ่มแชตใน Terminal:
ollama run inkling-2-mini --verbose
การเริ่มครั้งแรกใช้เวลาสักครู่ เพราะ Ollama โหลด 20 GB จากไดรฟ์ของคุณเข้าสู่หน่วยความจำ จากนั้นคุณจะเห็น >>> พรอมต์ ลองพิมพ์อะไรแบบนี้:
อธิบายในสามประโยคว่า looped transformer คืออะไร
Inkling 2 Mini คิดก่อนตอบ, ดังนั้นคุณจะเห็นเหตุผลของมันขึ้นมาก่อน ตามด้วยคำตอบ ถ้าไม่อยากดูมันคิด ให้เริ่มด้วย --hidethinking แทน
อ่านตัวเลข
เพราะคุณเพิ่ม --verbose, Ollama จะพิมพ์สถิติหลังแต่ละคำตอบ มีสองบรรทัดที่สำคัญ:
| Line | ความหมาย |
|---|---|
| อัตราการประเมินพรอมต์ | โมเดลอ่าน อ่าน ข้อความของคุณได้เร็วแค่ไหน หน่วยเป็นโทเคนต่อวินาที |
| eval rate | ความเร็วที่มัน เขียน คำตอบ หน่วยเป็นโทเคนต่อวินาที หนึ่งโทเคนประมาณสามในสี่ของคำภาษาอังกฤษหนึ่งคำ |
สำหรับอ้างอิง การทดสอบ Ollama ที่เผยแพร่เพียงครั้งเดียวบน Mac 32 GB คือ M2 Max วัดได้ประมาณ 24 โทเคนต่อวินาที ส่วนที่ 8 มีการวัดอื่น ๆ
สิ่งที่ทำได้ต่อไป
- ออกจากแชต: type
/byeหรือกด Ctrl-D โมเดลจะยังอยู่ในหน่วยความจำห้านาที เผื่อคุณกลับมา - คืนหน่วยความจำทันที:
ollama stop inkling-2-mini. - ถามเกี่ยวกับรูปภาพ: พิมพ์คำถามของคุณ แล้วลากไฟล์รูปภาพจาก Finder ไปยังหน้าต่าง Terminal ซึ่งจะวางพาธเต็มของไฟล์ให้ กด Return
- ใช้แอปแทน: เปิดแอป Ollama เลือก
inkling-2-miniจากเมนูโมเดล แล้วแชตที่นั่น คุณลากรูปภาพใส่หน้าต่างได้ด้วย
ตรวจสอบว่า Inkling 2 Mini ทำงานถูกต้อง
ขณะที่โมเดลโหลดอยู่ ให้เปิดหน้าต่าง Terminal อีกหน้าต่างแล้วรัน:
ollama ps
| คอลัมน์ | สิ่งที่อยากเห็น |
|---|---|
| NAME | inkling-2-mini:latest |
| SIZE | โมเดลใช้หน่วยความจำเท่าไร |
| PROCESSOR | 100% GPU. บน Apple silicon นั่นหมายความว่ามันทำงานบนโปรเซสเซอร์กราฟิกในหน่วยความจำแบบรวม |
| CONTEXT | จำนวนโทเคนของบทสนทนาที่โมเดลเก็บไว้ได้ บน Mac 32 GB ส่วนใหญ่ค่านี้จะแสดง 4096 จนกว่าคุณจะเปลี่ยนในส่วนที่ 5 |
| RUNNER | mlx, เอนจินของ Ollama สำหรับ Apple silicon |
| UNTIL | เวลาที่ Ollama จะปลดโมเดลออกจากหน่วยความจำหากคุณไม่ใช้งาน |
คุณยังถาม Ollama ได้ด้วยว่าตอนเริ่มทำงานมันตรวจพบอะไร:
grep "vram-based default context" ~/.ollama/logs/server.log | tail -1
บน Mac 32 GB คุณควรเห็นค่า total_vram ราว 21 GiB และ default_num_ctx=4096. บรรทัดเดียวนี้คือคำอธิบายของเกือบทั้งหมดในส่วนที่ 5
ตอนที่ 5 — ขั้นตอนที่ 4: การตั้งค่าที่แนะนำสำหรับ Mac 32 GB
การแชตใช้ได้เลยโดยไม่ต้องแก้อะไร แต่เอเจนต์เขียนโค้ดและเอกสารยาวใช้ไม่ได้ เพราะวิธีที่ Mac 32 GB แบ่งหน่วยความจำ ตัวเลขหน่วยความจำทั้งหมดในส่วนนี้เป็นหน่วย GiB, คือกิกะไบต์แบบฐานสองที่ macOS และ Ollama รายงาน; Mac "32 GB" มี 32 GiB
นี่คือการแบ่งงบหน่วยความจำ น้ำหนักของ Inkling 2 Mini ใช้ไป 18.8 GiB. บน Mac 32 GB macOS อนุญาตให้โปรเซสเซอร์กราฟิกใช้หน่วยความจำราวสองในสาม ประมาณ 21.3 GiB, เว้นแต่คุณจะเปลี่ยนค่านี้ VisualInference วัดน้ำหนักต้นฉบับชุดเดียวกันนี้ในแอป MLX อีกตัวคือ mlx-vlm บน M4 Pro 48 GB หน่วยความจำพุ่งสูงสุดที่ 20.3 GiB ด้วยพรอมต์สั้น ๆ, 21.4 GiB ที่ 4,000 โทเคน และ 22.1 GiB ที่ 16,000 โทเคน กล่าวอีกนัยหนึ่ง เมื่อพรอมต์ยาวขึ้น ตัวโมเดลเพียงลำพังก็กินงบ GPU เริ่มต้นจนเกือบเต็ม และนั่นยังไม่นับ macOS กับแอปอื่นของคุณที่ต้องใช้ส่วนของตน

มีการตั้งค่าสี่ข้อที่สร้างความแตกต่าง
การตั้งค่าที่ 1: ความยาวบริบท (ข้อที่สำคัญที่สุด)
กรณี ความยาวบริบท คือปริมาณข้อความที่โมเดลเก็บไว้ได้ในคราวเดียว ซึ่งรวมข้อความของคุณและคำตอบของโมเดล และสำหรับเอเจนต์ยังรวมพรอมต์ระบบ คำนิยามเครื่องมือ และทุกไฟล์ที่มันอ่านแล้ว หากเล็กเกินไป เอเจนต์จะค่อย ๆ สูญเสียคำสั่งของมันโดยไม่รู้ตัวและเริ่มทำผิดแปลก ๆ หากใหญ่เกินไป คุณก็จองหน่วยความจำที่ไม่ได้ใช้เลย
Ollama เลือกค่าเริ่มต้นจากหน่วยความจำ GPU ที่ตรวจพบ:
| หน่วยความจำ GPU ที่ Ollama ตรวจพบ | บริบทเริ่มต้น |
|---|---|
| ต่ำกว่า 23 GiB (Mac 32 GB ส่วนใหญ่: ประมาณ 21.3 GiB) | 4K โทเคน |
| 23 ถึง 47 GiB | 32K โทเคน |
| 47 GiB ขึ้นไป | 256K โทเคน |
เอกสารของ Ollama ระบุระดับเป็นต่ำกว่า 24, 24–48 และ 48 GiB ขึ้นไป โค้ดใน 0.40.17 ใช้ 23 และ 47 GiB เพื่อเผื่อความต่างเล็กน้อยในค่าที่ Mac แต่ละเครื่องรายงาน
บริบทที่ใหญ่ขึ้นแลกมาด้วยหน่วยความจำเท่าไรสำหรับ Inkling 2 Mini คำนวณจากคอนฟิกของโมเดล:
| บริบท | หน่วยความจำที่เพิ่มขึ้นสำหรับบริบท |
|---|---|
| 4K | 0.28 GiB |
| 8K | 0.41 GiB |
| 16K | 0.66 GiB |
| 32K | 1.16 GiB |
| 64K | 2.16 GiB |
| 128K | 4.16 GiB |
Inkling 2 Mini ใช้หน่วยความจำต่อโทเคนของบริบทน้อยกว่าโมเดลขนาดเดียวกันส่วนใหญ่ เพราะมีเพียง 4 จาก 24 เลเยอร์ที่มองย้อนกลับไปทั้งบทสนทนา ส่วนหน่วยความจำที่ใช้ระหว่างอ่านพรอมต์นั้นเพิ่มเข้ามาอีก และค่าสูงสุดที่วัดได้ข้างต้นก็นับรวมส่วนนี้แล้ว
สิ่งที่ต้องตั้งค่า
| สิ่งที่คุณกำลังทำ | บริบท | ทำไม |
|---|---|---|
| การแชตและคำถามสั้น ๆ | 4K–8K (ค่าเริ่มต้นก็ใช้ได้) | ใช้หน่วยความจำน้อยที่สุด |
| การวางเอกสารยาวหรือไฟล์โค้ด | 16K | ประมาณ 12,000 คำภาษาอังกฤษ |
| Pi agent | 16K (8K บนชิปที่ไม่มีการอ่านพรอมต์แบบประหยัดหน่วยความจำตามที่อธิบายในส่วนที่ 6) | คำสั่งของ Pi เองมีขนาดเล็กนิดเดียว (ส่วนที่ 7) |
| OpenCode | 32K บน M2 Pro | เป็นค่าสูงสุดที่ให้ได้อย่างสบาย ๆ บน 32 GB Ollama แนะนำ 64K ขึ้นไปสำหรับเอเจนต์ ซึ่ง Mac เครื่องนี้รับไม่ไหวจริง ๆ เมื่อต้องแบกโมเดลขนาด 20 GB ไว้ด้วย บนชิปอื่นควรอ่านส่วนที่ 6 ก่อน |
| Claude Code | 64K ขึ้นไป ตามที่ Ollama แนะนำ | ไม่สมจริงบน 32 GB ดูส่วนที่ 7 |
วิธีตั้งค่า
วิธีที่ง่ายที่สุดในการเปลี่ยนความยาวบริบทของ Ollama คือใช้แอป: เปิด Settings → Context length แล้วเลื่อนสไลเดอร์ ซึ่งมีจุดหยุดที่ 4k, 8k, 16k, 32k, 64k, 128k และ 256k Ollama จะรีสตาร์ตเซิร์ฟเวอร์เพื่อใช้ค่านี้ และการตั้งค่านี้ยังอยู่แม้คุณรีสตาร์ต Mac
ยังมีอีกสามวิธีซึ่งมีประโยชน์ในภายหลัง:
# ใช้เฉพาะแชตเซสชันเดียว ภายใน `ollama run`:
/set parameter num_ctx 16384
# สำหรับแอป Ollama จนกว่าคุณจะรีสตาร์ต Mac (แล้วปิดและเปิด Ollama ใหม่):
launchctl setenv OLLAMA_CONTEXT_LENGTH 32768
ถ้าคุณเลื่อนสไลเดอร์ของแอปไปแล้ว สไลเดอร์จะมีผลเหนือ launchctl การตั้งค่า
หรือสร้าง สำเนาของโมเดลที่ฝังบริบทของตัวเองไว้ในตัว, ซึ่งมีประโยชน์เมื่อคุณต้องการ 8K สำหรับแชตแต่ 32K สำหรับเอเจนต์ วางคำสั่งนี้ลงใน Terminal แล้วมันจะสร้างไฟล์ข้อความขนาดเล็กชื่อ Modelfile แล้วจึงสร้างโมเดลใหม่:
cat > Modelfile <<'EOF'
FROM inkling-2-mini
PARAMETER num_ctx 32768
EOF
ollama create inkling-2-mini-32k -f Modelfile
สำเนานี้ไม่ได้ดาวน์โหลดหรือทำซ้ำเวตขนาด 20 GB จากนั้นคุณใช้ inkling-2-mini-32k ทุกที่ที่คุณจะใช้ inkling-2-mini. ไม่ว่าคุณจะเลือกวิธีใด ให้ยืนยันใน CONTEXT คอลัมน์ของ ollama ps.
การตั้งค่า 2: ให้พื้นที่ GPU มากขึ้น (ไม่บังคับ)
macOS จำกัดปริมาณหน่วยความจำที่ GPU อาจเก็บไว้ใช้เอง และ Ollama ถือขีดจำกัดนั้นเป็น "VRAM" ของคุณ บน Mac 32 GB ค่านี้อยู่ที่ราว 21.3 GiB จึงเกิดผลตามมาสามข้อ Ollama กำหนดบริบทเริ่มต้นจากค่านี้ (การตั้งค่า 1) เอนจิน MLX ของ Ollama เก็บโมเดลที่โหลดไว้ในหน่วยความจำจนถึงขีดจำกัดนั้น หากโมเดลใหญ่กว่านั้น ระบบจะบันทึกคำเตือนว่าประสิทธิภาพอาจลดลง และเมื่อขั้นตอนการทำงานขั้นเดียวต้องใช้หน่วยความจำ GPU มากกว่าที่มี macOS จะสั่งหยุด นั่นคือ หน่วยความจำไม่เพียงพอ ที่เกิดขึ้นในส่วนที่ 6 เอกสารของ Apple ระบุว่าหมายถึง GPU ไม่มีหน่วยความจำพอที่จะรันบัฟเฟอร์คำสั่ง
คุณเพิ่มขีดจำกัดนี้ได้จนกว่าจะรีสตาร์ตครั้งถัดไป เอกสาร MLX ของ Apple ให้คำสั่งสำหรับเรื่องนี้โดยเฉพาะ ตรวจสอบค่าปัจจุบันก่อน 0 หมายถึงค่าเริ่มต้นของ macOS:
sysctl iogpu.wired_limit_mb
เพิ่มเป็น 24 GiB ซึ่งเหลือ 8 GiB ให้ macOS และแอปของคุณ:
sudo sysctl iogpu.wired_limit_mb=24576
จากนั้นออกจาก Ollama จากแถบเมนูแล้วเปิดใหม่ เพราะ Ollama อ่านขีดจำกัดเฉพาะตอนเริ่มทำงาน รัน grep คำสั่งจากส่วนที่ 4 อีกครั้ง แล้ว total_vram ตอนนี้ควรแสดงประมาณ 24 GiB
สี่สิ่งที่ควรรู้
- ค่านี้เปลี่ยนบริบทเริ่มต้นของคุณด้วย เมื่อตรวจพบ 24 GiB ค่าเริ่มต้นของ Ollama จะกระโดดจาก 4K เป็น 32K (ตารางด้านบน) คุณจึงอาจไม่ต้องใช้การตั้งค่า 1 เลย
- มันให้พื้นที่ GPU มากขึ้น ไม่ใช่หน่วยความจำมากขึ้น มันเลื่อนเส้นแบ่งระหว่าง GPU กับ macOS ไม่ได้เพิ่มหน่วยความจำให้ หากแอปอื่นของคุณขาดหน่วยความจำ macOS จะใช้ swap แทน
- ค่านี้รีเซ็ตเมื่อคุณรีสตาร์ต Mac นั่นคือตาข่ายนิรภัย ไม่ใช่บั๊ก ถ้าอยากย้อนกลับเร็วขึ้น:
sudo sysctl iogpu.wired_limit_mb=0. - นี่ไม่ใช่การตั้งค่ามาตรฐานของ macOS มีการใช้กันอย่างแพร่หลายสำหรับ AI ภายในเครื่อง แต่ถ้า Mac ของคุณ swap หนักมาก ค้าง หรือรีสตาร์ตเองระหว่างใช้งาน ให้ตั้งกลับเป็น 0 อย่าตั้งสูงกว่า 24 GiB มากนักบน Mac 32 GB
การตั้งค่า 3: ระดับความพยายามในการให้เหตุผล
Inkling 2 Mini ตัดสินใจว่าจะคิดหนักแค่ไหนจาก ระดับความพยายามในการให้เหตุผล การตั้งค่านี้ ค่าเริ่มต้นของ Ollama คือ สูง. นี่คือวิธีที่ Ollama 0.40.17 แปลชื่อเหล่านี้เป็นค่าที่โมเดลได้รับจริง:
| การตั้งค่า Ollama | ความพยายามที่โมเดลได้รับ | เหมาะกับ |
|---|---|---|
none หรือ false |
0 (ซ่อนการคิด) | การค้นหาแบบง่าย |
minimal |
0.1 | ข้อเท็จจริงสั้น ๆ |
ต่ำ |
0.2 | คำตอบสั้น สรุป และการเขียนใหม่ |
medium |
0.7 | คำถามในชีวิตประจำวัน |
สูง หรือ true (default) |
0.9 | การเขียนโค้ดและงานเอเจนต์ |
xhigh หรือ สูงสุด |
0.99 | ปัญหายาก เมื่อคุณรอได้ |
จากตัวเรนเดอร์ Inkling 2 Mini ของ Ollama 0.40.17 Thinking Machines ระบุว่าแม้แต่ระดับต่ำสุดก็ไม่ได้ปิดการให้เหตุผลโดยสมบูรณ์

xhigh และ สูงสุด ส่งค่าเดียวกัน ค่าเริ่มต้นคือ high ซึ่งเป็นค่าที่เหมาะสมกับการเขียนโค้ดหากต้องการตั้งค่าสำหรับแชต:
ollama run inkling-2-mini --think=low
ภายในแชต, /set nothink จะลดระดับลงต่ำสุดและซ่อนการคิด และ /set think จะเปิดกลับมา ใน API ของ Ollama ชื่อเดียวกันนี้จะใส่ใน think ฟิลด์
ข้อแนะนำของผม: ปล่อยไว้ที่ สูง สำหรับการเขียนโค้ดและเอเจนต์ ซึ่งการคิดนั้นคุ้มค่าในตัวเอง ใช้ ต่ำ หรือ medium สำหรับคำถามสั้น ๆ เพื่อไม่ต้องรอการให้เหตุผลยาว ๆ สำหรับคำตอบเพียงบรรทัดเดียว
การตั้งค่าที่ 4: โหลดค้างไว้ และถอดออกเมื่อใช้เสร็จ
Ollama จะถอดโมเดลออกหลังจาก ห้านาที โดยไม่มีการใช้งาน และการโหลด 20 GB อีกครั้งต้องใช้เวลา ระหว่างเซสชันเอเจนต์ที่มีช่วงหยุดพัก สิ่งนี้กวนใจมาก หากต้องการให้โหลดค้างไว้ 30 นาทีหลังการใช้งานแต่ละครั้ง:
launchctl setenv OLLAMA_KEEP_ALIVE 30m
จากนั้นปิดและเปิด Ollama ใหม่ สำหรับแชตครั้งเดียว, ollama run inkling-2-mini --keepalive 30m ให้ผลเหมือนกัน อีกด้านหนึ่ง เมื่อใช้งานเสร็จแล้ว คืนหน่วยความจำด้วย ollama stop inkling-2-mini.
อีกสองตัวเลือกสำหรับคนที่อยากลอง
- ตัวช่วยร่างในตัว Thinking Machines มาพร้อม Inkling 2 Mini โดยมีเครือข่ายตัวช่วยขนาดเล็กชื่อ DSpark ที่เดาคำล่วงหน้าสองสามคำ จากนั้นโมเดลหลักจะตรวจคำเหล่านั้นในครั้งเดียว Ollama รองรับฟีเจอร์นี้และเปิดการร่างไว้เป็นค่าเริ่มต้นสำหรับโมเดลใดก็ตามที่มีตัวร่าง ในการทดสอบ MLX ที่เผยแพร่ภายนอก Ollama นั้น DSpark เพิ่มความเร็วการเขียนของ Inkling จาก 43.6 เป็น 70.9 โทเคนต่อวินาทีบน M5 Max ส่วนบน M4 Pro กลับลดความเร็วจาก 31.1 เหลือ 18.7 ดังนั้นลองทดสอบบน Mac ของคุณ: ในแชต,
/set parameter draft_num_predict 0จะปิดมัน เปรียบเทียบ eval rate แบบเปิดและแบบปิด - คำขอแบบขนาน ตั้งแต่ 0.40.17 เป็นต้นมา Ollama บน Apple silicon สามารถตอบหลายคำขอพร้อมกันได้ และแต่ละคำขอต้องมีหน่วยความจำบริบทของตัวเอง Ollama เลือกค่าเริ่มต้นที่ระมัดระวังจากหน่วยความจำว่างของคุณ หากเอเจนต์ที่รันตัวช่วยแบบขนานยังทำให้ Mac ของคุณใช้สวอป จำกัดให้เหลือหนึ่งคำขอด้วย
launchctl setenv OLLAMA_NUM_PARALLEL 1จากนั้นปิดและเปิด Ollama ใหม่
การตั้งค่าที่ไม่ช่วยในกรณีนี้
คู่มือสำหรับโมเดลอื่นมักแนะนำ OLLAMA_KV_CACHE_TYPE=q8_0 เพื่อลดหน่วยความจำที่บริบทใช้ลงครึ่งหนึ่ง พร้อมกับ flash attention ใน Ollama 0.40.17 การตั้งค่าเหล่านี้เป็นของ llama.cpp เอนจินของมัน ส่วน Inkling 2 Mini ทำงานบน MLX เอนจินนั้น และไม่มีส่วนใดในโค้ดของเอนจินนั้นอ่านค่าเหล่านี้ เช่นเดียวกับการตั้งค่าชั้น GPU เช่น num_gpuและปล่อย temperature เท่านั้น: แพ็กเกจของ Ollama ใช้ค่าเริ่มต้น 1.0 ของ Thinking Machines ซึ่งเป็นค่าที่ Unsloth แนะนำเช่นกัน
ก่อนเริ่มเซสชันยาว: ทำให้หน่วยความจำว่าง
เปิด Activity Monitor (อยู่ใน Applications → Utilities) แล้วคลิก ความจำ แท็บ ที่ด้านล่างคุณจะเห็น Memory Pressure กราฟ และ Swap Used. สีเขียวคือดี สีเหลืองหมายความว่า macOS กำลังบีบอัดหน่วยความจำ และสีแดงหมายความว่ากำลังสลับข้อมูลลงดิสก์ของคุณ ซึ่งทำให้ทุกอย่างช้า ก่อนเริ่มเซสชันเอเจนต์ ให้ปิดแอปที่กินหน่วยความจำมาก: เบราว์เซอร์ที่เปิดหลายแท็บ, Docker Desktop, ซิมูเลเตอร์ iPhone, โปรแกรมตัดต่อวิดีโอและภาพ ถ้าใช้แล็ปท็อป ให้เสียบอะแดปเตอร์ไว้เมื่อรันนาน ๆ
ตอนที่ 6 — เช็กความจริงเรื่อง 32 GB: ชิปของคุณสำคัญ
ส่วนนี้สำคัญหาก Mac ของคุณใช้ชิปอื่นที่ไม่ใช่ M2 Pro (หรือ M5 Max ขนาด 36 GB) ซึ่งก็คือ Mac 32 GB ส่วนใหญ่ และยังเป็นส่วนที่บันทึกการอัปเดตของ Ollama ไม่ได้กล่าวถึง
เกิดอะไรขึ้นเมื่อ Inkling 2 Mini อ่านพรอมต์ยาว
ก่อนที่โมเดลจะเขียนอะไร มันจะอ่านพรอมต์ทั้งหมดของคุณก่อน เอนจิน MLX ของ Ollama ทำแบบนั้น ครั้งละ 2,048 โทเคน. ในแต่ละชังก์ Inkling 2 Mini จะคำนวณว่าโทเคนใหม่แต่ละตัวสัมพันธ์กับทุกโทเคนที่มาก่อนอย่างไร โดยใช้ค่าวัดระยะห่างระหว่างกันที่เรียนรู้มา ขั้นตอนนี้ต้องใช้ตารางชั่วคราวที่ขยายตามทุกอย่างที่โมเดลอ่านไปแล้วในบทสนทนา
Ollama 0.40.17 มีวิธี ประหยัดหน่วยความจำ ในการทำเช่นนี้ ซึ่งจัดการพรอมต์เป็นชิ้นย่อย ๆ เพื่อให้ตารางไม่ใหญ่ขึ้น รหัสต้นฉบับของมันเปิดใช้เฉพาะชิปเหล่านี้: M2 Pro, M2 Ultra, M3 Ultra, M4 Pro และ M5 Pro, Max และ Ultra. ชิปอื่นทั้งหมดจะถอยไปใช้วิธีทั่วไปซึ่งการใช้หน่วยความจำเพิ่มขึ้นตามความยาวของพรอมต์ ซึ่งรวมถึง M1 Pro และ Max, M2 Max, M4 รุ่นพื้นฐาน และ M5 รุ่นพื้นฐาน
สิ่งนั้นหน้าตาเป็นอย่างไรบน M2 Max 32 GB
การทดสอบ Ollama 0.40.17 บน Mac 32 GB เพียงรายการเดียวที่เผยแพร่มาจากนักพัฒนา Genex พวกเขาลอง Inkling 2 Mini บน M2 Max ขนาด 32 GB:
- ดาวน์โหลดได้สำเร็จ และคำขอเรียกเครื่องมือแบบสั้นให้คำตอบที่ถูกต้องที่ประมาณ 24 โทเคนต่อวินาที.
- คำขอขนาด 18,003 โทเคน หยุดทำงานหลังผ่านไป 12,288 โทเคน พร้อมข้อผิดพลาด
mlx: [METAL] Command buffer execution failed: Insufficient Memory. การตั้งหน้าต่างบริบทเป็น 32,768 และขนาดแบทช์เป็น 512 ไม่ช่วย - พรอมต์จริงของพวกเขาขนาด 15,089 โทเคนก็หยุดทำงานแบบเดียวกัน
- ลูปการใช้งานคอมพิวเตอร์ที่ขับเคลื่อนด้วยภาพหน้าจอจริงทำงานได้
พวกเขาสรุปว่าโมเดลนี้เหมาะกับ Mac 32 GB เมื่อพรอมต์สั้น แต่ไม่เหมาะกับพรอมต์ยาวของแอป ellos ดังนั้นพวกเขาจึงเปลี่ยนแอปให้แนะนำ Inkling 2 Mini เฉพาะตั้งแต่ 48 GB ขึ้นไป
จะรับมืออย่างไร
| ชิปของคุณ | สิ่งที่คาดได้ในตอนนี้ | สิ่งที่ต้องทำ |
|---|---|---|
| M2 Pro (32 GB) หรือ M5 Max (36 GB) | พรอมต์ยาวใช้หน่วยความจำแบบมีขอบเขต | เอเจนต์ที่หน้าต่างบริบท 16K–32K พร้อมเพิ่มโควต้า GPU (ตอนที่ 5) |
| M1 Pro, M1 Max, M2 Max, M4, M5 (32 GB) | เซสชันที่โตเกินประมาณ 10,000 โทเคนไปมาก ๆ เสี่ยงที่จะหยุดทำงานด้วย "Insufficient Memory" | ใช้สำหรับแชตและเอกสารสั้น ๆ สำหรับเอเจนต์ ให้ใช้ Pi ที่หน้าต่างบริบท 8K และเริ่มเซสชันใหม่ทุกงาน เพิ่มโควต้า GPU และอัปเดต Ollama ทุกครั้งที่มีเวอร์ชันใหม่ออกมา |
| M3 Pro, M3 Max, M4 Max (36 GB) | ทางถอยเดียวกัน แต่มีพื้นที่เพิ่มขึ้นราว 4 GB | เหมือนข้างบน แต่มีช่องว่างเหลือมากกว่าเล็กน้อย |
มีสองเรื่องที่ควรทำความเข้าใจให้ถูกต้อง เรื่องแรก นี่เป็น ข้อจำกัดของซอฟต์แวร์ไม่ใช่ข้อจำกัดของฮาร์ดแวร์ โค้ดที่ช่วยประหยัดหน่วยความจำมีอยู่แล้ว เพียงแต่ยังไม่ได้เปิดใช้กับทุกชิป และ Ollama ออกเวอร์ชันใหม่เกือบทุกสัปดาห์ ควรอ่านรีลีสโน้ตเมื่ออัปเดต เรื่องที่สอง สิ่งที่นับคือปริมาณข้อความที่โมเดลต้องประมวลผลในหนึ่งเซสชัน ไม่ใช่ตัวเลขบนแถบเลื่อนหน้าต่างบริบท ทุกส่วนใหม่จะถูกเทียบกับทุกอย่างที่มาก่อนหน้า บทสนทนายาวจึงกินหน่วยความจำพอ ๆ กับพรอมต์ยาวหนึ่งอัน และเอเจนต์เขียนโค้ดสร้างบทสนทนายาวได้อย่างรวดเร็ว หน้าต่างบริบทเล็กทำให้เซสชันสั้น การเริ่มเซสชันใหม่ก็ยิ่งทำให้สั้นลงอีก
ตอนที่ 7 — ขั้นตอนที่ 5: ใช้ Inkling 2 Mini เป็นแบ็กเอนด์โลคอลสำหรับเอเจนต์เขียนโค้ด
เอเจนต์เขียนโค้ดคือโปรแกรมที่มอบเครื่องมือให้โมเดล เช่น การอ่านไฟล์ การแก้ไขไฟล์ และการรันคำสั่ง ช่วยให้โมเดลทำงานหนึ่งชิ้นทีละขั้นตอน ปกติโมเดลจะอยู่ในศูนย์ข้อมูล แต่ในที่นี้ Inkling 2 Mini บน Mac ของคุณกลายเป็น แบ็กเอนด์ภายในเครื่อง: เอเจนต์จึงส่งคำขอไปยัง Ollama แทน

วิธีการทำงาน
เมื่อ Ollama ทำงานอยู่ จะรับฟังที่ http://localhost:11434ซึ่งเป็นที่อยู่ที่โปรแกรมบน Mac ของคุณเข้าถึงได้เท่านั้น รองรับรูปแบบ API ที่เอเจนต์รู้จักอยู่แล้ว คือ แบบที่เข้ากันได้กับ OpenAI หนึ่งตัวที่ http://localhost:11434/v1อีกตัว ที่เข้ากันได้กับ Anthropic สำหรับ Claude Code และแบบของตัวเอง เอเจนต์ส่งพรอมต์และคำนิยามเครื่องมือไป และ Inkling 2 Mini ตัดสินใจว่าจะเรียกเครื่องมือใด เอเจนต์รันเครื่องมือนั้นบน Mac ของคุณแล้วส่งผลลัพธ์กลับมา วนซ้ำเช่นนี้จนงานเสร็จ
คุณไม่ต้องกำหนดค่าใด ๆ เหล่านั้นด้วยตัวเอง คำสั่ง ollama launch จะติดตั้งเอเจนต์ที่รองรับให้หากยังไม่มี ชี้ไปที่ Ollama แล้วเริ่มทำงาน
ก่อนเปิดเอเจนต์ตัวใดก็ตาม
- ตั้งค่าหน้าต่างบริบทก่อน (ตอนที่ 5) เรื่องนี้สำคัญกว่าที่ฟังดู เมื่อคุณเริ่ม OpenCode ผ่าน
ollama launchOllama จะอ่านหน้าต่างบริบทที่โมเดลโหลดจริงและบอกตัวเลขนั้นแก่ OpenCode ถ้า Ollama ยังอยู่ที่ 4K OpenCode ก็เชื่อตามนั้น - ทำงานในโฟลเดอร์ทดสอบภายใต้ Gitเพื่อให้คุณเห็นและย้อนทุกการเปลี่ยนแปลงได้:
mkdir -p ~/Projects/inkling-test
cd ~/Projects/inkling-test
git init
ครั้งแรกที่คุณใช้ gitmacOS อาจเสนอให้ติดตั้งเครื่องมือสำหรับนักพัฒนาชนิดบรรทัดคำสั่งของ Apple ให้ยอมรับ ใช้เวลาไม่กี่นาที
- ปิดแอปที่กินหน่วยความจำมาก (ตอนที่ 5)
ควรใช้เอเจนต์ตัวไหนกับ 32 GB?
| Pi | OpenCode | Claude Code | |
|---|---|---|---|
| ติดตั้งด้วยคำสั่งเดียว | ollama launch pi --model inkling-2-mini |
ollama launch opencode --model inkling-2-mini |
ollama launch claude --model inkling-2-mini |
| คุณติดตั้งเองก่อน | Node.js | ไม่มีเลย Ollama เสนอติดตั้งให้ | ไม่มีเลย Ollama เสนอติดตั้งให้ |
| คำสั่งและเครื่องมือที่ส่งไปก่อนคุณพิมพ์คำแรก | ต่ำกว่า 1,000 โทเคน | ราว 6,900 โทเคน | ราว 32,800 โทเคน |
| ถามก่อนรันคำสั่ง | ไม่ใช่, โดยการออกแบบ | ไม่ใช่ค่าเริ่มต้น; การเปลี่ยนการตั้งค่าหนึ่งครั้งจะเปิดใช้งาน | ใช่, สำหรับการกระทำส่วนใหญ่ |
| บริบทที่ควรตั้งบน 32 GB | 16K (8K บนชิปที่ไม่มีระบบอ่านพรอมต์แบบประหยัดหน่วยความจำ) | 32K บน M2 Pro | Ollama แนะนำ 64K ขึ้นไป |
| เหมาะที่สุดบน | Mac 32 GB ทุกรุ่น ในโฟลเดอร์ที่ใช้แล้วทิ้ง | M2 Pro ที่ 32 GB หรือ 48 GB ขึ้นไป | 48 GB ขึ้นไป |
ตัวเลขของ Pi’ มาจากผู้เขียนของมัน ตัวเลขของ OpenCode และ Claude Code มาจากการวัดของ Systima’ ในเดือนกรกฎาคม 2026 ของคำขอแรกของเอเจนต์แต่ละตัว’ Systima ใช้โปรเจกต์ว่างที่ไม่มี MCP เซิร์ฟเวอร์ OpenCode 1.17 และ Claude Code 2.1 กับโมเดล Claude เอเจนต์ทั้งสองได้รับการอัปเดตตั้งแต่นั้นมา ดังนั้นให้อ่านตัวเลขเหล่านี้เป็นเพียงลำดับขนาด คำแนะนำทั่วไปของ Ollama’ สำหรับเอเจนต์คือบริบทอย่างน้อย 64K

ตัวเลือก A: Pi เบาที่สุด
Pi เป็นเอเจนต์เขียนโค้ดที่ตั้งใจทำให้เล็กที่สุด มีเครื่องมือสี่อย่าง คือ read, write, edit และ bash ผู้เขียนของมันบอกว่าพรอมต์ระบบและคำนิยามเครื่องมือรวมกันแล้วมีขนาด ต่ำกว่า 1,000 โทเคน. นั่นทำให้มันเหมาะที่สุดสำหรับ Mac 32 GB และมัน’ คือเอเจนต์ที่ Ollama แนะนำในประกาศ Inkling 2 Mini ของตัวเอง
- ติดตั้ง Node.js: ดาวน์โหลดตัวติดตั้ง LTS จาก nodejs.org แล้วเรียกใช้งาน
ollama launch piต้องใช้ Node’npmเพื่อติดตั้ง Pi - ไปที่โฟลเดอร์ทดสอบของคุณแล้วเรียกใช้:
cd ~/Projects/inkling-test
ollama launch pi --model inkling-2-mini
Ollama จะติดตั้ง Pi ตั้งค่าให้ใช้โมเดลในเครื่องของคุณ และเปิดเซสชัน
⚠️ Pi ไม่ถามอะไรเลย ผู้เขียนของมันอธิบายว่ามันทำงานใน "โหมด YOLO เต็มรูปแบบ": ไม่มีการถามสิทธิ์สำหรับการทำงานกับไฟล์หรือคำสั่ง และเข้าถึงไฟล์ของคุณได้แบบไม่จำกัด Thinking Machines ยังเตือนว่า Inkling 2 Mini อาจลบหรือเขียนทับไฟล์โดยไม่ยืนยัน เมื่อรวมกันแล้ว นั่นหมายความว่า: ใช้ Pi ในโฟลเดอร์ที่ใช้แล้วทิ้งเท่านั้น, ห้ามใช้ในโฟลเดอร์บ้านของคุณหรือโปรเจกต์ที่ไม่มีข้อมูลสำรอง ผู้เขียนแนะนำให้รันมันในคอนเทนเนอร์ถ้าต้องการขอบเขตที่แท้จริง ส่วน คู่มือคอนเทนเนอร์ของ Apple แสดงวิธีตั้งค่าขึ้นมาบน Mac
รายละเอียดอีกอย่างหนึ่ง: เมื่อเรียกใช้ Pi ผ่าน Ollama เครื่องมือค้นหาเว็บของมันจะใช้การค้นหาเว็บบนคลาวด์ของ Ollama ซึ่งต้องมีบัญชี Ollama และเปิดการตั้งค่า Cloud ไว้ ส่วนอย่างอื่นทั้งหมดยังอยู่บน Mac ของคุณ
ตัวเลือก B: OpenCode ทางสายกลางที่ขัดเกลาแล้ว
OpenCode เป็นเอเจนต์เขียนโค้ดโอเพนซอร์สยอดนิยมที่มีอินเทอร์เฟซเทอร์มินัลเต็มหน้าจอ สแนปช็อตทุกขั้นตอน และระบบสิทธิ์ที่คุณปรับให้เข้มขึ้นได้
cd ~/Projects/inkling-test
ollama launch opencode --model inkling-2-mini
ถ้ายังไม่ได้ติดตั้ง OpenCode’ Ollama จะถามว่าจะติดตั้งหรือไม่ ให้ตอบใช่ จากนั้น Ollama จะส่งการตั้งค่าสำหรับเซสชันนี้ให้ OpenCode โดยไม่เขียนทับของคุณเอง ~/.config/opencode/opencode.json. ระบบจะปรับขีดจำกัดของ OpenCode’ ให้ตรงกับบริบทที่โมเดลโหลดมา และเก็บไว้หนึ่งในสี่ของจำนวนนั้น สูงสุด 8K โทเคน สำหรับคำตอบ ตั้งแต่ 0.40.17 เป็นต้นไป ยังส่งตัวเลือกการคิดของ Inkling 2 Mini’ ต่อไปด้วย
คำขอเปิดของ OpenCode’ อยู่ในระดับปานกลาง ประมาณ 6,900 โทเคนในการวัดของ Systima’ เมื่อเดือนกรกฎาคม แต่ทุกไฟล์ที่มันอ่านและทุกผลลัพธ์คำสั่งที่ได้รับกลับมาจะถูกเพิ่มเข้าไปในการสนทนา บน Mac 32 GB ที่ไม่มีการอ่านพรอมต์แบบประหยัดหน่วยความจำจาก Part 6’ นั่นคือตัวเลขที่ต้องจับตา ไม่ต้องใช้ไฟล์มากนักก็ทะลุ 12,000 โทเคนที่ M2 Max’ เคยพังไปแล้ว
OpenCode v2 ยังค้นหาโมเดลของ Ollama’ ได้เองเมื่อเริ่มทำงาน ดังนั้นคุณจึงเพียงแค่รัน opencode แล้วเลือกโมเดลด้วย /models. การเปิดผ่าน Ollama ยังเป็นเส้นทางที่ดีกว่าบนเครื่อง 32 GB เพราะมันบอก OpenCode ว่าคุณมีหน้าต่างบริบทจริงเท่าไร
ทำให้มันถามก่อน และจำกัดจำนวนขั้นของมัน
โดยค่าเริ่มต้น OpenCode v2 ปล่อยให้โมเดลรันคำสั่งเชลล์และแก้ไขไฟล์โดยไม่ถาม กฎเริ่มต้นของมันถามเฉพาะตอนจะอ่าน .env ไฟล์ ด้วยโมเดลที่ผู้ผลิตเตือนเรื่องการกระทำที่ทำลายข้อมูล คุณควรเปลี่ยนค่านั้น Thinking Machines ยังแนะนำให้จำกัดจำนวนรอบของเอเจนต์ เพราะบางครั้งโมเดลติดอยู่ในลูปการให้เหตุผลยาว ๆ โดยเฉพาะตอนดีบัก และของ OpenCode’ steps ออปชันทำหน้าที่นั้น ใส่ทั้งสองอย่างใน ~/.config/opencode/opencode.json (สร้างไฟล์หากยังไม่มี’):
{
"$schema": "https://opencode.ai/config.json",
"permissions": [
{ "action": "shell", "resource": "*", "effect": "ask" },
{ "action": "edit", "resource": "*", "effect": "ask" }
],
"agents": {
"build": { "steps": 40 }
}
}
กรณี permissions ทำให้ OpenCode ถามก่อนทุกคำสั่งเชลล์และทุกการแก้ไข เอเจนต์ build เอเจนต์เป็นค่าเริ่มต้นของ OpenCode’ เมื่อถึงขั้นสุดท้ายที่อนุญาต OpenCode จะถอดเครื่องมือออกและขอให้โมเดลสรุป ตรวจสอบว่ามีผลแล้วโดยขอให้ OpenCode สร้างไฟล์: ตอนนี้มันควรถามคุณก่อน’ ถ้าไม่ใช่ เอกสารสิทธิ์ของ OpenCode’ อธิบายว่าเอเจนต์จะเพิ่มกฎของตัวเองได้อย่างไร สำหรับเรื่องอื่น ๆ เกี่ยวกับ OpenCode ตั้งแต่แพ็กเกจไปจนถึงเซิร์ฟเวอร์ MCP ดูโพสต์ของฉันได้ที่ OpenCode ของผม.
ตัวเลือก C: Claude Code ตัวที่หนักที่สุด
Claude Code ทำงานกับ Ollama ผ่าน API ที่เข้ากันได้กับ Anthropic ของ Ollama’ ดังนั้นคำขอของมันจะไปที่ Mac ของคุณแทนที่จะไปยังเซิร์ฟเวอร์ของ Anthropic’ โดยค่าเริ่มต้นมันขออนุญาตก่อนการกระทำส่วนใหญ่ ซึ่งทำให้เป็นตัวที่ระวังที่สุดในสามตัว
cd ~/Projects/inkling-test
ollama launch claude --model inkling-2-mini
Ollama เสนอติดตั้ง Claude Code ให้หากยังไม่มี’ หากคุณ’อยากเริ่มด้วยตัวเองในภายหลัง นี่คือการตั้งค่าที่ ollama launch จัดการให้:
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model inkling-2-mini
Ollama’ 0.40.17 ยังให้ Claude Code โหลดเครื่องมือ MCP’ เฉพาะเมื่อจำเป็น แทนที่จะโหลดทั้งหมดพร้อมกัน ซึ่งช่วยให้พรอมต์สั้นลง อย่างไรก็ตามมันไม่แตะต้องเครื่องมือในตัวของ Claude Code’ และสิ่งเหล่านั้นคือสิ่งที่ทำให้มันหนัก ในการวัดของ Systima’ ในเดือนกรกฎาคมโดยไม่มีเซิร์ฟเวอร์ MCP คำขอแรกสุดของ Claude Code’ อยู่ที่ประมาณ 32,800 โทเคน, ส่วนใหญ่เป็นนิยามเครื่องมือ นั่น’มากกว่าที่หน้าต่างบริบท 32K จะรับได้ และเกิน 12,000 โทเคนที่ M2 Max พังไปมาก Ollama แนะนำหน้าต่างบริบท 64K ขึ้นไปสำหรับมัน บน Mac 32 GB ลองได้ถ้าอยากรู้’ แต่ควรวางแผนใช้ตั้งแต่ 48 GB
เอเจนต์และแอปอื่น ๆ
หน้าคลังของ Ollama’ แสดงการเปิดใช้งานด้วยคำสั่งเดียวสำหรับเอเจนต์อีกสองตัว และรูปแบบเดียวกันใช้ได้กับ Codex:
ollama launch hermes --model inkling-2-mini # Hermes Agent
ollama launch openclaw --model inkling-2-mini # OpenClaw
ollama launch codex --model inkling-2-mini # OpenAI's Codex CLI
เครื่องมืออื่นใดที่รองรับ OpenAI API ก็ใช้ Inkling 2 Mini ได้เช่นกัน ให้มันใช้ base URL http://localhost:11434/v1, ชื่อโมเดล inkling-2-mini และข้อความใดก็ได้เป็น API key Ollama’ ไม่ตรวจสอบคีย์ แต่เครื่องมือหลายตัวไม่ยอมรับคีย์ว่าง
งานแรกกับเอเจนต์ของคุณ
เริ่มจากสิ่งเล็ก ๆ ที่มองเห็นได้ ในโฟลเดอร์ทดสอบของคุณ:
สร้างหน้าเว็บรายการสิ่งที่ต้องทำแบบไฟล์เดียวชื่อ index.html ที่บันทึกงาน
ในเบราว์เซอร์ ให้เรียบง่ายและอธิบายวิธีเปิดมันเมื่อทำเสร็จ
ดูว่ามันทำอะไร: อ่านไฟล์ใด เขียนอะไร รันคำสั่งใด เมื่อเสร็จแล้วให้เปิดหน้าด้วย open index.html, และตรวจการเปลี่ยนแปลงด้วย Git:
git status # ไฟล์ใดเปลี่ยนแปลงหรือเพิ่งปรากฏขึ้น
git diff # มีอะไรเปลี่ยนในไฟล์ที่ Git รู้จักอยู่แล้ว
ถ้าคุณไม่ชอบผลลัพธ์’ ให้ลบโฟลเดอร์แล้วเริ่มใหม่ นั่น’คือจุดประสงค์ของโฟลเดอร์ทดสอบ
ห้ากฎสำหรับการรันเอเจนต์ในเครื่องอย่างปลอดภัย
การ์ดโมเดลของ Thinking Machines’ เปิดเผยตรงไปตรงมาอย่างผิดปกติเกี่ยวกับโหมดความล้มเหลวของ Inkling 2 Mini’ มันอาจติดอยู่ในลูปการให้เหตุผลยาว ๆ มันอาจลบหรือเขียนทับไฟล์โดยไม่ยืนยัน และอาจรายงานผลงานของตัวเองไม่ถูกต้อง และมัน’ยังมีแนวโน้มมากกว่าโมเดลที่ใหญ่กว่าที่จะกล่าวข้อเท็จจริงผิด ๆ อย่างมั่นใจ ไม่มีอะไรในนั้นผิดปกติสำหรับโมเดลขนาดนี้ มันเพียงหมายความว่า:
- ใช้ Git หรือไฟล์สำเนาไว้เสมอ อย่าปล่อยให้เอเจนต์แตะต้องไฟล์ที่คุณกู้คืนไม่ได้’ เด็ดขาด
- เปิดพรอมต์ขออนุญาต ที่เอเจนต์มีอยู่ (OpenCode ต้องเปลี่ยนการตั้งค่าข้างต้น) และอ่านสิ่งที่คุณอนุมัติ
- จำกัดจำนวนขั้นตอนและเอาต์พุต ใช้การตั้งค่าของ OpenCode
stepsส่วนในแชต Ollama/set parameter num_predict 4096จำกัดการตอบกลับเพียงครั้งเดียว - ตรวจสอบสิ่งที่มันอ้าง รันการทดสอบด้วยตัวเองก่อนจะเชื่อว่า "การทดสอบทั้งหมดผ่าน"
- อย่าชี้เอเจนต์ไปที่โฟลเดอร์บ้านของคุณเด็ดขาด และสำหรับ Pi ให้ใช้โฟลเดอร์ชั่วคราวหรือคอนเทนเนอร์
ถ้าคุณอยากไปไกลกว่านี้ คู่มือของผม ทักษะเอเจนต์และเซิร์ฟเวอร์ MCP ครอบคลุมวิธีจำกัดสิ่งที่เครื่องมือของเอเจนต์เข้าถึงได้ เปรียบเทียบ AI coding harness ทุกตัว อธิบายตัวเอเจนต์แต่ละตัวอย่างละเอียด
ตอนที่ 8 — Inkling 2 Mini เร็วแค่ไหนบน Mac 32 GB?
ความเร็วมีสองส่วน: ความเร็วที่โมเดล อ่าน พรอมต์ของคุณ และความเร็วที่มัน เขียน คำตอบของมัน นี่คือการวัดที่เกี่ยวข้องซึ่งเผยแพร่ภายในวันที่ 21 พฤศจิกายน พร้อมรันไทม์ที่แต่ละรายการใช้:
| Mac | รันไทม์ | ความเร็วในการเขียน | ความเร็วในการอ่าน | หมายเหตุ |
|---|---|---|---|---|
| M2 Max, 32 GB | Ollama 0.40.17 | ประมาณ 24 tok/s | ไม่เปิดเผย | คำขอเรียกเครื่องมือแบบสั้น |
| M4 Pro, 48 GB | Ollama 0.40.17 | ประมาณ 32 tok/s | 279 tok/s | พรอมต์ 12,000 โทเคน หน้าต่างบริบท 64K รวม 65 วินาที |
| M4 Pro, 48 GB | mlx-vlm น้ำหนักต้นฉบับชุดเดียวกัน | 25.9 tok/s | ไม่เปิดเผย | VisualInference |
| M5 Pro, 48 GB | MLX-VLM บิลด์ 4/8-bit จากคอมมูนิตี้ | ประมาณ 27 tok/s | ประมาณ 123–144 tok/s เมื่อพรอมต์สั้นมาก | ModelFit; พรอมต์ที่สั้นมากอ่านได้ช้า จึงเทียบกับค่า 279 ข้างต้นไม่ได้ |
Third-party measurements, collected on 21 November 2026. No published Ollama runs yet for the M1 Pro, M1 Max, M2 Pro, base M4 or base M5.

ตัวเลขเหล่านี้หมายถึงอะไรในทางปฏิบัติ
- สำหรับแชต, ประมาณ 24 โทเคนต่อวินาทีนั้นเร็วกว่าที่คุณอ่าน คำตอบ 300 คำหลังการคิดหนึ่งพันโทเคน รวมราว 1,400 โทเคน ใช้เวลาราวหนึ่งนาทีที่ความเร็วนั้น ถ้าลดความพยายามในการให้เหตุผลลงสำหรับคำถามเร็ว ๆ มันจะสั้นลงมาก
- สำหรับเอเจนต์, ความเร็วในการอ่านสำคัญพอ ๆ กับความเร็วในการเขียน เพราะเอเจนต์ส่งพรอมต์ยาวในทุกเทิร์น บน M4 Pro 48 GB พรอมต์ 12,000 โทเคนใช้เวลาอ่านประมาณ 43 วินาที Ollama นำแคชของส่วนต้นบทสนทนาที่ใช้ร่วมกันกลับมาใช้ซ้ำระหว่างเทิร์น เทิร์นหลัง ๆ จึงอ่านแค่สิ่งที่’ใหม่เป็นหลัก
- เพื่อเปรียบเทียบ, บน M4 Pro เครื่องเดียวกันนั้น Qwen3.8-27B ใช้เวลา 122 วินาทีสำหรับงาน 12,000 โทเคนที่ Inkling 2 Mini ทำเสร็จใน 65 วินาที Qwen อ่านที่ 107 และเขียนที่ 27 โทเคนต่อวินาที ของผม การเปรียบเทียบของสองโมเดล อธิบายเหตุผล และข้อควรระวังหนึ่งข้อ: Inkling 2 Mini มักเขียนโทเคนต่อภารกิจมากกว่า
สิ่งที่คาดหวังได้บน Mac 32 GB รุ่นอื่น
ยังไม่มีใครเผยแพร่ตัวเลข Ollama สำหรับ M4 และ M5 รุ่นพื้นฐาน แบนด์วิดท์หน่วยความจำอยู่ที่ 120 และ 153.6 GB/s เทียบกับ 409.6 GB/s ของ M2 Max ที่ทำได้ประมาณ 24 โทเคนต่อวินาที คาดว่าพวกมันจะช้ากว่าอย่างเห็นได้ชัด จะช้ากว่าแค่ไหนบอกล่วงหน้าได้ยาก เพราะบนซอฟต์แวร์ปัจจุบัน Inkling 2 Mini ไม่ได้เร็วขึ้น’ตามสัดส่วนของแบนด์วิดท์ ถ้าคุณมีเครื่องหนึ่ง รัน --verbose การทดสอบจากส่วนที่ 4 แล้วคุณ’จะรู้ภายในหนึ่งนาที
ตอนที่ 9 — แก้ปัญหา Inkling 2 Mini ใน Ollama
หาอาการของคุณด้านล่าง ถ้า’ไม่อยู่ในรายการ บันทึกของ Ollama’มักบอกว่าอะไรผิดพลาด ส่วนสุดท้ายของตอนนี้แสดงวิธีอ่านมัน

ถ้า Inkling 2 Mini ไม่ยอม’ดาวน์โหลดหรือเริ่มทำงาน
| อาการ | สาเหตุที่เป็นไปได้ | วิธีแก้ |
|---|---|---|
ollama pull inkling-2-mini ล้มเหลวด้วย 412 และ "requires a newer version" |
Ollama เก่ากว่า 0.40.17 | อัปเดต (ส่วนที่ 2) แล้ว pull อีกครั้ง |
ollama: command not found |
ลิงก์บรรทัดคำสั่งไม่ได้’ถูกสร้าง | เปิดแอป Ollama แล้วยอมรับข้อเสนอให้ติดตั้งคำสั่ง หรือติดตั้งแอปใหม่ |
PROCESSOR ใน ollama ps ไม่’แสดง 100% GPU |
การตั้งค่า GPU มีปัญหา | ออกแล้วเปิด Ollama ใหม่; ตรวจสอบว่าคุณ’ใช้ Apple silicon และ macOS 14 หรือใหม่กว่า |
| คุณใช้ Windows หรือ Linux | Ollama 0.40.17 รองรับ Inkling 2 Mini บน Apple silicon เท่านั้น; โมเดลที่ใช้ได้เฉพาะ Mac ของ Ollama’ปฏิเสธการดาวน์โหลดที่อื่นด้วย 412: this model requires macOS |
รอรีลีสที่ใหม่กว่า หรือใช้ llama.cpp หรือ vLLM |
ถ้า Inkling 2 Mini แครช ลืม หรือทำให้ Mac ช้าลง
| อาการ | สาเหตุที่เป็นไปได้ | วิธีแก้ |
|---|---|---|
โมเดลหยุดกลางคำตอบ ด้วย หน่วยความจำไม่เพียงพอ หรือ Command buffer execution failed ในบันทึก |
พรอมต์ยาวเกินหน่วยความจำของชิป’คุณในตอนนี้ (ส่วนที่ 6) หรือแอปอื่นแย่งหน่วยความจำไป | ปิดแอป ย่อพรอมต์หรือเอกสารที่คุณวาง ใช้ Pi แทนเอเจนต์ที่หนักกว่า เพิ่มงบ GPU (ส่วนที่ 5) และอัปเดต Ollama |
| เอเจนต์ลืมคำสั่ง การเรียกเครื่องมือล้มเหลว การแก้ไขหยุดกลางทาง | บริบทเล็กเกินไป: น่าจะเป็นค่าเริ่มต้น 4K | ตั้งเป็น 16K–32K (ส่วนที่ 5) และตรวจสอบคอลัมน์ CONTEXT ใน ollama ps. แล้วเปิดเอเจนต์ใหม่ |
| Mac ของคุณช้าจนแทบหยุด พัดลมหมุน swap โตขึ้น | แรงกดดันหน่วยความจำ | ตรวจสอบ Activity Monitor; ปิดแอป; ลดบริบท; ollama stop โมเดลอื่นที่โหลดอยู่ |
| คำตอบแรกหลังหยุดพักจะช้า | Ollama ถอนโมเดลออกหลังจากไม่ได้ใช้งานห้านาที | ตั้ง OLLAMA_KEEP_ALIVE (ตอนที่ 5) |
ถ้าเอเจนต์เขียนโค้ดทำงานผิดปกติ
| อาการ | สาเหตุที่เป็นไปได้ | วิธีแก้ |
|---|---|---|
| โมเดลคิดนานมากหรือวนพูดซ้ำตัวเอง | ลูปการให้เหตุผลที่ยาวนาน ซึ่ง Thinking Machines เตือนไว้ | มอบงานที่เล็กลง จำกัดจำนวนขั้นและโทเคนเอาต์พุต และใช้ความพยายามต่ำลงกับคำถามง่าย ๆ |
| เอเจนต์บอกว่าไม่มีโมเดลนี้ | พิมพ์ชื่อโมเดลผิด | ใช้ให้ตรงกับ inkling-2-mini; ollama ls ซึ่งแสดงรายการที่มีอยู่ |
| การค้นหาเว็บของ Pi ใช้ไม่ได้ | มันใช้การค้นหาเว็บบนคลาวด์ของ Ollama | ลงชื่อเข้าใช้ Ollama แล้วเปิด Cloud หรือทำงานโดยไม่ใช้การค้นหาเว็บ |
| OpenCode แก้ไขไฟล์โดยไม่ถามก่อน | OpenCode v2 อนุญาตให้แก้ไขไฟล์และรันคำสั่งเชลล์เป็นค่าเริ่มต้น | เพิ่ม permissions กฎจากตอนที่ 7 |
ตรวจดูบันทึกของ Ollama
บันทึกของ Ollama อยู่ที่ ~/.ollama/logs/server.log. หากต้องการดูบรรทัดท้าย ๆ เมื่อเกิดปัญหา:
tail -n 40 ~/.ollama/logs/server.log
ตอนที่ 10 — เมื่อ 32 GB ยังไม่พอ
คุณจะรู้ว่าถึงขีดจำกัดแล้วเมื่อพรอมต์ยาว ๆ พัง เมื่อเอเจนต์ต้องย่อบทสนทนาซ้ำ ๆ หรือเมื่อ Mac ของคุณสลับหน่วยความจำทุกครั้งที่โหลดโมเดล สามตัวเลือกแรกไม่มีค่าใช้จ่าย ส่วนสามตัวเลือกหลังมีค่าใช้จ่ายทั้งเรื่องเงิน ความเป็นส่วนตัว หรือทั้งสองอย่าง
บน Mac ที่คุณมี
- เก็บไว้ และใช้กับสิ่งที่เหมาะกับมัน แชท เอกสารสั้น คำถามเกี่ยวกับภาพ และ Pi กับงานเล็ก ๆ ทำงานได้ดีบน Mac 32 GB ทุกรุ่น จับตาบันทึกการอัปเดตของ Ollama ไว้: หากการอ่านพรอมต์แบบประหยัดหน่วยความจำจากตอนที่ 6 ครอบคลุมชิปมากขึ้น ทุกอย่างจะเปลี่ยนไปในชั่วข้ามคืน
- ไฟล์ที่เล็กลงในรันไทม์อื่น เวอร์ชัน 4 บิตของ Unsloth มีขนาด 17.6 GB เล็วกว่าแพ็กเกจของ Ollama ประมาณ 2.6 GB และทำงานบนบิลด์ llama.cpp ของ Unsloth เอง สายเทคนิคกว่า และการรองรับในวันแรกก็หยาบกว่า; บทความเปรียบเทียบของฉัน ครอบคลุมเรื่องนี้
- โมเดลโลคัลอีกรุ่น Qwen3.8-27B ได้คะแนนเท่ากับ Inkling 2 Mini บนดัชนีของ Artificial Analysis รันได้ทุกที่ และเก่งกว่าด้านคำถามความรู้ แต่ช้ากว่าบน Mac เครื่องเดียวกัน บทความเดียวกัน
เกินกว่า Mac ของคุณ
- หน่วยความจำมากขึ้น ตั้งแต่ 48 GB ขึ้นไป Inkling 2 Mini รันเอเจนต์ได้อย่างสบาย และตั้งแต่ 64 GB คุณเก็บโมเดลนี้ไว้พร้อมกับอีกโมเดลหนึ่งได้ ถ้าคุณกำลังตัดสินใจว่าจะซื้ออะไร คู่มือของผมเกี่ยวกับ ว่า MacBook สำหรับ LLM โลคัลคุ้มค่าหรือไม่ และ MacBook Pro M5 Pro ความจุ 64 GB ชั่งน้ำหนักข้อดีข้อเสีย
- พี่ใหญ่บนคลาวด์ Inkling 2 Small โมเดลขนาด 594 พันล้านพารามิเตอร์ของ Thinking Machines อยู่บนคลาวด์ของ Ollama ในชื่อ
inkling-2-small:cloud. ใช้งานได้กับคำสั่งเปิดแบบเดียวกัน ตัวอย่างเช่นollama launch opencode --model inkling-2-small:cloud. ต้องมีบัญชี Ollama และพรอมต์ของคุณจะออกจาก Mac ไป - แผนเขียนโค้ดสำหรับ 10% ที่ยากที่สุด หลายคนใช้โมเดลภายในเครื่องสำหรับงานส่วนตัวและงานประจำวัน แล้วส่งงานวางแผนและดีบักที่ยากที่สุดไปยังโมเดลคลาวด์ขนาดใหญ่ ตัวเลือกที่ราคาไม่แพงคือ GLM Coding Plan ของ Z.ai’ ซึ่งใช้ได้ใน OpenCode, Claude Code และเอเจนต์อื่น ๆ คุณสามารถ รับส่วนลด 10% สำหรับ GLM Coding Plan ผ่านลิงก์พันธมิตรของผม. (ลิงก์พันธมิตร — ดูคำชี้แจงที่ด้านบน)
คำถามที่พบบ่อย
ใช่ ทั้ง Thinking Machines และ Ollama รองรับ Inkling 2 Mini บน Mac ชิป Apple silicon ที่มีหน่วยความจำ 32 GB ขึ้นไป ผ่าน Ollama 0.40.17 หรือใหม่กว่า โมเดลใช้พื้นที่ราว 20 GB การแชตและเอกสารสั้น ๆ จึงทำงานได้ดี พรอมต์ยาวคือขีดจำกัด บนชิป 32 GB ส่วนใหญ่ Ollama 0.40.17 ยังไม่ใช้การอ่านพรอมต์แบบประหยัดหน่วยความจำ การทดสอบหนึ่งครั้งบน M2 Max ล่มหลังผ่านไปราว 12,000 โทเคน
Ollama 0.40.17 หรือใหม่กว่า Ollama ประกาศรองรับ Inkling 2 Mini ใน 0.40.17 เมื่อวันที่ 20 พฤศจิกายน 2026 ในรูปแบบพรีรีลีส และ 0.40.17 ฉบับสมบูรณ์ตามมาภายในหนึ่งวัน ตรวจสอบด้วย ollama --version. เวอร์ชันเก่าจะปฏิเสธการดาวน์โหลดด้วยข้อผิดพลาด 412 ใน 0.40.17 รองรับ Inkling 2 Mini บน Apple silicon เท่านั้น
20,188,097,271 ไบต์ ประมาณ 20.2 GB หรือ 18.8 GiB แท็กทั้งสาม latest, 26b-a5b และ 26b-a5b-nvfp4เป็นแพ็กเกจเดียวกัน: น้ำหนัก NVFP4 และ MXFP8 ดั้งเดิมของ Thinking Machines’ พร้อมการรองรับรูปภาพ ไม่มีเวอร์ชัน Ollama ที่เล็กกว่านี้ ที่ 100 Mbit/s การดาวน์โหลดใช้เวลาราว 27 นาที
Ollama กำหนดบริบทเริ่มต้นจากหน่วยความจำ GPU ที่ตรวจพบ: 4K เมื่อต่ำกว่าราว 23 GiB, 32K เมื่อถึงราว 47 GiB และ 256K เมื่อสูงกว่านั้น บน Mac ตัวเลขนั้นคืองบ GPU ที่ macOS อนุญาต ซึ่งบน Mac 32 GB อยู่ที่ราว 21.3 GiB คุณจึงได้ 4K เปลี่ยนได้ด้วยแถบเลื่อน Context length ในการตั้งค่าของ Ollama’ หรือโดยการเพิ่มงบ GPU เป็น 24 GiB
16K สำหรับ Pi และ 32K สำหรับ OpenCode บน M2 Pro ซึ่งเป็นค่าสูงสุดที่ Mac 32 GB ให้ได้อย่างสบาย ๆ เมื่อมีโมเดล 20 GB อยู่ด้วย บนชิปที่ไม่มีการอ่านพรอมต์แบบประหยัดหน่วยความจำของ Ollama’ ให้ใช้ 8K และเซสชันสั้น ๆ Ollama แนะนำ 64K ขึ้นไปสำหรับเอเจนต์เขียนโค้ด ซึ่งทำงานได้ตั้งแต่ 48 GB ตั้งค่าก่อนเปิดเอเจนต์ เพราะ ollama launch opencode จะส่งบริบทที่โหลดแล้วต่อไปยัง OpenCode
บน Mac 32 GB มันช่วยได้ การรัน sudo sysctl iogpu.wired_limit_mb=24576 เพิ่มงบ GPU จากราว 21.3 GiB เป็น 24 GiB และเหลือ 8 GiB ให้ macOS จากนั้น Ollama จะตั้งบริบทเริ่มต้นเป็น 32K ออกจาก Ollama แล้วเปิดใหม่หลังจากนั้น การตั้งค่านี้จะรีเซ็ตเมื่อคุณรีสตาร์ต Mac; sudo sysctl iogpu.wired_limit_mb=0 จะคืนค่าเริ่มต้นเร็วขึ้น นี่ไม่ใช่การตั้งค่าอย่างเป็นทางการของ macOS ดังนั้นให้ย้อนกลับหาก Mac ของคุณสลับหน่วยความจำหนักหรือเริ่มไม่เสถียร
ใช้ --think แฟล็ก: ollama run inkling-2-mini --think=low. Ollama ยอมรับ none, minimal, ต่ำ, medium, สูง (ค่าเริ่มต้น), xhigh และ สูงสุดซึ่งส่งไปยังโมเดลเป็นค่าความพยายามตั้งแต่ 0 ถึง 0.99 ภายในแชต /set nothink ตั้งระดับต่ำสุดและซ่อนการคิด แม้แต่ระดับต่ำสุดก็ไม่ได้ปิดการให้เหตุผลทั้งหมด
Pi เพราะพรอมต์ระบบและเครื่องมือรวมกันต่ำกว่า 1,000 โทเคน ซึ่งช่วยให้พรอมต์สั้นลง: ollama launch pi --model inkling-2-mini. แต่ Pi รันคำสั่งโดยไม่ถาม ดังนั้นใช้ในโฟลเดอร์ชั่วคราวเท่านั้น OpenCode เปิดด้วยพรอมต์ราว 6,900 โทเคน และทำงานที่บริบท 32K ดีที่สุดบน M2 Pro มันจะถามก่อนลงมือเมื่อคุณเพิ่มกฎสิทธิ์สองข้อในการตั้งค่า Claude Code ถามเป็นค่าเริ่มต้น แต่คำขอแรกวัดได้ราว 32,800 โทเคน มากกว่าที่บริบท 32K จะรองรับได้ จึงเหมาะกว่าตั้งแต่ 48 GB
เป็นไปได้มากว่าพรอมต์หรือบทสนทนายาวเกินหน่วยความจำ GPU ของ Mac คุณ Ollama 0.40.17 อ่านพรอมต์ยาวด้วยวิธีประหยัดหน่วยความจำเฉพาะบน M2 Pro, M2 Ultra, M3 Ultra, M4 Pro และ M5 Pro, Max และ Ultra บนชิปอื่น การใช้หน่วยความจำจะโตตามทุกอย่างที่โมเดลอ่าน และ M2 Max 32 GB เครื่องหนึ่งล่มหลัง 12,288 โทเคน ปิดแอปอื่น เก็บเซสชันให้สั้น ใช้ Pi เพิ่มงบ GPU และหมั่นอัปเดต Ollama
ในการทดสอบ Ollama บน Mac 32 GB ครั้งเดียวที่มีการเผยแพร่ ซึ่งใช้ M2 Max คำขอสั้นทำงานที่ประมาณ 24 โทเคนต่อวินาที บน M4 Pro 48 GB ที่ใช้ Ollama 0.40.17 โมเดลเขียนที่ประมาณ 32 โทเคนต่อวินาที และอ่านพรอมต์ 12,000 โทเคนที่ 279 โทเคนต่อวินาที Mac รุ่น M4 และ M5 พื้นฐานมีแบนด์วิดท์หน่วยความจำน้อยกว่ามากและควรช้ากว่า ยังไม่มีการเผยแพร่ผลการทดสอบใด ๆ
ไม่ใช่กับแพ็กเกจของ Ollama’ ซึ่งมีเวอร์ชันเดียวขนาด 20 GB และ Thinking Machines รองรับขั้นต่ำ 32 GB Unsloth เผยแพร่ไฟล์ 2-bit และ 3-bit ขนาดราว 9 ถึง 14 GB ที่รันด้วยบิลด์ llama.cpp ของตัวเองบน Mac รุ่นเล็กกว่า ไฟล์เหล่านี้สูญเสียคุณภาพบ้างและต้องตั้งค่ามากกว่า
ไม่ใช่เมื่อรันในเครื่อง Ollama รันโมเดลบน Mac ของคุณ และคำถามที่พบบ่อยระบุว่าไม่เห็นพรอมต์หรือข้อมูลของคุณเมื่อรันในเครื่อง เอเจนต์เขียนโค้ดที่เปิดด้วย ollama launch จะคุยกับ Ollama ที่ localhost:11434บนเครื่องของคุณเอง โมเดลคลาวด์และการค้นเว็บแตกต่างออกไป: พวกมันส่งข้อมูลไปยังเซิร์ฟเวอร์ของ Ollama’ และคุณปิดได้ด้วยการตั้งค่า Cloud เอเจนต์เป็นโปรแกรมแยกที่มีเครื่องมือเครือข่ายของตัวเอง เช่น web fetch ของ OpenCode’ ดังนั้นตรวจสอบการตั้งค่าหากคุณต้องทำงานออฟไลน์เต็มรูปแบบ
ไม่ใช่ใน Ollama 0.40.17 ซึ่งบันทึกการออกรุ่นระบุว่ารองรับ Inkling 2 Mini บน Apple silicon เท่านั้นในรุ่นนั้น บนฮาร์ดแวร์ NVIDIA Thinking Machines รองรับ vLLM และ SGLang และบิลด์ llama.cpp ของ Unsloth’ รันไฟล์ GGUF ของมันได้ รุ่นหลังของ Ollama อาจเพิ่มแพลตฟอร์มอื่น
เรียกใช้ ollama rm inkling-2-mini. ลบสำเนาใด ๆ ที่คุณสร้างด้วย ollama createเช่น inkling-2-mini-32kด้วยวิธีเดียวกัน: น้ำหนัก 20 GB จะถูกคืนเมื่อไม่มีโมเดลใดใช้งาน หากต้องการลบ Ollama เอง ให้ออกจากโปรแกรม ลบจาก Applications และลบโฟลเดอร์ .ollama ในโฟลเดอร์บ้านของคุณ; เอกสาร macOS ของ Ollama’ ระบุไฟล์ทั้งหมด
บทสรุป
Inkling 2 Mini เป็นโมเดลโอเพนซอร์สที่ความสามารถสูง ซึ่งผู้ผลิต รองรับบน Mac 32 GB และ Ollama ทำให้พื้นฐานง่ายจริง ๆ: ติดตั้ง ดึง รัน สำหรับการแชต เอกสาร และคำถามเกี่ยวกับรูปภาพ Mac 32 GB ก็เพียงพอ
จุดที่ 32 GB เริ่มตึงคือตอนใช้เอเจนต์ ด้วยเหตุผลสองข้อ Ollama เริ่มต้น Mac 32 GB ส่วนใหญ่ที่บริบท 4K ซึ่งทำให้เอเจนต์พังเงียบ ๆ จนกว่าคุณจะเปลี่ยนค่า และบนชิป 32 GB ส่วนใหญ่ พรอมต์ยาว ๆ ก็ยังอาจหน่วยความจำไม่พอ เพราะการอ่านพรอมต์แบบประหยัดหน่วยความจำของ Ollama’s ครอบคลุมแค่บางชิป ดังนั้นจงตั้งค่าบริบท เพิ่มงบ GPU และปิดเบราว์เซอร์ เริ่มด้วย Pi ในโฟลเดอร์ชั่วคราว แล้วอัปเดต Ollama บ่อย ๆ
ถ้าคุณมี M2 Pro คุณ’อยู่ในตำแหน่งที่ดีที่สุดเท่าที่ Mac 32 GB จะเป็นได้ในวันนี้ ถ้าคุณมี 48 GB ขึ้นไป ข้อควรระวังส่วนใหญ่ในที่นี้ก็หายไป และไม่ว่าคุณจะมี Mac รุ่นไหน ollama run inkling-2-mini --verbose ก็จะบอกคุณได้มากเกี่ยวกับเครื่องของคุณเองในห้านาที มากกว่าตารางใด ๆ ในคู่มือนี้
กำลังรัน Inkling 2 Mini บน Mac 32 GB อยู่หรือเปล่า แบ่งปันชิป เวอร์ชัน Ollama การตั้งค่าบริบท และ --verbose ตัวเลขในความคิดเห็น โดยเฉพาะจาก M1, M4 หรือ M5 ผม’จะเพิ่มผลลัพธ์ที่มีประโยชน์ที่สุดลงในตอนที่ 8 พร้อมให้เครดิต ยินดีรับคำแก้ไขเช่นกัน เพราะด้วยการสนับสนุนที่ใหม่ขนาดนี้ รายละเอียดบางอย่างในวันนี้จะเปลี่ยนไปอย่างรวดเร็ว
การเปิดเผย: คู่มือนี้มีลิงก์พันธมิตรอยู่หนึ่งลิงก์ คือ GLM Coding Plan ของ Z.ai (ในตอนที่ 10) การสมัครสมาชิกผ่านลิงก์นั้นทำให้คุณได้ส่วนลด 10% และอาจทำให้ผมได้รับค่าคอมมิชชันโดยที่คุณไม่ต้องจ่ายเพิ่ม ไม่มีผลิตภัณฑ์หรือบริษัทอื่นใดในคู่มือนี้ที่ได้รับการสนับสนุน และไม่มีรายใดได้รับการตรวจสอบก่อนเผยแพร่
Facts checked: 21 November 2026.



