จากตอนที่แล้ว เราได้เห็นแล้วว่า Function Calling คือคำขอเรียกเครื่องมือที่ส่งออกมาจากตัว Model เพื่อบอกให้ Harness ช่วยหยิบจับเครื่องมือ (Tools) ในคอมพิวเตอร์มาทำงานแทนเรา
แต่ในตอนท้ายของตอนที่ 10 ผมก็ได้ทิ้งปริศนาข้อใหญ่ที่คนทำระบบในยุคแรกต้องปวดหัวไว้ว่า: “ทำไมเวลาเราต่อเครื่องมือเยอะ ๆ เข้ากับ AI... สายไฟหลังบ้านถึงได้ระโยงระยางจนพันกันมั่วไปหมด?”
ตรงนี้เองที่ MCP (Model Context Protocol) เข้ามาทำหน้าที่เป็น "มาตรฐานการเชื่อมต่อสากลระหว่าง Host/Client กับ Tool Server ภายนอก" เพื่อให้การส่งคำขอ Function Calling ข้ามไปยังเครื่องมือต่าง ๆ ไม่ต้องเดินสายไฟเฉพาะค่ายอีกต่อไปครับ!
สำหรับตอนนี้ ผมขอสารภาพตามตรงจากใจเลยครับว่า:
“แม้ตัวผมเองจะยังไม่ได้ลงมือเขียนโค้ดเซ็ตอัป MCP ใช้งานจริงจังด้วยตัวเองในระบบ...
แต่ในฐานะคนทำระบบซอฟต์แวร์ พอผมได้ศึกษาและทำความเข้าใจ Concept ของมัน
ผมถึงกับ 'ร้องอ๋อ' ทันที เพราะนี่คือการแก้ปัญหาคลาสสิกที่ประวัติศาสตร์ซอฟต์แวร์เคยเจอมาแล้วนับครั้งไม่ถ้วนครับ!” 5555
วันนี้ผมเลยอยากชวนทุกคนมาทำความเข้าใจแนวคิดของ MCP (Model Context Protocol) ผ่านแว่นของคนทำระบบ โดยไม่ต้องไปปวดหัวกับการเขียนโค้ดกันครับ!
1. ย้อนอดีต: ปัญหารังนกสายไฟ "N × M"
เพื่อให้เข้าใจว่าทำไมวงการ AI ถึงตื่นเต้นกับคำว่า MCP กันนักหนา เราต้องย้อนกลับไปดูความทุกข์ทรมานของคนทำระบบในยุค Function Calling ดั้งเดิมกันก่อนครับ:
สมมติว่าในตลาดมี แอปพลิเคชัน AI อยู่ 3 ค่าย (เช่น ค่าย A, ค่าย B, ค่าย C) และในโลกความเป็นจริง เรามี เครื่องมือที่เราอยากให้ AI ใช้งานอยู่ 5 อย่าง (เช่น Google Drive, Slack, GitHub, ฐานข้อมูล Postgres, ปฏิทิน)
ในยุคแรก สิ่งที่เกิดขึ้นคือ:
- ค่าย A มีวิธีเขียนโค้ดเรียก Function Calling แบบของตัวเอง
- ค่าย B ก็มีรูปแบบการต่อเครื่องมืออีกแบบหนึ่ง
- ค่าย C ก็คิดมาตรฐานของตัวเองขึ้นมาอีก!
ผลลัพธ์ที่ตามมาคืออะไรล่ะครับ?
- ถ้าคนทำ Google Drive อยากให้ AI ทั้ง 3 ค่ายใช้เครื่องมือของตนได้ → เขาต้องเขียนโค้ดเชื่อมต่อแยกกันถึง 3 แบบ!
- และถ้าคนทำแอปพลิเคชัน AI อยากต่อเครื่องมือให้ครบทั้ง 5 อย่าง → เขาก็ต้องมานั่งเขียนโค้ดต่อสายเองทั้ง 5 เส้น!
ในทางวิศวกรรมซอฟต์แวร์ เราเรียกปัญหานี้ว่า "ปัญหา N × M" สายไฟหลังบ้านจะระโยงระยางเหมือนรังนก ถ้าวันพรุ่งนี้มีเครื่องมือใหม่โผล่มาอีก 10 ตัว ทุกคนก็ต้องมานั่งเขียนโค้ดใหม่อีก 10 รอบ เหนื่อยและเสียเวลาพัฒนาโดยใช่เหตุครับ!
2. อุปมา First Principles: วันที่โลกไอทีมี "พอร์ต USB"
ถ้าใครนึกภาพปัญหานี้ไม่ออก ให้ลองนึกถึง คอมพิวเตอร์ตั้งโต๊ะในยุค 30 ปีก่อน ดูครับ:
- เวลาจะเสียบคีย์บอร์ด → ต้องใช้พอร์ตกลม ๆ สีม่วง (PS/2)
- เวลาจะเสียบเมาส์ → ต้องใช้พอร์ตกลม ๆ สีเขียว
- เวลาจะต่อพรินเตอร์ → ต้องใช้สายเคเบิลเส้นเบ้อเริ่มที่มีหัวเสียบยักษ์ 25 พิน (Parallel Port)
- เวลาจะต่อจอยเกม → มีพอร์ตเหลือง ๆ เฉพาะอีกแบบหนึ่ง (Gameport)
ถ้าเราซื้ออุปกรณ์ใหม่มาทีไร เป็นอันต้องก้มลงไปมุดใต้โต๊ะ แล้วลุ้นว่าจะเสียบเข้ากับรูหลังเครื่องคอมของเราได้ไหม!
แต่วันหนึ่ง... วงการคอมพิวเตอร์ก็รวมตัวกันสร้างมาตรฐานกลางที่ชื่อว่า "USB" (Universal Serial Bus) ขึ้นมา โดยมีข้อตกลงง่าย ๆ ร่วมกันว่า:
“ต่อไปนี้ ไม่ว่าคุณจะทำเมาส์ คีย์บอร์ด แฟลชไดรฟ์ หรือพรินเตอร์...
ทุกคนช่วยทำ 'หัวเสียบ USB' ตามมาตรฐานเดียวกันนะ
แล้วฝั่งผู้ผลิตคอมพิวเตอร์ ก็เจาะ 'รูเสียบ USB' มารอรับไว้
ช่วยให้อุปกรณ์ต่าง ๆ เชื่อมต่อและสื่อสารกันได้ง่ายขึ้นมาก โดยไม่ต้องซื้อการ์ดแปลงสายเฉพาะรุ่นอีกต่อไป!”
กลับมาที่โลกของ AI ยุคนี้ครับ: MCP (Model Context Protocol) ก็คือ "พอร์ต USB สากลสำหรับโลกของ AI" นั่นเองครับ!
3. ถอดรหัส MCP: ใครทำหน้าที่อะไรกันบ้าง?
มาตรฐาน MCP ถูกเปิดตัวออกมาเป็นมาตรฐานเปิด (Open Standard) โดยบริษัท Anthropic ในช่วงปลายปี 2024 และกลายเป็นกระแสที่ทั้งวงการ ไม่ว่าจะเป็นนักพัฒนาซอฟต์แวร์ หรือบริษัทคู่แข่ง ต่างพากันหันมาให้ความสนใจและเริ่มนำไปปรับใช้
ในเชิงแนวคิด (Concept) สถาปัตยกรรมของ MCP มีองค์ประกอบหลักที่ทำงานร่วมกันดังนี้ครับ:
- MCP Host: คือตัวแอปพลิเคชันหลักหรือสภาพแวดล้อมที่ผู้ใช้งานเปิดทำงานอยู่ เช่น โปรแกรมเขียนโค้ด (Cursor, Cline), แอปแชตบนคอมพิวเตอร์ (เช่น Claude Desktop), หรือแม้กระทั่งตัวระบบ Harness ที่เราพัฒนาขึ้นมาเอง เปรียบเสมือน "ตัวเครื่องคอมพิวเตอร์หลัก" ที่ต้องการต่อขยายความสามารถ
- MCP Client: คือ องค์ประกอบหรือโมดูลซอฟต์แวร์ภายในตัว Host ที่ทำหน้าที่เป็นตัวประสานงานและต่อสายสื่อสารโดยตรงกับ MCP Server (โดย Host ตัวหนึ่ง สามารถมี Client หลายตัวเพื่อเปิดช่องเชื่อมต่อไปยัง Server หลาย ๆ แห่งพร้อมกันได้) เปรียบเสมือน "แผงวงจรและช่องเสียบพอร์ต USB" ในเครื่องคอมพิวเตอร์
- MCP Server: คือโปรแกรมเฉพาะทางฝั่งเครื่องมือหรือแหล่งข้อมูล ที่ถูกเขียนขึ้นมารอรับคำสั่ง เช่น เซิร์ฟเวอร์สำหรับค้นข้อมูลในฐานข้อมูล Postgres, หรือเซิร์ฟเวอร์สำหรับจัดการไฟล์ใน Google Drive เปรียบเสมือน "อุปกรณ์เสริมที่มีสายปลั๊ก USB พร้อมเสียบเข้าเครื่อง"
- Protocol (โพรโทคอล): คือ "กติกาและภาษากลาง" ที่ทั้งสองฝั่งตกลงใช้คุยกันผ่านสาย เช่น เวลา Client ถามว่า "มีเครื่องมืออะไรให้เรียกใช้ได้บ้าง?" Server ก็จะตอบกลับมาด้วยรูปแบบข้อความมาตรฐานเดียวกันเสมอ
ผลลัพธ์ของมาตรฐานนี้ คือการเปลี่ยนจากปัญหา N × M อันยุ่งเหยิง ให้กลายเป็น “ทุกคนต่อเข้าหาปลั๊กไฟมาตรฐานเดียวกัน”:
- คนทำเครื่องมือ เขียน MCP Server ครั้งเดียว → สามารถรองรับแอปพลิเคชัน AI ค่ายใดก็ได้ที่รองรับมาตรฐานนี้
- คนทำแอป AI ติดตั้ง MCP Client ครั้งเดียว → ผู้ใช้สามารถนำเครื่องมือ MCP Server จากหลากหลายผู้พัฒนามาเชื่อมต่อได้สะดวกขึ้นมาก
(อย่างไรก็ตาม มีจุดสำคัญที่คนทำระบบต้องตระหนักไว้เสมอครับว่า: การรองรับมาตรฐาน MCP ไม่ได้รับประกันว่าจะใช้งานได้ทันทีในทุกกรณีแบบไม่ต้องทำอะไรเลย! เพราะในความเป็นจริง ระบบยังคงต้องจัดการเรื่อง การยืนยันตัวตน (Authentication / API Keys), การควบคุมสิทธิ์ความปลอดภัย (Permissions) ว่าอนุญาตให้เครื่องมือเข้าถึงข้อมูลใดได้บ้าง และ การตั้งค่าสภาพแวดล้อม (Configuration) ให้ถูกต้อง มาตรฐาน MCP เพียงแค่ช่วยตัดความยุ่งยากในการเขียนโค้ดเชื่อมต่อเฉพาะค่ายออกไปเท่านั้นครับ)
4. มองมุมผ่านแว่น Software Architect: การทลายกำแพงระบบปิด
แม้ว่าตัวผมเองจะยังไม่ได้กระโจนลงไปเขียนโค้ดต่อสาย MCP ด้วยตัวเองในทุกโปรเจกต์ แต่การเข้าใจ Concept ของมัน ทำให้เรามองเห็นภาพใหญ่ของสถาปัตยกรรมซอฟต์แวร์ได้อย่างน่าสนใจมากครับ:
1) การทลายกำแพงระบบปิด (Breaking the Walled Gardens)
ในยุคก่อน บริษัทยักษ์ใหญ่แต่ละค่ายมักจะพยายามสร้าง "ระบบปิด" (Proprietary Ecosystem) ของตัวเอง เพื่อบังคับให้ผู้ใช้ต้องใช้เครื่องมือเฉพาะของค่ายนั้นเท่านั้น แต่การมาของ MCP เป็นสัญญาณชัดเจนว่า วงการกำลังเดินหน้าสู่มาตรฐานเปิด ซึ่งช่วยป้องกันไม่ให้คนทำระบบต้องติดกับดักการผูกขาดกับค่ายใดค่ายหนึ่ง (Vendor Lock-in)
2) ประวัติศาสตร์มักซ้ำรอยเสมอในโลกซอฟต์แวร์
สำหรับคนทำงานสายเทคนิค การเห็น MCP เกิดขึ้น จะทำให้นึกถึงวิวัฒนาการในอดีตทันที:
- เหมือนวันที่วงการฐานข้อมูลตกลงใช้มาตรฐาน ODBC / JDBC เพื่อให้โปรแกรมอะไรก็ได้เชื่อมต่อกับฐานข้อมูลยี่ห้อไหนก็ได้
- เหมือนวันที่วงการโปรแกรมเขียนโค้ดตกลงใช้มาตรฐาน LSP (Language Server Protocol) เพื่อให้โปรแกรมเมอร์ไม่ต้องเขียนตัวตรวจไวยากรณ์ภาษาใหม่สำหรับ Text Editor ทุกตัวในโลก
MCP ก็คือประวัติศาสตร์หน้าเดิมที่กำลังเกิดขึ้นซ้ำอีกครั้งในยุคของ AI นั่นเองครับ!
ปริศนาส่งท้าย: เมื่อปลั๊กไฟพร้อม... แล้วใครเป็นคนสั่ง และใครเป็นคนเก็บเงินเรา?
มาถึงจุดนี้ ในองค์ที่ 3 เราเริ่มเห็นภาพจิ๊กซอว์ของการลงมือทำงานชัดเจนขึ้นเรื่อย ๆ แล้วครับ:
- เรารู้แล้วว่าโมเดลไม่มีมือเท้า แต่ใช้ Function Calling ส่งสัญญาณบอก Harness ให้ทำแทน
- เรารู้แล้วว่าถ้ามีเครื่องมือเยอะ ๆ เราสามารถใช้ MCP เป็นปลั๊กไฟมาตรฐานกลางในการเสียบเชื่อมต่อได้อย่างง่ายดาย
แต่พอเราเริ่มก้าวเท้าเข้าสู่โลกของการใช้งานจริง... คำถามชวนเวียนหัวระลอกใหม่ก็วิ่งเข้ามาชนอย่างจังครับ:
- ทำไม โมเดลตัวเดียวกันแท้ ๆ พอเราสั่งงานผ่านหน้าเว็บ ได้คำตอบแบบหนึ่ง แต่พอเอาไปสั่งงานผ่านเครื่องมืออย่าง Cursor, Cline, Codex หรือ Antigravity ประสบการณ์และความเก่งถึงได้ต่างกันลิบลับ?
- และคำถามที่คาใจคนใช้งานและคนทำระบบมากที่สุดก็คือ: “ใครเป็นคนเก็บเงินเรากันแน่?” ทำไมบางค่ายจ่ายรายเดือนแล้วจบ บางค่ายต้องเติมเงิน API บางค่ายให้เอาคีย์ไปเสียบเอง (BYOK) และทำไมงานเขียนโค้ดที่รันต่อเนื่องหลายรอบ ถึงเผาเงินในกระเป๋าเร็วกว่าการคุยแชตธรรมดาเป็นสิบเท่า?
ก่อนที่เราจะปล่อยให้ AI วิ่งทำงานอัตโนมัติหลายขั้นตอน... เราต้องมาทำความเข้าใจ "เหล่าผู้กำกับ (Harness) แต่ละค่าย และแผนที่ค่าบริการในโลก AI" เพื่อให้ใช้เครื่องมือได้อย่างฉลาดและคุ้มค่าที่สุดกันก่อนครับ!
เตรียมตัวพบกับความจริงหลังม่านของโลก AI ได้ใน ตอนที่ 12: หนึ่งสมอง หลายผู้กำกับ — รู้จัก AI Harness และโลกของค่าบริการ ครับ!
ศัพท์เทคนิค → คำแปลภาษาคนทำงาน — แตะเพื่อย่อ/ขยาย
- MCP (Model Context Protocol): โปรโตคอลมาตรฐานกลางแบบเปิด (Open Standard) ที่ทำหน้าที่เสมือนพอร์ต USB สากล ช่วยให้ระบบ AI และแอปพลิเคชัน สามารถเชื่อมต่อกับเครื่องมือและแหล่งข้อมูลต่าง ๆ ได้อย่างเป็นมาตรฐานเดียวกัน
- MCP Host: แอปพลิเคชันหรือสภาพแวดล้อมหลักที่ผู้ใช้ทำงานอยู่ (เช่น Claude Desktop, IDE, หรือระบบ Harness) ซึ่งทำหน้าที่เป็นแพลตฟอร์มรองรับการทำงาน
- MCP Client: องค์ประกอบหรือโมดูลซอฟต์แวร์ภายในตัว Host ที่ทำหน้าที่ต่อสายสื่อสารโดยตรงกับ MCP Server แต่ละตัว
- MCP Server: โปรแกรมหรือบริการภายนอก (เช่น ตัวเชื่อมต่อ GitHub, Google Drive, ฐานข้อมูล) ที่เปิดฟังก์ชันและแหล่งข้อมูลในรูปแบบมาตรฐาน MCP เพื่อรอรับการเชื่อมต่อจาก Client
หลักคิดเชิงสถาปัตยกรรม — แตะเพื่อย่อ/ขยาย
- ทลายปัญหารังนกสายไฟ N × M: จากเดิมที่แอป M ตัวต้องเขียนโค้ดเชื่อมกับเครื่องมือ N ชิ้นจนวุ่นวาย การมี MCP ทำให้ทุกคนเขียนโค้ดเข้าหามาตรฐานกลางเพียงครั้งเดียว ลดความซ้ำซ้อนในการพัฒนาลงมหาศาล
- มาตรฐานกลางช่วยลดความซ้ำซ้อน แต่ยังต้องดูแลความปลอดภัย: แม้ MCP จะช่วยปลดล็อกปัญหาสายไฟระโยงระยาง แต่การนำไปใช้จริงยังต้องจัดการเรื่องการยืนยันตัวตน (Authentication), การควบคุมสิทธิ์ (Permissions) และการตั้งค่า Configuration ให้รัดกุมเสมอ ไม่ใช่ระบบที่เสียบแล้วใช้งานได้ทันทีโดยไม่ต้องควบคุม
- เข้าใจ Concept สำคัญกว่าการรีบใช้ทุกเครื่องมือ: แม้จะยังไม่ได้ลงมือเขียนโค้ด MCP เองในทุกโปรเจกต์ แต่การเข้าใจสถาปัตยกรรมของมัน ช่วยให้เรามองเห็นทิศทางของอุตสาหกรรม และเลือกวางโครงสร้างระบบที่พร้อมรองรับมาตรฐานเปิดโดยไม่ติดกับดัก Vendor Lock-in
- บทเรียนเดิมในร่างใหม่: MCP เดินตามรอยความสำเร็จของมาตรฐานอย่าง USB ในวงการฮาร์ดแวร์ หรือ LSP ในวงการซอฟต์แวร์ ซึ่งพิสูจน์แล้วว่าระบบที่จะอยู่รอดในระยะยาว คือระบบที่เชื่อมต่อกับโลกภายนอกได้อย่างเปิดกว้างและเป็นมาตรฐานสากลครับ