สอนสร้าง MCP Tool ด้วย Python SDK ตั้งแต่เริ่มต้น

สรุป: ทำไมต้องสร้าง MCP Tool ของตัวเอง?

MCP Tool คืออะไรและทำงานอย่างไร?

• Tool Definition — กำหนดชื่อ คำอธิบาย และพารามิเตอร์ของฟังก์ชัน
• Tool Executor — โค้ดที่รันเมื่อ AI เรียกใช้งาน
• Result Formatter — แปลงผลลัพธ์เป็นรูปแบบที่ AI เข้าใจได้

เปรียบเทียบราคาและประสิทธิภาพ API สำหรับ MCP Development

ติดตั้ง Python SDK และเตรียม Environment

# ติดตั้ง dependencies
pip install openai>=1.12.0
pip install mcp>=1.0.0
pip install fastapi>=0.109.0
pip install uvicorn>=0.27.0

สร้างไฟล์ requirements.txt
cat > requirements.txt << 'EOF'
openai>=1.12.0
mcp>=1.0.0
fastapi>=0.109.0
uvicorn>=0.27.0
pydantic>=2.5.0
python-dotenv>=1.0.0
EOF

ตรวจสอบเวอร์ชัน
python --version
pip show openai | grep Version

# สร้างไฟล์ .env สำหรับเก็บ API Key
cat > .env << 'EOF'
HolySheep AI API Configuration
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
HOLYSHEEP_BASE_URL=https://api.holysheep.ai/v1

Model Selection
MODEL_NAME=gpt-4.1
TEMPERATURE=0.7
MAX_TOKENS=2048
EOF

ตรวจสอบว่าตั้งค่าถูกต้อง
source .env && echo "HOLYSHEEP_BASE_URL: $HOLYSHEEP_BASE_URL"

สร้าง MCP Tool พื้นฐาน: ระบบค้นหาและตอบคำถาม

import os
from dotenv import load_dotenv
from openai import OpenAI
from pydantic import BaseModel, Field
from typing import Optional, List, Dict, Any
from mcp.server import MCPServer
from mcp.types import Tool, ToolResult, TextContent

โหลด environment variables
load_dotenv()

class SearchQuery(BaseModel):
    """โครงสร้างข้อมูลสำหรับค้นหา"""
    query: str = Field(description="คำถามที่ต้องการค้นหา")
    max_results: int = Field(default=5, description="จำนวนผลลัพธ์สูงสุด")
    category: Optional[str] = Field(default=None, description="หมวดหมู่ที่ต้องการค้นหา")

class SearchResult(BaseModel):
    """โครงสร้างผลลัพธ์การค้นหา"""
    title: str
    content: str
    relevance_score: float
    source_url: Optional[str] = None

class MCPClient:
    """
    MCP Tool Client สำหรับ HolySheep AI
    รองรับการเรียก function calling ผ่าน OpenAI-compatible API
    """
    
    def __init__(self):
        self.base_url = os.getenv("HOLYSHEEP_BASE_URL", "https://api.holysheep.ai/v1")
        self.api_key = os.getenv("HOLYSHEEP_API_KEY")
        
        if not self.api_key:
            raise ValueError("กรุณาตั้งค่า HOLYSHEEP_API_KEY ในไฟล์ .env")
        
        self.client = OpenAI(
            api_key=self.api_key,
            base_url=self.base_url
        )
        
        # กำหนด tools ที่รองรับ
        self.tools = self._define_tools()
    
    def _define_tools(self) -> List[Dict[str, Any]]:
        """
        กำหนดรายการ MCP Tools 
        แต่ละ tool มี name, description, parameters
        """
        return [
            {
                "type": "function",
                "function": {
                    "name": "search_knowledge_base",
                    "description": "ค้นหาข้อมูลจากฐานความรู้เพื่อตอบคำถาม",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "query": {
                                "type": "string",
                                "description": "คำถามที่ต้องการค้นหาคำตอบ"
                            },
                            "max_results": {
                                "type": "integer",
                                "description": "จำนวนผลลัพธ์สูงสุดที่ต้องการ",
                                "default": 5
                            },
                            "category": {
                                "type": "string",
                                "description": "หมวดหมู่ที่ต้องการค้นหา เช่น 'technical', 'business', 'faq'",
                                "enum": ["technical", "business", "faq", "all"]
                            }
                        },
                        "required": ["query"]
                    }
                }
            },
            {
                "type": "function",
                "function": {
                    "name": "calculate_metrics",
                    "description": "คำนวณค่าทางสถิติจากข้อมูลที่ให้มา",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "data": {
                                "type": "array",
                                "items": {"type": "number"},
                                "description": "อาร์เรย์ของตัวเลขที่ต้องการคำนวณ"
                            },
                            "metrics": {
                                "type": "array",
                                "items": {"type": "string"},
                                "description": "ประเภทการคำนวณที่ต้องการ เช่น 'mean', 'median', 'std', 'sum'",
                                "enum": ["mean", "median", "std", "sum", "min", "max"]
                            }
                        },
                        "required": ["data", "metrics"]
                    }
                }
            }
        ]
    
    def execute_tool(self, tool_name: str, arguments: Dict[str, Any]) -> ToolResult:
        """
        Execute MCP Tool ตามชื่อและ arguments ที่ได้รับ
        """
        if tool_name == "search_knowledge_base":
            return self._search_knowledge_base(**arguments)
        elif tool_name == "calculate_metrics":
            return self._calculate_metrics(**arguments)
        else:
            return ToolResult(
                content=[TextContent(type="text", text=f"ไม่พบ tool: {tool_name}")],
                isError=True
            )
    
    def _search_knowledge_base(
        self, 
        query: str, 
        max_results: int = 5, 
        category: Optional[str] = None
    ) -> ToolResult:
        """
        ค้นหาข้อมูลจากฐานความรู้ (จำลอง)
        ใน production ให้เชื่อมต่อกับ Elasticsearch, Pinecone, หรือ vector database
        """
        # จำลองผลการค้นหา
        mock_results = [
            {
                "title": f"เอกสารเกี่ยวกับ {query} - ส่วนที่ {i+1}",
                "content": f"นี่คือเนื้อหาตัวอย่างสำหรับ '{query}' ซึ่งมีรายละเอียดที่เป็นประโยชน์...",
                "relevance_score": 0.95 - (i * 0.1),
                "source_url": f"https://docs.example.com/article-{i+1}"
            }
            for i in range(min(max_results, 3))
        ]
        
        result_text = f"พบ {len(mock_results)} ผลลัพธ์สำหรับคำค้นหา '{query}'\n\n"
        for idx, item in enumerate(mock_results, 1):
            result_text += f"{idx}. {item['title']} (ความเกี่ยวข้อง: {item['relevance_score']:.2f})\n"
            result_text += f"   {item['content']}\n"
            if item['source_url']:
                result_text += f"   ที่มา: {item['source_url']}\n"
            result_text += "\n"
        
        return ToolResult(content=[TextContent(type="text", text=result_text)])
    
    def _calculate_metrics(
        self, 
        data: List[float], 
        metrics: List[str]
    ) -> ToolResult:
        """
        คำนวณค่าทางสถิติ
        """
        import statistics
        
        results = {}
        
        if "mean" in metrics:
            results["mean"] = statistics.mean(data) if data else 0
        if "median" in metrics:
            results["median"] = statistics.median(data) if data else 0
        if "std" in metrics:
            results["std"] = statistics.stdev(data) if len(data) > 1 else 0
        if "sum" in metrics:
            results["sum"] = sum(data)
        if "min" in metrics:
            results["min"] = min(data) if data else 0
        if "max" in metrics:
            results["max"] = max(data) if data else 0
        
        result_text = f"ผลการคำนวณจากข้อมูล {len(data)} รายการ:\n"
        for metric, value in results.items():
            result_text += f"- {metric}: {value:.4f}\n"
        
        return ToolResult(content=[TextContent(type="text", text=result_text)])

ทดสอบการใช้งาน
if __name__ == "__main__":
    try:
        mcp = MCPClient()
        print("✅ MCP Client สร้างสำเร็จ")
        print(f"📡 Base URL: {mcp.base_url}")
        print(f"🔧 Tools ที่รองรับ: {[t['function']['name'] for t in mcp.tools]}")
    except Exception as e:
        print(f"❌ เกิดข้อผิดพลาด: {e}")

สร้าง API Server สำหรับ MCP Tool

Initialize MCP Client
mcp_client = MCPClient()

class ChatMessage(BaseModel):
    """โครงสร้างข้อความแชท"""
    role: str = Field(..., description="'user', 'assistant', หรือ 'system'")
    content: str = Field(..., description="เนื้อหาข้อความ")

class ChatRequest(BaseModel):
    """Request สำหรับ chat API"""
    messages: List[ChatMessage] = Field(..., description="รายการข้อความในการสนทนา")
    model: str = Field(default="gpt-4.1", description
แหล่งข้อมูลที่เกี่ยวข้อง
📚 บทช่วยสอน AI API
💰 ดูราคา
📖 เอกสารสำหรับนักพัฒนา
🚀 สมัครฟรี
บทความที่เกี่ยวข้อง
NVIDIA TensorRT-LLM 推理加速完整教程
คู่มือการย้ายระบบ AI API สำหรับนักพัฒนาในปี 2026
Multi-Tenant AI API Service: Data Isolation และ Permission M