wehub-resource-sync
72 KiB
MCP Core Concepts: การเรียนรู้โปรโตคอลบริบทโมเดลสำหรับการรวม AI
(คลิกที่ภาพด้านบนเพื่อดูวิดีโอบทเรียนนี้)
Model Context Protocol (MCP) เป็นกรอบงานมาตรฐานที่มีประสิทธิภาพซึ่งช่วยเพิ่มประสิทธิภาพการสื่อสารระหว่าง Large Language Models (LLMs) กับเครื่องมือ แอปพลิเคชัน และแหล่งข้อมูลภายนอก
คู่มือนี้จะพาคุณผ่านแนวคิดหลักของ MCP คุณจะได้เรียนรู้เกี่ยวกับสถาปัตยกรรมลูกค้า-เซิร์ฟเวอร์ส่วนสำคัญ องค์ประกอบที่จำเป็น กลไกการสื่อสาร และแนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้งาน
-
ความยินยอมจากผู้ใช้ที่ชัดเจน: การเข้าถึงข้อมูลและการดำเนินการทั้งหมดต้องได้รับการอนุมัติอย่างชัดเจนจากผู้ใช้ก่อนดำเนินการ ผู้ใช้ต้องเข้าใจอย่างชัดเจนว่าจะเข้าถึงข้อมูลใดและจะดำเนินการอะไร พร้อมการควบคุมสิทธิ์และการอนุญาตอย่างละเอียดถี่ถ้วน
-
การปกป้องความเป็นส่วนตัวของข้อมูล: ข้อมูลของผู้ใช้จะถูกเปิดเผยเฉพาะด้วยความยินยอมอย่างชัดเจนและต้องได้รับการปกป้องด้วยมาตรการควบคุมการเข้าถึงที่เข้มงวดตลอดวงจรการโต้ตอบทั้งหมด การใช้งานต้องป้องกันการส่งข้อมูลโดยไม่ได้รับอนุญาตและรักษาขอบเขตความเป็นส่วนตัวอย่างเข้มงวด
-
ความปลอดภัยในการเรียกใช้เครื่องมือ: ทุกการเรียกใช้เครื่องมือต้องได้รับความยินยอมจากผู้ใช้โดยชัดเจน พร้อมความเข้าใจที่ชัดเจนเกี่ยวกับฟังก์ชันการทำงาน พารามิเตอร์ และผลกระทบที่อาจเกิดขึ้น ขอบเขตความปลอดภัยที่แข็งแกร่งต้องป้องกันการเรียกใช้เครื่องมือที่ไม่ตั้งใจ ไม่ปลอดภัย หรือเป็นอันตราย
-
ความปลอดภัยของชั้นการขนส่ง: ช่องทางการสื่อสารทั้งหมดควรใช้กลไกการเข้ารหัสและการพิสูจน์ตัวตนที่เหมาะสม การเชื่อมต่อระยะไกลควรใช้โปรโตคอลการขนส่งที่ปลอดภัยและมีการจัดการข้อมูลประจำตัวที่ถูกต้อง
แนวทางการใช้งาน:
- การจัดการสิทธิ์: ใช้ระบบสิทธิ์ควบคุมละเอียดเพื่อให้ผู้ใช้สามารถควบคุมเซิร์ฟเวอร์ เครื่องมือ และทรัพยากรที่เข้าถึงได้
- การพิสูจน์ตัวตนและอนุญาต: ใช้วิธีการพิสูจน์ตัวตนที่ปลอดภัย (OAuth, API keys) พร้อมการจัดการโทเคนและการหมดอายุที่เหมาะสม
- การตรวจสอบข้อมูลนำเข้า: ตรวจสอบพารามิเตอร์และข้อมูลนำเข้าทั้งหมดตามโครงร่างที่กำหนดเพื่อป้องกันการโจมตีแบบ injection
- การบันทึกตรวจสอบ: เก็บบันทึกการดำเนินการทั้งหมดอย่างครบถ้วนเพื่อการเฝ้าระวังความปลอดภัยและการปฏิบัติตามข้อกำหนด
ภาพรวม
บทเรียนนี้จะสำรวจสถาปัตยกรรมพื้นฐานและส่วนประกอบที่ประกอบเป็นระบบนิเวศของ Model Context Protocol (MCP)
คุณจะได้เรียนรู้เกี่ยวกับสถาปัตยกรรมลูกค้า-เซิร์ฟเวอร์ องค์ประกอบสำคัญ และกลไกการสื่อสารที่สนับสนุนการโต้ตอบของ MCP
วัตถุประสงค์การเรียนรู้หลัก
เมื่อจบบทเรียนนี้ คุณจะสามารถ:
- เข้าใจสถาปัตยกรรมลูกค้า-เซิร์ฟเวอร์ของ MCP
- ระบุบทบาทและความรับผิดชอบของ Hosts, Clients และ Servers
- วิเคราะห์คุณสมบัติหลักที่ทำให้ MCP เป็นเลเยอร์การรวมที่ยืดหยุ่น
- เรียนรู้การไหลของข้อมูลภายในระบบนิเวศของ MCP
- ได้รับข้อมูลเชิงลึกเชิงปฏิบัติผ่านตัวอย่างโค้ดใน .NET, Java, Python และ JavaScript
สถาปัตยกรรม MCP: เจาะลึก
ระบบนิเวศ MCP สร้างขึ้นบนโมเดลลูกค้า-เซิร์ฟเวอร์
โครงสร้างแบบโมดูลาร์นี้ช่วยให้อินเทอร์แอคชันของแอปพลิเคชัน AI กับเครื่องมือ ฐานข้อมูล API และทรัพยากรบริบทมีประสิทธิภาพ เราลองแบ่งสถาปัตยกรรมนี้ออกเป็นองค์ประกอบหลัก
ในแกนกลาง MCP จะใช้สถาปัตยกรรมลูกค้า-เซิร์ฟเวอร์ที่แอปโฮสต์สามารถเชื่อมต่อกับเซิร์ฟเวอร์หลายตัว:
flowchart LR
subgraph "คอมพิวเตอร์ของคุณ"
Host["โฮสต์ที่มี MCP (Visual Studio, VS Code, IDEs, เครื่องมือ)"]
S1["เซิร์ฟเวอร์ MCP A"]
S2["เซิร์ฟเวอร์ MCP B"]
S3["เซิร์ฟเวอร์ MCP C"]
Host <-->|"โปรโตคอล MCP"| S1
Host <-->|"โปรโตคอล MCP"| S2
Host <-->|"โปรโตคอล MCP"| S3
S1 <--> D1[("แหล่งข้อมูลท้องถิ่น A")]
S2 <--> D2[("แหล่งข้อมูลท้องถิ่น B")]
end
subgraph "อินเทอร์เน็ต"
S3 <-->|"เว็บ API"| D3[("บริการระยะไกล")]
end
- MCP Hosts: โปรแกรมเช่น VSCode, Claude Desktop, IDEs หรือเครื่องมือ AI ที่ต้องการเข้าถึงข้อมูลผ่าน MCP
- MCP Clients: ลูกค้าของโปรโตคอลที่รักษาการเชื่อมต่อแบบ 1:1 กับเซิร์ฟเวอร์
- MCP Servers: โปรแกรมขนาดเบาที่แต่ละตัวเปิดเผยความสามารถเฉพาะผ่าน Model Context Protocol ที่เป็นมาตรฐาน
- แหล่งข้อมูลในเครื่อง: ไฟล์ ฐานข้อมูล และบริการในคอมพิวเตอร์ของคุณซึ่ง MCP servers สามารถเข้าถึงได้อย่างปลอดภัย
- บริการระยะไกล: ระบบภายนอกที่เข้าถึงได้ผ่านอินเทอร์เน็ตซึ่ง MCP servers สามารถเชื่อมต่อผ่าน API
โปรโตคอล MCP เป็นมาตรฐานที่พัฒนาต่อเนื่องโดยใช้การตั้งเวอร์ชันแบบวันที่ (รูปแบบ YYYY-MM-DD) เวอร์ชันโปรโตคอลปัจจุบันคือ 2025-11-25 คุณสามารถดูการอัปเดตล่าสุดได้ที่ คำสั่งโปรโตคอล
1. Hosts
ใน Model Context Protocol (MCP), Hosts คือแอปพลิเคชัน AI ที่ทำหน้าที่เป็นอินเทอร์เฟซหลักที่ผู้ใช้โต้ตอบกับโปรโตคอล
Hosts จะประสานงานและจัดการการเชื่อมต่อกับเซิร์ฟเวอร์ MCP หลายตัวโดยสร้างลูกค้า MCP ที่เฉพาะเจาะจงสำหรับแต่ละการเชื่อมต่อเซิร์ฟเวอร์ ตัวอย่าง Hosts เช่น:
- แอปพลิเคชัน AI: Claude Desktop, Visual Studio Code, Claude Code
- สภาพแวดล้อมการพัฒนา: IDE และโปรแกรมแก้ไขโค้ดที่รวม MCP
- แอปพลิเคชันที่สร้างเอง: ตัวแทน AI และเครื่องมือที่ออกแบบเฉพาะ
Hosts คือแอปพลิเคชันที่ประสานงานการโต้ตอบกับโมเดล AI พวกเขา:
- ควบคุมการทำงานของโมเดล AI: ดำเนินการหรือโต้ตอบกับ LLM เพื่อสร้างคำตอบและประสานงานขั้นตอนการทำงาน AI
- จัดการการเชื่อมต่อลูกค้า: สร้างและรักษาลูกค้า MCP หนึ่งตัวต่อการเชื่อมต่อเซิร์ฟเวอร์ MCP หนึ่งการเชื่อมต่อ
- ควบคุมอินเทอร์เฟซผู้ใช้: จัดการการไหลของบทสนทนา การโต้ตอบของผู้ใช้ และการแสดงคำตอบ
- บังคับใช้ความปลอดภัย: ควบคุมสิทธิ์ ข้อจำกัดด้านความปลอดภัย และการพิสูจน์ตัวตน
- จัดการความยินยอมของผู้ใช้: ควบคุมการอนุมัติการแชร์ข้อมูลและการเรียกใช้เครื่องมือ
2. Clients
Clients เป็นส่วนประกอบสำคัญที่รักษาการเชื่อมต่อแบบ 1 ต่อ 1 โดยเฉพาะระหว่าง Hosts และเซิร์ฟเวอร์ MCP
ลูกค้า MCP แต่ละตัวถูกสร้างโดย Host เพื่อเชื่อมต่อกับเซิร์ฟเวอร์ MCP เฉพาะเจาะจง ช่วยให้ช่องทางสื่อสารถูกจัดระบบและปลอดภัย
หลายๆ Clients ช่วยให้ Hosts เชื่อมต่อไปยังเซิร์ฟเวอร์หลายตัวพร้อมกัน
Clients คือส่วนประกอบตัวเชื่อมต่อภายในแอปโฮสต์ พวกเขา:
- สื่อสารโปรโตคอล: ส่งคำขอ JSON-RPC 2.0 ไปยังเซิร์ฟเวอร์พร้อมพรอมต์และคำสั่ง
- เจรจาความสามารถ: เจรจาคุณสมบัติที่รองรับและเวอร์ชันโปรโตคอลกับเซิร์ฟเวอร์ในช่วงเริ่มต้น
- เรียกใช้เครื่องมือ: จัดการคำขอเรียกใช้เครื่องมือจากโมเดลและประมวลผลคำตอบ
- อัปเดตแบบเรียลไทม์: ประมวลผลการแจ้งเตือนและอัปเดตเรียลไทม์จากเซิร์ฟเวอร์
- ประมวลผลคำตอบ: ประมวลผลและจัดรูปแบบคำตอบจากเซิร์ฟเวอร์เพื่อแสดงผลแก่ผู้ใช้
3. Servers
Servers คือโปรแกรมที่ให้บริบท เครื่องมือ และความสามารถแก่ลูกค้า MCP
พวกเขาสามารถทำงานในเครื่อง (เครื่องเดียวกับ Host) หรือระยะไกล (บนแพลตฟอร์มภายนอก) และรับผิดชอบจัดการคำขอของลูกค้าและส่งคำตอบที่มีโครงสร้าง
เซิร์ฟเวอร์จะเปิดเผยฟังก์ชันเฉพาะผ่าน Model Context Protocol ที่เป็นมาตรฐาน
Servers คือบริการที่ให้บริบทและความสามารถ พวกเขา:
- ลงทะเบียนฟีเจอร์: ลงทะเบียนและเปิดเผย primitive ที่ใช้งานได้ (ทรัพยากร, พรอมต์, เครื่องมือ) ต่อ Clients
- ประมวลผลคำขอ: รับและดำเนินการเรียกใช้เครื่องมือ คำขอทรัพยากร และพรอมต์จาก Clients
- จัดเตรียมบริบท: ให้ข้อมูลบริบทและข้อมูลเพื่อช่วยเพิ่มประสิทธิภาพการตอบของโมเดล
- จัดการสถานะ: รักษาสถานะเซสชันและจัดการการโต้ตอบที่มีสถานะตามต้องการ
- แจ้งเตือนแบบเรียลไทม์: ส่งการแจ้งเตือนเกี่ยวกับการเปลี่ยนแปลงและอัปเดตความสามารถไปยัง Clients ที่เชื่อมต่อ
เซิร์ฟเวอร์สามารถพัฒนาโดยใครก็ได้เพื่อขยายขีดความสามารถของโมเดลด้วยฟังก์ชันเฉพาะ และรองรับทั้งการใช้งานในเครื่องและระยะไกล
4. Server Primitives
เซิร์ฟเวอร์ใน Model Context Protocol (MCP) จะให้ primitive 3 ประเภทหลักที่กำหนดบล็อกโครงสร้างพื้นฐานสำหรับการโต้ตอบที่สมบูรณ์ระหว่าง Clients, Hosts และโมเดลภาษา
primitive เหล่านี้กำหนดประเภทข้อมูลบริบทและการกระทำที่สามารถทำได้ผ่านโปรโตคอล
เซิร์ฟเวอร์ MCP สามารถเปิดเผยชุด primitive ใดก็ได้จาก 3 ตัวต่อไปนี้:
Resources
Resources คือแหล่งข้อมูลที่ให้ข้อมูลบริบทแก่แอปพลิเคชัน AI
พวกเขาเป็นเนื้อหาคงที่หรือตัวแปรที่ช่วยเพิ่มความเข้าใจและการตัดสินใจของโมเดล:
- ข้อมูลบริบท: ข้อมูลที่มีโครงสร้างและบริบทสำหรับการใช้โมเดล AI
- ฐานความรู้: แหล่งเอกสาร บทความ คู่มือ และงานวิจัย
- แหล่งข้อมูลในเครื่อง: ไฟล์ ฐานข้อมูล และข้อมูลระบบในเครื่อง
- ข้อมูลภายนอก: การตอบสนอง API, เว็บเซอร์วิส และข้อมูลจากระบบระยะไกล
- เนื้อหาแบบไดนามิก: ข้อมูลแบบเรียลไทม์ที่อัปเดตตามเงื่อนไขภายนอก
Resources ถูกระบุด้วย URI และรองรับการค้นหาผ่านเมธอด resources/list และการดึงข้อมูลผ่านเมธอด resources/read:
file://documents/project-spec.md
database://production/users/schema
api://weather/current
Prompts
Prompts คือแม่แบบที่ใช้ซ้ำได้ซึ่งช่วยกำหนดโครงสร้างการโต้ตอบกับโมเดลภาษา
พวกเขามอบรูปแบบการโต้ตอบมาตรฐานและเวิร์กโฟลว์ที่เป็นแม่แบบ:
- การโต้ตอบแบบแม่แบบ: ข้อความล่วงหน้าและการเริ่มบทสนทนาที่มีโครงสร้าง
- แม่แบบเวิร์กโฟลว์: ลำดับมาตรฐานสำหรับงานและการโต้ตอบทั่วไป
- ตัวอย่างแบบ Few-shot: แม่แบบที่ใช้ตัวอย่างสำหรับคำสั่งโมเดล
- พรอมต์ระบบ: พรอมต์พื้นฐานที่กำหนดพฤติกรรมและบริบทของโมเดล
- แม่แบบไดนามิก: พรอมต์ที่ระบุพารามิเตอร์และปรับตามบริบทเฉพาะ
Prompts รองรับการแทนที่ตัวแปรและสามารถค้นหาได้ผ่าน prompts/list และดึงผ่าน prompts/get:
Generate a {{task_type}} for {{product}} targeting {{audience}} with the following requirements: {{requirements}}
Tools
Tools คือฟังก์ชันที่สามารถเรียกใช้งานได้ซึ่งโมเดล AI ใช้เพื่อดำเนินการกระทำเฉพาะ
พวกเขาคือ "กริยา" ของระบบนิเวศ MCP ที่ช่วยให้โมเดลโต้ตอบกับระบบภายนอก:
- ฟังก์ชันที่เรียกใช้ได้: การดำเนินการแยกส่วนที่โมเดลสามารถเรียกด้วยพารามิเตอร์เฉพาะ
- การรวมระบบภายนอก: การเรียก API, การสืบค้นฐานข้อมูล, การจัดการไฟล์, การคำนวณ
- เอกลักษณ์เฉพาะ: เครื่องมือแต่ละตัวมีชื่อ คำอธิบาย และโครงร่างพารามิเตอร์เฉพาะ
- อินพุต/เอาต์พุตที่มีโครงสร้าง: เครื่องมือรับพารามิเตอร์ที่ตรวจสอบและคืนคำตอบที่มีโครงสร้างและระบุชนิดข้อมูล
- ความสามารถในการกระทำ: ช่วยให้โมเดลทำงานในโลกจริงและดึงข้อมูลสด
เครื่องมือถูกกำหนดโดย JSON Schema สำหรับการตรวจสอบพารามิเตอร์ และค้นหาได้ผ่าน tools/list และเรียกใช้ผ่าน tools/call เครื่องมือยังสามารถรวม ไอคอน เป็นข้อมูลประกอบเพิ่มเติมเพื่อการแสดง UI ที่ดียิ่งขึ้น
คำอธิบายเครื่องมือ: เครื่องมือรองรับคำอธิบายพฤติกรรม (เช่น readOnlyHint, destructiveHint) เพื่อระบุว่าเครื่องมือเป็นแบบอ่านอย่างเดียวหรืออันตราย ซึ่งช่วยให้ลูกค้าตัดสินใจเรียกใช้เครื่องมือได้ถูกต้อง
ตัวอย่างการกำหนดเครื่องมือ:
server.tool(
"search_products",
{
query: z.string().describe("Search query for products"),
category: z.string().optional().describe("Product category filter"),
max_results: z.number().default(10).describe("Maximum results to return")
},
async (params) => {
// ดำเนินการค้นหาและส่งคืนผลลัพธ์ในรูปแบบโครงสร้าง
return await productService.search(params);
}
);
Client Primitives
ใน Model Context Protocol (MCP), Clients สามารถเปิดเผย primitive ที่ช่วยให้เซิร์ฟเวอร์ร้องขอความสามารถเพิ่มเติมจากแอปโฮสต์ได้
primitive ฝั่งไคลเอนต์เหล่านี้ช่วยให้เซิร์ฟเวอร์มีการใช้งานที่โต้ตอบและสมบูรณ์ยิ่งขึ้นโดยเข้าถึงความสามารถของโมเดล AI และการโต้ตอบผู้ใช้
Sampling
Sampling ช่วยให้เซิร์ฟเวอร์ร้องขอการเติมเนื้อหาจากโมเดลภาษาของแอป AI ของไคลเอนต์
primitive ตัวนี้ช่วยให้เซิร์ฟเวอร์เข้าถึงขีดความสามารถ LLM โดยไม่ต้องฝัง SDK โมเดลของตัวเอง:
- การเข้าถึงอิสระจากโมเดล: เซิร์ฟเวอร์สามารถร้องขอการเติมเนื้อหาโดยไม่ต้องรวม SDK LLM หรือจัดการการเข้าถึงโมเดล
- AI ที่เซิร์ฟเวอร์เริ่มต้น: ช่วยให้เซิร์ฟเวอร์สามารถสร้างเนื้อหาอย่างเป็นอิสระโดยใช้โมเดล AI ของไคลเอนต์
- การโต้ตอบ LLM ซ้อนกัน: รองรับสถานการณ์ซับซ้อนที่เซิร์ฟเวอร์ต้องการความช่วยเหลือจาก AI ในการประมวลผล
- การสร้างเนื้อหาไดนามิก: ช่วยให้เซิร์ฟเวอร์สร้างคำตอบตามบริบทโดยใช้โมเดลของโฮสต์
- รองรับการเรียกใช้เครื่องมือ: เซิร์ฟเวอร์สามารถรวมพารามิเตอร์
toolsและtoolChoiceเพื่อเปิดใช้งานโมเดลของไคลเอนต์เรียกใช้เครื่องมือระหว่างการสุ่ม
Sampling ถูกเริ่มต้นผ่านเมธอด sampling/complete ซึ่งเซิร์ฟเวอร์ส่งคำขอเติมเนื้อหาไปยัง Clients
Roots
Roots ให้วิธีการมาตรฐานสำหรับ Clients ในการเปิดเผยขอบเขตระบบไฟล์ให้เซิร์ฟเวอร์ทราบ ช่วยให้เซิร์ฟเวอร์เข้าใจว่ามีสิทธิ์เข้าถึงไดเรกทอรีและไฟล์ใดได้บ้าง:
- ขอบเขตระบบไฟล์: กำหนดขอบเขตที่เซิร์ฟเวอร์สามารถทำงานภายในระบบไฟล์ได้
- การควบคุมการเข้าถึง: ช่วยเซิร์ฟเวอร์เข้าใจว่าไดเรกทอรีและไฟล์ใดที่มีสิทธิ์เข้าถึง
- อัปเดตแบบไดนามิก: Clients สามารถแจ้งเตือนไปยังเซิร์ฟเวอร์เมื่อลิสต์ roots เปลี่ยนแปลง
- การระบุด้วย URI: Roots ใช้ URI แบบ
file://เพื่อระบุไดเรกทอรีและไฟล์ที่เข้าถึงได้
Roots ถูกค้นหาผ่านเมธอด roots/list โดย Clients ส่งการแจ้งเตือน notifications/roots/list_changed เมื่อ roots เปลี่ยนแปลง
Elicitation
Elicitation ช่วยให้เซิร์ฟเวอร์ร้องขอข้อมูลเพิ่มเติมหรือการยืนยันจากผู้ใช้ผ่านอินเทอร์เฟซของไคลเอนต์:
- การร้องขอข้อมูลจากผู้ใช้: เซิร์ฟเวอร์สามารถถามข้อมูลเพิ่มเติมเมื่อจำเป็นสำหรับการเรียกใช้เครื่องมือ
- กล่องโต้ตอบยืนยัน: ขอความยินยอมจากผู้ใช้สำหรับการดำเนินการที่ละเอียดอ่อนหรือมีผลกระทบ
- เวิร์กโฟลว์แบบโต้ตอบ: ช่วยให้เซิร์ฟเวอร์สร้างการโต้ตอบกับผู้ใช้ทีละขั้นตอน
- รวบรวมพารามิเตอร์แบบไดนามิก: รวบรวมพารามิเตอร์ที่ขาดหายหรือเป็นทางเลือกในระหว่างการเรียกใช้เครื่องมือ
คำขอ elicitation ทำผ่านเมธอด elicitation/request เพื่อรวบรวมข้อมูลผู้ใช้ทางอินเทอร์เฟซของไคลเอนต์
Elicitation โหมด URL: เซิร์ฟเวอร์ยังสามารถร้องขอการโต้ตอบผู้ใช้ผ่าน URL ซึ่งอนุญาตให้เซิร์ฟเวอร์นำทางผู้ใช้ไปยังเว็บภายนอกสำหรับการพิสูจน์ตัวตน การยืนยัน หรือป้อนข้อมูล
Logging
Logging ช่วยให้เซิร์ฟเวอร์ส่งข้อความบันทึกแบบมีโครงสร้างไปยัง Clients เพื่อการดีบั๊ก การตรวจสอบ และการมองเห็นการทำงาน:
- สนับสนุนการดีบั๊ก: ช่วยให้เซิร์ฟเวอร์ให้บันทึกรายละเอียดการทำงานสำหรับแก้ไขปัญหา
- การตรวจสอบการดำเนินงาน: ส่งอัปเดตสถานะและเมตริกประสิทธิภาพไปยัง Clients
- การรายงานข้อผิดพลาด: ให้ข้อมูลบริบทข้อผิดพลาดและข้อมูลวินิจฉัยอย่างละเอียด
- เส้นทางตรวจสอบ: สร้างบันทึกครบถ้วนของการดำเนินการและการตัดสินใจของเซิร์ฟเวอร์
ข้อความบันทึกถูกส่งถึง Clients เพื่อให้การดำเนินการของเซิร์ฟเวอร์มีความโปร่งใสและช่วยการดีบั๊ก
การไหลของข้อมูลใน MCP
Model Context Protocol (MCP) กำหนดการไหลของข้อมูลแบบมีโครงสร้างระหว่าง Hosts, Clients, Servers และโมเดล
ความเข้าใจถึงการไหลนี้ช่วยชี้แจงวิธีการประมวลผลคำขอของผู้ใช้และวิธีการผสานเครื่องมือและข้อมูลภายนอกเข้าสู่คำตอบของโมเดลได้อย่างไร
-
โฮสต์เริ่มต้นเชื่อมต่อ
แอปพลิเคชันโฮสต์ (เช่น IDE หรืออินเทอร์เฟซแชท) สร้างการเชื่อมต่อไปยังเซิร์ฟเวอร์ MCP โดยปกติผ่าน STDIO, WebSocket หรือวิธีการขนส่งที่รองรับอื่นๆ -
การเจรจาความสามารถ
ฝั่งไคลเอนต์ (ฝังอยู่ในโฮสต์) และเซิร์ฟเวอร์แลกเปลี่ยนข้อมูลเกี่ยวกับฟีเจอร์ เครื่องมือ ทรัพยากร และเวอร์ชันโปรโตคอลที่รองรับ เพื่อให้มั่นใจว่าทั้งสองฝ่ายเข้าใจว่ามีความสามารถใดบ้างสำหรับเซสชันนี้ -
คำขอของผู้ใช้
ผู้ใช้โต้ตอบกับโฮสต์ (เช่น ป้อนพรอมต์หรือคำสั่ง) โฮสต์รวบรวมข้อมูลป้อนนี้และส่งต่อไปยังไคลเอนต์เพื่อประมวลผล -
การใช้ทรัพยากรหรือเครื่องมือ
- ไคลเอนต์อาจขอบริบทหรือทรัพยากรเพิ่มเติมจากเซิร์ฟเวอร์ (เช่น ไฟล์ รายการฐานข้อมูล หรือบทความในฐานความรู้) เพื่อเสริมความเข้าใจของโมเดล
- หากโมเดลตัดสินใจว่าเครื่องมือจำเป็น (เช่น เพื่อดึงข้อมูล ทำการคำนวณ หรือเรียก API) ไคลเอนต์จะส่งคำขอเรียกใช้เครื่องมือไปยังเซิร์ฟเวอร์ โดยระบุชื่อเครื่องมือและพารามิเตอร์
-
การดำเนินการของเซิร์ฟเวอร์
เซิร์ฟเวอร์รับคำขอทรัพยากรหรือเครื่องมือ ดำเนินงานที่จำเป็น (เช่น รันฟังก์ชัน สืบค้นฐานข้อมูล หรือดึงไฟล์) และส่งผลลัพธ์กลับไปยังไคลเอนต์ในรูปแบบที่มีโครงสร้าง -
การสร้างคำตอบ
ไคลเอนต์บูรณาการคำตอบจากเซิร์ฟเวอร์ (ข้อมูลทรัพยากร ผลลัพธ์จากเครื่องมือ ฯลฯ) ลงในการโต้ตอบของโมเดลต่อเนื่อง โมเดลใช้ข้อมูลนี้เพื่อสร้างคำตอบที่ครอบคลุมและเหมาะสมกับบริบท -
การนำเสนอผลลัพธ์
โฮสต์รับผลลัพธ์สุดท้ายจากไคลเอนต์และแสดงให้ผู้ใช้เห็น โดยมักรวมทั้งข้อความที่โมเดลสร้างและผลลัพธ์จากเครื่องมือหรือการเรียกดูทรัพยากร
โฟลว์นี้ช่วยให้ MCP รองรับแอปพลิเคชัน AI ที่ล้ำหน้า โต้ตอบได้ และรู้บริบท โดยเชื่อมต่อโมเดลเข้ากับเครื่องมือและแหล่งข้อมูลภายนอกได้อย่างราบรื่น
สถาปัตยกรรมและชั้นโปรโตคอล
MCP ประกอบด้วยสองชั้นสถาปัตยกรรมที่ร่วมกันทำงานเพื่อให้กรอบการสื่อสารที่สมบูรณ์:
ชั้นข้อมูล
ชั้นข้อมูล ใช้โปรโตคอล MCP หลักโดยอิงกับ JSON-RPC 2.0 เป็นฐาน ชั้นนี้กำหนดโครงสร้างข้อความ ความหมาย และรูปแบบการโต้ตอบ:
ส่วนประกอบหลัก:
- โปรโตคอล JSON-RPC 2.0: การสื่อสารทั้งหมดใช้รูปแบบข้อความมาตรฐาน JSON-RPC 2.0 สำหรับการเรียกเมธอด การตอบกลับ และการแจ้งเตือน
- การจัดการวงจรชีวิต: จัดการการเริ่มต้นเชื่อมต่อ การเจรจาความสามารถ และการสิ้นสุดเซสชันระหว่างไคลเอนต์และเซิร์ฟเวอร์
- เซิร์ฟเวอร์พริมิตีฟ: เปิดให้เซิร์ฟเวอร์ให้บริการฟังก์ชันหลักผ่านเครื่องมือ ทรัพยากร และพรอมต์
- ไคลเอนต์พริมิตีฟ: เปิดให้เซิร์ฟเวอร์ขอตัวอย่างจาก LLMs รับข้อมูลผู้ใช้ และส่งข้อความล็อก
- การแจ้งเตือนแบบเรียลไทม์: รองรับการแจ้งเตือนแบบอะซิงโครนัสสำหรับอัปเดตแบบไดนามิกโดยไม่ต้องสอบถามซ้ำ
คุณสมบัติเด่น:
- การเจรจาเวอร์ชันโปรโตคอล: ใช้การจัดเวอร์ชันแบบวันที่ (YYYY-MM-DD) เพื่อความเข้ากันได้
- การค้นพบความสามารถ: ไคลเอนต์และเซิร์ฟเวอร์แลกเปลี่ยนข้อมูลฟีเจอร์ที่รองรับในช่วงเริ่มต้น
- เซสชันมีสถานะ: รักษาสถานะการเชื่อมต่อระหว่างหลายการโต้ตอบเพื่อคงบริบท
ชั้นขนส่ง
ชั้นขนส่ง จัดการช่องทางการสื่อสาร การกำหนดกรอบข้อความ และการตรวจสอบสิทธิ์ระหว่างผู้เข้าร่วม MCP:
กลไกการขนส่งที่รองรับ:
-
ขนส่ง STDIO:
- ใช้สตรีมเข้า/ออกมาตรฐานสำหรับการสื่อสารระหว่างกระบวนการโดยตรง
- เหมาะสำหรับกระบวนการในเครื่องเดียวกันโดยไม่มีภาระเครือข่าย
- ใช้กันทั่วไปสำหรับการติดตั้งเซิร์ฟเวอร์ MCP ในเครื่อง
-
ขนส่ง HTTP แบบสตรีม:
- ใช้ HTTP POST สำหรับข้อความจากไคลเอนต์ไปเซิร์ฟเวอร์
- อ็อปชัน Server-Sent Events (SSE) สำหรับสตรีมข้อมูลจากเซิร์ฟเวอร์ไปไคลเอนต์
- รองรับการสื่อสารเซิร์ฟเวอร์ระยะไกลผ่านเครือข่าย
- รองรับการตรวจสอบสิทธิ์ HTTP มาตรฐาน (โทเค็น bearer, API keys, header แบบกำหนดเอง)
- MCP แนะนำให้ใช้ OAuth เพื่อความปลอดภัยของการตรวจสอบสิทธิ์ด้วยโทเค็น
การแยกชั้นขนส่ง:
ชั้นขนส่งแยกความรายละเอียดของการสื่อสารออกจากชั้นข้อมูล ทำให้ใช้งานรูปแบบข้อความ JSON-RPC 2.0 เดียวกันในทุกกลไกการขนส่งได้ การแยกนี้ช่วยให้แอปพลิเคชันสลับระหว่างเซิร์ฟเวอร์ในเครื่องและระยะไกลได้อย่างราบรื่น
ข้อควรพิจารณาด้านความปลอดภัย
การใช้งาน MCP ต้องปฏิบัติตามหลักการด้านความปลอดภัยที่สำคัญหลายประการเพื่อให้การโต้ตอบในโปรโตคอลมีความปลอดภัย เชื่อถือได้ และปลอดภัย:
-
การยินยอมและการควบคุมของผู้ใช้: ผู้ใช้ต้องให้ความยินยอมชัดเจนก่อนที่จะเข้าถึงข้อมูลหรือดำเนินการใดๆ พวกเขาควรมีการควบคุมที่ชัดเจนเกี่ยวกับข้อมูลที่แชร์และการอนุญาตการกระทำ พร้อมด้วยอินเทอร์เฟซผู้ใช้ที่ใช้งานง่ายสำหรับทบทวนและอนุมัติการดำเนินการ
-
ความเป็นส่วนตัวของข้อมูล: ข้อมูลผู้ใช้ควรถูกเปิดเผยเฉพาะเมื่อได้รับความยินยอมชัดเจนและต้องได้รับการปกป้องด้วยการควบคุมการเข้าถึงที่เหมาะสม การใช้งาน MCP จะต้องป้องกันการส่งข้อมูลโดยไม่ได้รับอนุญาตและรักษาความเป็นส่วนตัวตลอดการโต้ตอบทั้งหมด
-
ความปลอดภัยของเครื่องมือ: ก่อนเรียกใช้เครื่องมือใดๆ ต้องได้รับความยินยอมชัดเจนจากผู้ใช้ ผู้ใช้ควรเข้าใจฟังก์ชันของเครื่องมือแต่ละอย่างอย่างชัดเจน และต้องบังคับใช้เขตความปลอดภัยที่เข้มงวดเพื่อป้องกันการดำเนินการที่ไม่ตั้งใจหรือไม่ปลอดภัย
ด้วยการปฏิบัติตามหลักการด้านความปลอดภัยเหล่านี้ MCP ช่วยรักษาความเชื่อถือ ความเป็นส่วนตัว และความปลอดภัยของผู้ใช้ตลอดการโต้ตอบในโปรโตคอล พร้อมทั้งเปิดโอกาสในการผสาน AI ที่ทรงพลัง
ตัวอย่างโค้ด: ส่วนประกอบหลัก
ต่อไปนี้คือตัวอย่างโค้ดในหลายภาษาโปรแกรมยอดนิยมที่แสดงวิธีการใช้งานส่วนประกอบเซิร์ฟเวอร์ MCP และเครื่องมือสำคัญ
ตัวอย่าง .NET: สร้างเซิร์ฟเวอร์ MCP ง่ายๆ พร้อมเครื่องมือ
นี่คือตัวอย่างโค้ด .NET ที่ปฏิบัติจริงแสดงวิธีใช้งานเซิร์ฟเวอร์ MCP ง่ายๆ พร้อมเครื่องมือที่กำหนดเอง ตัวอย่างนี้แสดงวิธีการกำหนดและลงทะเบียนเครื่องมือ การจัดการคำขอ และการเชื่อมต่อเซิร์ฟเวอร์โดยใช้ Model Context Protocol
using System;
using System.Threading.Tasks;
using ModelContextProtocol.Server;
using ModelContextProtocol.Server.Transport;
using ModelContextProtocol.Server.Tools;
public class WeatherServer
{
public static async Task Main(string[] args)
{
// Create an MCP server
var server = new McpServer(
name: "Weather MCP Server",
version: "1.0.0"
);
// Register our custom weather tool
server.AddTool<string, WeatherData>("weatherTool",
description: "Gets current weather for a location",
execute: async (location) => {
// Call weather API (simplified)
var weatherData = await GetWeatherDataAsync(location);
return weatherData;
});
// Connect the server using stdio transport
var transport = new StdioServerTransport();
await server.ConnectAsync(transport);
Console.WriteLine("Weather MCP Server started");
// Keep the server running until process is terminated
await Task.Delay(-1);
}
private static async Task<WeatherData> GetWeatherDataAsync(string location)
{
// This would normally call a weather API
// Simplified for demonstration
await Task.Delay(100); // Simulate API call
return new WeatherData {
Temperature = 72.5,
Conditions = "Sunny",
Location = location
};
}
}
public class WeatherData
{
public double Temperature { get; set; }
public string Conditions { get; set; }
public string Location { get; set; }
}
ตัวอย่าง Java: ส่วนประกอบเซิร์ฟเวอร์ MCP
ตัวอย่างนี้แสดงเซิร์ฟเวอร์ MCP และการลงทะเบียนเครื่องมือเหมือนกับตัวอย่าง .NET ข้างต้น แต่ใช้ภาษา Java
import io.modelcontextprotocol.server.McpServer;
import io.modelcontextprotocol.server.McpToolDefinition;
import io.modelcontextprotocol.server.transport.StdioServerTransport;
import io.modelcontextprotocol.server.tool.ToolExecutionContext;
import io.modelcontextprotocol.server.tool.ToolResponse;
public class WeatherMcpServer {
public static void main(String[] args) throws Exception {
// สร้างเซิร์ฟเวอร์ MCP
McpServer server = McpServer.builder()
.name("Weather MCP Server")
.version("1.0.0")
.build();
// ลงทะเบียนเครื่องมือสภาพอากาศ
server.registerTool(McpToolDefinition.builder("weatherTool")
.description("Gets current weather for a location")
.parameter("location", String.class)
.execute((ToolExecutionContext ctx) -> {
String location = ctx.getParameter("location", String.class);
// รับข้อมูลสภาพอากาศ (แบบง่าย)
WeatherData data = getWeatherData(location);
// ส่งกลับข้อมูลที่จัดรูปแบบแล้ว
return ToolResponse.content(
String.format("Temperature: %.1f°F, Conditions: %s, Location: %s",
data.getTemperature(),
data.getConditions(),
data.getLocation())
);
})
.build());
// เชื่อมต่อเซิร์ฟเวอร์โดยใช้การขนส่ง stdio
try (StdioServerTransport transport = new StdioServerTransport()) {
server.connect(transport);
System.out.println("Weather MCP Server started");
// รักษาเซิร์ฟเวอร์ให้ทำงานจนกว่ากระบวนการจะถูกยกเลิก
Thread.currentThread().join();
}
}
private static WeatherData getWeatherData(String location) {
// การใช้จริงจะเรียก API สภาพอากาศ
// ทำให้ง่ายขึ้นเพื่อวัตถุประสงค์ตัวอย่าง
return new WeatherData(72.5, "Sunny", location);
}
}
class WeatherData {
private double temperature;
private String conditions;
private String location;
public WeatherData(double temperature, String conditions, String location) {
this.temperature = temperature;
this.conditions = conditions;
this.location = location;
}
public double getTemperature() {
return temperature;
}
public String getConditions() {
return conditions;
}
public String getLocation() {
return location;
}
}
ตัวอย่าง Python: การสร้างเซิร์ฟเวอร์ MCP
ตัวอย่างนี้ใช้ fastmcp กรุณาติดตั้งก่อนใช้งาน:
pip install fastmcp
Code Sample:
#!/usr/bin/env python3
import asyncio
from fastmcp import FastMCP
from fastmcp.transports.stdio import serve_stdio
# สร้างเซิร์ฟเวอร์ FastMCP
mcp = FastMCP(
name="Weather MCP Server",
version="1.0.0"
)
@mcp.tool()
def get_weather(location: str) -> dict:
"""Gets current weather for a location."""
return {
"temperature": 72.5,
"conditions": "Sunny",
"location": location
}
# วิธีทางเลือกโดยใช้คลาส
class WeatherTools:
@mcp.tool()
def forecast(self, location: str, days: int = 1) -> dict:
"""Gets weather forecast for a location for the specified number of days."""
return {
"location": location,
"forecast": [
{"day": i+1, "temperature": 70 + i, "conditions": "Partly Cloudy"}
for i in range(days)
]
}
# ลงทะเบียนเครื่องมือของคลาส
weather_tools = WeatherTools()
# เริ่มเซิร์ฟเวอร์
if __name__ == "__main__":
asyncio.run(serve_stdio(mcp))
ตัวอย่าง JavaScript: การสร้างเซิร์ฟเวอร์ MCP
ตัวอย่างนี้แสดงการสร้างเซิร์ฟเวอร์ MCP ด้วย JavaScript และวิธีการลงทะเบียนเครื่องมือสองตัวที่เกี่ยวกับสภาพอากาศ
// ใช้ SDK ของ Model Context Protocol อย่างเป็นทางการ
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod"; // สำหรับการตรวจสอบพารามิเตอร์
// สร้างเซิร์ฟเวอร์ MCP
const server = new McpServer({
name: "Weather MCP Server",
version: "1.0.0"
});
// กำหนดเครื่องมือพยากรณ์อากาศ
server.tool(
"weatherTool",
{
location: z.string().describe("The location to get weather for")
},
async ({ location }) => {
// โดยปกติจะเรียกใช้ API สภาพอากาศ
// ทำให้เรียบง่ายสำหรับการสาธิต
const weatherData = await getWeatherData(location);
return {
content: [
{
type: "text",
text: `Temperature: ${weatherData.temperature}°F, Conditions: ${weatherData.conditions}, Location: ${weatherData.location}`
}
]
};
}
);
// กำหนดเครื่องมือพยากรณ์ล่วงหน้า
server.tool(
"forecastTool",
{
location: z.string(),
days: z.number().default(3).describe("Number of days for forecast")
},
async ({ location, days }) => {
// โดยปกติจะเรียกใช้ API สภาพอากาศ
// ทำให้เรียบง่ายสำหรับการสาธิต
const forecast = await getForecastData(location, days);
return {
content: [
{
type: "text",
text: `${days}-day forecast for ${location}: ${JSON.stringify(forecast)}`
}
]
};
}
);
// ฟังก์ชันช่วยเหลือ
async function getWeatherData(location) {
// จำลองการเรียก API
return {
temperature: 72.5,
conditions: "Sunny",
location: location
};
}
async function getForecastData(location, days) {
// จำลองการเรียก API
return Array.from({ length: days }, (_, i) => ({
day: i + 1,
temperature: 70 + Math.floor(Math.random() * 10),
conditions: i % 2 === 0 ? "Sunny" : "Partly Cloudy"
}));
}
// เชื่อมต่อเซิร์ฟเวอร์โดยใช้การขนส่ง stdio
const transport = new StdioServerTransport();
server.connect(transport).catch(console.error);
console.log("Weather MCP Server started");
ตัวอย่าง JavaScript นี้แสดงวิธีสร้างเซิร์ฟเวอร์ MCP โดยใช้ Model Context Protocol SDK แสดงวิธีลงทะเบียนเครื่องมือสองตัวชื่อ weatherTool และ forecastTool และทำให้พร้อมใช้งานกับไคลเอนต์ MCP ผ่าน StdioServerTransport
ความปลอดภัยและการอนุญาต
MCP มีแนวคิดและกลไกในตัวสำหรับจัดการความปลอดภัยและการอนุญาตตลอดโปรโตคอล:
-
การควบคุมสิทธิ์เครื่องมือ:
ไคลเอนต์สามารถระบุได้ว่าโมเดลอนุญาตให้ใช้เครื่องมือใดบ้างในเซสชัน เพื่อให้มั่นใจว่าเข้าถึงเฉพาะเครื่องมือที่ได้รับอนุญาตเท่านั้น ลดความเสี่ยงจากการดำเนินการที่ไม่ตั้งใจหรือไม่ปลอดภัย สิทธิ์สามารถกำหนดแบบไดนามิกตามความชอบของผู้ใช้ นโยบายองค์กร หรือบริบทของการโต้ตอบ -
การตรวจสอบสิทธิ์:
เซิร์ฟเวอร์อาจต้องมีการตรวจสอบสิทธิ์ก่อนให้เข้าถึงเครื่องมือ ทรัพยากร หรือการดำเนินการที่ละเอียดอ่อน อาจใช้คีย์ API โทเค็น OAuth หรือวิธีตรวจสอบสิทธิ์อื่นๆ การตรวจสอบสิทธิ์ที่เหมาะสมช่วยให้มั่นใจว่าเฉพาะไคลเอนต์และผู้ใช้ที่เชื่อถือได้เท่านั้นที่เรียกใช้ฟังก์ชันของเซิร์ฟเวอร์ได้ -
การตรวจสอบความถูกต้อง:
มีการบังคับตรวจสอบพารามิเตอร์สำหรับทุกการเรียกใช้เครื่องมือ เครื่องมือแต่ละตัวกำหนดประเภท รูปแบบ และข้อจำกัดที่คาดหวังของพารามิเตอร์ และเซิร์ฟเวอร์ตรวจสอบคำขอที่เข้ามาตามนั้น ป้องกันข้อมูลป้อนผิดพลาดหรือเป็นอันตรายไม่ให้ส่งไปยังการใช้งานเครื่องมือ และช่วยรักษาความสมบูรณ์ของการดำเนินการ -
การจำกัดอัตรา:
เพื่อป้องกันการใช้ในทางที่ผิดและประกันการใช้ทรัพยากรเซิร์ฟเวอร์อย่างเป็นธรรม เซิร์ฟเวอร์ MCP สามารถใช้นโยบายจำกัดอัตราการเรียกเครื่องมือและการเข้าถึงทรัพยากรได้ ขีดจำกัดอัตราสามารถใช้ตามผู้ใช้ ตามเซสชัน หรือทั่วทั้งระบบ และช่วยป้องกันการโจมตีปฏิเสธการให้บริการหรือการใช้ทรัพยากรเกินจำเป็น
โดยการรวมกลไกเหล่านี้ MCP จึงมอบพื้นฐานที่ปลอดภัยสำหรับการผสานโมเดลภาษาเข้ากับเครื่องมือและแหล่งข้อมูลภายนอก พร้อมทั้งให้ผู้ใช้และนักพัฒนาควบคุมการเข้าถึงและการใช้งานอย่างละเอียด
ข้อความโปรโตคอลและโฟลว์การสื่อสาร
การสื่อสาร MCP ใช้ข้อความ JSON-RPC 2.0 ที่มีโครงสร้างเพื่ออำนวยความสะดวกในการโต้ตอบที่ชัดเจนและเชื่อถือได้ระหว่างโฮสต์ ไคลเอนต์ และเซิร์ฟเวอร์ โปรโตคอลกำหนดรูปแบบข้อความเฉพาะสำหรับประเภทการดำเนินการต่างๆ:
ประเภทข้อความหลัก:
ข้อความเริ่มต้น
- คำขอ
initialize: สร้างการเชื่อมต่อและเจรจาเวอร์ชันโปรโตคอลและความสามารถ - การตอบกลับ
initialize: ยืนยันฟีเจอร์ที่รองรับและข้อมูลเซิร์ฟเวอร์ notifications/initialized: สัญญาณว่าเริ่มต้นเสร็จสมบูรณ์และเซสชันพร้อมใช้งาน
ข้อความค้นพบ
- คำขอ
tools/list: ค้นหาเครื่องมือที่มีจากเซิร์ฟเวอร์ - คำขอ
resources/list: รายการทรัพยากรที่มี (แหล่งข้อมูล) - คำขอ
prompts/list: ดึงเทมเพลตพรอมต์ที่มี
ข้อความดำเนินการ
- คำขอ
tools/call: เรียกใช้เครื่องมือเฉพาะด้วยพารามิเตอร์ที่ให้ - คำขอ
resources/read: ดึงเนื้อหาจากทรัพยากรเฉพาะ - คำขอ
prompts/get: ดึงเทมเพลตพรอมต์พร้อมพารามิเตอร์เสริม (ถ้ามี)
ข้อความฝั่งไคลเอนต์
- คำขอ
sampling/complete: เซิร์ฟเวอร์ขอผลลัพธ์ LLM จากไคลเอนต์ elicitation/request: เซิร์ฟเวอร์ขอข้อมูลผู้ใช้ผ่านอินเทอร์เฟซไคลเอนต์- ข้อความล็อก: เซิร์ฟเวอร์ส่งข้อความล็อกที่มีโครงสร้างไปยังไคลเอนต์
ข้อความแจ้งเตือน
notifications/tools/list_changed: เซิร์ฟเวอร์แจ้งไคลเอนต์ว่าเครื่องมือมีการเปลี่ยนแปลงnotifications/resources/list_changed: เซิร์ฟเวอร์แจ้งไคลเอนต์ว่าทรัพยากรมีการเปลี่ยนแปลงnotifications/prompts/list_changed: เซิร์ฟเวอร์แจ้งไคลเอนต์ว่าพรอมต์มีการเปลี่ยนแปลง
โครงสร้างข้อความ:
ข้อความ MCP ทั้งหมดปฏิบัติตามรูปแบบ JSON-RPC 2.0 โดยมี:
- ข้อความคำขอ: มี
id,methodและparamsแบบพารามิเตอร์ไม่บังคับ - ข้อความตอบกลับ: มี
idและมีresultหรือerror - ข้อความแจ้งเตือน: มี
methodและparamsแบบพารามิเตอร์ไม่บังคับ (ไม่มีidและไม่คาดหวังการตอบกลับ)
รูปแบบการสื่อสารนี้ช่วยให้การโต้ตอบมีความน่าเชื่อถือ ตรวจสอบได้ และขยายขีดความสามารถ รองรับสถานการณ์ขั้นสูงเช่น อัปเดตแบบเรียลไทม์ การเชื่อมโยงเครื่องมือ และการจัดการข้อผิดพลาดที่ทนทาน
งาน (Experimental)
งาน (Tasks) เป็นฟีเจอร์ทดลองที่ให้ “ห่อหุ้มการประมวลผลที่ยืดหยุ่น” เพื่ออนุญาตให้ดึงผลลัพธ์ล่าช้าและติดตามสถานะคำขอ MCP:
- การทำงานระยะยาว: ติดตามการคำนวณที่มีค่าใช้จ่ายสูง อัตโนมัติการทำงาน หรือประมวลผลแบบแบตช์
- ผลลัพธ์ล่าช้า: สอบถามสถานะงานและดึงผลลัพธ์เมื่อเสร็จสิ้น
- ติดตามสถานะ: เฝ้าระวังความก้าวหน้าของงานผ่านสถานะวงจรชีวิตที่กำหนด
- การทำงานหลายขั้นตอน: รองรับเวิร์กโฟลว์ซับซ้อนที่ข้ามหลายการโต้ตอบ
งานจะห่อคำขอ MCP มาตรฐานเพื่อเปิดใช้งานรูปแบบดำเนินการแบบอะซิงโครนัสสำหรับงานที่ไม่สามารถเสร็จทันทีได้
สรุปที่สำคัญ
- สถาปัตยกรรม: MCP ใช้สถาปัตยกรรมไคลเอนต์-เซิร์ฟเวอร์ที่โฮสต์บริหารการเชื่อมต่อไคลเอนต์หลายตัวกับเซิร์ฟเวอร์
- ผู้เข้าร่วม: ระบบประกอบด้วยโฮสต์ (แอป AI), ไคลเอนต์ (ตัวเชื่อมโปรโตคอล), และเซิร์ฟเวอร์ (ผู้ให้ความสามารถ)
- กลไกการขนส่ง: การสื่อสารรองรับ STDIO (ในเครื่อง) และ HTTP แบบสตรีมพร้อม SSE (ระยะไกล)
- พริมิตีฟหลัก: เซิร์ฟเวอร์เปิดเผยเครื่องมือ (ฟังก์ชันที่เรียกใช้ได้) ทรัพยากร (แหล่งข้อมูล) และพรอมต์ (เทมเพลต)
- พริมิตีฟไคลเอนต์: เซิร์ฟเวอร์สามารถขอตัวอย่าง (ผลลัพธ์ LLM พร้อมสนับสนุนการเรียกเครื่องมือ), ข้อมูลผู้ใช้ (รวมโหมด URL), ขอบเขตระบบไฟล์ และการล็อกจากไคลเอนต์
- ฟีเจอร์ทดลอง: งานให้การห่อหุ้มการประมวลผลสำหรับงานระยะยาว
- พื้นฐานโปรโตคอล: สร้างบน JSON-RPC 2.0 พร้อมการจัดเวอร์ชันตามวันที่ (ปัจจุบัน: 2025-11-25)
- ความสามารถแบบเรียลไทม์: รองรับการแจ้งเตือนเพื่ออัปเดตแบบไดนามิกและการซิงโครไนซ์แบบเรียลไทม์
- ความปลอดภัยเป็นหลัก: ต้องการความยินยอมชัดเจนของผู้ใช้ การปกป้องความเป็นส่วนตัว และการขนส่งที่ปลอดภัยเป็นหลัก
แบบฝึกหัด
ออกแบบเครื่องมือ MCP ง่ายๆ ที่จะเป็นประโยชน์ในโดเมนของคุณ กำหนด:
- ชื่อเครื่องมือ
- พารามิเตอร์ที่จะรับ
- ผลลัพธ์ที่จะส่งคืน
- วิธีที่โมเดลอาจใช้เครื่องมือนี้เพื่อแก้ปัญหาของผู้ใช้
ต่อไป
ถัดไป: บทที่ 2: ความปลอดภัย
คำปฏิเสธ: เอกสารฉบับนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI Co-op Translator แม้เราจะพยายามให้มีความถูกต้อง แต่โปรดทราบว่าการแปลอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารฉบับต้นฉบับในภาษาต้นทางควรถูกพิจารณาเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลสำคัญ ขอแนะนำให้ใช้บริการแปลโดยมนุษย์ผู้เชี่ยวชาญ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดที่เกิดจากการใช้การแปลนี้