จับเครื่องว่าง สามเครื่อง รวมเป็น LLM endpoint เดียว ที่เราเป็นเจ้าของ

ที่บ้านเรามีเครื่องกระจัดกระจายอยู่หลายเครื่อง มีกล่องเซิร์ฟเวอร์ (box) ที่รันงานตลอด มี Mac ที่ใช้ทำงานทุกวัน แล้วบางทีก็เช่า pod การ์ดจอ 5090 มาใช้เป็นครั้ง ๆ ปัญหาคือแต่ละเครื่องต่างคนต่างรันโมเดล พอจะเรียกใช้ทีก็ต้องจำว่าตัวไหนอยู่เครื่องไหน พอร์ตอะไร วุ่นวายกว่าที่ควร

เมื่อสี่วันก่อนไปเจอ repo ชื่อ mesh-llm เข้า มันเสนอไอเดียที่ตรงกับปัญหานี้พอดี จับทุกเครื่องมารวมเป็นก้อนเดียว แล้วเปิดออกมาเป็นช่องทางเรียกใช้ช่องเดียว เราเลย fork มาลอง deploy จริงข้ามสามเครื่องในบ้าน ดูว่ามันทำได้อย่างที่โฆษณาไหม

เกริ่นก่อนว่าบทความนี้ต่างจากรีวิว repo รอบก่อน ๆ ของเราตรงที่ เราเอามันไปรันจริง ไม่ได้แค่อ่านโค้ด ส่วนที่เป็นสถาปัตยกรรมข้างในมาจากการอ่านโค้ดกับเอกสาร ส่วนที่เป็นผลการ deploy กับจุดที่สะดุด มาจากการลงมือรันเองข้ามสามเครื่อง ไล่เป็นสามช่วง เริ่มจาก mesh-llm คืออะไร ต่อด้วย ตอน deploy จริงเจออะไรบ้าง แล้วปิดที่ เหมาะกับใคร ไม่เหมาะกับใคร

ช่วงที่ 1mesh-llm คืออะไร

ปกติถ้าอยากรันโมเดลบนเครื่องตัวเอง คนส่วนใหญ่ใช้ Ollama ซึ่งเก่งเรื่องรันบนเครื่องเดียว mesh-llm เล่นคนละโจทย์ มันจับ GPU กับหน่วยความจำจากหลายเครื่องมารวมกัน แล้วเปิดออกมาเป็น ช่องเรียกใช้ช่องเดียว ที่ localhost:9337/v1 หน้าตาเหมือน API ของ OpenAI เป๊ะ เครื่องมือหรือโค้ดที่เคยต่อ OpenAI ไว้ ก็ชี้มาที่นี่ได้เลยไม่ต้องแก้อะไร

เสน่ห์อยู่ที่ค่อย ๆ โตได้ เริ่มจากเปิดเครื่องเดียวก่อน วันหลังมีเครื่องเพิ่มก็ดึงเข้ามาต่อ ทุกเครื่องเปิดหน้า /v1 เหมือนกันหมด เรียกจากตรงไหนก็ได้ พอสั่งงานมันดูจากชื่อโมเดลว่าใครรับไหว แล้ว route ไปเครื่องนั้นให้เอง

ของเด่นที่ทำให้มันต่าง

• เครื่องเดียวพอ ก็ไม่ต้องกระจาย ถ้าโมเดลเล็กพอที่เครื่องเดียวรับไหว มันรันจบในเครื่องนั้นเลย ไม่มีการวิ่งข้ามเครื่องให้เสียเวลา
• โมเดลใหญ่เกินเครื่องเดียว แบ่งเป็นชั้น ตัวที่เรียกว่า Skippy stage split จะหั่นโมเดลเป็นชั้น ๆ กระจายรันข้ามหลายเครื่อง เครื่องเล็ก ๆ หลายตัวเลยรวมพลังรันตัวใหญ่ได้
• รองรับโมเดลเยอะ Qwen, Llama, Gemma, Mistral, DeepSeek, GLM และอีกหลายตระกูล รวมถึงพวกอ่านรูปกับ OCR
• เลือกได้ว่าจะเปิดหรือปิด mesh ส่วนตัวใช้รหัสเชิญ(invite token) ดึงเครื่องเข้าหากันเงียบ ๆ ส่วน mesh สาธารณะที่อยากแบ่งพลังให้คนอื่นค่อยประกาศผ่านเครือข่าย Nostr

ตัวมันเขียนด้วย Rust เปิดซอร์สจริงภายใต้ลิขสิทธิ์ Apache-2.0 ติดตั้งได้ด้วยคำสั่งบรรทัดเดียว เป็นของโปรเจกต์ Mesh-LLM ตอนที่เขียนบทความนี้มีดาวราวสองพันแปดร้อยกว่าดวง (เราตรวจสดจาก GitHub) ทั้งหมดนี้คือสิ่งที่ได้จากการอ่านโค้ดกับเอกสาร ทีนี้ของจริงที่น่าสนใจกว่าคือ พอเอามารันเองแล้วมันเป็นยังไง

ช่วงที่ 2ตอน deploy จริงข้ามสามเครื่อง เจออะไรบ้าง

เราลองจับสามเครื่องที่หน้าตาต่างกันสุดขั้วมาต่อกัน กล่องเซิร์ฟเวอร์ที่มีแต่ CPU เครื่องเดียว การ์ดจอ 5090 บน pod เช่า และ Mac ที่ใช้ชิปตัวเอง (metal) ให้กล่องเซิร์ฟเวอร์เป็นศูนย์กลางที่เปิดค้างไว้ตลอด รันโมเดลเล็ก Qwen3 ตัว 0.6B ไว้บริการ ส่วน Mac เข้าร่วมแบบเป็นแค่ลูกข่ายที่เรียกใช้ ด้วยรหัสเชิญใบเดียว

บททดสอบจริงคือ เปิดเทอร์มินัลบน Mac แล้วยิง curl เข้า localhost:9337/v1 ปรากฏว่า คำตอบที่ได้กลับมา เป็นคำตอบที่ประมวลผลบนกล่องเซิร์ฟเวอร์ ทั้งที่เราสั่งจาก Mac มันเวิร์คจริงอย่างที่โฆษณา สั่งจากเครื่องไหนก็เหมือนคุยกับก้อนเดียว โดยไม่ต้องรู้ว่าโมเดลจริง ๆ นั่งอยู่เครื่องไหน

กับดักที่เจอ (ของจริงจากการรัน)

แต่กว่าจะถึงจุดนั้นก็สะดุดสองสามที่ อยากเล่าไว้เผื่อใครจะลอง

1. เลขที่อยู่ในรหัสเชิญดูน่ากลัว แต่ไม่เป็นไร ในรหัสเชิญมีเลขที่อยู่ของ docker ภายในเครื่องติดมาด้วย ตอนแรกนึกว่าจะพังเพราะเป็นเลขที่เครื่องอื่นมองไม่เห็น แต่ตัวเชื่อมต่อของมัน (iroh) ฉลาดกว่านั้น มันเริ่มจากคุยผ่านตัวกลางก่อน แล้วค่อยยกระดับไปต่อตรงกันเอง (วัดได้ราว 213 มิลลิวินาที) เลขที่อยู่ภายในที่ติดมาเลยไม่ได้สร้างปัญหาอะไร
2. โหมดคิดของ Qwen3 กินโควตาคำจนคำตอบหาย โมเดล Qwen3 ชอบ "คิดในใจ" ก่อนตอบ ซึ่งกินโควตาจำนวนคำที่ตั้งไว้จนหมด สุดท้ายส่วนคำตอบจริงเลยว่างเปล่ากลับมา ทางแก้คือสั่งไม่ให้มันคิด (โหมด /no_think) หรือไม่ก็ตั้งโควตาคำให้เยอะ ๆ ไปเลย
3. ตัวใหญ่ต้องจ่ายเพิ่ม กล่องเซิร์ฟเวอร์บริการแค่ตัวเล็ก 0.6B ได้ตลอดฟรี ๆ แต่พออยากได้ตัว 27B ต้องปลุก pod การ์ดจอเช่าขึ้นมา ซึ่งมีค่าใช้จ่ายเป็นรายชั่วโมง ใช้เสร็จก็ปิด ตรงนี้เป็นเรื่องของกระเป๋าเงิน ไม่ใช่ข้อจำกัดของตัว mesh

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

ช่วงที่ 3เหมาะกับใคร ไม่เหมาะกับใคร

ก่อนอื่นบอกตามตรง mesh-llm จะเปล่งประกายก็ต่อเมื่อคุณมีเครื่องมากกว่าหนึ่งเครื่อง ถ้ามีเครื่องเดียว Ollama ง่ายกว่าและจบกว่า และเป็นงานสายโครงสร้างพื้นฐานอยู่ดี ต้องยอมลงมือตั้งค่าพอสมควร ไม่ใช่โหลดมากดเปิดแล้วเสร็จ ส่วนโมเดลที่รองรับก็มีสถานะรับรองต่างกันไป บางตัวนิ่งแล้ว บางตัวยังต้องลอง

เหมาะ ถ้าคุณคือ

• คนที่มีเครื่องว่างมากกว่าหนึ่งเครื่อง เครื่องเล่นเกมที่มีการ์ดจอ กล่องเซิร์ฟเวอร์ตัวเก่า โน้ตบุ๊กอีกเครื่อง จับมารวมเป็นก้อนเดียวได้หมด
• คนที่อยากได้ช่อง OpenAI เดียวสำหรับทั้งบ้าน ชี้ทุกเครื่องมือมาที่เดียว ไม่ต้องจำว่าตัวไหนอยู่ไหน แถมข้อมูลไม่ออกจากเครื่อง
• คนที่อยากรันโมเดลใหญ่เกินเครื่องเดียวรับไหว Skippy split ช่วยหั่นกระจายให้เครื่องเล็กหลายตัวรวมพลังกันได้

ยังไม่เหมาะ ถ้าคุณ

• มีเครื่องเดียว Ollama ตอบโจทย์กว่า ไม่ต้องมี mesh ให้ยุ่ง
• อยากได้แบบเสียบแล้ววิ่งเลย ตัวนี้ยังต้องลงมือตั้งค่าและเข้าใจว่ากำลังต่ออะไรอยู่

เอาไอเดียไหนไปใช้ดี

ต่อให้ไม่ได้ลง mesh-llm ไอเดียที่คุ้มค่าเอาไปคิดต่อคือ เปิดช่องหน้าเดียวแบบ OpenAI ไว้ข้างหน้า แล้วให้มัน route ไปหลังบ้านตัวที่รับไหว พร้อมกฎง่าย ๆ ว่าเครื่องเดียวพอก็ไม่ต้องกระจาย กระจายเฉพาะตอนจำเป็น แพตเทิร์นนี้เอาไปวางกับ backend อะไรก็ได้ ไม่จำเป็นต้องเป็น mesh-llm

ที่น่าคิดกว่าตัวเครื่องมือคือ ทุกวันนี้เราหลายคนมีพลังประมวลผลที่นอนว่างอยู่โดยไม่รู้ตัว เครื่องเล่นเกมที่เปิดทิ้งไว้ โน้ตบุ๊กเครื่องเก่าในลิ้นชัก เครื่องมืออย่าง mesh-llm ทำให้พลังที่กระจัดกระจายพวกนั้น กลายเป็น LLM endpoint เดียวที่เราเป็นเจ้าของ ข้อมูลอยู่กับบ้าน ไม่ต้องเช่าใคร