จากตอนที่แล้ว เราได้รู้จักกับ "Harness" (ผู้กำกับหลังม่าน) ไปแล้วว่า มันคือโครงรถและระบบซอฟต์แวร์รอบนอกที่คอยใส่ System Prompt, ดึง Memory, เปิดตู้ RAG และกาง Guardrails เพื่อควบคุมดูแลเครื่องยนต์อย่าง Model ให้ทำงานได้อย่างปลอดภัย
แต่ถ้าเรามองย้อนกลับไปดูระบบที่เราคุยกันมาตั้งแต่ตอนที่ 01 จนถึงตอนที่ 09... สิ่งที่เราเห็นก็ยังคงเป็นวงจรเดิม ๆ ครับ นั่นคือ: “ผู้ใช้พิมพ์ข้อความเข้ามา → โมเดลอ่าน → แล้วโมเดลก็พิมพ์ข้อความตอบกลับไป”
ไม่ว่าข้อความนั้นจะดูฉลาด ลุ่มลึก หรือรู้ใจเราแค่ไหน... ความจริงก็คือ “มันยังทำได้แค่นั่งคุยอยู่บนหน้าจอเท่านั้นครับ!”
ลองคิดภาพตามนี้นะครับ:
- ถ้าเราบอกมันว่า: “ช่วยบวกเลขภาษี 7 หลักนี้ให้หน่อย” → โมเดลพยายามนั่งนึกในหัวตามสถิติความน่าจะเป็น ซึ่งมีโอกาสคำนวณเลขผิดได้อย่างง่ายดาย
- ถ้าเราบอกมันว่า: “ช่วยเช็กให้ทีว่าวันนี้มีไฟล์อะไรอยู่ในโฟลเดอร์งานของผมบ้าง” → โมเดลนั่งตาปริบ ๆ เพราะมันไม่มีมือไปเปิดดูฮาร์ดดิสก์ในคอมพิวเตอร์ของเรา
- หรือถ้าเราบอกมันว่า: “ช่วยแก้โค้ดในไฟล์
index.htmlให้หน่อย” → มันทำได้แค่พิมพ์โค้ดก้อนใหม่ออกมาบนหน้าจอแชต แล้วให้เราเป็นคนลากเมาส์ Copy ไป Paste ใส่โปรแกรมเอง!
คำถามสำคัญทางวิศวกรรมจึงเกิดขึ้นว่า:
“ถ้าเราอยากให้ AI มันก้าวข้ามจากการเป็นแค่นักพูดบนหน้าจอ...
มาเป็นคนทำงานที่ 'งอกมือ งอกเท้า' แล้วหยิบเครื่องมือในคอมพิวเตอร์มาทำงานแทนเราจริง ๆ ล่ะ?
วิศวกรซอฟต์แวร์เขาทำกันอย่างไร?”
1. สลายภาพลวงตา: โมเดลไม่ได้เป็นคนกดเปิดเครื่องมือเอง!
เวลาที่เราเห็นซอฟต์แวร์ AI ยุคนี้ สามารถคำนวณเลขได้อย่างแม่นยำ ค้นหาข้อมูลล่าสุดบนอินเทอร์เน็ตได้ หรือแม้กระทั่งกดบันทึกไฟล์ลงคอมพิวเตอร์ของเราได้จริง ๆ...
หลายคนมักจะจินตนาการไปไกลว่า: “โอ้โห... ตัวโมเดล AI มันคงมีแขนกล มีสายไฟต่อตรงเข้าไปในวินโดวส์ แล้วแอบไปกดเปิดโปรแกรมเครื่องคิดเลข หรือเปิด Google Chrome เองแน่ ๆ!”
ผมขอเบรกภาพในจินตนาการนั้น แล้วบอกความจริงตรงนี้เลยครับ: “ตัวโมเดล AI ไม่เคยมีมือเท้า และไม่สามารถกดรันโปรแกรมใด ๆ ในโลกนี้ได้ด้วยตัวเองเลยแม้แต่อย่างเดียวครับ!”
อุปมาให้เห็นภาพง่ายที่สุด: ตัวโมเดล AI เปรียบเสมือน "นักวิชาการอัจฉริยะที่ถูกขังอยู่ในห้องกระจกปิดสนิท" ในห้องนั้นไม่มีสายแลน ไม่มีไวไฟ ไม่มีคอมพิวเตอร์ และไม่มีเครื่องคิดเลข มีเพียงช่องเล็ก ๆ ใต้ประตู ไว้สำหรับรับแผ่นกระดาษข้อความเข้า-ออกเท่านั้น
แล้วถ้านักวิชาการในห้องกระจกคำนวณเลขยาก ๆ ในหัวไม่ไหว เขาจะทำอย่างไรล่ะครับ? สิ่งที่เขาทำ ไม่ใช่การพังห้องกระจกออกไปกดเครื่องคิดเลข แต่เขาจะ "เขียนข้อความสั่งการลงบนกระดาษ ยื่นลอดช่องประตูออกมาบอกคนข้างนอก" ว่า:
“คุณผู้ช่วยข้างนอกครับ ช่วยเอาตัวเลข
1,459,200ไปคูณกับ0.07บนเครื่องคิดเลขให้ผมที แล้วส่งผลลัพธ์กลับเข้ามาให้ผมด้วยนะ!”
และสิ่งนี้ในโลกของ AI... เราเรียกมันว่า "Function Calling" (การส่งสัญญาณขอเรียกใช้ฟังก์ชัน) ครับ!
2. เจาะลึกกลไก: Function Calling ทำงานอย่างไรกันแน่?
เมื่อระบบต้องการให้ AI ใช้เครื่องมือได้ ฝั่งผู้พัฒนาระบบ (คนสร้าง Harness) จะทำขั้นตอน 4 สเต็ปง่าย ๆ ดังนี้ครับ:
- บอกเมนูเครื่องมือ (Tool Definition): ตอนที่ Harness จัดเตรียมกระดาษคำสั่ง (Prompt) ส่งให้โมเดล Harness จะแนบ "คู่มือเครื่องมือ" บอกโมเดลไว้ก่อนว่า “ในระบบของเรา มีฟังก์ชันอะไรให้เรียกใช้ได้บ้าง แต่ละฟังก์ชันต้องการข้อมูลอะไร”
- โมเดลส่งสัญญาณขอใช้ (Function Calling): เมื่อผู้ใช้ถามคำถามที่เกินความสามารถ เช่น เรื่องคำนวณตัวเลขเป๊ะ ๆ หรือขอเปิดดูไฟล์ โมเดลจะรู้ตัวว่าตอบเองเสี่ยงมั่ว มันจึงหยุดสร้างคำตอบธรรมดา แล้วสร้าง "ชุดข้อมูลคำสั่งพิเศษ" (มักจะอยู่ในรูปแบบ JSON หรือแท็กเฉพาะ) ระบุชื่อเครื่องมือและตัวเลขที่ต้องการส่งให้เครื่องมือ
- Harness ตรวจสอบสิทธิ์และลงมือจริง (Validation & Execution): จุดสำคัญที่สุดตรงนี้คือ Harness ไม่ได้ทำตามทุกคำขอของโมเดลแบบหลับหูหลับตานะครับ! ก่อนจะกดรันคำสั่งใด ๆ Harness จะต้องทำหน้าที่เป็นด่านตรวจความปลอดภัย (Gatekeeper) ตรวจสอบพารามิเตอร์ว่าตรงตามสเปกไหม และตรวจสิทธิ์การเข้าถึง (Permission & Authorization) ว่าคำขอนั้นปลอดภัยหรือไม่ เช่น ถ้าโมเดลขออ่านไฟล์ทั่วไปก็อาจอนุญาตได้ทันที แต่ถ้าโมเดลขอทำคำสั่งที่มีความเสี่ยงสูง เช่น แก้ไขไฟล์สำคัญ ลบฐานข้อมูล หรือส่งข้อมูลออกนอกเครื่อง Harness จะต้องปฏิเสธ หรือส่งสัญญาณมาขอความยินยอมจากมนุษย์ (Human Confirmation) ก่อนเสมอ! เมื่อตรวจผ่านแล้ว Harness จึงจะส่งคำสั่งไปรันเครื่องมือจริง
- ส่งผลลัพธ์กลับมาสรุป (Result Feedback): พอได้ผลลัพธ์จริงกลับมา Harness ก็จะเขียนผลลัพธ์นั้นแปะใส่กระดาษ แล้วยื่นกลับเข้าไปในห้องกระจกให้โมเดลอ่าน เพื่อให้โมเดลนำคำตอบที่ถูกต้องมาร้อยเรียงเป็นภาษาคนที่ไพเราะส่งคืนให้ผู้ใช้ครับ!
เห็นไหมครับว่า... ตัวโมเดลไม่ได้แตะต้องเครื่องมือเลยแม้แต่ปลายนิ้ว แต่เกิดจากการที่โมเดลส่งสัญญาณขอใช้ (Function Calling) และมี Harness เป็นคนตรวจสิทธิ์ ตรวจพารามิเตอร์ แล้วลงมือทำแทนให้ทั้งสิ้นครับ!
อีกมุมมองหนึ่งที่ใกล้ตัวที่สุด: อุปมา "สมอง กับ ร่างกาย"
หรือถ้ามองอีกมุมหนึ่งที่ใกล้ตัวเราที่สุด... ลองเปรียบเทียบกับ "สมอง กับ ร่างกายมนุษย์" ดูครับ ซึ่งเป็นภาพที่สะท้อนการทำงานจริงของระบบได้เป็นธรรมชาติที่สุด:
- สมอง (The Model / LLM): ทำหน้าที่คิด ตรรกะ ประมวลผล เมื่อคิดเสร็จ สมองจะทำได้เพียง “ส่งกระแสประสาทสั่งการ” ออกมา (Function Calling) เพราะตัวก้อนสมองเองไม่มีกล้ามเนื้อที่จะขยับออกไปหยิบจับอะไรในโลกจริงได้
- ร่างกายและมือเท้า (Harness & Tools): เมื่อได้รับสัญญาณประสาท ร่างกายก็จะเป็นผู้ “ลงมือกระทำจริง (Execute)” เช่น ขยับนิ้วไปกดแป้นเครื่องคิดเลข หรือเอื้อมมือไปเปิดแฟ้มเอกสารในฮาร์ดดิสก์
- ประสาทสัมผัสส่งผลกลับ (Sensory Feedback): เมื่อมือเท้าทำเสร็จ ตัวเลขผลลัพธ์บนจอเครื่องคิดเลขหรือข้อมูลในแฟ้ม ก็จะถูกส่งผ่านประสาทสัมผัส วิ่งย้อนกลับไปให้สมองคิดต่อ เพื่อนำข้อมูลจริงนั้นมาร้อยเรียงเป็นคำตอบ หรือตัดสินใจสั่งการในก้าวถัดไป
สองสิ่งนี้จึงทำงานแยกขาดจากกันไม่ได้: มีแต่สมองไร้ร่างกาย ก็เหมือนคนเป็นอัมพาต ได้แต่นึกแต่ทำอะไรในโลกจริงไม่ได้... มีแต่ร่างกายไร้สมองสั่ง ก็ขยับสะเปะสะปะไร้ทิศทางและไร้เป้าหมายครับ!
3. ประสบการณ์จริงของผม: วันที่ใช้ Cline + DeepSeek แล้วค้างบ่อยตอน "Run Tools"
พอพูดถึงเรื่อง Function Calling และการรัน Tools... ผมอดไม่ได้ที่จะนึกย้อนไปถึงประสบการณ์จริงช่วงหนึ่งที่ผมเอา AI มาช่วยเขียนโค้ดครับ
ตอนนั้นผมกำลังใช้เครื่องมือช่วยเขียนโค้ดอยู่เป็นประจำ แต่มีสัปดาห์หนึ่งที่ โควตารายสัปดาห์ของ Codex ดันหมดลง แต่งานยังค้างอยู่และต้องเดินหน้าต่อ ผมก็เลยมองหาทางเลือกอื่นเพื่อเอาเข้ามาเสริมการทำงานชั่วคราว ผมจึงหยิบเครื่องมือ Coding Agent อย่าง Cline (ส่วนขยายใน VS Code ที่ให้ AI ช่วยเปิดไฟล์ อ่านโค้ด เขียนไฟล์ และรันคำสั่งใน Terminal ได้) มาต่อสายเชื่อมกับโมเดลราคาประหยัดและกำลังมาแรงอย่าง DeepSeek
มันไม่ได้มีฉากตื่นเต้นอะไรหรอกครับ 5555 เป็นแค่การแก้ปัญหาเฉพาะหน้าของคนทำงานที่โควตาเครื่องมือหลักหมด แล้วต้องหาเครื่องมืออื่นมาขัดตาทัพเพื่อทำงานต่อให้เสร็จ แต่พอเริ่มปล่อยให้มันทำงานจริง สั่งงานไปสักพัก หน้าจอก็ขึ้นสถานะว่า: Running tool: read_file... Running tool: write_to_file...
แล้วสักพัก... อาการที่ชวนปวดหัวก็โผล่มาทักทาย:
“อยู่ดี ๆ หน้าจอก็ขึ้นสถานะว่ากำลัง 'Run Tools...' แล้วก็นิ่งสนิท!
ตัวหมุนโหลดดิ้งหมุนติ้ว ๆ อยู่อย่างนั้นเป็นนาที... สองนาที... แล้วก็ค้างไปดื้อ ๆ!” 5555
ตอนนั้นผมก็ต้องมานั่งไล่ดูว่า: “เกิดอะไรขึ้นกันแน่? โมเดลติดขัดตรงไหน หรือตัวโปรแกรมสะดุดอะไร?”
พอผมค่อย ๆ เจาะเข้าไปดูการทำงานเบื้องหลังของระบบ ถึงได้ค้นพบความจริงที่ลึกซึ้งทางวิศวกรรมว่า: “การที่ระบบ AI จะ Run Tools ได้สำเร็จ มันคือการเล่นเกมรับ-ส่งลูกบอลที่ต้องเป๊ะระดับมิลลิเมตรครับ!”
ในความเป็นจริง อาการค้างตอนกำลัง Run Tools แบบนี้ อาจเกิดได้จากหลายสาเหตุ ในห่วงโซ่การทำงานครับ:
- รูปแบบสัญญาณไม่สมบูรณ์ (Malformed Format): ในยุคแรก โมเดลบางรุ่นยังไม่ได้ถูกเทรนเรื่อง Function Calling มาจนนิ่งสนิท บางทีแทนที่มันจะสร้างโครงสร้างข้อมูล JSON หรือแท็ก XML ออกมาให้เป๊ะ ๆ มันอาจเผลอใส่เครื่องหมายผิด ลืมปิดวงเล็บ หรือใส่ข้อความพูดคุยแทรกเข้ามาตรงกลาง ทำให้ตัวแยกแยะข้อมูล (Parser) ของ Harness อ่านไม่ออกและรอสัญญาณจนค้าง (Timeout)
- พารามิเตอร์ไม่ตรงข้อกำหนด (Schema Mismatch): เครื่องมือขอชื่อไฟล์เป็นข้อความ แต่โมเดลเผลอส่งมาเป็นก้อนข้อมูลอื่น ทำให้การส่งต่อไปยังโปรแกรมภายนอกเกิดข้อผิดพลาด
- คำสั่งในเครื่องรอการตอบรับจากคน (Interactive Hang): เวลาที่ Harness เอาสัญญาณไปสั่งรันคำสั่งใน Terminal แต่คำสั่งนั้นดันไปเจอคำถามที่รอให้ผู้ใช้เคาะแป้นพิมพ์กด
Y/nแต่ไม่มีใครไปกด ลูปการทำงานก็เลยนั่งค้างรออยู่อย่างนั้น - ความไม่พร้อมของระบบเครือข่ายหรือตัวเครื่องมือเอง: เช่น การเชื่อมต่อไปยัง API ของโมเดลติดขัด หรือตัวโปรแกรมภายนอกตอบสนองช้า
แม้ในเหตุการณ์ของผมจะไม่ได้มีหลักฐานชี้ชัดว่าอาการค้างในแต่ละครั้งเกิดจากจุดใดจุดหนึ่งเพียงอย่างเดียว แต่ประสบการณ์นั้นก็สะท้อนให้เห็นความจริงสำคัญทางวิศวกรรมว่า:
“การทำงานร่วมกับ Tools จะสำเร็จได้ ทุกรอยต่อของระบบต้องประสานกันอย่างราบรื่น
โดยเฉพาะตัวโมเดลเอง ที่ต้องมี 'วินัยในการปฏิบัติตามสเปก' (Strict Schema Following)
ส่งสัญญาณ Function Calling ได้ถูกต้องตามกติกา ไม่ตกหล่น
เพื่อลดโอกาสที่จะกลายเป็นจุดสะดุดตั้งแต่ต้นทางของการส่งลูกบอลครับ!”
4. แล้ว "Tools" ในโลกจริง... มีอะไรให้ AI หยิบใช้บ้าง?
พอสถาปัตยกรรม Function Calling เริ่มนิ่งและเสถียรขึ้น วงการซอฟต์แวร์ก็เริ่มต่อแขนต่อขาให้ AI ด้วยเครื่องมือสารพัดชนิด ซึ่งเราแบ่งกลุ่มหลัก ๆ ได้ดังนี้ครับ:
การมี Tools จึงเข้ามาช่วย "ชดเชยข้อจำกัดหลักของ LLM" ได้อย่างมีนัยสำคัญ:
- LLM คำนวณคณิตศาสตร์ไม่แม่นยำ → ส่งต่อให้ Tool เครื่องคิดเลขคำนวณตามสูตรแน่นอน
- LLM ไม่รู้ข้อมูลปัจจุบัน → ส่งต่อให้ Tool ค้นหาเว็บไปเปิดดูข้อมูลล่าสุด
- LLM จัดการไฟล์ในเครื่องไม่ได้ → ส่งต่อให้ Tool ระบบปฏิบัติการช่วยอ่านเขียนไฟล์
(อย่างไรก็ตาม เราต้องตระหนักเสมอว่า ตัว Tools เองก็ไม่ใช่สิ่งสมบูรณ์แบบและอาจเกิดข้อผิดพลาดได้ เช่น เว็บปลายทางตอบสนองช้า คำสั่งรันติดขัดเรื่องสิทธิ์ หรือข้อมูลที่ได้กลับมาไม่สมบูรณ์ ระบบที่ดีจึงต้องมีการดักจับข้อผิดพลาดอยู่เสมอครับ)
ตัวอย่างจริงใกล้ตัว: สถาปัตยกรรมของ Sabayjai Buddy กับการใช้ Tools ก่อนและหลัง Model
เพื่อให้เห็นภาพที่จับต้องได้จริงในโปรเจกต์ของพวกเราเอง ลองดูสถาปัตยกรรมของ Sabayjai Buddy เป็นตัวอย่างครับ:
หลายคนมักเข้าใจผิดว่าระบบอย่าง Sabayjai Buddy คือตัวโมเดล AI หรือเป็นแค่โปรแกรมชิ้นเดียว แต่ในความเป็นจริงทางวิศวกรรม Sabayjai Buddy คือ "Harness" ทั้งระบบ ที่ทำหน้าที่เป็นโครงรถและผู้กำกับดูแลการทำงานทั้งหมด โดยมีส่วนประกอบสำคัญคือ "Tools" ที่ประกบอยู่ทั้งก่อนและหลังการส่งเข้าโมเดล ดังนี้ครับ:
- Tools ก่อนส่งเข้า Model (Pre-processing Tools): Sabayjai Buddy จะมีเครื่องมือเฉพาะทางในการ บันทึกข้อมูล (Data Recording) และ ดึงข้อมูลเดิมขึ้นมา (Data Retrieval) จากระบบอย่างเป็นระเบียบและถูกต้องตามเงื่อนไข เพื่อจัดเตรียมข้อมูลให้พร้อมก่อนส่งเข้าโมเดล
- AI Model ทำหน้าที่ประมวลผลคำและวิเคราะห์: เมื่อข้อมูลถูกจัดวางอย่างเป็นระเบียบแล้ว โมเดล AI จึงเข้ามารับหน้าที่อ่าน ทำความเข้าใจ วิเคราะห์แนวโน้ม และสังเคราะห์ผลลัพธ์
- Tools หลังรับกลับจาก Model (Post-processing Tools): เมื่อโมเดลส่งผลลัพธ์กลับมา Sabayjai Buddy ไม่ได้โยนข้อความดิบ ๆ กลับไปหาผู้ใช้ทันที แต่จะนำผลลัพธ์นั้นมาเข้ากระบวนการตรวจสอบ ปรับแต่งรูปแบบ และจัดการข้อมูลให้เรียบร้อยสมบูรณ์ก่อนส่งมอบคำตอบกลับไปหาผู้ใช้ครับ
นี่คือภาพที่ชัดเจนที่สุดของการออกแบบสถาปัตยกรรมระบบ AI ครับ! Sabayjai Buddy คือ Harness ที่ร้อยเรียง Tools ประกบทั้งหัวและท้าย เพื่อให้งานตรรกะที่แน่นอน (การบันทึก การดึงข้อมูล และการปรับแต่งผลลัพธ์) ทำงานได้อย่างแม่นยำ โดยปล่อยให้โมเดล AI ทำเฉพาะงานวิเคราะห์ภาษาที่มันถนัดที่สุดครับ
ปริศนาส่งท้าย: เมื่อเครื่องมือเยอะขึ้น... ทำไมสายไฟถึงระโยงระยาง?
เมื่ออ่านมาถึงตรงนี้ ทุกคนคงเห็นแล้วว่า Function Calling คือกุญแจทองคำที่เปลี่ยนแชตบอตธรรมดาให้กลายเป็นผู้ช่วยที่มีมือมีเท้า
แต่ในทางปฏิบัติของคนทำระบบ ปัญหาปวดหัวข้อใหม่ก็วิ่งเข้ามาชนอย่างจังครับ:
ลองจินตนาการดูนะครับ:
- วันนี้บริษัทเราอยากให้ AI ต่อกับ Google Calendar → โปรแกรมเมอร์ต้องนั่งเขียนโค้ดต่อสาย Function Calling 1 ชุด
- พรุ่งนี้อยากให้ต่อกับ Slack → เขียนโค้ดต่อสายใหม่อีก 1 ชุด
- มะรืนอยากให้ต่อกับ GitHub และฐานข้อมูล Postgres → เขียนใหม่อีก 2 ชุด
- แล้วถ้าวันดีคืนดี เราอยากเปลี่ยนค่ายโมเดล จากค่าย A ไปค่าย B... รูปแบบ Function Calling ของแต่ละค่ายดันเขียนไม่เหมือนกันอีก ต้องมารื้อโค้ดเขียนใหม่อีกรอบ!
สุดท้าย ระบบหลังบ้านของเราจะกลายเป็น "รังนกสายไฟที่ระโยงระยางจนพันกันมั่วไปหมด" ต่ออะไรใหม่ทีไรก็เหนื่อยแทบขาดใจ!
วิศวกรซอฟต์แวร์ระดับโลก เขาแก้ปัญหาความยุ่งเหยิงนี้อย่างไร? เขาทำอย่างไรให้แอป AI หลายค่ายเชื่อมกับเครื่องมือที่รองรับมาตรฐานเดียวกันได้ โดยไม่ต้องเขียนโค้ดเชื่อมต่อใหม่ทุกครั้ง?
เตรียมตัวพบกับมาตรฐานเปลี่ยนโลกของวงการ AI ได้ใน ตอนที่ 11: ปลั๊กไฟมาตรฐานกลาง: ทำความรู้จัก "MCP" (Model Context Protocol) โดยจำง่าย ๆ ว่า: Function Calling คือคำขอเรียกเครื่องมือที่ส่งออกมาจากสมองกล (Model) ส่วน MCP คือมาตรฐานปลั๊กไฟที่ทำให้ Host ต่อเข้ากับเครื่องมือภายนอกได้อย่างเป็นสากล ครับ!
ศัพท์เทคนิค → คำแปลภาษาคนทำงาน — แตะเพื่อย่อ/ขยาย
- Tools / Tool Use (เครื่องมือ): ซอฟต์แวร์หรือโปรแกรมภายนอกที่เตรียมไว้ให้ระบบเรียกใช้ (เช่น เครื่องคิดเลข, โปรแกรมค้นหาเว็บ, ตัวจัดการไฟล์) เพื่อช่วยชดเชยข้อจำกัดหลักที่โมเดลทำเองไม่ได้
- Function Calling (การส่งสัญญาณเรียกฟังก์ชัน): ความสามารถของโมเดลในการอ่านคำถาม แล้วหยุดตอบเป็นภาษาคน แต่สร้างข้อความโครงสร้างพิเศษ (เช่น JSON) ส่งสัญญาณบอก Harness นอกห้องกระจกว่าต้องการเรียกใช้เครื่องมือใด พร้อมพารามิเตอร์ที่จำเป็น
หลักคิดเชิงสถาปัตยกรรม — แตะเพื่อย่อ/ขยาย
- โมเดลไม่มีมือเท้า และ Harness ต้องตรวจสิทธิ์เสมอ: อย่าหลงเชื่อภาพลวงตาว่า AI กดรันโปรแกรมเอง ทุกการกระทำเกิดขึ้นโดย Harness และที่สำคัญคือ Harness ต้องทำหน้าที่เป็นด่านตรวจความปลอดภัย ตรวจสอบสิทธิ์ (Authorization) และความถูกต้องของพารามิเตอร์ก่อนอนุญาตให้รันเครื่องมือทุกครั้ง ไม่ใช่ทำตามทุกคำขอแบบไร้การควบคุม
- สมองคิด สั่งการ และรับผลจากร่างกาย (The Brain-Body Feedback Loop): โมเดลเปรียบเหมือนสมองที่ส่งกระแสประสาทสั่งการ (Function Calling) ส่วน Harness และ Tools เปรียบเสมือนร่างกายและมือเท้าที่ลงมือทำจริง (Execute) แล้วส่งข้อมูลผลลัพธ์ผ่านประสาทสัมผัสกลับเข้าสมองเพื่อประมวลผลต่อ เกิดเป็นวงจรคิดและทำร่วมกันที่สมบูรณ์
- บทเรียนจริงจาก Cline + DeepSeek: อาการค้างตอน Run Tools อาจเกิดได้จากหลายสาเหตุในห่วงโซ่การทำงาน ทั้งการรออินพุตในเครื่อง เครือข่าย หรือรูปแบบข้อมูลที่ส่งมาไม่สมบูรณ์ ความสำเร็จของระบบ Agent จึงต้องการความสมบูรณ์ในทุกรอยต่อ โดยเฉพาะโมเดลที่ต้องมีวินัยในการปฏิบัติตามสเปก (Schema Following) อย่างเคร่งครัด
- แบ่งหน้าที่ให้ชัด (Separation of Concerns): หน้าที่ของโมเดลคือ "การเข้าใจภาษาและตัดสินใจว่าจะเรียกใช้เครื่องมืออะไร" ส่วนเรื่องตรรกะที่แน่นอน ปล่อยให้ Tool ภายนอกเป็นคนทำ โดยคำนึงเสมอว่าตัว Tool เองก็มีโอกาสเกิดข้อผิดพลาดได้ จึงต้องมีระบบดักจับ Error ที่รัดกุมครับ
- SabayJai Buddy กับการใช้ Tools ในชีวิตจริง: SabayJai Buddy เป็นตัวอย่างของระบบ AI ที่ทำหน้าที่เป็น Harness โดยภายในมี Tools สำหรับบันทึกข้อมูล (Data Recording) และดึงข้อมูล (Data Retrieval) ก่อนส่งต่อให้ AI Model วิเคราะห์และสังเคราะห์ผลลัพธ์