MCP Basic

รู้จักกับ MCP

ref: https://artofinfra.com/what-is-mcp/

เริ่มต้น เรามาทำความรู้จักก่อนว่า MCP คืออะไร ?

ในโลกที่ AI กำลังพัฒนาอย่างรวดเร็ว หนึ่งในข้อจำกัดสำคัญของโมเดล AI คือ การเข้าถึงข้อมูลและเครื่องมือภายนอก ซึ่งส่งผลให้ AI ไม่สามารถทำงานร่วมกับแหล่งข้อมูลจริงได้อย่างเต็มประสิทธิภาพ

https://www.anthropic.com/news/model-context-protocol

เพื่อแก้ปัญหานี้ Anthropic ได้พัฒนา Model Context Protocol (MCP) ซึ่งเป็น Open Protocol ที่ทำหน้าที่เป็น “สะพานเชื่อม” ระหว่าง AI models กับแหล่งข้อมูลและเครื่องมือภายนอก ช่วยให้ AI ไม่จำเป็นต้องพึ่งพาข้อมูลที่ถูกฝึกมาเพียงอย่างเดียวอีกต่อไป

ลองนึกภาพว่า MCP เป็นเหมือนพอร์ต USB-C สำหรับ AI – ช่วยให้ AI models (เช่น Claude) สามารถเชื่อมต่อกับ ฐานข้อมูล, APIs, ระบบไฟล์ และเครื่องมืออื่นๆ ได้โดย ไม่ต้องเขียนโค้ดใหม่ทุกครั้งที่ต้องการเชื่อมต่อกับแหล่งข้อมูลใหม่

คำถามคือ “MCP ตั้งใจเกิดขึ้นมาเพื่อแก้ปัญหาอะไร ?”

ปัจจุบัน AI models มีข้อจำกัดหลายอย่างที่ทำให้การทำงานร่วมกับแหล่งข้อมูลภายนอกเป็นเรื่องยาก MCP ถูกออกแบบมาเพื่อแก้ปัญหาเหล่านี้

1. AI ไม่สามารถเข้าถึงข้อมูลปัจจุบันและเครื่องมือเฉพาะทาง AI โดยทั่วไป ไม่สามารถเชื่อมต่อกับอินเทอร์เน็ต หรือดึงข้อมูลจากฐานข้อมูลแบบเรียลไทม์ นักพัฒนาต้องสร้างการเชื่อมต่อ (integration) ใหม่ทุกครั้งที่ต้องการให้ AI ทำงานร่วมกับแหล่งข้อมูลอื่นๆ ซึ่งเป็น เรื่องที่ซับซ้อนและใช้เวลามาก
2. การเชื่อมต่อกับแหล่งข้อมูลต่างๆ เป็นเรื่องยุ่งยาก: ปกติแล้ว การเชื่อมต่อ AI กับแหล่งข้อมูลแต่ละประเภทต้องใช้ ตัวเชื่อมต่อ (connectors) แยกกัน การบำรุงรักษาตัวเชื่อมต่อเหล่านี้เป็นภาระของนักพัฒนา และอาจทำให้ระบบล้าสมัยได้เร็ว
3. AI ไม่สามารถขยายความสามารถของตัวเองได้: โมเดล AI ส่วนใหญ่ ไม่สามารถบันทึกข้อมูลลงไฟล์ หรือเข้าถึงเครื่องมือภายนอกได้โดยตรง ทำให้ AI มีข้อจำกัดในการทำงาน และไม่สามารถเรียนรู้จากข้อมูลใหม่ๆ ได้
4. การเปลี่ยนผู้ให้บริการ AI เป็นเรื่องยุ่งยาก: ถ้านักพัฒนาต้องการเปลี่ยนจาก AI ตัวหนึ่งไปใช้อีกตัวหนึ่ง เช่น จาก Claude ไปเป็น GPT หรือ Gemini อาจต้อง เขียนการเชื่อมต่อใหม่ทั้งหมด ซึ่งเป็นภาระที่ใหญ่มาก

แล้ว MCP มาช่วยแก้ปัญหานี้อย่างไร

1. สร้างมาตรฐานกลาง: แทนที่จะต้องสร้างตัวเชื่อมต่อแยกกันสำหรับแต่ละระบบ MCP เป็นโปรโตคอลมาตรฐานเดียว ที่ช่วยให้ AI เชื่อมต่อกับแหล่งข้อมูลต่างๆ ได้ง่ายขึ้น
2. มีการบูรณาการที่พร้อมใช้งาน: MCP มาพร้อมกับ integration สำเร็จรูป ทำให้ AI สามารถเริ่มใช้งานเครื่องมือต่างๆ ได้ทันที
3. เพิ่มความยืดหยุ่นในการเปลี่ยน AI models: นักพัฒนาสามารถ เปลี่ยนผู้ให้บริการ AI ได้ง่ายขึ้น โดยไม่ต้องเขียนโค้ดการเชื่อมต่อใหม่ทั้งหมด
4. เพิ่มความปลอดภัยของข้อมูล: MCP มี คุณสมบัติด้านความปลอดภัย ที่ช่วยปกป้องข้อมูลที่ละเอียดอ่อนจากการเข้าถึงที่ไม่ได้รับอนุญาต
5. ช่วยให้ AI เชื่อมต่อกับโลกแห่งความเป็นจริง: MCP ลดข้อจำกัดของ AI models ทำให้ AI สามารถเข้าถึงข้อมูลและเครื่องมือภายนอกได้ อย่างชาญฉลาดและมีประสิทธิภาพมากขึ้น

ทีนี้ถ้าจะ implement MCP กันเราจำเป็นต้องมาเข้าใจ MCP Architecture ก่อนว่ามีหลักการประมาณไหนบ้าง

MCP Architecture

ref: https://modelcontextprotocol.io/introduction

โดยหลักการทำงานของ MCP นั้น MCP จะใช้ สถาปัตยกรรมแบบ Client-Server โดยมีองค์ประกอบหลัก 3 ส่วนคือ

1. Host เป็น Application AI (เช่น Claude) ที่ทำหน้าที่เป็นแพลตฟอร์มให้ AI ทำงานร่วมกับเครื่องมือภายนอก โดย Host จะรัน MCP Client เพื่อช่วยให้ AI เชื่อมต่อกับข้อมูลและเครื่องมืออื่นๆได้
2. MCP Client เป็น ตัวกลางที่ช่วยให้ AI สื่อสารกับ MCP Server เมื่อ AI ต้องการเข้าถึงฐานข้อมูล เช่น PostgreSQL, MCP Client จะ จัดรูปแบบคำขอ และส่งไปยัง MCP Server
3. MCP Server ทำหน้าที่เป็น ตัวเชื่อมต่อระหว่าง AI กับแหล่งข้อมูลภายนอก เช่น ฐานข้อมูล, Google Drive หรือ APIs ต่างๆ เช่น ถ้า AI ต้องการดึงข้อมูลจาก PostgreSQL, MCP Server จะทำหน้าที่เป็นตัวกลางที่ช่วยให้ AI สามารถสื่อสารกับฐานข้อมูลได้อย่างราบรื่น

โดยเมื่อแยกองค์ประกอบหลักของ MCP (Primitives) ออกมา MCP มี 5 องค์ประกอบสำคัญ ซึ่งแบ่งออกเป็น 2 กลุ่ม คือ

1. สำหรับ Clients (AI models เช่น Claude)
   • Roots: ช่วยให้ AI เข้าถึงไฟล์อย่างปลอดภัย
   • Sampling: ใช้สำหรับ สร้างคำขอหรือคำสั่ง (เช่น Query ฐานข้อมูล) เพื่อให้ AI ทำงานได้ง่ายขึ้น
2. สำหรับ Servers (ระบบภายนอก เช่น ฐานข้อมูลหรือ API)
   • Prompts: ช่วยให้ AI ได้รับคำแนะนำที่เหมาะสม
   • Resources: เป็น แหล่งข้อมูลที่ AI สามารถอ้างอิงได้
   • Tools: เป็น ฟังก์ชันที่ AI สามารถเรียกใช้ เช่น การสืบค้นข้อมูลในฐานข้อมูล

คำถามก็คือจาก Architecture ที่เราเห็น “แล้ว MCP Client ส่งข้อมูลไปยัง MCP Server ได้อย่างไร เพื่อให้สามารถตอบสนองได้อย่างถูกต้อง ?” ถ้าให้ไล่ลำดับการทำงาน กระบวนการทำงานจะมีขั้นตอนตามนี้

1. การเริ่มต้นโดยโมเดล AI: เมื่อแอปพลิเคชัน AI อย่างเช่น Claude ต้องการข้อมูลจากระบบภายนอก (เช่น ฐานข้อมูล) หรือจำเป็นต้องดำเนินการบางอย่าง (เช่น รันคำสั่ง query) แอปพลิเคชันจะเริ่มต้นคำขอนี้ผ่าน MCP Client ภายในของตน
2. การจัดรูปแบบคำขอ: MCP Client จะนำคำขอของ AI มาจัดรูปแบบให้เป็น structured message ตามมาตรฐานของ Model Context Protocol โปรโตคอลนี้กำหนดรูปแบบของคำขอและการตอบกลับ เพื่อให้แน่ใจว่าโมเดลและเครื่องมือที่แตกต่างกันสามารถทำงานร่วมกันได้
3. การสื่อสารผ่าน standard protocol: คำขอที่จัดรูปแบบแล้วจะถูกส่งจาก MCP Client ไปยัง MCP Server ที่เหมาะสม โดยผ่าน Transports ที่เป็นกลไกการสื่อสารของ MCP ซึ่งหมายความว่ามีวิธีการที่กำหนดไว้อย่างชัดเจนสำหรับการแลกเปลี่ยนข้อมูลระหว่าง client และ server
   • MCP Client จะใช้หนึ่งใน transport mechanisms ที่รองรับเพื่อส่ง structured message ไปยัง MCP Server โดยตัวเลือกของ transport อาจขึ้นอยู่กับสภาพแวดล้อมของการใช้งาน (local หรือ remote) และข้อกำหนดของการรับ-ส่งข้อความ (เช่น ต้องการให้ Server สามารถส่งข้อความไปยัง Client ผ่าน SSE) โดย Transport layer ทำหน้าที่จัดการการสื่อสารจริงระหว่าง Clients และ Servers เช่น
     • Stdio transport: ใช้ standard input/output เหมาะสำหรับกระบวนการที่ทำงานในเครื่องเดียวกัน
     • HTTP with SSE transport: ใช้ Server-Sent Events (SSE) สำหรับข้อความจาก Server ไปยัง Client และ HTTP POST สำหรับข้อความจาก Client ไปยัง Server เหมาะสำหรับการทำงานร่วมกับ HTTP
4. การประมวลผลโดย MCP Server: MCP Server จะรับข้อความที่มีโครงสร้างจาก MCP Client ซึ่งทำหน้าที่เป็นตัวกลางที่เข้าใจวิธีโต้ตอบกับระบบภายนอกที่เฉพาะเจาะจง (เช่น PostgreSQL หรือ Google Drive) ** มองเป็นเหมือน Backend Service ตัวหนึ่งที่สามารถเชื่อมต่อไปยัง 3rd party ได้
5. การจัดรูปแบบคำตอบ: เมื่อ MCP Server ได้รับข้อมูลที่ร้องขอหรือดำเนินการเสร็จสิ้นแล้ว ระบบจะนำผลลัพธ์มาจัดรูปแบบเป็น structured response ตามมาตรฐานของ Model Context Protocol
6. การส่งคำตอบกลับ: MCP Server จะส่ง structured response กลับไปยัง MCP Client ต้นทาง
7. การส่งข้อมูลให้โมเดล AI: MCP Client รับคำตอบและนำข้อมูลกลับไปให้โมเดล AI เพื่อให้สามารถใช้ข้อมูลนั้นในการให้เหตุผลและสร้าง output ได้

โดยสรุปแล้ว MCP Client ทำหน้าที่เป็นตัวกลางระหว่าง AI กับ MCP Server โดยแปลงความต้องการของ AI ให้อยู่ในรูปแบบมาตรฐานที่ MCP Server สามารถเข้าใจได้

ขณะเดียวกัน Standard Protocol ช่วยให้การสื่อสารมีเสถียรภาพและสามารถใช้งานร่วมกับระบบภายนอกได้อย่างราบรื่น โดยไม่จำเป็นต้องสร้างการเชื่อมต่อแบบเฉพาะสำหรับแต่ละระบบ เนื้อหาของข้อความที่ถูกแลกเปลี่ยนจะขึ้นอยู่กับว่าคำขอนั้นเกี่ยวข้องกับ Resource หรือ Tool ภายใน MCP นั่นเอง

มาลองทำ MCP Server

ref: https://modelcontextprotocol.io/quickstart/server

มาลองทำ MCP Server ในการดึงข้อมูลผ่าน Mock API

• ทำ get_blogs สำหรับดึงข้อมูล blogs ทั้งหมด
• ทำ search_blogs สำหรับค้นหา Blog ตามข้อมูลที่ส่งมา
• ทำ add_blog สำหรับเพิ่ม Blog ใหม่เข้าไป

เริ่มต้น install uv command

curl -LsSf https://astral.sh/uv/install.sh | sh

• uv (https://github.com/astral-sh/uv) เป็นตัวจัดการแพ็กเกจสำหรับ Python ที่ทำงานคล้ายกับ pip แต่มีประสิทธิภาพสูงกว่า เนื่องจากถูกพัฒนาโดยใช้ Rust เป็นแกนหลัก ทำให้การติดตั้งและจัดการแพ็กเกจรวดเร็วยิ่งขึ้น
• นอกจากความเร็วแล้ว uv ยังรองรับการจัดการ environment และ lockfile ในตัว เช่นเดียวกับ pip-tools หรือ Poetry อีกทั้งยังสามารถทำงานร่วมกับ pyproject.toml ได้โดยตรง ทำให้การจัดการ dependencies เป็นระบบและสะดวกขึ้น ต่างจาก pip ที่ต้องพึ่งพา requirements.txt หรือ pip-tools เพื่อให้การจัดการ dependencies มีความแน่นอน (deterministic) มากขึ้น

start project

# Create a new directory for our project
uv init mikelopster-blog
cd mikelopster-blog

# Install dependencies
uv add "mcp[cli]" httpx

และเราจะแก้กันที่ main.py code เริ่มต้น เราจะลอง get blog ทั้งหมดออกมา

from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP

# Initialize FastMCP server
mcp = FastMCP("mikelopster-product")

# Constants
mock_api_base = "https://<mock id api>.mockapi.io/blogs"

@mcp.tool()
async def get_blogs() -> Any:
    """Get all blogs via GET mock_api_base and return JSON."""
    async with httpx.AsyncClient() as client:
        response = await client.get(mock_api_base)
        return response.json()

if __name__ == "__main__":
    # Initialize and run the server
    mcp.run(transport='stdio')

อธิบายเพิ่มเติมบรรทัด mcp.run(transport='stdio')

• บรรทัด mcp.run(transport='stdio') เป็น ฟังก์ชันอำนวยความสะดวกที่มีให้โดย MCP SDK ซึ่งมีหน้าที่ เริ่มต้นเซิร์ฟเวอร์ MCP และกำหนดให้ใช้การสื่อสารผ่าน standard input/output (stdio) เป็น transport
  • mcp.run(): ฟังก์ชันนี้ จะรวมกระบวนการต่างๆ ที่จำเป็นสำหรับการเริ่มต้นและรันเซิร์ฟเวอร์ MCP เอาไว้ เช่น การสร้างอินสแตนซ์ของเซิร์ฟเวอร์และการเชื่อมโยง transport ที่กำหนด
  • transport='stdio': กำหนดให้เซิร์ฟเวอร์ใช้ stdio transport mechanism ซึ่งอาศัย standard input และ standard output streams ในการรับ-ส่งข้อมูล วิธีนี้เหมาะสำหรับการสื่อสารระหว่างโปรเซสที่ทำงานบนเครื่องเดียวกันโดยไม่ต้องใช้เครือข่ายในการส่งข้อมูล

เมื่อ mcp.run(transport='stdio') ถูกเรียกใช้ เซิร์ฟเวอร์ MCP จะ

1. เริ่มต้นเซิร์ฟเวอร์และรอรับการเชื่อมต่อ ผ่าน standard input/output streams
2. ไม่มีเอาต์พุตที่มองเห็นได้บนคอนโซล เหมือนเซิร์ฟเวอร์เครือข่ายที่อาจพิมพ์ข้อความเช่น “Listening on port X” แต่จะรอรับข้อมูลทาง standard input แทน
3. เปิดให้ MCP Client ที่รันอยู่ในโปรเซสแยกต่างหาก (แต่บนเครื่องเดียวกัน) สามารถเชื่อมต่อได้ โดยการกำหนดให้ standard output ของไคลเอนต์ส่งไปยัง standard input ของเซิร์ฟเวอร์ และในทางกลับกัน ไคลเอนต์จะต้องถูกตั้งค่าให้ใช้ stdio transport และสามารถสื่อสารตาม Model Context Protocol ได้

เพิ่ม mcp client ให้รู้จักกับ mcp server ใน Claude desktop

• ถ้าใน Mac path จะอยู่ที่ /Users/<User on mac>/Library/Application\ Support/Claude

สามารถเข้าได้โดยตรงผ่าน Settings > Develop > Edit Config เสร็จแล้วจะเจอ json file ที่สามารถแก้ไขได้

ให้เพิ่ม config นี้เข้าไป

{
    "mcpServers": {
        "mikelopster-blog": {
            "command": "uv",
            "args": [
                "--directory",
                "<PATH to project>",
                "run",
                "main.py"
            ]
        }
    }
}

ตัวอย่างแบบนี้

เมื่อกลับมาเปิด Claude Desktop อีกจะต้องเจอว่าลงไว้แล้วเรียบร้อยตรง MCP Tools

จากนั้นให้ลองทดสอบดู โดยจาก API ตัวอย่างที่ทำมาของ Mock API หน้าตาแบบนี้

ก็จะได้ผลลัพธ์ประมาณนี้ออกมา

ซึ่งมันก็คือการเอาผลลัพธ์ API มาใช้งานต่อที่ LLM นั่นเอง

Search Blog

Next step เราจะลองให้มีการส่ง Context เข้ามาเพิ่มเติมบ้าง เราจะลองเพิ่ม search blogs กัน โดยเพิ่ม code ให้กับ python module search_blogs ขึ้นมา

@mcp.tool()
async def search_blogs(title: str) -> Any:
    """Search blogs by title via GET mock_api_base?title=<title param> and return JSON."""
    async with httpx.AsyncClient() as client:
        response = await client.get(f"{mock_api_base}?title={title}")
        return response.json()

เมื่อลองกลับมาเปิด Claude Desktop ใหม่ก็จะเจอ search blogs ขึ้นมา (ไม่ต้อง update config อะไรเพราะมัน connect กับ MCP Server ของเราอยู่แล้ว)

ลองทดสอบผ่านข้อความใน Claude Desktop

อย่างที่เห็นคือ มันก็จะเอาผลลัพธ์ API มาใช้ต่อใน Context ได้นั่นเอง ที่เหลือก็จะเหมือนการ implement ตาม server ทั่วไปและ

Add Blogs

อีกหนึ่งเคส คือเคสที่มี action เพิ่มเติมกันบ้าง (ซิ่งจริงๆก็ไม่ต่างกันเท่าไหร่)

@mcp.tool()
async def add_blog(title: str, body: str) -> Any:
    """Add new blog via POST mock_api_base with JSON { title, body }."""
    async with httpx.AsyncClient() as client:
        response = await client.post(mock_api_base, json={'title': title, 'body': body})
        return response.json()['id']

ผลลัพธ์

ตรวจสอบผ่าน API

Tools อื่นๆเพิ่มเติมของ MCP

วิธี Debug https://modelcontextprotocol.io/docs/tools/debugging

 tail -n 20 -F ~/Library/Logs/Claude/mcp*.log

รวมถึงมี inspector ด้วย https://modelcontextprotocol.io/docs/tools/inspector

npx @modelcontextprotocol/inspector \
  uv \
  --directory /Users/tanitphonpaniwan/Repositories/temp/weather \
  run \
  main.py \
  args..

จะ run inspector ขึ้นมาได้

ทดสอบยิงข้อมูลผ่านเครื่องมือได้

Reference

• https://www.anthropic.com/news/model-context-protocol
• https://blog.bytebytego.com/p/ep154-what-is-mcp
• https://blog.replit.com/everything-you-need-to-know-about-mcp